From ca8948ab8a079b9d8bf98387e617ed0392292fab Mon Sep 17 00:00:00 2001
From: Micah Cantor <micahcantor01@gmail.com>
Date: Wed, 21 Jun 2023 14:59:14 +0200
Subject: [PATCH 001/112] init

---
 compiler/lib/deadcode_dgraph.ml | 84 +++++++++++++++++++++++++++++++++
 1 file changed, 84 insertions(+)
 create mode 100644 compiler/lib/deadcode_dgraph.ml

diff --git a/compiler/lib/deadcode_dgraph.ml b/compiler/lib/deadcode_dgraph.ml
new file mode 100644
index 0000000000..fcce9d3ab3
--- /dev/null
+++ b/compiler/lib/deadcode_dgraph.ml
@@ -0,0 +1,84 @@
+(* Js_of_ocaml compiler
+ * http://www.ocsigen.org/js_of_ocaml/
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, with linking exception;
+ * either version 2.1 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *)
+
+open Code
+
+type def =
+  | Expr of expr
+  | Var of Var.t
+
+type state =
+  { blocks : block Addr.Map.t
+  ; var_life : bool Var.Tbl.t
+  ; defs : def list array
+  ; pure_funs : Var.Set.t
+  }
+
+module G = Dgraph.Make_Imperative (Var) (Var.ISet) (Var.Tbl)
+
+module Domain = struct
+  type t = bool
+
+  let equal = Bool.equal
+
+  let bot = false
+end
+
+module Solver = G.Solver (Domain)
+
+let pure_expr pure_funs e = Pure_fun.pure_expr pure_funs e && Config.Flag.deadcode ()
+
+let live_instr st i =
+  match i with
+  | Let (x, e) ->
+      (* variable has been marked as live or the expression is impure *)
+      Var.Tbl.get st.var_life x || not (pure_expr st.pure_funs e)
+  | Assign (x, _) ->
+      (* variable has been marked as live *)
+      Var.Tbl.get st.var_life x
+  | Set_field _ | Offset_ref _ | Array_set _ ->
+      (* these are impure so always live *)
+      true
+
+let propagate deps (defs : def array) pure_funs st x =
+  match defs.(Var.idx x) with
+  | Expr e -> _
+  | Var v -> Var.Tbl.get st.var_life x
+
+let solver vars deps defs pure_funs =
+  let g =
+    { G.domain = vars; G.iter_children = (fun f x -> Var.Set.iter f deps.(Var.idx x)) }
+  in
+  Solver.f () g (propagate deps defs pure_funs)
+
+let run (p : program) =
+  let blocks = p.blocks in
+  let vars, deps, defs = program_deps p in
+  let pure_funs = Pure_fun.f p in
+  let var_life = solver vars deps defs pure_funs in
+  let st = { blocks; var_life; defs; pure_funs } in
+  let remove_dead (block : block) =
+    { params = List.filter (fun x -> Var.Tbl.get st.var_life x) block.params
+    ; body = (* remove dead instructions *)
+             _
+    ; branch = (* Remove dead code from the last instruction *)
+               _
+    }
+  in
+  let blocks = Addr.Map.map remove_dead p.blocks in
+  { p with blocks }

From 31fe9f0fdc77e62cd4bc153ca378c38619252738 Mon Sep 17 00:00:00 2001
From: Micah Cantor <micahcantor01@gmail.com>
Date: Thu, 22 Jun 2023 15:09:07 +0200
Subject: [PATCH 002/112] more progress

---
 compiler/lib/deadcode_dgraph.ml | 101 ++++++++++++++++++++++++++------
 1 file changed, 82 insertions(+), 19 deletions(-)

diff --git a/compiler/lib/deadcode_dgraph.ml b/compiler/lib/deadcode_dgraph.ml
index fcce9d3ab3..02ca57bed8 100644
--- a/compiler/lib/deadcode_dgraph.ml
+++ b/compiler/lib/deadcode_dgraph.ml
@@ -21,11 +21,12 @@ open Code
 type def =
   | Expr of expr
   | Var of Var.t
+  | Unknown
 
 type state =
   { blocks : block Addr.Map.t
-  ; var_life : bool Var.Tbl.t
-  ; defs : def list array
+  ; live : bool Var.Tbl.t
+  ; defs : def array
   ; pure_funs : Var.Set.t
   }
 
@@ -43,37 +44,99 @@ module Solver = G.Solver (Domain)
 
 let pure_expr pure_funs e = Pure_fun.pure_expr pure_funs e && Config.Flag.deadcode ()
 
+(* Returns an array of definitions of each variable *)
+let definitions (p : program) =
+  let defs = Array.make 0 Unknown in
+  Addr.Map.iter
+    (fun _ block ->
+      List.iter
+        (fun (i, _) ->
+          match i with
+          | Let (x, e) -> defs.(Var.idx x) <- Expr e
+          | Assign (x, y) -> defs.(Var.idx x) <- Var y
+          | _ -> ())
+        block.body)
+    p.blocks;
+  defs
+
+(* Returns the adjacency list for the variable dependency graph. *)
+let dependencies (defs : def array) =
+  let deps = Array.make 0 Var.Set.empty in
+  let add_dep i x = deps.(i) <- Var.Set.add x deps.(i) in
+  Array.iteri
+    (fun i d ->
+      match d with
+      | Expr e -> (
+          match e with
+          | Apply { f; args; _ } ->
+              add_dep i f;
+              List.iter (add_dep i) args
+          | Block (_, params, _) -> Array.iter (add_dep i) params
+          | Field (z, _) -> add_dep i z
+          | Constant _ -> ()
+          (* Not exactly sure how to handle these two *)
+          | Closure (_, _) -> ()
+          | Prim (_, _) -> ())
+      | Var y -> add_dep i y
+      | Unknown -> ())
+    defs;
+  deps
+
+(* Returns a boolean array representing whether each variable appears in an effectful definition. *)
+let effectful defs pure_funs =
+  let effs = Array.make 0 false in
+  Array.iteri
+    (fun i d ->
+      match d with
+      | Expr e -> if not (pure_expr pure_funs e) then effs.(i) <- true
+      | Var y -> effs.(i) <- effs.(Var.idx y)
+      | Unknown -> ())
+    defs;
+  effs
+
+(* Returns the set of variables given the adjacency list of variable depencies. *)
+let variables (deps : Var.Set.t array) =
+  let vars = Var.ISet.empty () in
+  Array.iter (fun s -> Var.Set.iter (fun v -> Var.ISet.add vars v) s) deps;
+  vars
+
+(* A variable x is live if either
+   (1) it appears in an effectful expression; or
+   (2) there exists a live variable y that depends on x. *)
+let propagate deps effectful live x =
+  let idx = Var.idx x in
+  effectful.(idx) || Var.Set.exists (fun y -> Var.Tbl.get live y) deps.(idx)
+
+let solver vars deps effectful =
+  let g =
+    { G.domain = vars; G.iter_children = (fun f x -> Var.Set.iter f deps.(Var.idx x)) }
+  in
+  Solver.f () g (propagate deps effectful)
+
 let live_instr st i =
   match i with
   | Let (x, e) ->
       (* variable has been marked as live or the expression is impure *)
-      Var.Tbl.get st.var_life x || not (pure_expr st.pure_funs e)
+      Var.Tbl.get st.live x || not (pure_expr st.pure_funs e)
   | Assign (x, _) ->
       (* variable has been marked as live *)
-      Var.Tbl.get st.var_life x
+      Var.Tbl.get st.live x
   | Set_field _ | Offset_ref _ | Array_set _ ->
       (* these are impure so always live *)
       true
 
-let propagate deps (defs : def array) pure_funs st x =
-  match defs.(Var.idx x) with
-  | Expr e -> _
-  | Var v -> Var.Tbl.get st.var_life x
-
-let solver vars deps defs pure_funs =
-  let g =
-    { G.domain = vars; G.iter_children = (fun f x -> Var.Set.iter f deps.(Var.idx x)) }
-  in
-  Solver.f () g (propagate deps defs pure_funs)
-
 let run (p : program) =
   let blocks = p.blocks in
-  let vars, deps, defs = program_deps p in
+  let defs = definitions p in
+  let deps = dependencies defs in
   let pure_funs = Pure_fun.f p in
-  let var_life = solver vars deps defs pure_funs in
-  let st = { blocks; var_life; defs; pure_funs } in
+  let effs = effectful defs pure_funs in
+  let vars = variables deps in
+  let live = solver vars deps effs in
+  (* Now that we have live variable table, remove dead ones *)
+  let st = { blocks; live; defs; pure_funs } in
   let remove_dead (block : block) =
-    { params = List.filter (fun x -> Var.Tbl.get st.var_life x) block.params
+    { params = List.filter (fun x -> Var.Tbl.get st.live x) block.params
     ; body = (* remove dead instructions *)
              _
     ; branch = (* Remove dead code from the last instruction *)

From 55e413dde7344fe8205cad986e95a89bf5dc7e2d Mon Sep 17 00:00:00 2001
From: Micah Cantor <micahcantor01@gmail.com>
Date: Thu, 22 Jun 2023 17:07:25 +0200
Subject: [PATCH 003/112] prep for debugging

---
 compiler/lib/deadcode_dgraph.ml  | 96 +++++++++++++++-----------------
 compiler/lib/deadcode_dgraph.mli | 19 +++++++
 compiler/lib/driver.ml           |  2 +-
 3 files changed, 64 insertions(+), 53 deletions(-)
 create mode 100644 compiler/lib/deadcode_dgraph.mli

diff --git a/compiler/lib/deadcode_dgraph.ml b/compiler/lib/deadcode_dgraph.ml
index 02ca57bed8..23ab0db845 100644
--- a/compiler/lib/deadcode_dgraph.ml
+++ b/compiler/lib/deadcode_dgraph.ml
@@ -21,14 +21,13 @@ open Code
 type def =
   | Expr of expr
   | Var of Var.t
-  | Unknown
 
-type state =
+(* type state =
   { blocks : block Addr.Map.t
   ; live : bool Var.Tbl.t
-  ; defs : def array
+  ; defs : def list array
   ; pure_funs : Var.Set.t
-  }
+  } *)
 
 module G = Dgraph.Make_Imperative (Var) (Var.ISet) (Var.Tbl)
 
@@ -45,57 +44,59 @@ module Solver = G.Solver (Domain)
 let pure_expr pure_funs e = Pure_fun.pure_expr pure_funs e && Config.Flag.deadcode ()
 
 (* Returns an array of definitions of each variable *)
-let definitions (p : program) =
-  let defs = Array.make 0 Unknown in
+let definitions nv (p : program) =
+  let defs = Array.make nv [] in
+  let add_def x d = defs.(Var.idx x) <- d :: defs.(Var.idx x) in
   Addr.Map.iter
     (fun _ block ->
       List.iter
         (fun (i, _) ->
           match i with
-          | Let (x, e) -> defs.(Var.idx x) <- Expr e
-          | Assign (x, y) -> defs.(Var.idx x) <- Var y
+          | Let (x, e) -> add_def x (Expr e)
+          | Assign (x, y) -> add_def x (Var y)
           | _ -> ())
         block.body)
     p.blocks;
   defs
 
 (* Returns the adjacency list for the variable dependency graph. *)
-let dependencies (defs : def array) =
-  let deps = Array.make 0 Var.Set.empty in
+let dependencies nv defs =
+  let deps = Array.make nv Var.Set.empty in
   let add_dep i x = deps.(i) <- Var.Set.add x deps.(i) in
   Array.iteri
-    (fun i d ->
-      match d with
-      | Expr e -> (
-          match e with
-          | Apply { f; args; _ } ->
-              add_dep i f;
-              List.iter (add_dep i) args
-          | Block (_, params, _) -> Array.iter (add_dep i) params
-          | Field (z, _) -> add_dep i z
-          | Constant _ -> ()
-          (* Not exactly sure how to handle these two *)
-          | Closure (_, _) -> ()
-          | Prim (_, _) -> ())
-      | Var y -> add_dep i y
-      | Unknown -> ())
+    (fun i ds ->
+      List.iter
+        (fun d ->
+          match d with
+          | Expr e -> (
+              match e with
+              | Apply { f; args; _ } ->
+                  add_dep i f;
+                  List.iter (add_dep i) args
+              | Block (_, params, _) -> Array.iter (add_dep i) params
+              | Field (z, _) -> add_dep i z
+              | Constant _ -> ()
+              (* Not exactly sure how to handle these two *)
+              | Closure (_, _) -> ()
+              | Prim (_, _) -> ())
+          | Var y -> add_dep i y)
+        ds)
     defs;
   deps
 
 (* Returns a boolean array representing whether each variable appears in an effectful definition. *)
-let effectful defs pure_funs =
-  let effs = Array.make 0 false in
-  Array.iteri
-    (fun i d ->
-      match d with
-      | Expr e -> if not (pure_expr pure_funs e) then effs.(i) <- true
-      | Var y -> effs.(i) <- effs.(Var.idx y)
-      | Unknown -> ())
-    defs;
+let effectful nv defs pure_funs =
+  let effs = Array.make nv false in
+  let set_eff i d =
+    match d with
+    | Expr e -> if not (pure_expr pure_funs e) then effs.(i) <- true
+    | Var y -> effs.(i) <- effs.(Var.idx y)
+  in
+  Array.iteri (fun i ds -> List.iter (fun d -> set_eff i d) ds) defs;
   effs
 
 (* Returns the set of variables given the adjacency list of variable depencies. *)
-let variables (deps : Var.Set.t array) =
+let variables deps =
   let vars = Var.ISet.empty () in
   Array.iter (fun s -> Var.Set.iter (fun v -> Var.ISet.add vars v) s) deps;
   vars
@@ -113,7 +114,7 @@ let solver vars deps effectful =
   in
   Solver.f () g (propagate deps effectful)
 
-let live_instr st i =
+(* let live_instr st i =
   match i with
   | Let (x, e) ->
       (* variable has been marked as live or the expression is impure *)
@@ -123,25 +124,16 @@ let live_instr st i =
       Var.Tbl.get st.live x
   | Set_field _ | Offset_ref _ | Array_set _ ->
       (* these are impure so always live *)
-      true
+      true *)
 
 let run (p : program) =
+  let nv = Var.count () in
   let blocks = p.blocks in
-  let defs = definitions p in
-  let deps = dependencies defs in
+  let defs = definitions nv p in
+  let deps = dependencies nv defs in
   let pure_funs = Pure_fun.f p in
-  let effs = effectful defs pure_funs in
+  let effs = effectful nv defs pure_funs in
   let vars = variables deps in
   let live = solver vars deps effs in
-  (* Now that we have live variable table, remove dead ones *)
-  let st = { blocks; live; defs; pure_funs } in
-  let remove_dead (block : block) =
-    { params = List.filter (fun x -> Var.Tbl.get st.live x) block.params
-    ; body = (* remove dead instructions *)
-             _
-    ; branch = (* Remove dead code from the last instruction *)
-               _
-    }
-  in
-  let blocks = Addr.Map.map remove_dead p.blocks in
-  { p with blocks }
+  Var.Tbl.iter (fun v b -> Format.eprintf "%a: %b\n" Var.print v b) live;
+  { p with blocks }, Array.make nv 0
diff --git a/compiler/lib/deadcode_dgraph.mli b/compiler/lib/deadcode_dgraph.mli
new file mode 100644
index 0000000000..1a356d6543
--- /dev/null
+++ b/compiler/lib/deadcode_dgraph.mli
@@ -0,0 +1,19 @@
+(* Js_of_ocaml compiler
+ * http://www.ocsigen.org/js_of_ocaml/
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, with linking exception;
+ * either version 2.1 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *)
+
+val run : Code.program -> Code.program * (int array)
\ No newline at end of file
diff --git a/compiler/lib/driver.ml b/compiler/lib/driver.ml
index b1c2b93b57..15524a75bc 100644
--- a/compiler/lib/driver.ml
+++ b/compiler/lib/driver.ml
@@ -38,7 +38,7 @@ let tailcall p =
 
 let deadcode' p =
   if debug () then Format.eprintf "Dead-code...@.";
-  Deadcode.f p
+  Deadcode_dgraph.run p
 
 let deadcode p =
   let r, _ = deadcode' p in

From c63bd523868cee269e7ee7c63c416a44be2a7dc9 Mon Sep 17 00:00:00 2001
From: Micah Cantor <micahcantor01@gmail.com>
Date: Fri, 23 Jun 2023 12:41:27 +0200
Subject: [PATCH 004/112] more updates, debugging info

---
 compiler/lib/deadcode_dgraph.ml | 70 ++++++++++++++++++++++-----------
 1 file changed, 46 insertions(+), 24 deletions(-)

diff --git a/compiler/lib/deadcode_dgraph.ml b/compiler/lib/deadcode_dgraph.ml
index 23ab0db845..ab4e624af9 100644
--- a/compiler/lib/deadcode_dgraph.ml
+++ b/compiler/lib/deadcode_dgraph.ml
@@ -23,11 +23,11 @@ type def =
   | Var of Var.t
 
 (* type state =
-  { blocks : block Addr.Map.t
-  ; live : bool Var.Tbl.t
-  ; defs : def list array
-  ; pure_funs : Var.Set.t
-  } *)
+   { blocks : block Addr.Map.t
+   ; live : bool Var.Tbl.t
+   ; defs : def list array
+   ; pure_funs : Var.Set.t
+   } *)
 
 module G = Dgraph.Make_Imperative (Var) (Var.ISet) (Var.Tbl)
 
@@ -76,9 +76,14 @@ let dependencies nv defs =
               | Block (_, params, _) -> Array.iter (add_dep i) params
               | Field (z, _) -> add_dep i z
               | Constant _ -> ()
-              (* Not exactly sure how to handle these two *)
-              | Closure (_, _) -> ()
-              | Prim (_, _) -> ())
+              | Closure (params, _) -> List.iter (add_dep i) params
+              | Prim (_, args) ->
+                  List.iter
+                    (fun arg ->
+                      match arg with
+                      | Pv v -> add_dep i v
+                      | Pc _ -> ())
+                    args)
           | Var y -> add_dep i y)
         ds)
     defs;
@@ -87,12 +92,15 @@ let dependencies nv defs =
 (* Returns a boolean array representing whether each variable appears in an effectful definition. *)
 let effectful nv defs pure_funs =
   let effs = Array.make nv false in
-  let set_eff i d =
-    match d with
-    | Expr e -> if not (pure_expr pure_funs e) then effs.(i) <- true
-    | Var y -> effs.(i) <- effs.(Var.idx y)
-  in
-  Array.iteri (fun i ds -> List.iter (fun d -> set_eff i d) ds) defs;
+  Array.iteri (* For each set of definitions *)
+    (fun i ds ->
+      List.iter (* For each definition *)
+        (fun d -> (* See if definition is effectful *)
+          match d with
+          | Expr e -> if not (pure_expr pure_funs e) then effs.(i) <- true
+          | Var y -> effs.(i) <- effs.(Var.idx y))
+        ds)
+    defs;
   effs
 
 (* Returns the set of variables given the adjacency list of variable depencies. *)
@@ -106,6 +114,7 @@ let variables deps =
    (2) there exists a live variable y that depends on x. *)
 let propagate deps effectful live x =
   let idx = Var.idx x in
+  Format.eprintf "%b\n" effectful.(idx);
   effectful.(idx) || Var.Set.exists (fun y -> Var.Tbl.get live y) deps.(idx)
 
 let solver vars deps effectful =
@@ -115,25 +124,38 @@ let solver vars deps effectful =
   Solver.f () g (propagate deps effectful)
 
 (* let live_instr st i =
-  match i with
-  | Let (x, e) ->
-      (* variable has been marked as live or the expression is impure *)
-      Var.Tbl.get st.live x || not (pure_expr st.pure_funs e)
-  | Assign (x, _) ->
-      (* variable has been marked as live *)
-      Var.Tbl.get st.live x
-  | Set_field _ | Offset_ref _ | Array_set _ ->
-      (* these are impure so always live *)
-      true *)
+   match i with
+   | Let (x, e) ->
+       (* variable has been marked as live or the expression is impure *)
+       Var.Tbl.get st.live x || not (pure_expr st.pure_funs e)
+   | Assign (x, _) ->
+       (* variable has been marked as live *)
+       Var.Tbl.get st.live x
+   | Set_field _ | Offset_ref _ | Array_set _ ->
+       (* these are impure so always live *)
+       true *)
 
 let run (p : program) =
   let nv = Var.count () in
   let blocks = p.blocks in
   let defs = definitions nv p in
   let deps = dependencies nv defs in
+  (* Print out dependency info *)
+  Format.eprintf "Dependencies:\n";
+  Array.iteri
+    (fun i ds ->
+      Format.eprintf "%d: { " i;
+      Var.Set.iter (fun d -> Format.eprintf "%a " Var.print d) ds;
+      Format.eprintf "}\n")
+    deps;
   let pure_funs = Pure_fun.f p in
   let effs = effectful nv defs pure_funs in
+  (* Print out effectfulness info *)
+  Format.eprintf "Effectful:\n";
+  Array.iteri (fun i b -> Format.eprintf "%d: %b\n" i b) effs;
   let vars = variables deps in
   let live = solver vars deps effs in
+  (* Print out liveness info *)
+  Format.eprintf "Liveness:\n";
   Var.Tbl.iter (fun v b -> Format.eprintf "%a: %b\n" Var.print v b) live;
   { p with blocks }, Array.make nv 0

From dbdf3bba062fd5612136e46e7d38d86705431ff6 Mon Sep 17 00:00:00 2001
From: Micah Cantor <micahcantor01@gmail.com>
Date: Mon, 26 Jun 2023 17:14:48 +0200
Subject: [PATCH 005/112] updates

---
 compiler/lib/deadcode_dgraph.ml | 70 ++++++++++++++++++++++++---------
 1 file changed, 51 insertions(+), 19 deletions(-)

diff --git a/compiler/lib/deadcode_dgraph.ml b/compiler/lib/deadcode_dgraph.ml
index ab4e624af9..1341074cbe 100644
--- a/compiler/lib/deadcode_dgraph.ml
+++ b/compiler/lib/deadcode_dgraph.ml
@@ -44,7 +44,7 @@ module Solver = G.Solver (Domain)
 let pure_expr pure_funs e = Pure_fun.pure_expr pure_funs e && Config.Flag.deadcode ()
 
 (* Returns an array of definitions of each variable *)
-let definitions nv (p : program) =
+let definitions nv prog =
   let defs = Array.make nv [] in
   let add_def x d = defs.(Var.idx x) <- d :: defs.(Var.idx x) in
   Addr.Map.iter
@@ -56,16 +56,16 @@ let definitions nv (p : program) =
           | Assign (x, y) -> add_def x (Var y)
           | _ -> ())
         block.body)
-    p.blocks;
+    prog.blocks;
   defs
 
 (* Returns the adjacency list for the variable dependency graph. *)
 let dependencies nv defs =
   let deps = Array.make nv Var.Set.empty in
-  let add_dep i x = deps.(i) <- Var.Set.add x deps.(i) in
-  Array.iteri
+  let add_dep i x = deps.(Var.idx x) <- Var.Set.add (Var.of_idx i) deps.(Var.idx x) in
+  Array.iteri (* For each set of definitions *)
     (fun i ds ->
-      List.iter
+      List.iter (* For each definition *)
         (fun d ->
           match d with
           | Expr e -> (
@@ -89,18 +89,51 @@ let dependencies nv defs =
     defs;
   deps
 
-(* Returns a boolean array representing whether each variable appears in an effectful definition. *)
-let effectful nv defs pure_funs =
+let expr_contains_var x e =
+  match e with
+  | Apply { f; args; _ } -> Var.equal x f || List.exists (Var.equal x) args
+  | Block (_, params, _) -> Array.exists (Var.equal x) params
+  | Field (z, _) -> Var.equal x z
+  | Constant _ -> false
+  | Closure (params, _) -> List.exists (Var.equal x) params
+  | Prim (_, args) ->
+      List.exists
+        (fun arg ->
+          match arg with
+          | Pv v -> Var.equal x v
+          | Pc _ -> false)
+        args
+
+(* Returns a boolean array representing whether each variable appears in an effectful instruction. *)
+let effectful nv prog pure_funs =
   let effs = Array.make nv false in
-  Array.iteri (* For each set of definitions *)
-    (fun i ds ->
-      List.iter (* For each definition *)
-        (fun d -> (* See if definition is effectful *)
-          match d with
-          | Expr e -> if not (pure_expr pure_funs e) then effs.(i) <- true
-          | Var y -> effs.(i) <- effs.(Var.idx y))
-        ds)
-    defs;
+  let effectful_instruction i =
+    match i with
+    | Let (x, e) ->
+        if (not (pure_expr pure_funs e)) && expr_contains_var x e
+        then effs.(Var.idx x) <- true
+    | Assign (x, _) -> effs.(Var.idx x) <- true (* TODO: correct? *)
+    | _ -> ()
+  in
+  let rec effectful_block block =
+    List.iter (fun (i, _) -> effectful_instruction i) block.body;
+    match fst block.branch with
+    | Stop -> ()
+    | Return x | Raise (x, _) -> effs.(Var.idx x) <- true
+    | Branch cont | Poptrap cont ->
+        effectful_continuation prog cont;
+        effectful_continuation prog cont
+    | Cond (_, cont1, cont2) | Pushtrap (cont1, _, cont2, _) ->
+        effectful_continuation prog cont1;
+        effectful_continuation prog cont2
+    | Switch (_, a1, a2) ->
+        Array.iter (fun cont -> effectful_continuation prog cont) a1;
+        Array.iter (fun cont -> effectful_continuation prog cont) a2
+  and effectful_continuation prog ((pc, _) : cont) =
+    let block = Addr.Map.find pc prog.blocks in
+    effectful_block block
+  in
+  Addr.Map.iter (fun _ block -> effectful_block block) prog.blocks;
   effs
 
 (* Returns the set of variables given the adjacency list of variable depencies. *)
@@ -114,14 +147,13 @@ let variables deps =
    (2) there exists a live variable y that depends on x. *)
 let propagate deps effectful live x =
   let idx = Var.idx x in
-  Format.eprintf "%b\n" effectful.(idx);
   effectful.(idx) || Var.Set.exists (fun y -> Var.Tbl.get live y) deps.(idx)
 
 let solver vars deps effectful =
   let g =
     { G.domain = vars; G.iter_children = (fun f x -> Var.Set.iter f deps.(Var.idx x)) }
   in
-  Solver.f () g (propagate deps effectful)
+  Solver.f () (G.invert () g) (propagate deps effectful)
 
 (* let live_instr st i =
    match i with
@@ -149,7 +181,7 @@ let run (p : program) =
       Format.eprintf "}\n")
     deps;
   let pure_funs = Pure_fun.f p in
-  let effs = effectful nv defs pure_funs in
+  let effs = effectful nv p pure_funs in
   (* Print out effectfulness info *)
   Format.eprintf "Effectful:\n";
   Array.iteri (fun i b -> Format.eprintf "%d: %b\n" i b) effs;

From 4a389e37cfd70df8002765746a22a93323dcdb4d Mon Sep 17 00:00:00 2001
From: Micah Cantor <micahcantor01@gmail.com>
Date: Tue, 27 Jun 2023 11:51:53 +0200
Subject: [PATCH 006/112] more updates

---
 compiler/lib/deadcode_dgraph.ml | 43 +++++++++++++++++++--------------
 1 file changed, 25 insertions(+), 18 deletions(-)

diff --git a/compiler/lib/deadcode_dgraph.ml b/compiler/lib/deadcode_dgraph.ml
index 1341074cbe..93ad16e1ee 100644
--- a/compiler/lib/deadcode_dgraph.ml
+++ b/compiler/lib/deadcode_dgraph.ml
@@ -89,29 +89,36 @@ let dependencies nv defs =
     defs;
   deps
 
-let expr_contains_var x e =
-  match e with
-  | Apply { f; args; _ } -> Var.equal x f || List.exists (Var.equal x) args
-  | Block (_, params, _) -> Array.exists (Var.equal x) params
-  | Field (z, _) -> Var.equal x z
-  | Constant _ -> false
-  | Closure (params, _) -> List.exists (Var.equal x) params
+(* Return the set of variables used in a given expression *)
+let expr_vars (e : expr) =
+  let vars = Var.ISet.empty () in
+  (match e with
+  | Apply { f; args; _ } ->
+      Var.ISet.add vars f;
+      List.iter (Var.ISet.add vars) args
+  | Block (_, params, _) -> Array.iter (Var.ISet.add vars) params
+  | Field (z, _) -> Var.ISet.add vars z
+  | Constant _ -> ()
+  | Closure (params, _) -> List.iter (Var.ISet.add vars) params
   | Prim (_, args) ->
-      List.exists
-        (fun arg ->
-          match arg with
-          | Pv v -> Var.equal x v
-          | Pc _ -> false)
-        args
+      List.iter
+        (fun v ->
+          match v with
+          | Pv v -> Var.ISet.add vars v
+          | Pc _ -> ())
+        args);
+  vars
 
 (* Returns a boolean array representing whether each variable appears in an effectful instruction. *)
 let effectful nv prog pure_funs =
   let effs = Array.make nv false in
   let effectful_instruction i =
     match i with
-    | Let (x, e) ->
-        if (not (pure_expr pure_funs e)) && expr_contains_var x e
-        then effs.(Var.idx x) <- true
+    | Let (_, e) ->
+        if not (pure_expr pure_funs e)
+        then
+          let vars = expr_vars e in
+          Var.ISet.iter (fun v -> effs.(Var.idx v) <- true) vars
     | Assign (x, _) -> effs.(Var.idx x) <- true (* TODO: correct? *)
     | _ -> ()
   in
@@ -136,10 +143,10 @@ let effectful nv prog pure_funs =
   Addr.Map.iter (fun _ block -> effectful_block block) prog.blocks;
   effs
 
-(* Returns the set of variables given the adjacency list of variable depencies. *)
+(* Returns the set of variables given the adjacency list of variable dependencies. *)
 let variables deps =
   let vars = Var.ISet.empty () in
-  Array.iter (fun s -> Var.Set.iter (fun v -> Var.ISet.add vars v) s) deps;
+  Array.iteri (fun i _ -> Var.ISet.add vars (Var.of_idx i)) deps;
   vars
 
 (* A variable x is live if either

From f8e73efedb5af34c3ad6312954e74cc36d9d09fa Mon Sep 17 00:00:00 2001
From: Micah Cantor <micahcantor01@gmail.com>
Date: Mon, 3 Jul 2023 16:05:04 +0200
Subject: [PATCH 007/112] initial support for annotating blocks

---
 compiler/lib/deadcode_dgraph.ml | 161 +++++++++++++++++++++-----------
 1 file changed, 104 insertions(+), 57 deletions(-)

diff --git a/compiler/lib/deadcode_dgraph.ml b/compiler/lib/deadcode_dgraph.ml
index 93ad16e1ee..a5713e7ea4 100644
--- a/compiler/lib/deadcode_dgraph.ml
+++ b/compiler/lib/deadcode_dgraph.ml
@@ -17,26 +17,29 @@
  *)
 
 open Code
+open Stdlib
 
 type def =
   | Expr of expr
   | Var of Var.t
 
-(* type state =
-   { blocks : block Addr.Map.t
-   ; live : bool Var.Tbl.t
-   ; defs : def list array
-   ; pure_funs : Var.Set.t
-   } *)
+type live =
+  | Live of IntSet.t
+  | Dead
+
+let live_to_string = function
+  | Live fields ->
+      "live { " ^ IntSet.fold (fun i s -> s ^ Format.sprintf "%d" i) fields "" ^ " }"
+  | Dead -> "dead"
 
 module G = Dgraph.Make_Imperative (Var) (Var.ISet) (Var.Tbl)
 
 module Domain = struct
-  type t = bool
+  type t = live
 
-  let equal = Bool.equal
+  let equal = Poly.( = )
 
-  let bot = false
+  let bot = Dead
 end
 
 module Solver = G.Solver (Domain)
@@ -50,7 +53,7 @@ let definitions nv prog =
   Addr.Map.iter
     (fun _ block ->
       List.iter
-        (fun (i, _) ->
+        ~f:(fun (i, _) ->
           match i with
           | Let (x, e) -> add_def x (Expr e)
           | Assign (x, y) -> add_def x (Var y)
@@ -64,22 +67,23 @@ let dependencies nv defs =
   let deps = Array.make nv Var.Set.empty in
   let add_dep i x = deps.(Var.idx x) <- Var.Set.add (Var.of_idx i) deps.(Var.idx x) in
   Array.iteri (* For each set of definitions *)
-    (fun i ds ->
+    ~f:(fun i ds ->
       List.iter (* For each definition *)
-        (fun d ->
+        ~f:(fun d ->
           match d with
+          (* Add dependencies from definition *)
           | Expr e -> (
               match e with
               | Apply { f; args; _ } ->
                   add_dep i f;
-                  List.iter (add_dep i) args
-              | Block (_, params, _) -> Array.iter (add_dep i) params
+                  List.iter ~f:(add_dep i) args
+              | Block (_, params, _) -> Array.iter ~f:(add_dep i) params
               | Field (z, _) -> add_dep i z
               | Constant _ -> ()
-              | Closure (params, _) -> List.iter (add_dep i) params
+              | Closure (params, _) -> List.iter ~f:(add_dep i) params
               | Prim (_, args) ->
                   List.iter
-                    (fun arg ->
+                    ~f:(fun arg ->
                       match arg with
                       | Pv v -> add_dep i v
                       | Pc _ -> ())
@@ -90,77 +94,120 @@ let dependencies nv defs =
   deps
 
 (* Return the set of variables used in a given expression *)
-let expr_vars (e : expr) =
+let expr_vars e =
   let vars = Var.ISet.empty () in
   (match e with
   | Apply { f; args; _ } ->
       Var.ISet.add vars f;
-      List.iter (Var.ISet.add vars) args
-  | Block (_, params, _) -> Array.iter (Var.ISet.add vars) params
+      List.iter ~f:(Var.ISet.add vars) args
+  | Block (_, params, _) -> Array.iter ~f:(Var.ISet.add vars) params
   | Field (z, _) -> Var.ISet.add vars z
   | Constant _ -> ()
-  | Closure (params, _) -> List.iter (Var.ISet.add vars) params
+  | Closure (params, _) -> List.iter ~f:(Var.ISet.add vars) params
   | Prim (_, args) ->
       List.iter
-        (fun v ->
+        ~f:(fun v ->
           match v with
           | Pv v -> Var.ISet.add vars v
           | Pc _ -> ())
         args);
   vars
 
-(* Returns a boolean array representing whether each variable appears in an effectful instruction. *)
-let effectful nv prog pure_funs =
-  let effs = Array.make nv false in
-  let effectful_instruction i =
+(* Returns a boolean array representing whether each variable either
+   (1) appears in an effectful instruction; or
+   (2) is returned or raised by a function. *)
+let liveness nv prog pure_funs defs =
+  let live_vars = Array.make nv Dead in
+  let add_live v =
+    let idx = Var.idx v in
+    let fields =
+      List.fold_left
+        ~f:(fun acc def ->
+          match def with
+          | Expr (Field (_, i)) -> IntSet.add i acc
+          | _ -> acc)
+        ~init:IntSet.empty
+        defs.(idx)
+    in
+    live_vars.(idx) <- Live fields
+  in
+  let live_instruction i =
     match i with
     | Let (_, e) ->
         if not (pure_expr pure_funs e)
         then
           let vars = expr_vars e in
-          Var.ISet.iter (fun v -> effs.(Var.idx v) <- true) vars
-    | Assign (x, _) -> effs.(Var.idx x) <- true (* TODO: correct? *)
-    | _ -> ()
+          Var.ISet.iter add_live vars
+    | Assign (_, _) -> ()
+    | Set_field (x, _, y) ->
+        add_live x;
+        add_live y
+    | Array_set (x, y, z) ->
+        add_live x;
+        add_live y;
+        add_live z
+    | Offset_ref (x, _) -> add_live x
   in
-  let rec effectful_block block =
-    List.iter (fun (i, _) -> effectful_instruction i) block.body;
+  let rec live_block block =
+    List.iter ~f:(fun (i, _) -> live_instruction i) block.body;
     match fst block.branch with
+    (* Base Cases *)
     | Stop -> ()
-    | Return x | Raise (x, _) -> effs.(Var.idx x) <- true
+    | Return x | Raise (x, _) -> add_live x
+    (* Recursive cases *)
     | Branch cont | Poptrap cont ->
-        effectful_continuation prog cont;
-        effectful_continuation prog cont
+        live_continuation prog cont;
+        live_continuation prog cont
     | Cond (_, cont1, cont2) | Pushtrap (cont1, _, cont2, _) ->
-        effectful_continuation prog cont1;
-        effectful_continuation prog cont2
+        live_continuation prog cont1;
+        live_continuation prog cont2
     | Switch (_, a1, a2) ->
-        Array.iter (fun cont -> effectful_continuation prog cont) a1;
-        Array.iter (fun cont -> effectful_continuation prog cont) a2
-  and effectful_continuation prog ((pc, _) : cont) =
+        Array.iter ~f:(fun cont -> live_continuation prog cont) a1;
+        Array.iter ~f:(fun cont -> live_continuation prog cont) a2
+  and live_continuation prog ((pc, _) : cont) =
     let block = Addr.Map.find pc prog.blocks in
-    effectful_block block
+    live_block block
   in
-  Addr.Map.iter (fun _ block -> effectful_block block) prog.blocks;
-  effs
+  Addr.Map.iter (fun _ block -> live_block block) prog.blocks;
+  live_vars
 
 (* Returns the set of variables given the adjacency list of variable dependencies. *)
 let variables deps =
   let vars = Var.ISet.empty () in
-  Array.iteri (fun i _ -> Var.ISet.add vars (Var.of_idx i)) deps;
+  Array.iteri ~f:(fun i _ -> Var.ISet.add vars (Var.of_idx i)) deps;
   vars
 
 (* A variable x is live if either
-   (1) it appears in an effectful expression; or
-   (2) there exists a live variable y that depends on x. *)
-let propagate deps effectful live x =
+    (1) it appears in an effectful expression;
+    (2) it is returned or raised by a function; or
+    (3) there exists a live variable y that depends on x.
+   The first two conditions are determined by a traversal of the program and given by `live_vars`.
+   The third is determined here by propagating liveness to a variable's dependencies. *)
+
+(* We want to know which fields of x are used
+   Look at definition of y, if y is a field access, then set that field to be live in the block *)
+let propagate deps live_vars live_table x =
   let idx = Var.idx x in
-  effectful.(idx) || Var.Set.exists (fun y -> Var.Tbl.get live y) deps.(idx)
+  let union_deps fields =
+    Var.Set.fold
+      (fun y acc ->
+        match Var.Tbl.get live_table y with
+        | Live y_fields -> IntSet.union acc y_fields
+        | Dead -> acc)
+      deps.(idx)
+      fields
+  in
+  match live_vars.(idx) with
+  | Live fields -> Live (union_deps fields)
+  | Dead ->
+      let fields = union_deps IntSet.empty in
+      if IntSet.is_empty fields then Dead else Live fields
 
-let solver vars deps effectful =
+let solver vars deps live_vars =
   let g =
     { G.domain = vars; G.iter_children = (fun f x -> Var.Set.iter f deps.(Var.idx x)) }
   in
-  Solver.f () (G.invert () g) (propagate deps effectful)
+  Solver.f () (G.invert () g) (propagate deps live_vars)
 
 (* let live_instr st i =
    match i with
@@ -174,7 +221,7 @@ let solver vars deps effectful =
        (* these are impure so always live *)
        true *)
 
-let run (p : program) =
+let run p =
   let nv = Var.count () in
   let blocks = p.blocks in
   let defs = definitions nv p in
@@ -182,19 +229,19 @@ let run (p : program) =
   (* Print out dependency info *)
   Format.eprintf "Dependencies:\n";
   Array.iteri
-    (fun i ds ->
+    ~f:(fun i ds ->
       Format.eprintf "%d: { " i;
       Var.Set.iter (fun d -> Format.eprintf "%a " Var.print d) ds;
       Format.eprintf "}\n")
     deps;
   let pure_funs = Pure_fun.f p in
-  let effs = effectful nv p pure_funs in
-  (* Print out effectfulness info *)
-  Format.eprintf "Effectful:\n";
-  Array.iteri (fun i b -> Format.eprintf "%d: %b\n" i b) effs;
-  let vars = variables deps in
-  let live = solver vars deps effs in
+  let live_vars = liveness nv p pure_funs defs in
   (* Print out liveness info *)
   Format.eprintf "Liveness:\n";
-  Var.Tbl.iter (fun v b -> Format.eprintf "%a: %b\n" Var.print v b) live;
+  Array.iteri ~f:(fun i l -> Format.eprintf "%d: %s\n" i (live_to_string l)) live_vars;
+  let vars = variables deps in
+  let live_table = solver vars deps live_vars in
+  (* After dependency propagation *)
+  Format.eprintf "Liveness with dependencies:\n";
+  Var.Tbl.iter (fun v l -> Format.eprintf "%a: %s\n" Var.print v (live_to_string l)) live_table;
   { p with blocks }, Array.make nv 0

From 7d6e5bf0709fdc2e913d465392afc5b246f8afb6 Mon Sep 17 00:00:00 2001
From: Micah Cantor <micahcantor01@gmail.com>
Date: Tue, 4 Jul 2023 14:12:16 +0200
Subject: [PATCH 008/112] more updates

---
 compiler/lib/deadcode_dgraph.ml | 86 +++++++++++++++++++++------------
 1 file changed, 54 insertions(+), 32 deletions(-)

diff --git a/compiler/lib/deadcode_dgraph.ml b/compiler/lib/deadcode_dgraph.ml
index a5713e7ea4..0aff42795b 100644
--- a/compiler/lib/deadcode_dgraph.ml
+++ b/compiler/lib/deadcode_dgraph.ml
@@ -25,11 +25,13 @@ type def =
 
 type live =
   | Live of IntSet.t
+  | Top
   | Dead
 
 let live_to_string = function
   | Live fields ->
-      "live { " ^ IntSet.fold (fun i s -> s ^ Format.sprintf "%d" i) fields "" ^ " }"
+      "live { " ^ IntSet.fold (fun i s -> s ^ Format.sprintf "%d " i) fields "" ^ "}"
+  | Top -> "top"
   | Dead -> "dead"
 
 module G = Dgraph.Make_Imperative (Var) (Var.ISet) (Var.Tbl)
@@ -116,20 +118,17 @@ let expr_vars e =
 (* Returns a boolean array representing whether each variable either
    (1) appears in an effectful instruction; or
    (2) is returned or raised by a function. *)
-let liveness nv prog pure_funs defs =
+let liveness nv prog pure_funs =
   let live_vars = Array.make nv Dead in
-  let add_live v =
+  let add_top v =
     let idx = Var.idx v in
-    let fields =
-      List.fold_left
-        ~f:(fun acc def ->
-          match def with
-          | Expr (Field (_, i)) -> IntSet.add i acc
-          | _ -> acc)
-        ~init:IntSet.empty
-        defs.(idx)
-    in
-    live_vars.(idx) <- Live fields
+    live_vars.(idx) <- Top
+  in
+  let add_live v i =
+    let idx = Var.idx v in
+    match live_vars.(idx) with
+    | Live fields -> live_vars.(idx) <- Live (IntSet.add i fields)
+    | _ -> live_vars.(idx) <- Live (IntSet.singleton i)
   in
   let live_instruction i =
     match i with
@@ -137,23 +136,24 @@ let liveness nv prog pure_funs defs =
         if not (pure_expr pure_funs e)
         then
           let vars = expr_vars e in
-          Var.ISet.iter add_live vars
+          Var.ISet.iter add_top vars
     | Assign (_, _) -> ()
-    | Set_field (x, _, y) ->
-        add_live x;
-        add_live y
+    (* TODO: what to do with these? *)
+    | Set_field (x, i, y) ->
+        add_live x i;
+        add_top y
     | Array_set (x, y, z) ->
-        add_live x;
-        add_live y;
-        add_live z
-    | Offset_ref (x, _) -> add_live x
+        add_top x;
+        add_top y;
+        add_top z
+    | Offset_ref (x, i) -> add_live x i
   in
   let rec live_block block =
     List.iter ~f:(fun (i, _) -> live_instruction i) block.body;
     match fst block.branch with
     (* Base Cases *)
     | Stop -> ()
-    | Return x | Raise (x, _) -> add_live x
+    | Return x | Raise (x, _) -> add_top x
     (* Recursive cases *)
     | Branch cont | Poptrap cont ->
         live_continuation prog cont;
@@ -184,30 +184,50 @@ let variables deps =
    The first two conditions are determined by a traversal of the program and given by `live_vars`.
    The third is determined here by propagating liveness to a variable's dependencies. *)
 
-(* We want to know which fields of x are used
-   Look at definition of y, if y is a field access, then set that field to be live in the block *)
-let propagate deps live_vars live_table x =
+(* Look at each dependency y of x.
+   - If x is Live fields, then x becomes Live (union_deps fields)
+   - If x is Top, then if union_deps is not empty (some y is Live fields) then x is Live (union_deps empty)
+   - If x is Dead, then if union_deps is empty and all dependencies are dead, x is dead. If a dep
+    is Top then x is Top. *)
+let propagate deps defs live_vars live_table x =
   let idx = Var.idx x in
   let union_deps fields =
     Var.Set.fold
       (fun y acc ->
         match Var.Tbl.get live_table y with
         | Live y_fields -> IntSet.union acc y_fields
-        | Dead -> acc)
+        | Top | Dead ->
+            List.fold_left
+              ~f:(fun acc def ->
+                match def with
+                | Expr (Field (_, i)) -> IntSet.add i acc
+                | _ -> acc)
+              ~init:acc
+              defs.(Var.idx y))
       deps.(idx)
       fields
   in
+  let is_top x =
+    match Var.Tbl.get live_table x with
+    | Top -> true
+    | _ -> false
+  in
   match live_vars.(idx) with
   | Live fields -> Live (union_deps fields)
+  | Top ->
+      let fields = union_deps IntSet.empty in
+      if IntSet.is_empty fields then Top else Live fields
   | Dead ->
       let fields = union_deps IntSet.empty in
-      if IntSet.is_empty fields then Dead else Live fields
+      if IntSet.is_empty fields
+      then if Var.Set.exists is_top deps.(idx) then Top else Dead
+      else Live fields
 
-let solver vars deps live_vars =
+let solver vars deps defs live_vars =
   let g =
     { G.domain = vars; G.iter_children = (fun f x -> Var.Set.iter f deps.(Var.idx x)) }
   in
-  Solver.f () (G.invert () g) (propagate deps live_vars)
+  Solver.f () (G.invert () g) (propagate deps defs live_vars)
 
 (* let live_instr st i =
    match i with
@@ -235,13 +255,15 @@ let run p =
       Format.eprintf "}\n")
     deps;
   let pure_funs = Pure_fun.f p in
-  let live_vars = liveness nv p pure_funs defs in
+  let live_vars = liveness nv p pure_funs in
   (* Print out liveness info *)
   Format.eprintf "Liveness:\n";
   Array.iteri ~f:(fun i l -> Format.eprintf "%d: %s\n" i (live_to_string l)) live_vars;
   let vars = variables deps in
-  let live_table = solver vars deps live_vars in
+  let live_table = solver vars deps defs live_vars in
   (* After dependency propagation *)
   Format.eprintf "Liveness with dependencies:\n";
-  Var.Tbl.iter (fun v l -> Format.eprintf "%a: %s\n" Var.print v (live_to_string l)) live_table;
+  Var.Tbl.iter
+    (fun v l -> Format.eprintf "%a: %s\n" Var.print v (live_to_string l))
+    live_table;
   { p with blocks }, Array.make nv 0

From e42a15b4a5cefb354b34822f98505c51cd8f9d87 Mon Sep 17 00:00:00 2001
From: Micah Cantor <micahcantor01@gmail.com>
Date: Tue, 4 Jul 2023 16:14:31 +0200
Subject: [PATCH 009/112] join propagation

---
 compiler/lib/deadcode_dgraph.ml | 77 +++++++++++++--------------------
 1 file changed, 30 insertions(+), 47 deletions(-)

diff --git a/compiler/lib/deadcode_dgraph.ml b/compiler/lib/deadcode_dgraph.ml
index 0aff42795b..b56af22f94 100644
--- a/compiler/lib/deadcode_dgraph.ml
+++ b/compiler/lib/deadcode_dgraph.ml
@@ -60,7 +60,16 @@ let definitions nv prog =
           | Let (x, e) -> add_def x (Expr e)
           | Assign (x, y) -> add_def x (Var y)
           | _ -> ())
-        block.body)
+        block.body;
+      match fst block.branch with
+      | Return _ -> _
+      | Raise (_, _) -> _
+      | Stop -> _
+      | Branch _ -> _
+      | Cond (_, _, _) -> _
+      | Switch (_, _, _) -> _
+      | Pushtrap (_, _, _, _) -> _
+      | Poptrap _ -> _)
     prog.blocks;
   defs
 
@@ -184,44 +193,30 @@ let variables deps =
    The first two conditions are determined by a traversal of the program and given by `live_vars`.
    The third is determined here by propagating liveness to a variable's dependencies. *)
 
-(* Look at each dependency y of x.
-   - If x is Live fields, then x becomes Live (union_deps fields)
-   - If x is Top, then if union_deps is not empty (some y is Live fields) then x is Live (union_deps empty)
-   - If x is Dead, then if union_deps is empty and all dependencies are dead, x is dead. If a dep
-    is Top then x is Top. *)
+(* Look at all the places that x is used (deps.(Var.idx x))
+   If that variable y is...
+    - Live or Top and it is a field access, add i to fields(x)
+    - Dead, then do nothing *)
 let propagate deps defs live_vars live_table x =
   let idx = Var.idx x in
-  let union_deps fields =
-    Var.Set.fold
-      (fun y acc ->
-        match Var.Tbl.get live_table y with
-        | Live y_fields -> IntSet.union acc y_fields
-        | Top | Dead ->
-            List.fold_left
-              ~f:(fun acc def ->
-                match def with
-                | Expr (Field (_, i)) -> IntSet.add i acc
-                | _ -> acc)
-              ~init:acc
-              defs.(Var.idx y))
-      deps.(idx)
-      fields
+  let join l1 l2 =
+    match l1, l2 with
+    | _, Top | Top, _ -> Top
+    | Live f1, Live f2 -> Live (IntSet.union f1 f2)
+    | Dead, Live f | Live f, Dead -> Live f
+    | Dead, Dead -> Dead
   in
-  let is_top x =
-    match Var.Tbl.get live_table x with
-    | Top -> true
-    | _ -> false
+  let contribution y =
+    List.fold_left
+      ~f:(fun acc def ->
+        match def with
+        | Expr (Field (_, i)) -> join acc (Live (IntSet.singleton i))
+        | Var z -> join acc (Var.Tbl.get live_table z)
+        | _ -> join acc Top)
+      ~init:Dead
+      defs.(Var.idx y)
   in
-  match live_vars.(idx) with
-  | Live fields -> Live (union_deps fields)
-  | Top ->
-      let fields = union_deps IntSet.empty in
-      if IntSet.is_empty fields then Top else Live fields
-  | Dead ->
-      let fields = union_deps IntSet.empty in
-      if IntSet.is_empty fields
-      then if Var.Set.exists is_top deps.(idx) then Top else Dead
-      else Live fields
+  Var.Set.fold (fun y live -> join (contribution y) live) deps.(idx) live_vars.(idx)
 
 let solver vars deps defs live_vars =
   let g =
@@ -229,18 +224,6 @@ let solver vars deps defs live_vars =
   in
   Solver.f () (G.invert () g) (propagate deps defs live_vars)
 
-(* let live_instr st i =
-   match i with
-   | Let (x, e) ->
-       (* variable has been marked as live or the expression is impure *)
-       Var.Tbl.get st.live x || not (pure_expr st.pure_funs e)
-   | Assign (x, _) ->
-       (* variable has been marked as live *)
-       Var.Tbl.get st.live x
-   | Set_field _ | Offset_ref _ | Array_set _ ->
-       (* these are impure so always live *)
-       true *)
-
 let run p =
   let nv = Var.count () in
   let blocks = p.blocks in

From a37fa061bebde4253ea8e7e21010fcff28270003 Mon Sep 17 00:00:00 2001
From: Micah Cantor <micahcantor01@gmail.com>
Date: Tue, 4 Jul 2023 16:15:05 +0200
Subject: [PATCH 010/112] remove old comments

---
 compiler/lib/deadcode_dgraph.ml | 11 -----------
 1 file changed, 11 deletions(-)

diff --git a/compiler/lib/deadcode_dgraph.ml b/compiler/lib/deadcode_dgraph.ml
index b56af22f94..5661548cdf 100644
--- a/compiler/lib/deadcode_dgraph.ml
+++ b/compiler/lib/deadcode_dgraph.ml
@@ -186,17 +186,6 @@ let variables deps =
   Array.iteri ~f:(fun i _ -> Var.ISet.add vars (Var.of_idx i)) deps;
   vars
 
-(* A variable x is live if either
-    (1) it appears in an effectful expression;
-    (2) it is returned or raised by a function; or
-    (3) there exists a live variable y that depends on x.
-   The first two conditions are determined by a traversal of the program and given by `live_vars`.
-   The third is determined here by propagating liveness to a variable's dependencies. *)
-
-(* Look at all the places that x is used (deps.(Var.idx x))
-   If that variable y is...
-    - Live or Top and it is a field access, add i to fields(x)
-    - Dead, then do nothing *)
 let propagate deps defs live_vars live_table x =
   let idx = Var.idx x in
   let join l1 l2 =

From 647d6953e9343f8650c666b09c93b61ca53e370d Mon Sep 17 00:00:00 2001
From: Micah Cantor <micahcantor01@gmail.com>
Date: Tue, 4 Jul 2023 17:16:42 +0200
Subject: [PATCH 011/112] add block param defs

---
 compiler/lib/deadcode_dgraph.ml | 37 +++++++++++++++++++++++----------
 1 file changed, 26 insertions(+), 11 deletions(-)

diff --git a/compiler/lib/deadcode_dgraph.ml b/compiler/lib/deadcode_dgraph.ml
index 5661548cdf..3de9f0fa6d 100644
--- a/compiler/lib/deadcode_dgraph.ml
+++ b/compiler/lib/deadcode_dgraph.ml
@@ -52,8 +52,21 @@ let pure_expr pure_funs e = Pure_fun.pure_expr pure_funs e && Config.Flag.deadco
 let definitions nv prog =
   let defs = Array.make nv [] in
   let add_def x d = defs.(Var.idx x) <- d :: defs.(Var.idx x) in
+  let rec add_arg_def params args =
+    match params, args with
+    | x :: params, y :: args ->
+        add_def x (Var y);
+        add_arg_def params args
+    | _ -> ()
+  in
+  let add_cont_defs (pc, args) =
+    match try Some (Addr.Map.find pc prog.blocks) with Not_found -> None with
+    | Some block -> add_arg_def block.params args
+    | None -> () (* Dead continuation *)
+  in
   Addr.Map.iter
     (fun _ block ->
+      (* Add definitions from block body *)
       List.iter
         ~f:(fun (i, _) ->
           match i with
@@ -61,15 +74,20 @@ let definitions nv prog =
           | Assign (x, y) -> add_def x (Var y)
           | _ -> ())
         block.body;
+      (* Add definitions for block parameters *)
       match fst block.branch with
-      | Return _ -> _
-      | Raise (_, _) -> _
-      | Stop -> _
-      | Branch _ -> _
-      | Cond (_, _, _) -> _
-      | Switch (_, _, _) -> _
-      | Pushtrap (_, _, _, _) -> _
-      | Poptrap _ -> _)
+      | Return _ | Raise _ | Stop -> ()
+      | Branch cont -> add_cont_defs cont
+      | Cond (_, cont1, cont2) ->
+          add_cont_defs cont1;
+          add_cont_defs cont2
+      | Switch (_, a1, a2) ->
+          Array.iter ~f:add_cont_defs a1;
+          Array.iter ~f:add_cont_defs a2
+      | Pushtrap (cont, _, cont_h, _) ->
+          add_cont_defs cont;
+          add_cont_defs cont_h
+      | Poptrap cont -> add_cont_defs cont)
     prog.blocks;
   defs
 
@@ -124,9 +142,6 @@ let expr_vars e =
         args);
   vars
 
-(* Returns a boolean array representing whether each variable either
-   (1) appears in an effectful instruction; or
-   (2) is returned or raised by a function. *)
 let liveness nv prog pure_funs =
   let live_vars = Array.make nv Dead in
   let add_top v =

From ccc5dd59334fbc65a64d229ec9fca960394c7f04 Mon Sep 17 00:00:00 2001
From: Micah Cantor <micahcantor01@gmail.com>
Date: Wed, 5 Jul 2023 15:41:53 +0200
Subject: [PATCH 012/112] fix equality, dep contribution

---
 compiler/lib/deadcode_dgraph.ml | 59 +++++++++++++++++++++------------
 1 file changed, 38 insertions(+), 21 deletions(-)

diff --git a/compiler/lib/deadcode_dgraph.ml b/compiler/lib/deadcode_dgraph.ml
index 3de9f0fa6d..ab6aa6d2bc 100644
--- a/compiler/lib/deadcode_dgraph.ml
+++ b/compiler/lib/deadcode_dgraph.ml
@@ -24,8 +24,8 @@ type def =
   | Var of Var.t
 
 type live =
-  | Live of IntSet.t
   | Top
+  | Live of IntSet.t
   | Dead
 
 let live_to_string = function
@@ -39,9 +39,20 @@ module G = Dgraph.Make_Imperative (Var) (Var.ISet) (Var.Tbl)
 module Domain = struct
   type t = live
 
-  let equal = Poly.( = )
+  let equal l1 l2 =
+    match l1, l2 with
+    | Top, Top | Dead, Dead -> true
+    | Live l1, Live l2 -> IntSet.equal l1 l2
+    | _ -> false
 
   let bot = Dead
+
+  let join l1 l2 =
+    match l1, l2 with
+    | _, Top | Top, _ -> Top
+    | Live f1, Live f2 -> Live (IntSet.union f1 f2)
+    | Dead, Live f | Live f, Dead -> Live f
+    | Dead, Dead -> Dead
 end
 
 module Solver = G.Solver (Domain)
@@ -49,15 +60,13 @@ module Solver = G.Solver (Domain)
 let pure_expr pure_funs e = Pure_fun.pure_expr pure_funs e && Config.Flag.deadcode ()
 
 (* Returns an array of definitions of each variable *)
+(* TODO: Change this to return def array instead of def list array *)
 let definitions nv prog =
   let defs = Array.make nv [] in
   let add_def x d = defs.(Var.idx x) <- d :: defs.(Var.idx x) in
-  let rec add_arg_def params args =
-    match params, args with
-    | x :: params, y :: args ->
-        add_def x (Var y);
-        add_arg_def params args
-    | _ -> ()
+  let add_arg_def params args =
+    try List.iter2 ~f:(fun x y -> add_def x (Var y)) params args
+    with Invalid_argument _ -> ()
   in
   let add_cont_defs (pc, args) =
     match try Some (Addr.Map.find pc prog.blocks) with Not_found -> None with
@@ -203,24 +212,20 @@ let variables deps =
 
 let propagate deps defs live_vars live_table x =
   let idx = Var.idx x in
-  let join l1 l2 =
-    match l1, l2 with
-    | _, Top | Top, _ -> Top
-    | Live f1, Live f2 -> Live (IntSet.union f1 f2)
-    | Dead, Live f | Live f, Dead -> Live f
-    | Dead, Dead -> Dead
-  in
   let contribution y =
     List.fold_left
       ~f:(fun acc def ->
         match def with
-        | Expr (Field (_, i)) -> join acc (Live (IntSet.singleton i))
-        | Var z -> join acc (Var.Tbl.get live_table z)
-        | _ -> join acc Top)
+        | Expr (Field (_, i)) -> Domain.join acc (Live (IntSet.singleton i))
+        | Var _ -> Domain.join acc (Var.Tbl.get live_table y)
+        | _ -> Top)
       ~init:Dead
       defs.(Var.idx y)
   in
-  Var.Set.fold (fun y live -> join (contribution y) live) deps.(idx) live_vars.(idx)
+  Var.Set.fold
+    (fun y live -> Domain.join (contribution y) live)
+    deps.(idx)
+    live_vars.(idx)
 
 let solver vars deps defs live_vars =
   let g =
@@ -232,12 +237,24 @@ let run p =
   let nv = Var.count () in
   let blocks = p.blocks in
   let defs = definitions nv p in
+  (* Print out definitions *)
+  Format.eprintf "Definitions:\n";
+  Array.iteri
+    ~f:(fun i defs ->
+      Format.eprintf "v%d: { " i;
+      List.iter
+        ~f:(function
+          | Expr e -> Format.eprintf "%a " Print.expr e
+          | Var y -> Format.eprintf "%a " Var.print y)
+        defs;
+      Format.eprintf "}\n")
+    defs;
   let deps = dependencies nv defs in
   (* Print out dependency info *)
   Format.eprintf "Dependencies:\n";
   Array.iteri
     ~f:(fun i ds ->
-      Format.eprintf "%d: { " i;
+      Format.eprintf "v%d: { " i;
       Var.Set.iter (fun d -> Format.eprintf "%a " Var.print d) ds;
       Format.eprintf "}\n")
     deps;
@@ -245,7 +262,7 @@ let run p =
   let live_vars = liveness nv p pure_funs in
   (* Print out liveness info *)
   Format.eprintf "Liveness:\n";
-  Array.iteri ~f:(fun i l -> Format.eprintf "%d: %s\n" i (live_to_string l)) live_vars;
+  Array.iteri ~f:(fun i l -> Format.eprintf "v%d: %s\n" i (live_to_string l)) live_vars;
   let vars = variables deps in
   let live_table = solver vars deps defs live_vars in
   (* After dependency propagation *)

From cacad1d76df24fcc2abb55fe689ae6e218d4bfe3 Mon Sep 17 00:00:00 2001
From: Micah Cantor <micahcantor01@gmail.com>
Date: Wed, 5 Jul 2023 16:37:13 +0200
Subject: [PATCH 013/112] move some logic from defs to deps

---
 compiler/lib/deadcode_dgraph.ml | 156 ++++++++++++++++----------------
 1 file changed, 76 insertions(+), 80 deletions(-)

diff --git a/compiler/lib/deadcode_dgraph.ml b/compiler/lib/deadcode_dgraph.ml
index ab6aa6d2bc..0eb8c068b4 100644
--- a/compiler/lib/deadcode_dgraph.ml
+++ b/compiler/lib/deadcode_dgraph.ml
@@ -21,7 +21,7 @@ open Stdlib
 
 type def =
   | Expr of expr
-  | Var of Var.t
+  | Param
 
 type live =
   | Top
@@ -59,77 +59,76 @@ module Solver = G.Solver (Domain)
 
 let pure_expr pure_funs e = Pure_fun.pure_expr pure_funs e && Config.Flag.deadcode ()
 
-(* Returns an array of definitions of each variable *)
-(* TODO: Change this to return def array instead of def list array *)
 let definitions nv prog =
-  let defs = Array.make nv [] in
-  let add_def x d = defs.(Var.idx x) <- d :: defs.(Var.idx x) in
-  let add_arg_def params args =
-    try List.iter2 ~f:(fun x y -> add_def x (Var y)) params args
-    with Invalid_argument _ -> ()
+  let defs = Array.make nv Param in
+  let set_def x d = defs.(Var.idx x) <- d in
+  Addr.Map.iter
+    (fun _ block ->
+      (* Add defs/deps from block body *)
+      List.iter
+        ~f:(fun (i, _) ->
+          match i with
+          | Let (x, e) -> set_def x (Expr e)
+          | Assign (x, _) -> set_def x Param
+          | _ -> ())
+        block.body)
+    prog.blocks;
+  defs
+
+let usages nv prog =
+  let uses = Array.make nv Var.Set.empty in
+  let add_use x y = uses.(Var.idx y) <- Var.Set.add x uses.(Var.idx y) in
+  let add_arg_dep params args =
+    try List.iter2 ~f:(fun x y -> add_use x y) params args with Invalid_argument _ -> ()
   in
-  let add_cont_defs (pc, args) =
+  let add_cont_deps (pc, args) =
     match try Some (Addr.Map.find pc prog.blocks) with Not_found -> None with
-    | Some block -> add_arg_def block.params args
+    | Some block -> add_arg_dep block.params args
     | None -> () (* Dead continuation *)
   in
+  let add_expr_uses x e =
+    match e with
+    | Apply { f; args; _ } ->
+        add_use x f;
+        List.iter ~f:(add_use x) args
+    | Block (_, params, _) -> Array.iter ~f:(add_use x) params
+    | Field (z, _) -> add_use x z
+    | Constant _ -> ()
+    | Closure (params, _) -> List.iter ~f:(add_use x) params
+    | Prim (_, args) ->
+        List.iter
+          ~f:(fun arg ->
+            match arg with
+            | Pv v -> add_use x v
+            | Pc _ -> ())
+          args
+  in
   Addr.Map.iter
     (fun _ block ->
-      (* Add definitions from block body *)
+      (* Add deps from block body *)
       List.iter
         ~f:(fun (i, _) ->
           match i with
-          | Let (x, e) -> add_def x (Expr e)
-          | Assign (x, y) -> add_def x (Var y)
+          | Let (x, e) -> add_expr_uses x e
+          | Assign (x, y) -> add_use x y
           | _ -> ())
         block.body;
-      (* Add definitions for block parameters *)
+      (* Add deps from block branch *)
       match fst block.branch with
       | Return _ | Raise _ | Stop -> ()
-      | Branch cont -> add_cont_defs cont
+      | Branch cont -> add_cont_deps cont
       | Cond (_, cont1, cont2) ->
-          add_cont_defs cont1;
-          add_cont_defs cont2
+          add_cont_deps cont1;
+          add_cont_deps cont2
       | Switch (_, a1, a2) ->
-          Array.iter ~f:add_cont_defs a1;
-          Array.iter ~f:add_cont_defs a2
+          Array.iter ~f:add_cont_deps a1;
+          Array.iter ~f:add_cont_deps a2
       | Pushtrap (cont, _, cont_h, _) ->
-          add_cont_defs cont;
-          add_cont_defs cont_h
-      | Poptrap cont -> add_cont_defs cont)
+          add_cont_deps cont;
+          add_cont_deps cont_h
+      | Poptrap cont -> add_cont_deps cont)
     prog.blocks;
-  defs
-
-(* Returns the adjacency list for the variable dependency graph. *)
-let dependencies nv defs =
-  let deps = Array.make nv Var.Set.empty in
-  let add_dep i x = deps.(Var.idx x) <- Var.Set.add (Var.of_idx i) deps.(Var.idx x) in
-  Array.iteri (* For each set of definitions *)
-    ~f:(fun i ds ->
-      List.iter (* For each definition *)
-        ~f:(fun d ->
-          match d with
-          (* Add dependencies from definition *)
-          | Expr e -> (
-              match e with
-              | Apply { f; args; _ } ->
-                  add_dep i f;
-                  List.iter ~f:(add_dep i) args
-              | Block (_, params, _) -> Array.iter ~f:(add_dep i) params
-              | Field (z, _) -> add_dep i z
-              | Constant _ -> ()
-              | Closure (params, _) -> List.iter ~f:(add_dep i) params
-              | Prim (_, args) ->
-                  List.iter
-                    ~f:(fun arg ->
-                      match arg with
-                      | Pv v -> add_dep i v
-                      | Pc _ -> ())
-                    args)
-          | Var y -> add_dep i y)
-        ds)
-    defs;
-  deps
+  uses
 
 (* Return the set of variables used in a given expression *)
 let expr_vars e =
@@ -210,28 +209,27 @@ let variables deps =
   Array.iteri ~f:(fun i _ -> Var.ISet.add vars (Var.of_idx i)) deps;
   vars
 
-let propagate deps defs live_vars live_table x =
+let propagate uses defs live_vars live_table x =
   let idx = Var.idx x in
   let contribution y =
-    List.fold_left
-      ~f:(fun acc def ->
-        match def with
-        | Expr (Field (_, i)) -> Domain.join acc (Live (IntSet.singleton i))
-        | Var _ -> Domain.join acc (Var.Tbl.get live_table y)
+    match Var.Tbl.get live_table y with
+    | Dead -> Dead
+    | _ -> (
+        match defs.(Var.idx y) with
+        | Expr (Field (_, i)) -> Live (IntSet.singleton i)
+        | Param -> Var.Tbl.get live_table y
         | _ -> Top)
-      ~init:Dead
-      defs.(Var.idx y)
   in
   Var.Set.fold
     (fun y live -> Domain.join (contribution y) live)
-    deps.(idx)
+    uses.(idx)
     live_vars.(idx)
 
-let solver vars deps defs live_vars =
+let solver vars uses defs live_vars =
   let g =
-    { G.domain = vars; G.iter_children = (fun f x -> Var.Set.iter f deps.(Var.idx x)) }
+    { G.domain = vars; G.iter_children = (fun f x -> Var.Set.iter f uses.(Var.idx x)) }
   in
-  Solver.f () (G.invert () g) (propagate deps defs live_vars)
+  Solver.f () (G.invert () g) (propagate uses defs live_vars)
 
 let run p =
   let nv = Var.count () in
@@ -240,31 +238,29 @@ let run p =
   (* Print out definitions *)
   Format.eprintf "Definitions:\n";
   Array.iteri
-    ~f:(fun i defs ->
-      Format.eprintf "v%d: { " i;
-      List.iter
-        ~f:(function
-          | Expr e -> Format.eprintf "%a " Print.expr e
-          | Var y -> Format.eprintf "%a " Var.print y)
-        defs;
-      Format.eprintf "}\n")
+    ~f:(fun i def ->
+      Format.eprintf "v%d: " i;
+      (match def with
+      | Expr e -> Format.eprintf "%a " Print.expr e
+      | Param -> Format.eprintf "param");
+      Format.eprintf "\n")
     defs;
-  let deps = dependencies nv defs in
-  (* Print out dependency info *)
-  Format.eprintf "Dependencies:\n";
+  (* Print out usage info *)
+  let uses = usages nv p in
+  Format.eprintf "Usages:\n";
   Array.iteri
     ~f:(fun i ds ->
       Format.eprintf "v%d: { " i;
       Var.Set.iter (fun d -> Format.eprintf "%a " Var.print d) ds;
       Format.eprintf "}\n")
-    deps;
+    uses;
   let pure_funs = Pure_fun.f p in
   let live_vars = liveness nv p pure_funs in
   (* Print out liveness info *)
   Format.eprintf "Liveness:\n";
   Array.iteri ~f:(fun i l -> Format.eprintf "v%d: %s\n" i (live_to_string l)) live_vars;
-  let vars = variables deps in
-  let live_table = solver vars deps defs live_vars in
+  let vars = variables uses in
+  let live_table = solver vars uses defs live_vars in
   (* After dependency propagation *)
   Format.eprintf "Liveness with dependencies:\n";
   Var.Tbl.iter

From 3b7e81138761699b232c959a259490e73b4d69a5 Mon Sep 17 00:00:00 2001
From: Micah Cantor <micahcantor01@gmail.com>
Date: Thu, 6 Jul 2023 12:41:11 +0200
Subject: [PATCH 014/112] clean up small bugs

---
 compiler/lib/deadcode_dgraph.ml | 15 +++++++++------
 1 file changed, 9 insertions(+), 6 deletions(-)

diff --git a/compiler/lib/deadcode_dgraph.ml b/compiler/lib/deadcode_dgraph.ml
index 0eb8c068b4..68d5e0b2fd 100644
--- a/compiler/lib/deadcode_dgraph.ml
+++ b/compiler/lib/deadcode_dgraph.ml
@@ -64,7 +64,7 @@ let definitions nv prog =
   let set_def x d = defs.(Var.idx x) <- d in
   Addr.Map.iter
     (fun _ block ->
-      (* Add defs/deps from block body *)
+      (* Add defs from block body *)
       List.iter
         ~f:(fun (i, _) ->
           match i with
@@ -111,7 +111,8 @@ let usages nv prog =
           match i with
           | Let (x, e) -> add_expr_uses x e
           | Assign (x, y) -> add_use x y
-          | _ -> ())
+          (* TODO: These? *)
+          | Set_field (_, _, _) | Offset_ref (_, _) | Array_set (_, _, _) -> ())
         block.body;
       (* Add deps from block branch *)
       match fst block.branch with
@@ -164,11 +165,12 @@ let liveness nv prog pure_funs =
   in
   let live_instruction i =
     match i with
-    | Let (_, e) ->
+    | Let (x, e) ->
         if not (pure_expr pure_funs e)
-        then
+        then (
           let vars = expr_vars e in
-          Var.ISet.iter add_top vars
+          Var.ISet.iter add_top vars;
+          add_top x)
     | Assign (_, _) -> ()
     (* TODO: what to do with these? *)
     | Set_field (x, i, y) ->
@@ -213,8 +215,9 @@ let propagate uses defs live_vars live_table x =
   let idx = Var.idx x in
   let contribution y =
     match Var.Tbl.get live_table y with
-    | Dead -> Dead
+    | Dead -> Dead (* If x is used in y, and y is dead, then x is dead. *)
     | _ -> (
+        (* Otherwise we may be able to refine y's liveness. *)
         match defs.(Var.idx y) with
         | Expr (Field (_, i)) -> Live (IntSet.singleton i)
         | Param -> Var.Tbl.get live_table y

From 85ed6aed7026a2b8fa01e2f182ae7470d87bdb2c Mon Sep 17 00:00:00 2001
From: Micah Cantor <micahcantor01@gmail.com>
Date: Thu, 6 Jul 2023 14:33:01 +0200
Subject: [PATCH 015/112] don't count closure params as used

---
 compiler/lib/deadcode_dgraph.ml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/compiler/lib/deadcode_dgraph.ml b/compiler/lib/deadcode_dgraph.ml
index 68d5e0b2fd..33f7f0a3b9 100644
--- a/compiler/lib/deadcode_dgraph.ml
+++ b/compiler/lib/deadcode_dgraph.ml
@@ -94,7 +94,7 @@ let usages nv prog =
     | Block (_, params, _) -> Array.iter ~f:(add_use x) params
     | Field (z, _) -> add_use x z
     | Constant _ -> ()
-    | Closure (params, _) -> List.iter ~f:(add_use x) params
+    | Closure (_, cont) -> add_cont_deps cont
     | Prim (_, args) ->
         List.iter
           ~f:(fun arg ->

From eb7c895ed959efec6c10ff903087026b49b97919 Mon Sep 17 00:00:00 2001
From: Micah Cantor <micahcantor01@gmail.com>
Date: Fri, 7 Jul 2023 14:56:35 +0200
Subject: [PATCH 016/112] add initial elimination alg

---
 compiler/lib/deadcode_dgraph.ml | 134 +++++++++++++++++++++++++-------
 1 file changed, 104 insertions(+), 30 deletions(-)

diff --git a/compiler/lib/deadcode_dgraph.ml b/compiler/lib/deadcode_dgraph.ml
index 33f7f0a3b9..35014e3543 100644
--- a/compiler/lib/deadcode_dgraph.ml
+++ b/compiler/lib/deadcode_dgraph.ml
@@ -42,7 +42,7 @@ module Domain = struct
   let equal l1 l2 =
     match l1, l2 with
     | Top, Top | Dead, Dead -> true
-    | Live l1, Live l2 -> IntSet.equal l1 l2
+    | Live f1, Live f2 -> IntSet.equal f1 f2
     | _ -> false
 
   let bot = Dead
@@ -216,7 +216,7 @@ let propagate uses defs live_vars live_table x =
   let contribution y =
     match Var.Tbl.get live_table y with
     | Dead -> Dead (* If x is used in y, and y is dead, then x is dead. *)
-    | _ -> (
+    | Top | Live _ -> (
         (* Otherwise we may be able to refine y's liveness. *)
         match defs.(Var.idx y) with
         | Expr (Field (_, i)) -> Live (IntSet.singleton i)
@@ -234,39 +234,113 @@ let solver vars uses defs live_vars =
   in
   Solver.f () (G.invert () g) (propagate uses defs live_vars)
 
-let run p =
+let eliminate (prog : program) (live_table : live Var.Tbl.t) : program =
+  let is_live v =
+    match Var.Tbl.get live_table v with
+    | Dead -> false
+    | _ -> true
+  in
+  let eliminate_cont ((pc, params) : cont) =
+    let params = List.filter ~f:is_live params in
+    pc, params
+  in
+  let update_block block =
+    let params = List.filter ~f:is_live block.params in
+    (* Analyze block instructions *)
+    let body =
+      List.filter_map
+        ~f:(fun (instr, loc) ->
+          match instr with
+          | Let (x, e) -> (
+              match Var.Tbl.get live_table x with
+              | Top -> Some (instr, loc)
+              | Live fields -> (
+                  match e with
+                  (* Eliminate unused fields from block *)
+                  | Block (start, vars, is_array) ->
+                      let used_vars =
+                        Array.to_list vars
+                        |> List.filteri ~f:(fun i _ -> IntSet.mem i fields)
+                        |> Array.of_list
+                      in
+                      let e = Block (start, used_vars, is_array) in
+                      Some (Let (x, e), loc)
+                  (* This should never happen *)
+                  | _ -> Some (instr, loc))
+              | Dead -> None)
+          (* TODO: These? *)
+          | Assign (_, _) | Set_field (_, _, _) | Offset_ref (_, _) | Array_set (_, _, _)
+            -> Some (instr, loc))
+        block.body
+    in
+    (* Analyze branch *)
+    let branch =
+      let last, loc = block.branch in
+      let last =
+        match last with
+        | Return _ | Raise (_, _) | Stop -> last
+        | Branch cont -> Branch (eliminate_cont cont)
+        | Cond (x, cont1, cont2) -> Cond (x, eliminate_cont cont1, eliminate_cont cont2)
+        | Switch (x, a1, a2) ->
+            Switch (x, Array.map ~f:eliminate_cont a1, Array.map ~f:eliminate_cont a2)
+        | Pushtrap (cont1, x, cont2, pcs) ->
+            Pushtrap (eliminate_cont cont1, x, eliminate_cont cont2, pcs)
+        | Poptrap cont -> Poptrap (eliminate_cont cont)
+      in
+      last, loc
+    in
+    { params; body; branch }
+  in
+  let blocks = Addr.Map.map update_block prog.blocks in
+  { prog with blocks }
+
+module Debug = struct
+  let print_defs defs =
+    Format.eprintf "Definitions:\n";
+    Array.iteri
+      ~f:(fun i def ->
+        Format.eprintf "v%d: " i;
+        (match def with
+        | Expr e -> Format.eprintf "%a " Print.expr e
+        | Param -> Format.eprintf "param");
+        Format.eprintf "\n")
+      defs
+
+  let print_uses uses =
+    Format.eprintf "Usages:\n";
+    Array.iteri
+      ~f:(fun i ds ->
+        Format.eprintf "v%d: { " i;
+        Var.Set.iter (fun d -> Format.eprintf "%a " Var.print d) ds;
+        Format.eprintf "}\n")
+      uses
+
+  let print_liveness live_vars =
+    Format.eprintf "Liveness:\n";
+    Array.iteri ~f:(fun i l -> Format.eprintf "v%d: %s\n" i (live_to_string l)) live_vars
+
+  let print_live_tbl live_table =
+    Format.eprintf "Liveness with dependencies:\n";
+    Var.Tbl.iter
+      (fun v l -> Format.eprintf "%a: %s\n" Var.print v (live_to_string l))
+      live_table
+end
+
+let f p =
   let nv = Var.count () in
-  let blocks = p.blocks in
+  (* Compute definitions *)
   let defs = definitions nv p in
-  (* Print out definitions *)
-  Format.eprintf "Definitions:\n";
-  Array.iteri
-    ~f:(fun i def ->
-      Format.eprintf "v%d: " i;
-      (match def with
-      | Expr e -> Format.eprintf "%a " Print.expr e
-      | Param -> Format.eprintf "param");
-      Format.eprintf "\n")
-    defs;
-  (* Print out usage info *)
+  Debug.print_defs defs;
+  (* Compute usages *)
   let uses = usages nv p in
-  Format.eprintf "Usages:\n";
-  Array.iteri
-    ~f:(fun i ds ->
-      Format.eprintf "v%d: { " i;
-      Var.Set.iter (fun d -> Format.eprintf "%a " Var.print d) ds;
-      Format.eprintf "}\n")
-    uses;
+  Debug.print_uses uses;
+  (* Compute initial liveness *)
   let pure_funs = Pure_fun.f p in
   let live_vars = liveness nv p pure_funs in
-  (* Print out liveness info *)
-  Format.eprintf "Liveness:\n";
-  Array.iteri ~f:(fun i l -> Format.eprintf "v%d: %s\n" i (live_to_string l)) live_vars;
+  Debug.print_liveness live_vars;
+  (* Propagate liveness to dependencies *)
   let vars = variables uses in
   let live_table = solver vars uses defs live_vars in
+  Debug.print_live_tbl live_table;
   (* After dependency propagation *)
-  Format.eprintf "Liveness with dependencies:\n";
-  Var.Tbl.iter
-    (fun v l -> Format.eprintf "%a: %s\n" Var.print v (live_to_string l))
-    live_table;
-  { p with blocks }, Array.make nv 0
+  eliminate p live_table

From 20ca40da7a8794d130986b1729ccbb67a5b54089 Mon Sep 17 00:00:00 2001
From: Micah Cantor <micahcantor01@gmail.com>
Date: Fri, 7 Jul 2023 17:07:16 +0200
Subject: [PATCH 017/112] rearranging

---
 compiler/lib/deadcode_dgraph.ml | 25 +++++++++++++------------
 1 file changed, 13 insertions(+), 12 deletions(-)

diff --git a/compiler/lib/deadcode_dgraph.ml b/compiler/lib/deadcode_dgraph.ml
index 35014e3543..1e1490d888 100644
--- a/compiler/lib/deadcode_dgraph.ml
+++ b/compiler/lib/deadcode_dgraph.ml
@@ -28,12 +28,6 @@ type live =
   | Live of IntSet.t
   | Dead
 
-let live_to_string = function
-  | Live fields ->
-      "live { " ^ IntSet.fold (fun i s -> s ^ Format.sprintf "%d " i) fields "" ^ "}"
-  | Top -> "top"
-  | Dead -> "dead"
-
 module G = Dgraph.Make_Imperative (Var) (Var.ISet) (Var.Tbl)
 
 module Domain = struct
@@ -293,8 +287,15 @@ let eliminate (prog : program) (live_table : live Var.Tbl.t) : program =
   in
   let blocks = Addr.Map.map update_block prog.blocks in
   { prog with blocks }
+  
+(* 
+module Print = struct
+  let live_to_string = function
+    | Live fields ->
+        "live { " ^ IntSet.fold (fun i s -> s ^ Format.sprintf "%d " i) fields "" ^ "}"
+    | Top -> "top"
+    | Dead -> "dead"
 
-module Debug = struct
   let print_defs defs =
     Format.eprintf "Definitions:\n";
     Array.iteri
@@ -325,22 +326,22 @@ module Debug = struct
       (fun v l -> Format.eprintf "%a: %s\n" Var.print v (live_to_string l))
       live_table
 end
-
+ *)
 let f p =
   let nv = Var.count () in
   (* Compute definitions *)
   let defs = definitions nv p in
-  Debug.print_defs defs;
   (* Compute usages *)
   let uses = usages nv p in
-  Debug.print_uses uses;
   (* Compute initial liveness *)
   let pure_funs = Pure_fun.f p in
   let live_vars = liveness nv p pure_funs in
-  Debug.print_liveness live_vars;
   (* Propagate liveness to dependencies *)
   let vars = variables uses in
   let live_table = solver vars uses defs live_vars in
-  Debug.print_live_tbl live_table;
+  (* Print.print_defs defs;
+     Print.print_uses uses;
+     Print.print_liveness live_vars;
+     Print.print_live_tbl live_table; *)
   (* After dependency propagation *)
   eliminate p live_table

From 49d5f9a1b117af7af98d96f4b8d93d75f4da8b25 Mon Sep 17 00:00:00 2001
From: Micah Cantor <micahcantor01@gmail.com>
Date: Mon, 10 Jul 2023 10:52:14 +0200
Subject: [PATCH 018/112] update deadcode sig

---
 compiler/lib/deadcode_dgraph.mli | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/compiler/lib/deadcode_dgraph.mli b/compiler/lib/deadcode_dgraph.mli
index 1a356d6543..951ebf8a52 100644
--- a/compiler/lib/deadcode_dgraph.mli
+++ b/compiler/lib/deadcode_dgraph.mli
@@ -16,4 +16,4 @@
  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  *)
 
-val run : Code.program -> Code.program * (int array)
\ No newline at end of file
+val f : Code.program -> Code.program
\ No newline at end of file

From bfd58d5491a0f1274c213ee2718e40e22c1e3564 Mon Sep 17 00:00:00 2001
From: Micah Cantor <micahcantor01@gmail.com>
Date: Mon, 10 Jul 2023 10:52:33 +0200
Subject: [PATCH 019/112] expose expr print

---
 compiler/lib/code.mli | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/compiler/lib/code.mli b/compiler/lib/code.mli
index 4f72ee7e68..f0f5c40ccd 100644
--- a/compiler/lib/code.mli
+++ b/compiler/lib/code.mli
@@ -222,6 +222,8 @@ module Print : sig
     | Instr of (instr * loc)
     | Last of (last * loc)
 
+  val expr : Format.formatter -> expr -> unit
+
   val var_list : Format.formatter -> Var.t list -> unit
 
   val instr : Format.formatter -> instr * loc -> unit

From b3db3dde956d0c31c73c0f839e16043bb251ce6e Mon Sep 17 00:00:00 2001
From: Micah Cantor <micahcantor01@gmail.com>
Date: Mon, 10 Jul 2023 14:21:13 +0200
Subject: [PATCH 020/112] fix filter args and closure cont

---
 compiler/lib/deadcode_dgraph.ml | 105 ++++++++++++++++++--------------
 1 file changed, 59 insertions(+), 46 deletions(-)

diff --git a/compiler/lib/deadcode_dgraph.ml b/compiler/lib/deadcode_dgraph.ml
index 1e1490d888..8efde0ba7d 100644
--- a/compiler/lib/deadcode_dgraph.ml
+++ b/compiler/lib/deadcode_dgraph.ml
@@ -228,15 +228,22 @@ let solver vars uses defs live_vars =
   in
   Solver.f () (G.invert () g) (propagate uses defs live_vars)
 
-let eliminate (prog : program) (live_table : live Var.Tbl.t) : program =
+let eliminate prog live_table =
   let is_live v =
     match Var.Tbl.get live_table v with
     | Dead -> false
     | _ -> true
   in
-  let eliminate_cont ((pc, params) : cont) =
-    let params = List.filter ~f:is_live params in
-    pc, params
+  let rec filter_args pl al =
+    match pl, al with
+    | x :: pl, y :: al -> if is_live x then y :: filter_args pl al else filter_args pl al
+    | [], _ -> []
+    | _ -> assert false
+  in
+  let eliminate_cont ((pc, args) : cont) =
+    let block = Addr.Map.find pc prog.blocks in
+    let args = filter_args block.params args in
+    pc, args
   in
   let update_block block =
     let params = List.filter ~f:is_live block.params in
@@ -247,24 +254,30 @@ let eliminate (prog : program) (live_table : live Var.Tbl.t) : program =
           match instr with
           | Let (x, e) -> (
               match Var.Tbl.get live_table x with
-              | Top -> Some (instr, loc)
+              | Top -> (
+                  match e with
+                  | Closure (l, cont) ->
+                      let e = Closure (l, eliminate_cont cont) in
+                      Some (Let (x, e), loc)
+                  | _ -> Some (instr, loc))
               | Live fields -> (
                   match e with
                   (* Eliminate unused fields from block *)
                   | Block (start, vars, is_array) ->
-                      let used_vars =
+                      let _used_vars =
                         Array.to_list vars
                         |> List.filteri ~f:(fun i _ -> IntSet.mem i fields)
                         |> Array.of_list
                       in
-                      let e = Block (start, used_vars, is_array) in
+                      let e = Block (start, vars, is_array) in
                       Some (Let (x, e), loc)
                   (* This should never happen *)
                   | _ -> Some (instr, loc))
               | Dead -> None)
-          (* TODO: These? *)
-          | Assign (_, _) | Set_field (_, _, _) | Offset_ref (_, _) | Array_set (_, _, _)
-            -> Some (instr, loc))
+          (* TODO: need to filter closure cont for assign too *)
+          | Assign (x, _) -> if is_live x then Some (instr, loc) else None
+          | Set_field (_, _, _) | Offset_ref (_, _) | Array_set (_, _, _) ->
+              Some (instr, loc))
         block.body
     in
     (* Analyze branch *)
@@ -287,46 +300,46 @@ let eliminate (prog : program) (live_table : live Var.Tbl.t) : program =
   in
   let blocks = Addr.Map.map update_block prog.blocks in
   { prog with blocks }
-  
-(* 
-module Print = struct
-  let live_to_string = function
-    | Live fields ->
-        "live { " ^ IntSet.fold (fun i s -> s ^ Format.sprintf "%d " i) fields "" ^ "}"
-    | Top -> "top"
-    | Dead -> "dead"
 
-  let print_defs defs =
-    Format.eprintf "Definitions:\n";
-    Array.iteri
-      ~f:(fun i def ->
-        Format.eprintf "v%d: " i;
-        (match def with
-        | Expr e -> Format.eprintf "%a " Print.expr e
-        | Param -> Format.eprintf "param");
-        Format.eprintf "\n")
-      defs
+(*
+   module Print = struct
+     let live_to_string = function
+       | Live fields ->
+           "live { " ^ IntSet.fold (fun i s -> s ^ Format.sprintf "%d " i) fields "" ^ "}"
+       | Top -> "top"
+       | Dead -> "dead"
 
-  let print_uses uses =
-    Format.eprintf "Usages:\n";
-    Array.iteri
-      ~f:(fun i ds ->
-        Format.eprintf "v%d: { " i;
-        Var.Set.iter (fun d -> Format.eprintf "%a " Var.print d) ds;
-        Format.eprintf "}\n")
-      uses
+     let print_defs defs =
+       Format.eprintf "Definitions:\n";
+       Array.iteri
+         ~f:(fun i def ->
+           Format.eprintf "v%d: " i;
+           (match def with
+           | Expr e -> Format.eprintf "%a " Print.expr e
+           | Param -> Format.eprintf "param");
+           Format.eprintf "\n")
+         defs
 
-  let print_liveness live_vars =
-    Format.eprintf "Liveness:\n";
-    Array.iteri ~f:(fun i l -> Format.eprintf "v%d: %s\n" i (live_to_string l)) live_vars
+     let print_uses uses =
+       Format.eprintf "Usages:\n";
+       Array.iteri
+         ~f:(fun i ds ->
+           Format.eprintf "v%d: { " i;
+           Var.Set.iter (fun d -> Format.eprintf "%a " Var.print d) ds;
+           Format.eprintf "}\n")
+         uses
 
-  let print_live_tbl live_table =
-    Format.eprintf "Liveness with dependencies:\n";
-    Var.Tbl.iter
-      (fun v l -> Format.eprintf "%a: %s\n" Var.print v (live_to_string l))
-      live_table
-end
- *)
+     let print_liveness live_vars =
+       Format.eprintf "Liveness:\n";
+       Array.iteri ~f:(fun i l -> Format.eprintf "v%d: %s\n" i (live_to_string l)) live_vars
+
+     let print_live_tbl live_table =
+       Format.eprintf "Liveness with dependencies:\n";
+       Var.Tbl.iter
+         (fun v l -> Format.eprintf "%a: %s\n" Var.print v (live_to_string l))
+         live_table
+   end
+*)
 let f p =
   let nv = Var.count () in
   (* Compute definitions *)

From 3a97925d11dd1fe27c16857dae90ecec44b5304a Mon Sep 17 00:00:00 2001
From: Micah Cantor <micahcantor01@gmail.com>
Date: Mon, 10 Jul 2023 16:12:08 +0200
Subject: [PATCH 021/112] fix bug with cond

---
 compiler/lib/deadcode_dgraph.ml | 92 +++++++++++++++++----------------
 1 file changed, 48 insertions(+), 44 deletions(-)

diff --git a/compiler/lib/deadcode_dgraph.ml b/compiler/lib/deadcode_dgraph.ml
index 8efde0ba7d..5038a6d149 100644
--- a/compiler/lib/deadcode_dgraph.ml
+++ b/compiler/lib/deadcode_dgraph.ml
@@ -186,10 +186,12 @@ let liveness nv prog pure_funs =
     | Branch cont | Poptrap cont ->
         live_continuation prog cont;
         live_continuation prog cont
-    | Cond (_, cont1, cont2) | Pushtrap (cont1, _, cont2, _) ->
+    | Cond (x, cont1, cont2) | Pushtrap (cont1, x, cont2, _) ->
+        add_top x;
         live_continuation prog cont1;
         live_continuation prog cont2
-    | Switch (_, a1, a2) ->
+    | Switch (x, a1, a2) ->
+        add_top x;
         Array.iter ~f:(fun cont -> live_continuation prog cont) a1;
         Array.iter ~f:(fun cont -> live_continuation prog cont) a2
   and live_continuation prog ((pc, _) : cont) =
@@ -264,12 +266,12 @@ let eliminate prog live_table =
                   match e with
                   (* Eliminate unused fields from block *)
                   | Block (start, vars, is_array) ->
-                      let _used_vars =
+                      let used_vars =
                         Array.to_list vars
                         |> List.filteri ~f:(fun i _ -> IntSet.mem i fields)
                         |> Array.of_list
                       in
-                      let e = Block (start, vars, is_array) in
+                      let e = Block (start, used_vars, is_array) in
                       Some (Let (x, e), loc)
                   (* This should never happen *)
                   | _ -> Some (instr, loc))
@@ -301,45 +303,44 @@ let eliminate prog live_table =
   let blocks = Addr.Map.map update_block prog.blocks in
   { prog with blocks }
 
-(*
-   module Print = struct
-     let live_to_string = function
-       | Live fields ->
-           "live { " ^ IntSet.fold (fun i s -> s ^ Format.sprintf "%d " i) fields "" ^ "}"
-       | Top -> "top"
-       | Dead -> "dead"
+module Print = struct
+  let live_to_string = function
+    | Live fields ->
+        "live { " ^ IntSet.fold (fun i s -> s ^ Format.sprintf "%d " i) fields "" ^ "}"
+    | Top -> "top"
+    | Dead -> "dead"
 
-     let print_defs defs =
-       Format.eprintf "Definitions:\n";
-       Array.iteri
-         ~f:(fun i def ->
-           Format.eprintf "v%d: " i;
-           (match def with
-           | Expr e -> Format.eprintf "%a " Print.expr e
-           | Param -> Format.eprintf "param");
-           Format.eprintf "\n")
-         defs
+  let _print_defs defs =
+    Format.eprintf "Definitions:\n";
+    Array.iteri
+      ~f:(fun i def ->
+        Format.eprintf "v%d: " i;
+        (match def with
+        | Expr e -> Format.eprintf "%a " Print.expr e
+        | Param -> Format.eprintf "param");
+        Format.eprintf "\n")
+      defs
 
-     let print_uses uses =
-       Format.eprintf "Usages:\n";
-       Array.iteri
-         ~f:(fun i ds ->
-           Format.eprintf "v%d: { " i;
-           Var.Set.iter (fun d -> Format.eprintf "%a " Var.print d) ds;
-           Format.eprintf "}\n")
-         uses
+  let print_uses uses =
+    Format.eprintf "Usages:\n";
+    Array.iteri
+      ~f:(fun i ds ->
+        Format.eprintf "v%d: { " i;
+        Var.Set.iter (fun d -> Format.eprintf "%a " Var.print d) ds;
+        Format.eprintf "}\n")
+      uses
 
-     let print_liveness live_vars =
-       Format.eprintf "Liveness:\n";
-       Array.iteri ~f:(fun i l -> Format.eprintf "v%d: %s\n" i (live_to_string l)) live_vars
+  let print_liveness live_vars =
+    Format.eprintf "Liveness:\n";
+    Array.iteri ~f:(fun i l -> Format.eprintf "v%d: %s\n" i (live_to_string l)) live_vars
+
+  let print_live_tbl live_table =
+    Format.eprintf "Liveness with dependencies:\n";
+    Var.Tbl.iter
+      (fun v l -> Format.eprintf "%a: %s\n" Var.print v (live_to_string l))
+      live_table
+end
 
-     let print_live_tbl live_table =
-       Format.eprintf "Liveness with dependencies:\n";
-       Var.Tbl.iter
-         (fun v l -> Format.eprintf "%a: %s\n" Var.print v (live_to_string l))
-         live_table
-   end
-*)
 let f p =
   let nv = Var.count () in
   (* Compute definitions *)
@@ -352,9 +353,12 @@ let f p =
   (* Propagate liveness to dependencies *)
   let vars = variables uses in
   let live_table = solver vars uses defs live_vars in
-  (* Print.print_defs defs;
-     Print.print_uses uses;
-     Print.print_liveness live_vars;
-     Print.print_live_tbl live_table; *)
+  (* Print.print_defs defs; *)
+  Print.print_uses uses;
+  Print.print_liveness live_vars;
+  Print.print_live_tbl live_table;
   (* After dependency propagation *)
-  eliminate p live_table
+  let p = eliminate p live_table in
+  Format.eprintf "After Elimination:\n";
+  Code.Print.program (fun _ _ -> "") p;
+  p

From 4e8097a42070d68b7e8321c6d9ad972a3d277f34 Mon Sep 17 00:00:00 2001
From: Micah Cantor <micahcantor01@gmail.com>
Date: Tue, 11 Jul 2023 11:04:31 +0200
Subject: [PATCH 022/112] add sentinal var

---
 compiler/lib/deadcode_dgraph.ml | 72 ++++++++++++++++++++-------------
 1 file changed, 44 insertions(+), 28 deletions(-)

diff --git a/compiler/lib/deadcode_dgraph.ml b/compiler/lib/deadcode_dgraph.ml
index 5038a6d149..f7759f2ce1 100644
--- a/compiler/lib/deadcode_dgraph.ml
+++ b/compiler/lib/deadcode_dgraph.ml
@@ -231,6 +231,18 @@ let solver vars uses defs live_vars =
   Solver.f () (G.invert () g) (propagate uses defs live_vars)
 
 let eliminate prog live_table =
+  let sentinal = Var.fresh () in
+  let add_sentinal_instr blocks =
+    Addr.Map.update
+      0
+      (fun b ->
+        match b with
+        | None -> assert false (* Unreachable *)
+        | Some block ->
+            let body = (Let (sentinal, Constant (Int 0l)), Before 0) :: block.body in
+            Some { block with body })
+      blocks
+  in
   let is_live v =
     match Var.Tbl.get live_table v with
     | Dead -> false
@@ -247,39 +259,43 @@ let eliminate prog live_table =
     let args = filter_args block.params args in
     pc, args
   in
+  let eliminate_closure instr =
+    match instr with
+    | Let (x, Closure (args, cont)) -> Let (x, Closure (args, eliminate_cont cont))
+    | _ -> instr
+  in
+  let eliminate_instr instr =
+    match instr with
+    | Let (x, e) -> (
+        match Var.Tbl.get live_table x with
+        | Top -> Some instr
+        | Live fields -> (
+            match e with
+            (* Eliminate unused fields from block *)
+            | Block (start, vars, is_array) ->
+                let vars =
+                  Array.mapi
+                    ~f:(fun i v -> if IntSet.mem i fields then v else sentinal)
+                    vars
+                in
+                let e = Block (start, vars, is_array) in
+                Some (Let (x, e))
+            (* This should never happen *)
+            | _ -> None)
+        | Dead -> None)
+    | Assign (x, _) -> if is_live x then Some instr else None
+    | Set_field (_, _, _) | Offset_ref (_, _) | Array_set (_, _, _) -> Some instr
+  in
   let update_block block =
+    (* Filter dead params *)
     let params = List.filter ~f:is_live block.params in
     (* Analyze block instructions *)
     let body =
       List.filter_map
         ~f:(fun (instr, loc) ->
-          match instr with
-          | Let (x, e) -> (
-              match Var.Tbl.get live_table x with
-              | Top -> (
-                  match e with
-                  | Closure (l, cont) ->
-                      let e = Closure (l, eliminate_cont cont) in
-                      Some (Let (x, e), loc)
-                  | _ -> Some (instr, loc))
-              | Live fields -> (
-                  match e with
-                  (* Eliminate unused fields from block *)
-                  | Block (start, vars, is_array) ->
-                      let used_vars =
-                        Array.to_list vars
-                        |> List.filteri ~f:(fun i _ -> IntSet.mem i fields)
-                        |> Array.of_list
-                      in
-                      let e = Block (start, used_vars, is_array) in
-                      Some (Let (x, e), loc)
-                  (* This should never happen *)
-                  | _ -> Some (instr, loc))
-              | Dead -> None)
-          (* TODO: need to filter closure cont for assign too *)
-          | Assign (x, _) -> if is_live x then Some (instr, loc) else None
-          | Set_field (_, _, _) | Offset_ref (_, _) | Array_set (_, _, _) ->
-              Some (instr, loc))
+          Option.map
+            ~f:(fun instr -> eliminate_closure instr, loc)
+            (eliminate_instr instr))
         block.body
     in
     (* Analyze branch *)
@@ -300,7 +316,7 @@ let eliminate prog live_table =
     in
     { params; body; branch }
   in
-  let blocks = Addr.Map.map update_block prog.blocks in
+  let blocks = prog.blocks |> Addr.Map.map update_block |> add_sentinal_instr in
   { prog with blocks }
 
 module Print = struct

From c940f38b1bb8ddc792972b82f5e1f0b9e67399d8 Mon Sep 17 00:00:00 2001
From: Micah Cantor <micahcantor01@gmail.com>
Date: Tue, 11 Jul 2023 11:55:54 +0200
Subject: [PATCH 023/112] add basic compaction block pass

---
 compiler/lib/deadcode_dgraph.ml | 17 +++++++++++++----
 1 file changed, 13 insertions(+), 4 deletions(-)

diff --git a/compiler/lib/deadcode_dgraph.ml b/compiler/lib/deadcode_dgraph.ml
index f7759f2ce1..db33167bda 100644
--- a/compiler/lib/deadcode_dgraph.ml
+++ b/compiler/lib/deadcode_dgraph.ml
@@ -235,14 +235,22 @@ let eliminate prog live_table =
   let add_sentinal_instr blocks =
     Addr.Map.update
       0
-      (fun b ->
-        match b with
-        | None -> assert false (* Unreachable *)
+      (function
         | Some block ->
             let body = (Let (sentinal, Constant (Int 0l)), Before 0) :: block.body in
-            Some { block with body })
+            Some { block with body }
+        | None -> assert false (* Unreachable *))
       blocks
   in
+  let compact_vars vars =
+    let i = ref (Array.length vars - 1) in
+    while !i >= 0 && Var.equal vars.(!i) sentinal do
+      i := !i - 1
+    done;
+    let compacted = Array.make (!i + 1) sentinal in
+    Array.blit ~src:vars ~src_pos:0 ~dst:compacted ~dst_pos:0 ~len:(!i + 1);
+    compacted
+  in
   let is_live v =
     match Var.Tbl.get live_table v with
     | Dead -> false
@@ -277,6 +285,7 @@ let eliminate prog live_table =
                   Array.mapi
                     ~f:(fun i v -> if IntSet.mem i fields then v else sentinal)
                     vars
+                  |> compact_vars
                 in
                 let e = Block (start, vars, is_array) in
                 Some (Let (x, e))

From a61e0b2c929bbaa21e1f254b70dabb9d3c18204f Mon Sep 17 00:00:00 2001
From: Micah Cantor <micahcantor01@gmail.com>
Date: Tue, 11 Jul 2023 13:30:02 +0200
Subject: [PATCH 024/112] fix pushtrap variable

---
 compiler/lib/deadcode_dgraph.ml | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/compiler/lib/deadcode_dgraph.ml b/compiler/lib/deadcode_dgraph.ml
index db33167bda..a4ff834c5c 100644
--- a/compiler/lib/deadcode_dgraph.ml
+++ b/compiler/lib/deadcode_dgraph.ml
@@ -186,7 +186,10 @@ let liveness nv prog pure_funs =
     | Branch cont | Poptrap cont ->
         live_continuation prog cont;
         live_continuation prog cont
-    | Cond (x, cont1, cont2) | Pushtrap (cont1, x, cont2, _) ->
+    | Pushtrap (cont1, _, cont2, _) ->
+        live_continuation prog cont1;
+        live_continuation prog cont2
+    | Cond (x, cont1, cont2) ->
         add_top x;
         live_continuation prog cont1;
         live_continuation prog cont2

From 12fdc47e203325d91338b523d187c8e9aea6e660 Mon Sep 17 00:00:00 2001
From: Micah Cantor <micahcantor01@gmail.com>
Date: Wed, 12 Jul 2023 16:40:34 +0200
Subject: [PATCH 025/112] expose print constant

---
 compiler/lib/code.mli | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/compiler/lib/code.mli b/compiler/lib/code.mli
index f0f5c40ccd..8b95a1b874 100644
--- a/compiler/lib/code.mli
+++ b/compiler/lib/code.mli
@@ -224,6 +224,8 @@ module Print : sig
 
   val expr : Format.formatter -> expr -> unit
 
+  val constant : Format.formatter -> constant -> unit
+
   val var_list : Format.formatter -> Var.t list -> unit
 
   val instr : Format.formatter -> instr * loc -> unit

From 56902fe63a20a889d21bf3cc9925d8cb256109b3 Mon Sep 17 00:00:00 2001
From: Micah Cantor <micahcantor01@gmail.com>
Date: Wed, 12 Jul 2023 16:40:48 +0200
Subject: [PATCH 026/112] initial global support

---
 compiler/lib/deadcode_dgraph.ml | 94 ++++++++++++++++++++++-----------
 1 file changed, 62 insertions(+), 32 deletions(-)

diff --git a/compiler/lib/deadcode_dgraph.ml b/compiler/lib/deadcode_dgraph.ml
index a4ff834c5c..4d7754ce43 100644
--- a/compiler/lib/deadcode_dgraph.ml
+++ b/compiler/lib/deadcode_dgraph.ml
@@ -69,31 +69,49 @@ let definitions nv prog =
     prog.blocks;
   defs
 
-let usages nv prog =
-  let uses = Array.make nv Var.Set.empty in
-  let add_use x y = uses.(Var.idx y) <- Var.Set.add x uses.(Var.idx y) in
+type usage_kind =
+  | Compute (* variable y is used to compute x *)
+  | Propagate (* values of y propagate to x *)
+
+let usages nv prog (global_info : Global_flow.info) : usage_kind Var.Map.t array =
+  let uses = Array.make nv Var.Map.empty in
+  let add_use kind x y = uses.(Var.idx y) <- Var.Map.add x kind uses.(Var.idx y) in
   let add_arg_dep params args =
-    try List.iter2 ~f:(fun x y -> add_use x y) params args with Invalid_argument _ -> ()
+    try List.iter2 ~f:(fun x y -> add_use Propagate x y) params args
+    with Invalid_argument _ -> ()
   in
   let add_cont_deps (pc, args) =
     match try Some (Addr.Map.find pc prog.blocks) with Not_found -> None with
     | Some block -> add_arg_dep block.params args
     | None -> () (* Dead continuation *)
   in
-  let add_expr_uses x e =
+  let add_expr_uses x e : unit =
     match e with
     | Apply { f; args; _ } ->
-        add_use x f;
-        List.iter ~f:(add_use x) args
-    | Block (_, params, _) -> Array.iter ~f:(add_use x) params
-    | Field (z, _) -> add_use x z
+        (match Var.Tbl.get global_info.info_approximation f with
+        | Top -> ()
+        | Values { known; _ } ->
+            Var.Set.iter (* For each known value of f *)
+              (fun k ->
+                (* 1. Look at return values, and add edge between x and these values. *)
+                let return_values = Var.Map.find k global_info.info_return_vals in
+                Var.Set.iter (add_use Propagate x) return_values;
+                (* 2. If k is a closure, add an edge pairwise between the parameters and arguments *)
+                match global_info.info_defs.(Var.idx k) with
+                | Expr (Closure (params, _)) ->
+                    List.iter2 ~f:(add_use Propagate) params args
+                | _ -> ())
+              known);
+        add_use Compute x f
+    | Block (_, params, _) -> Array.iter ~f:(add_use Propagate x) params
+    | Field (z, _) -> add_use Compute x z
     | Constant _ -> ()
     | Closure (_, cont) -> add_cont_deps cont
     | Prim (_, args) ->
         List.iter
           ~f:(fun arg ->
             match arg with
-            | Pv v -> add_use x v
+            | Pv v -> add_use Compute x v
             | Pc _ -> ())
           args
   in
@@ -104,7 +122,7 @@ let usages nv prog =
         ~f:(fun (i, _) ->
           match i with
           | Let (x, e) -> add_expr_uses x e
-          | Assign (x, y) -> add_use x y
+          | Assign (x, y) -> add_use Compute x y
           (* TODO: These? *)
           | Set_field (_, _, _) | Offset_ref (_, _) | Array_set (_, _, _) -> ())
         block.body;
@@ -145,7 +163,7 @@ let expr_vars e =
         args);
   vars
 
-let liveness nv prog pure_funs =
+let liveness nv prog pure_funs (global_info : Global_flow.info) =
   let live_vars = Array.make nv Dead in
   let add_top v =
     let idx = Var.idx v in
@@ -162,9 +180,16 @@ let liveness nv prog pure_funs =
     | Let (x, e) ->
         if not (pure_expr pure_funs e)
         then (
+          (* TODO: if e is an impure application, then look at each argument, if they escape then set to top *)
           let vars = expr_vars e in
           Var.ISet.iter add_top vars;
-          add_top x)
+          add_top x;
+          match e with
+          | Apply { args; _ } ->
+              List.iter
+                ~f:(fun x -> if Var.ISet.mem global_info.info_may_escape x then add_top x)
+                args
+          | _ -> ())
     | Assign (_, _) -> ()
     (* TODO: what to do with these? *)
     | Set_field (x, i, y) ->
@@ -181,7 +206,8 @@ let liveness nv prog pure_funs =
     match fst block.branch with
     (* Base Cases *)
     | Stop -> ()
-    | Return x | Raise (x, _) -> add_top x
+    | Return x -> if Var.ISet.mem global_info.info_may_escape x then add_top x
+    | Raise (x, _) -> add_top x
     (* Recursive cases *)
     | Branch cont | Poptrap cont ->
         live_continuation prog cont;
@@ -210,26 +236,30 @@ let variables deps =
   Array.iteri ~f:(fun i _ -> Var.ISet.add vars (Var.of_idx i)) deps;
   vars
 
-let propagate uses defs live_vars live_table x =
+let propagate (uses : usage_kind Var.Map.t array) defs live_vars live_table x =
   let idx = Var.idx x in
-  let contribution y =
-    match Var.Tbl.get live_table y with
-    | Dead -> Dead (* If x is used in y, and y is dead, then x is dead. *)
-    | Top | Live _ -> (
-        (* Otherwise we may be able to refine y's liveness. *)
-        match defs.(Var.idx y) with
-        | Expr (Field (_, i)) -> Live (IntSet.singleton i)
-        | Param -> Var.Tbl.get live_table y
-        | _ -> Top)
+  let contribution y usage_kind =
+    match usage_kind with
+    | Compute -> (
+        match Var.Tbl.get live_table y with
+        | Dead -> Dead (* If x is used in y, and y is dead, then x is dead. *)
+        | Top | Live _ -> (
+            (* Otherwise we may be able to refine y's liveness. *)
+            match defs.(Var.idx y) with
+            | Expr (Field (_, i)) -> Live (IntSet.singleton i)
+            | _ -> Top))
+    | Propagate -> Var.Tbl.get live_table y
   in
-  Var.Set.fold
-    (fun y live -> Domain.join (contribution y) live)
+  Var.Map.fold
+    (fun y usage_kind live -> Domain.join (contribution y usage_kind) live)
     uses.(idx)
     live_vars.(idx)
 
-let solver vars uses defs live_vars =
+let solver vars (uses : usage_kind Var.Map.t array) defs live_vars =
   let g =
-    { G.domain = vars; G.iter_children = (fun f x -> Var.Set.iter f uses.(Var.idx x)) }
+    { G.domain = vars
+    ; G.iter_children = (fun f x -> Var.Map.iter (fun y _ -> f y) uses.(Var.idx x))
+    }
   in
   Solver.f () (G.invert () g) (propagate uses defs live_vars)
 
@@ -354,7 +384,7 @@ module Print = struct
     Array.iteri
       ~f:(fun i ds ->
         Format.eprintf "v%d: { " i;
-        Var.Set.iter (fun d -> Format.eprintf "%a " Var.print d) ds;
+        Var.Map.iter (fun d _ -> Format.eprintf "%a " Var.print d) ds;
         Format.eprintf "}\n")
       uses
 
@@ -369,15 +399,15 @@ module Print = struct
       live_table
 end
 
-let f p =
+let f p global_info =
   let nv = Var.count () in
   (* Compute definitions *)
   let defs = definitions nv p in
   (* Compute usages *)
-  let uses = usages nv p in
+  let uses = usages nv p global_info in
   (* Compute initial liveness *)
   let pure_funs = Pure_fun.f p in
-  let live_vars = liveness nv p pure_funs in
+  let live_vars = liveness nv p pure_funs global_info in
   (* Propagate liveness to dependencies *)
   let vars = variables uses in
   let live_table = solver vars uses defs live_vars in

From 49464e0c4d5ee5f84ef638608ef7f32a8b49418b Mon Sep 17 00:00:00 2001
From: Micah Cantor <micahcantor01@gmail.com>
Date: Wed, 12 Jul 2023 16:41:30 +0200
Subject: [PATCH 027/112] more global support

---
 compiler/lib/deadcode_dgraph.mli | 2 +-
 compiler/lib/driver.ml           | 5 ++++-
 compiler/lib/global_flow.ml      | 7 ++++++-
 compiler/lib/global_flow.mli     | 1 +
 4 files changed, 12 insertions(+), 3 deletions(-)

diff --git a/compiler/lib/deadcode_dgraph.mli b/compiler/lib/deadcode_dgraph.mli
index 951ebf8a52..aba550ed69 100644
--- a/compiler/lib/deadcode_dgraph.mli
+++ b/compiler/lib/deadcode_dgraph.mli
@@ -16,4 +16,4 @@
  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  *)
 
-val f : Code.program -> Code.program
\ No newline at end of file
+val f : Code.program -> Global_flow.info -> Code.program
\ No newline at end of file
diff --git a/compiler/lib/driver.ml b/compiler/lib/driver.ml
index 15524a75bc..803e815700 100644
--- a/compiler/lib/driver.ml
+++ b/compiler/lib/driver.ml
@@ -38,7 +38,10 @@ let tailcall p =
 
 let deadcode' p =
   if debug () then Format.eprintf "Dead-code...@.";
-  Deadcode_dgraph.run p
+  let global_info = Global_flow.f ~fast:false p in
+  let p = Deadcode_dgraph.f p global_info in
+  let _, live_vars = Deadcode.f p in
+  p, live_vars
 
 let deadcode p =
   let r, _ = deadcode' p in
diff --git a/compiler/lib/global_flow.ml b/compiler/lib/global_flow.ml
index 849b3456c6..6ad8b6cc48 100644
--- a/compiler/lib/global_flow.ml
+++ b/compiler/lib/global_flow.ml
@@ -540,6 +540,7 @@ type info =
   { info_defs : def array
   ; info_approximation : Domain.t Var.Tbl.t
   ; info_may_escape : Var.ISet.t
+  ; info_return_vals : Var.Set.t Var.Map.t
   }
 
 let f ~fast p =
@@ -625,7 +626,11 @@ let f ~fast p =
   Array.iteri
     ~f:(fun i s -> if Poly.(s <> No) then Var.ISet.add info_may_escape (Var.of_idx i))
     may_escape;
-  { info_defs = defs; info_approximation = approximation; info_may_escape }
+  { info_defs = defs
+  ; info_approximation = approximation
+  ; info_may_escape
+  ; info_return_vals = rets
+  }
 
 let exact_call info f n =
   match Var.Tbl.get info.info_approximation f with
diff --git a/compiler/lib/global_flow.mli b/compiler/lib/global_flow.mli
index 576f45f8b6..65d9cbfb59 100644
--- a/compiler/lib/global_flow.mli
+++ b/compiler/lib/global_flow.mli
@@ -35,6 +35,7 @@ type info =
   { info_defs : def array
   ; info_approximation : approx Var.Tbl.t
   ; info_may_escape : Var.ISet.t
+  ; info_return_vals : Var.Set.t Var.Map.t
   }
 
 val f : fast:bool -> Code.program -> info

From 936c3e467759b5fcdd4b1e06bcc9e7e2a9fdc126 Mon Sep 17 00:00:00 2001
From: Micah Cantor <micahcantor01@gmail.com>
Date: Wed, 12 Jul 2023 16:55:30 +0200
Subject: [PATCH 028/112] update print uses

---
 compiler/lib/deadcode_dgraph.ml | 11 ++++++++++-
 1 file changed, 10 insertions(+), 1 deletion(-)

diff --git a/compiler/lib/deadcode_dgraph.ml b/compiler/lib/deadcode_dgraph.ml
index 4d7754ce43..19d043413b 100644
--- a/compiler/lib/deadcode_dgraph.ml
+++ b/compiler/lib/deadcode_dgraph.ml
@@ -384,7 +384,16 @@ module Print = struct
     Array.iteri
       ~f:(fun i ds ->
         Format.eprintf "v%d: { " i;
-        Var.Map.iter (fun d _ -> Format.eprintf "%a " Var.print d) ds;
+        Var.Map.iter
+          (fun d k ->
+            Format.eprintf
+              "(%a, %s) "
+              Var.print
+              d
+              (match k with
+              | Compute -> "C"
+              | Propagate -> "P"))
+          ds;
         Format.eprintf "}\n")
       uses
 

From 9c45d785ea54b7a83c1fece9bd2a9c3ee96e51da Mon Sep 17 00:00:00 2001
From: Micah Cantor <micahcantor01@gmail.com>
Date: Wed, 19 Jul 2023 12:26:03 +0200
Subject: [PATCH 029/112] cleanup, fix block propagation

---
 compiler/lib/deadcode_dgraph.ml | 71 ++++++++++++++++++++++-----------
 1 file changed, 47 insertions(+), 24 deletions(-)

diff --git a/compiler/lib/deadcode_dgraph.ml b/compiler/lib/deadcode_dgraph.ml
index 19d043413b..e38a4aab62 100644
--- a/compiler/lib/deadcode_dgraph.ml
+++ b/compiler/lib/deadcode_dgraph.ml
@@ -102,8 +102,9 @@ let usages nv prog (global_info : Global_flow.info) : usage_kind Var.Map.t array
                     List.iter2 ~f:(add_use Propagate) params args
                 | _ -> ())
               known);
-        add_use Compute x f
-    | Block (_, params, _) -> Array.iter ~f:(add_use Propagate x) params
+        add_use Compute x f;
+        List.iter ~f:(add_use Compute x) args
+    | Block (_, vars, _) -> Array.iter ~f:(add_use Compute x) vars
     | Field (z, _) -> add_use Compute x z
     | Constant _ -> ()
     | Closure (_, cont) -> add_cont_deps cont
@@ -180,7 +181,6 @@ let liveness nv prog pure_funs (global_info : Global_flow.info) =
     | Let (x, e) ->
         if not (pure_expr pure_funs e)
         then (
-          (* TODO: if e is an impure application, then look at each argument, if they escape then set to top *)
           let vars = expr_vars e in
           Var.ISet.iter add_top vars;
           add_top x;
@@ -236,18 +236,32 @@ let variables deps =
   Array.iteri ~f:(fun i _ -> Var.ISet.add vars (Var.of_idx i)) deps;
   vars
 
-let propagate (uses : usage_kind Var.Map.t array) defs live_vars live_table x =
+let propagate uses defs live_vars live_table x =
   let idx = Var.idx x in
   let contribution y usage_kind =
     match usage_kind with
+    (* If x is used to compute y, we consider the liveness of y *)
     | Compute -> (
         match Var.Tbl.get live_table y with
-        | Dead -> Dead (* If x is used in y, and y is dead, then x is dead. *)
-        | Top | Live _ -> (
-            (* Otherwise we may be able to refine y's liveness. *)
+        (* If y is dead, then x is dead. *)
+        | Dead -> Dead
+        (* If y is a live block, then x is live if it is used in a live field *)
+        | Live fields -> (
+            match defs.(Var.idx y) with
+            | Expr (Block (_, vars, _)) ->
+                let found = ref false in
+                Array.iteri
+                  ~f:(fun i v ->
+                    if Var.equal v x && IntSet.mem i fields then found := true)
+                  vars;
+                if !found then Top else Dead
+            | _ -> Top)
+        (* If y is top, then if y is a field access, x depends only on that field *)
+        | Top -> (
             match defs.(Var.idx y) with
             | Expr (Field (_, i)) -> Live (IntSet.singleton i)
             | _ -> Top))
+    (* If x is used as an argument for parameter y, then contribution is liveness of y *)
     | Propagate -> Var.Tbl.get live_table y
   in
   Var.Map.fold
@@ -255,7 +269,7 @@ let propagate (uses : usage_kind Var.Map.t array) defs live_vars live_table x =
     uses.(idx)
     live_vars.(idx)
 
-let solver vars (uses : usage_kind Var.Map.t array) defs live_vars =
+let solver vars uses defs live_vars =
   let g =
     { G.domain = vars
     ; G.iter_children = (fun f x -> Var.Map.iter (fun y _ -> f y) uses.(Var.idx x))
@@ -263,17 +277,11 @@ let solver vars (uses : usage_kind Var.Map.t array) defs live_vars =
   in
   Solver.f () (G.invert () g) (propagate uses defs live_vars)
 
-let eliminate prog live_table =
-  let sentinal = Var.fresh () in
+let eliminate prog sentinal live_table =
   let add_sentinal_instr blocks =
-    Addr.Map.update
-      0
-      (function
-        | Some block ->
-            let body = (Let (sentinal, Constant (Int 0l)), Before 0) :: block.body in
-            Some { block with body }
-        | None -> assert false (* Unreachable *))
-      blocks
+    let block = Addr.Map.find 0 blocks in
+    let body = (Let (sentinal, Constant (Int 0l)), Before 0) :: block.body in
+    Addr.Map.add 0 { block with body } blocks
   in
   let compact_vars vars =
     let i = ref (Array.length vars - 1) in
@@ -302,7 +310,8 @@ let eliminate prog live_table =
   in
   let eliminate_closure instr =
     match instr with
-    | Let (x, Closure (args, cont)) -> Let (x, Closure (args, eliminate_cont cont))
+    | Let (x, Closure (args, cont)) ->
+        Let (x, Closure (args, eliminate_cont cont))
     | _ -> instr
   in
   let eliminate_instr instr =
@@ -322,8 +331,7 @@ let eliminate prog live_table =
                 in
                 let e = Block (start, vars, is_array) in
                 Some (Let (x, e))
-            (* This should never happen *)
-            | _ -> None)
+            | _ -> Some instr)
         | Dead -> None)
     | Assign (x, _) -> if is_live x then Some instr else None
     | Set_field (_, _, _) | Offset_ref (_, _) | Array_set (_, _, _) -> Some instr
@@ -368,7 +376,7 @@ module Print = struct
     | Top -> "top"
     | Dead -> "dead"
 
-  let _print_defs defs =
+  let print_defs defs =
     Format.eprintf "Definitions:\n";
     Array.iteri
       ~f:(fun i def ->
@@ -406,9 +414,24 @@ module Print = struct
     Var.Tbl.iter
       (fun v l -> Format.eprintf "%a: %s\n" Var.print v (live_to_string l))
       live_table
+
+  let annot live_table _ (xi : Code.Print.xinstr) =
+    match xi with
+    | Last _ -> ""
+    | Instr (i, _) -> (
+        match i with
+        | Let (x, _) -> (
+            match Var.Tbl.get live_table x with
+            | Dead -> "X"
+            | Top -> "T"
+            | Live fields ->
+                "{ " ^ IntSet.fold (fun i s -> s ^ Format.sprintf "%d " i) fields "" ^ "}"
+            )
+        | _ -> "")
 end
 
 let f p global_info =
+  let sentinal = Var.fresh () in
   let nv = Var.count () in
   (* Compute definitions *)
   let defs = definitions nv p in
@@ -422,10 +445,10 @@ let f p global_info =
   let live_table = solver vars uses defs live_vars in
   (* Print.print_defs defs; *)
   Print.print_uses uses;
-  Print.print_liveness live_vars;
+  (* Print.print_liveness live_vars; *)
   Print.print_live_tbl live_table;
   (* After dependency propagation *)
-  let p = eliminate p live_table in
+  let p = eliminate p sentinal live_table in
   Format.eprintf "After Elimination:\n";
   Code.Print.program (fun _ _ -> "") p;
   p

From 461fd7bf12a89faca4eb83c01f58f2a8857f3280 Mon Sep 17 00:00:00 2001
From: Micah Cantor <micahcantor01@gmail.com>
Date: Wed, 19 Jul 2023 13:20:45 +0200
Subject: [PATCH 030/112] add new debug flag

---
 compiler/lib/deadcode_dgraph.ml | 31 +++++++++----------------------
 1 file changed, 9 insertions(+), 22 deletions(-)

diff --git a/compiler/lib/deadcode_dgraph.ml b/compiler/lib/deadcode_dgraph.ml
index e38a4aab62..31aaf904d4 100644
--- a/compiler/lib/deadcode_dgraph.ml
+++ b/compiler/lib/deadcode_dgraph.ml
@@ -19,6 +19,8 @@
 open Code
 open Stdlib
 
+let debug = Debug.find "globaldeadcode"
+
 type def =
   | Expr of expr
   | Param
@@ -310,8 +312,7 @@ let eliminate prog sentinal live_table =
   in
   let eliminate_closure instr =
     match instr with
-    | Let (x, Closure (args, cont)) ->
-        Let (x, Closure (args, eliminate_cont cont))
+    | Let (x, Closure (args, cont)) -> Let (x, Closure (args, eliminate_cont cont))
     | _ -> instr
   in
   let eliminate_instr instr =
@@ -414,20 +415,6 @@ module Print = struct
     Var.Tbl.iter
       (fun v l -> Format.eprintf "%a: %s\n" Var.print v (live_to_string l))
       live_table
-
-  let annot live_table _ (xi : Code.Print.xinstr) =
-    match xi with
-    | Last _ -> ""
-    | Instr (i, _) -> (
-        match i with
-        | Let (x, _) -> (
-            match Var.Tbl.get live_table x with
-            | Dead -> "X"
-            | Top -> "T"
-            | Live fields ->
-                "{ " ^ IntSet.fold (fun i s -> s ^ Format.sprintf "%d " i) fields "" ^ "}"
-            )
-        | _ -> "")
 end
 
 let f p global_info =
@@ -443,12 +430,12 @@ let f p global_info =
   (* Propagate liveness to dependencies *)
   let vars = variables uses in
   let live_table = solver vars uses defs live_vars in
-  (* Print.print_defs defs; *)
-  Print.print_uses uses;
-  (* Print.print_liveness live_vars; *)
-  Print.print_live_tbl live_table;
   (* After dependency propagation *)
   let p = eliminate p sentinal live_table in
-  Format.eprintf "After Elimination:\n";
-  Code.Print.program (fun _ _ -> "") p;
+  if debug ()
+  then (
+    Print.print_uses uses;
+    Print.print_live_tbl live_table;
+    Format.eprintf "After Elimination:\n";
+    Code.Print.program (fun _ _ -> "") p);
   p

From 64de2533385cf3b6baf8a1c58f2181bf9828d596 Mon Sep 17 00:00:00 2001
From: Micah Cantor <micahcantor01@gmail.com>
Date: Thu, 20 Jul 2023 10:30:15 +0200
Subject: [PATCH 031/112] switch to zeroing out

---
 compiler/lib/deadcode_dgraph.ml | 130 ++++++++++++++------------------
 1 file changed, 55 insertions(+), 75 deletions(-)

diff --git a/compiler/lib/deadcode_dgraph.ml b/compiler/lib/deadcode_dgraph.ml
index 31aaf904d4..16a2bda259 100644
--- a/compiler/lib/deadcode_dgraph.ml
+++ b/compiler/lib/deadcode_dgraph.ml
@@ -93,15 +93,19 @@ let usages nv prog (global_info : Global_flow.info) : usage_kind Var.Map.t array
         (match Var.Tbl.get global_info.info_approximation f with
         | Top -> ()
         | Values { known; _ } ->
-            Var.Set.iter (* For each known value of f *)
+            Var.Set.iter (* For each known closure value of f *)
               (fun k ->
                 (* 1. Look at return values, and add edge between x and these values. *)
-                let return_values = Var.Map.find k global_info.info_return_vals in
-                Var.Set.iter (add_use Propagate x) return_values;
-                (* 2. If k is a closure, add an edge pairwise between the parameters and arguments *)
+                (* 2. Add an edge pairwise between the parameters and arguments *)
                 match global_info.info_defs.(Var.idx k) with
                 | Expr (Closure (params, _)) ->
-                    List.iter2 ~f:(add_use Propagate) params args
+                    (* If the function is under/over-applied then global flow will mark arguments and return value as escaping.
+                       So we only need to consider the case when there is an exact application. *)
+                    if List.length params = List.length args
+                    then (
+                      let return_values = Var.Map.find k global_info.info_return_vals in
+                      Var.Set.iter (add_use Propagate x) return_values;
+                      List.iter2 ~f:(add_use Propagate) params args)
                 | _ -> ())
               known);
         add_use Compute x f;
@@ -203,31 +207,15 @@ let liveness nv prog pure_funs (global_info : Global_flow.info) =
         add_top z
     | Offset_ref (x, i) -> add_live x i
   in
-  let rec live_block block =
+  let live_block block =
     List.iter ~f:(fun (i, _) -> live_instruction i) block.body;
     match fst block.branch with
-    (* Base Cases *)
     | Stop -> ()
     | Return x -> if Var.ISet.mem global_info.info_may_escape x then add_top x
     | Raise (x, _) -> add_top x
-    (* Recursive cases *)
-    | Branch cont | Poptrap cont ->
-        live_continuation prog cont;
-        live_continuation prog cont
-    | Pushtrap (cont1, _, cont2, _) ->
-        live_continuation prog cont1;
-        live_continuation prog cont2
-    | Cond (x, cont1, cont2) ->
-        add_top x;
-        live_continuation prog cont1;
-        live_continuation prog cont2
-    | Switch (x, a1, a2) ->
-        add_top x;
-        Array.iter ~f:(fun cont -> live_continuation prog cont) a1;
-        Array.iter ~f:(fun cont -> live_continuation prog cont) a2
-  and live_continuation prog ((pc, _) : cont) =
-    let block = Addr.Map.find pc prog.blocks in
-    live_block block
+    | Cond (x, _, _) -> add_top x
+    | Switch (x, _, _) -> add_top x
+    | Branch _ | Poptrap _ | Pushtrap _ -> ()
   in
   Addr.Map.iter (fun _ block -> live_block block) prog.blocks;
   live_vars
@@ -279,7 +267,7 @@ let solver vars uses defs live_vars =
   in
   Solver.f () (G.invert () g) (propagate uses defs live_vars)
 
-let eliminate prog sentinal live_table =
+let zero prog sentinal live_table =
   let add_sentinal_instr blocks =
     let block = Addr.Map.find 0 blocks in
     let body = (Let (sentinal, Constant (Int 0l)), Before 0) :: block.body in
@@ -299,31 +287,29 @@ let eliminate prog sentinal live_table =
     | Dead -> false
     | _ -> true
   in
-  let rec filter_args pl al =
-    match pl, al with
-    | x :: pl, y :: al -> if is_live x then y :: filter_args pl al else filter_args pl al
-    | [], _ -> []
-    | _ -> assert false
-  in
-  let eliminate_cont ((pc, args) : cont) =
-    let block = Addr.Map.find pc prog.blocks in
-    let args = filter_args block.params args in
-    pc, args
+  let zero_var x = if not (is_live x) then sentinal else x in
+  let zero_cont ((pc, args) : cont) =
+    match Addr.Map.find_opt pc prog.blocks with
+    | Some block ->
+        let args =
+          List.map2
+            ~f:(fun param arg -> if is_live param then arg else sentinal)
+            block.params
+            args
+        in
+        pc, args
+    | None -> pc, args
   in
-  let eliminate_closure instr =
-    match instr with
-    | Let (x, Closure (args, cont)) -> Let (x, Closure (args, eliminate_cont cont))
-    | _ -> instr
-  in
-  let eliminate_instr instr =
+  let zero_instr instr =
     match instr with
     | Let (x, e) -> (
-        match Var.Tbl.get live_table x with
-        | Top -> Some instr
-        | Live fields -> (
-            match e with
-            (* Eliminate unused fields from block *)
-            | Block (start, vars, is_array) ->
+        match e with
+        | Closure (args, cont) ->
+            let cont = zero_cont cont in
+            Let (x, Closure (args, cont))
+        | Block (start, vars, is_array) -> (
+            match Var.Tbl.get live_table x with
+            | Live fields ->
                 let vars =
                   Array.mapi
                     ~f:(fun i v -> if IntSet.mem i fields then v else sentinal)
@@ -331,43 +317,37 @@ let eliminate prog sentinal live_table =
                   |> compact_vars
                 in
                 let e = Block (start, vars, is_array) in
-                Some (Let (x, e))
-            | _ -> Some instr)
-        | Dead -> None)
-    | Assign (x, _) -> if is_live x then Some instr else None
-    | Set_field (_, _, _) | Offset_ref (_, _) | Array_set (_, _, _) -> Some instr
+                Let (x, e)
+            | _ -> instr)
+        | Apply ap ->
+            let args = List.map ~f:zero_var ap.args in
+            Let (x, Apply { ap with args })
+        | _ -> instr)
+    | _ -> instr
   in
-  let update_block block =
-    (* Filter dead params *)
-    let params = List.filter ~f:is_live block.params in
+  let zero_block block =
     (* Analyze block instructions *)
-    let body =
-      List.filter_map
-        ~f:(fun (instr, loc) ->
-          Option.map
-            ~f:(fun instr -> eliminate_closure instr, loc)
-            (eliminate_instr instr))
-        block.body
-    in
+    let body = List.map ~f:(fun (instr, loc) -> zero_instr instr, loc) block.body in
     (* Analyze branch *)
     let branch =
       let last, loc = block.branch in
       let last =
         match last with
-        | Return _ | Raise (_, _) | Stop -> last
-        | Branch cont -> Branch (eliminate_cont cont)
-        | Cond (x, cont1, cont2) -> Cond (x, eliminate_cont cont1, eliminate_cont cont2)
+        | Return x -> Return (zero_var x)
+        | Raise (_, _) | Stop -> last
+        | Branch cont -> Branch (zero_cont cont)
+        | Cond (x, cont1, cont2) -> Cond (x, zero_cont cont1, zero_cont cont2)
         | Switch (x, a1, a2) ->
-            Switch (x, Array.map ~f:eliminate_cont a1, Array.map ~f:eliminate_cont a2)
+            Switch (x, Array.map ~f:zero_cont a1, Array.map ~f:zero_cont a2)
         | Pushtrap (cont1, x, cont2, pcs) ->
-            Pushtrap (eliminate_cont cont1, x, eliminate_cont cont2, pcs)
-        | Poptrap cont -> Poptrap (eliminate_cont cont)
+            Pushtrap (zero_cont cont1, x, zero_cont cont2, pcs)
+        | Poptrap cont -> Poptrap (zero_cont cont)
       in
       last, loc
     in
-    { params; body; branch }
+    { block with body; branch }
   in
-  let blocks = prog.blocks |> Addr.Map.map update_block |> add_sentinal_instr in
+  let blocks = prog.blocks |> Addr.Map.map zero_block |> add_sentinal_instr in
   { prog with blocks }
 
 module Print = struct
@@ -418,7 +398,7 @@ module Print = struct
 end
 
 let f p global_info =
-  let sentinal = Var.fresh () in
+  let _sentinal = Var.fresh () in
   let nv = Var.count () in
   (* Compute definitions *)
   let defs = definitions nv p in
@@ -430,8 +410,8 @@ let f p global_info =
   (* Propagate liveness to dependencies *)
   let vars = variables uses in
   let live_table = solver vars uses defs live_vars in
-  (* After dependency propagation *)
-  let p = eliminate p sentinal live_table in
+  (* Zero out dead fields *)
+  (* let p = zero p sentinal live_table in *)
   if debug ()
   then (
     Print.print_uses uses;

From ac4358a534415b5951758a0cdf3dcf3baa5d9744 Mon Sep 17 00:00:00 2001
From: Micah Cantor <micahcantor01@gmail.com>
Date: Thu, 20 Jul 2023 13:14:08 +0200
Subject: [PATCH 032/112] call global flow once in driver

---
 compiler/lib/driver.ml | 55 +++++++++++++++++++++++-------------------
 1 file changed, 30 insertions(+), 25 deletions(-)

diff --git a/compiler/lib/driver.ml b/compiler/lib/driver.ml
index 803e815700..c1a57d97e4 100644
--- a/compiler/lib/driver.ml
+++ b/compiler/lib/driver.ml
@@ -36,21 +36,20 @@ let tailcall p =
   if debug () then Format.eprintf "Tail-call optimization...@.";
   Tailcall.f p
 
-let deadcode' p =
+let deadcode' _global_info p =
   if debug () then Format.eprintf "Dead-code...@.";
-  let global_info = Global_flow.f ~fast:false p in
-  let p = Deadcode_dgraph.f p global_info in
-  let _, live_vars = Deadcode.f p in
+  (* let p = Deadcode_dgraph.f p global_info in *)
+  let p, live_vars = Deadcode.f p in
   p, live_vars
 
-let deadcode p =
-  let r, _ = deadcode' p in
+let deadcode global_info p =
+  let r, _ = deadcode' global_info p in
   r
 
-let inline p =
+let inline global_info p =
   if Config.Flag.inline () && Config.Flag.deadcode ()
   then (
-    let p, live_vars = deadcode' p in
+    let p, live_vars = deadcode' global_info p in
     if debug () then Format.eprintf "Inlining...@.";
     Inline.f p live_vars)
   else p
@@ -127,27 +126,27 @@ let identity x = x
 
 (* o1 *)
 
-let o1 : 'a -> 'a =
+let o1 global_info =
   print
   +> tailcall
   +> flow_simple (* flow simple to keep information for future tailcall opt *)
   +> specialize'
   +> eval
-  +> inline (* inlining may reveal new tailcall opt *)
-  +> deadcode
+  +> inline global_info (* inlining may reveal new tailcall opt *)
+  +> deadcode global_info
   +> tailcall
   +> phi
   +> flow
   +> specialize'
   +> eval
-  +> inline
-  +> deadcode
+  +> inline global_info
+  +> deadcode global_info
   +> print
   +> flow
   +> specialize'
   +> eval
-  +> inline
-  +> deadcode
+  +> inline global_info
+  +> deadcode global_info
   +> phi
   +> flow
   +> specialize
@@ -155,23 +154,28 @@ let o1 : 'a -> 'a =
 
 (* o2 *)
 
-let o2 : 'a -> 'a = loop 10 "o1" o1 1 +> print
+let o2 global_info = loop 10 "o1" (o1 global_info) 1 +> print
 
 (* o3 *)
 
-let round1 : 'a -> 'a =
+let round1 global_info =
   print
   +> tailcall
-  +> inline (* inlining may reveal new tailcall opt *)
-  +> deadcode (* deadcode required before flow simple -> provided by constant *)
+  +> inline global_info (* inlining may reveal new tailcall opt *)
+  +> deadcode
+       global_info (* deadcode required before flow simple -> provided by constant *)
   +> flow_simple (* flow simple to keep information for future tailcall opt *)
   +> specialize'
   +> eval
   +> identity
 
-let round2 = flow +> specialize' +> eval +> deadcode +> o1
+let round2 global_info =
+  flow +> specialize' +> eval +> deadcode global_info +> o1 global_info
 
-let o3 = loop 10 "tailcall+inline" round1 1 +> loop 10 "flow" round2 1 +> print
+let o3 global_info =
+  loop 10 "tailcall+inline" (round1 global_info) 1
+  +> loop 10 "flow" (round2 global_info) 1
+  +> print
 
 let generate
     d
@@ -576,14 +580,15 @@ let configure formatter =
 let full ~standalone ~wrap_with_fun ~profile ~linkall ~source_map formatter d p =
   let exported_runtime = not standalone in
   let opt =
+    let global_info = Global_flow.f ~fast:false p in
     specialize_js_once
     +> (match profile with
-       | O1 -> o1
-       | O2 -> o2
-       | O3 -> o3)
+       | O1 -> o1 global_info
+       | O2 -> o2 global_info
+       | O3 -> o3 global_info)
     +> exact_calls profile
     +> effects
-    +> map_fst (Generate_closure.f +> deadcode')
+    +> map_fst (Generate_closure.f +> deadcode' global_info)
   in
   let emit =
     generate d ~exported_runtime ~wrap_with_fun ~warn_on_unhandled_effect:standalone

From 176cf0424beebf97c1289365788498d6c385cac0 Mon Sep 17 00:00:00 2001
From: Micah Cantor <micahcantor01@gmail.com>
Date: Thu, 20 Jul 2023 13:15:14 +0200
Subject: [PATCH 033/112] new test file

---
 compiler/tests-compiler/dune.inc           | 15 +++++++++++++++
 compiler/tests-compiler/global_deadcode.ml | 13 +++++++++++++
 2 files changed, 28 insertions(+)
 create mode 100644 compiler/tests-compiler/global_deadcode.ml

diff --git a/compiler/tests-compiler/dune.inc b/compiler/tests-compiler/dune.inc
index 16031627fa..08401a258f 100644
--- a/compiler/tests-compiler/dune.inc
+++ b/compiler/tests-compiler/dune.inc
@@ -374,6 +374,21 @@
  (preprocess
   (pps ppx_expect)))
 
+(library
+ ;; compiler/tests-compiler/global_deadcode.ml
+ (name global_deadcode_15)
+ (enabled_if true)
+ (modules global_deadcode)
+ (libraries js_of_ocaml_compiler unix str jsoo_compiler_expect_tests_helper)
+ (inline_tests
+  (enabled_if true)
+  (deps
+   (file %{project_root}/compiler/bin-js_of_ocaml/js_of_ocaml.exe)
+   (file %{project_root}/compiler/bin-jsoo_minify/jsoo_minify.exe)))
+ (flags (:standard -open Jsoo_compiler_expect_tests_helper))
+ (preprocess
+  (pps ppx_expect)))
+
 (library
  ;; compiler/tests-compiler/inlining.ml
  (name inlining_15)
diff --git a/compiler/tests-compiler/global_deadcode.ml b/compiler/tests-compiler/global_deadcode.ml
new file mode 100644
index 0000000000..a367ca0b1b
--- /dev/null
+++ b/compiler/tests-compiler/global_deadcode.ml
@@ -0,0 +1,13 @@
+open Util
+
+let%expect_test "" =
+  let program =
+    compile_and_parse
+      {|
+      |}
+  in
+  print_fun_decl program (Some "");
+  [%expect
+    {|
+    
+    //end |}]
\ No newline at end of file

From a38d18156fb598e5c6e264fca1ce8c65d27b8632 Mon Sep 17 00:00:00 2001
From: Micah Cantor <micahcantor01@gmail.com>
Date: Tue, 25 Jul 2023 13:30:24 +0200
Subject: [PATCH 034/112] add back dgraph call in driver

---
 compiler/lib/driver.ml | 17 +++++------------
 1 file changed, 5 insertions(+), 12 deletions(-)

diff --git a/compiler/lib/driver.ml b/compiler/lib/driver.ml
index c1a57d97e4..2cdebb71a7 100644
--- a/compiler/lib/driver.ml
+++ b/compiler/lib/driver.ml
@@ -36,9 +36,9 @@ let tailcall p =
   if debug () then Format.eprintf "Tail-call optimization...@.";
   Tailcall.f p
 
-let deadcode' _global_info p =
+let deadcode' global_info p =
   if debug () then Format.eprintf "Dead-code...@.";
-  (* let p = Deadcode_dgraph.f p global_info in *)
+  let p = Deadcode_dgraph.f p global_info in
   let p, live_vars = Deadcode.f p in
   p, live_vars
 
@@ -98,16 +98,9 @@ let effects p =
     p |> Deadcode.f +> Effects.f +> map_fst Lambda_lifting.f)
   else p, (Code.Var.Set.empty : Effects.cps_calls)
 
-let exact_calls profile p =
+let exact_calls global_info p =
   if not (Config.Flag.effects ())
-  then
-    let fast =
-      match profile with
-      | O3 -> false
-      | O1 | O2 -> true
-    in
-    let info = Global_flow.f ~fast p in
-    Specialize.f ~function_arity:(fun f -> Global_flow.function_arity info f) p
+  then Specialize.f ~function_arity:(fun f -> Global_flow.function_arity global_info f) p
   else p
 
 let print p =
@@ -586,7 +579,7 @@ let full ~standalone ~wrap_with_fun ~profile ~linkall ~source_map formatter d p
        | O1 -> o1 global_info
        | O2 -> o2 global_info
        | O3 -> o3 global_info)
-    +> exact_calls profile
+    +> exact_calls global_info
     +> effects
     +> map_fst (Generate_closure.f +> deadcode' global_info)
   in

From 18678f696379dc0340d751081d863798a9338247 Mon Sep 17 00:00:00 2001
From: Micah Cantor <micahcantor01@gmail.com>
Date: Tue, 25 Jul 2023 14:13:28 +0200
Subject: [PATCH 035/112] revert changes to driver

---
 compiler/lib/driver.ml | 67 +++++++++++++++++++++---------------------
 1 file changed, 33 insertions(+), 34 deletions(-)

diff --git a/compiler/lib/driver.ml b/compiler/lib/driver.ml
index 2cdebb71a7..b1c2b93b57 100644
--- a/compiler/lib/driver.ml
+++ b/compiler/lib/driver.ml
@@ -36,20 +36,18 @@ let tailcall p =
   if debug () then Format.eprintf "Tail-call optimization...@.";
   Tailcall.f p
 
-let deadcode' global_info p =
+let deadcode' p =
   if debug () then Format.eprintf "Dead-code...@.";
-  let p = Deadcode_dgraph.f p global_info in
-  let p, live_vars = Deadcode.f p in
-  p, live_vars
+  Deadcode.f p
 
-let deadcode global_info p =
-  let r, _ = deadcode' global_info p in
+let deadcode p =
+  let r, _ = deadcode' p in
   r
 
-let inline global_info p =
+let inline p =
   if Config.Flag.inline () && Config.Flag.deadcode ()
   then (
-    let p, live_vars = deadcode' global_info p in
+    let p, live_vars = deadcode' p in
     if debug () then Format.eprintf "Inlining...@.";
     Inline.f p live_vars)
   else p
@@ -98,9 +96,16 @@ let effects p =
     p |> Deadcode.f +> Effects.f +> map_fst Lambda_lifting.f)
   else p, (Code.Var.Set.empty : Effects.cps_calls)
 
-let exact_calls global_info p =
+let exact_calls profile p =
   if not (Config.Flag.effects ())
-  then Specialize.f ~function_arity:(fun f -> Global_flow.function_arity global_info f) p
+  then
+    let fast =
+      match profile with
+      | O3 -> false
+      | O1 | O2 -> true
+    in
+    let info = Global_flow.f ~fast p in
+    Specialize.f ~function_arity:(fun f -> Global_flow.function_arity info f) p
   else p
 
 let print p =
@@ -119,27 +124,27 @@ let identity x = x
 
 (* o1 *)
 
-let o1 global_info =
+let o1 : 'a -> 'a =
   print
   +> tailcall
   +> flow_simple (* flow simple to keep information for future tailcall opt *)
   +> specialize'
   +> eval
-  +> inline global_info (* inlining may reveal new tailcall opt *)
-  +> deadcode global_info
+  +> inline (* inlining may reveal new tailcall opt *)
+  +> deadcode
   +> tailcall
   +> phi
   +> flow
   +> specialize'
   +> eval
-  +> inline global_info
-  +> deadcode global_info
+  +> inline
+  +> deadcode
   +> print
   +> flow
   +> specialize'
   +> eval
-  +> inline global_info
-  +> deadcode global_info
+  +> inline
+  +> deadcode
   +> phi
   +> flow
   +> specialize
@@ -147,28 +152,23 @@ let o1 global_info =
 
 (* o2 *)
 
-let o2 global_info = loop 10 "o1" (o1 global_info) 1 +> print
+let o2 : 'a -> 'a = loop 10 "o1" o1 1 +> print
 
 (* o3 *)
 
-let round1 global_info =
+let round1 : 'a -> 'a =
   print
   +> tailcall
-  +> inline global_info (* inlining may reveal new tailcall opt *)
-  +> deadcode
-       global_info (* deadcode required before flow simple -> provided by constant *)
+  +> inline (* inlining may reveal new tailcall opt *)
+  +> deadcode (* deadcode required before flow simple -> provided by constant *)
   +> flow_simple (* flow simple to keep information for future tailcall opt *)
   +> specialize'
   +> eval
   +> identity
 
-let round2 global_info =
-  flow +> specialize' +> eval +> deadcode global_info +> o1 global_info
+let round2 = flow +> specialize' +> eval +> deadcode +> o1
 
-let o3 global_info =
-  loop 10 "tailcall+inline" (round1 global_info) 1
-  +> loop 10 "flow" (round2 global_info) 1
-  +> print
+let o3 = loop 10 "tailcall+inline" round1 1 +> loop 10 "flow" round2 1 +> print
 
 let generate
     d
@@ -573,15 +573,14 @@ let configure formatter =
 let full ~standalone ~wrap_with_fun ~profile ~linkall ~source_map formatter d p =
   let exported_runtime = not standalone in
   let opt =
-    let global_info = Global_flow.f ~fast:false p in
     specialize_js_once
     +> (match profile with
-       | O1 -> o1 global_info
-       | O2 -> o2 global_info
-       | O3 -> o3 global_info)
-    +> exact_calls global_info
+       | O1 -> o1
+       | O2 -> o2
+       | O3 -> o3)
+    +> exact_calls profile
     +> effects
-    +> map_fst (Generate_closure.f +> deadcode' global_info)
+    +> map_fst (Generate_closure.f +> deadcode')
   in
   let emit =
     generate d ~exported_runtime ~wrap_with_fun ~warn_on_unhandled_effect:standalone

From 65b7d9d2e10c4e2d7e207d9154d03a0e01e58761 Mon Sep 17 00:00:00 2001
From: Micah Cantor <micahcantor01@gmail.com>
Date: Wed, 26 Jul 2023 15:14:29 +0200
Subject: [PATCH 036/112] tweaks

---
 compiler/lib/deadcode_dgraph.ml  | 26 +++++++++++++++-----------
 compiler/lib/deadcode_dgraph.mli |  4 +++-
 2 files changed, 18 insertions(+), 12 deletions(-)

diff --git a/compiler/lib/deadcode_dgraph.ml b/compiler/lib/deadcode_dgraph.ml
index 16a2bda259..fa9eabcea5 100644
--- a/compiler/lib/deadcode_dgraph.ml
+++ b/compiler/lib/deadcode_dgraph.ml
@@ -21,6 +21,8 @@ open Stdlib
 
 let debug = Debug.find "globaldeadcode"
 
+let times = Debug.find "times"
+
 type def =
   | Expr of expr
   | Param
@@ -197,7 +199,6 @@ let liveness nv prog pure_funs (global_info : Global_flow.info) =
                 args
           | _ -> ())
     | Assign (_, _) -> ()
-    (* TODO: what to do with these? *)
     | Set_field (x, i, y) ->
         add_live x i;
         add_top y
@@ -246,7 +247,7 @@ let propagate uses defs live_vars live_table x =
                   vars;
                 if !found then Top else Dead
             | _ -> Top)
-        (* If y is top, then if y is a field access, x depends only on that field *)
+        (* If y is top and y is a field access, x depends only on that field *)
         | Top -> (
             match defs.(Var.idx y) with
             | Expr (Field (_, i)) -> Live (IntSet.singleton i)
@@ -268,11 +269,6 @@ let solver vars uses defs live_vars =
   Solver.f () (G.invert () g) (propagate uses defs live_vars)
 
 let zero prog sentinal live_table =
-  let add_sentinal_instr blocks =
-    let block = Addr.Map.find 0 blocks in
-    let body = (Let (sentinal, Constant (Int 0l)), Before 0) :: block.body in
-    Addr.Map.add 0 { block with body } blocks
-  in
   let compact_vars vars =
     let i = ref (Array.length vars - 1) in
     while !i >= 0 && Var.equal vars.(!i) sentinal do
@@ -347,7 +343,7 @@ let zero prog sentinal live_table =
     in
     { block with body; branch }
   in
-  let blocks = prog.blocks |> Addr.Map.map zero_block |> add_sentinal_instr in
+  let blocks = prog.blocks |> Addr.Map.map zero_block in
   { prog with blocks }
 
 module Print = struct
@@ -397,8 +393,13 @@ module Print = struct
       live_table
 end
 
-let f p global_info =
-  let _sentinal = Var.fresh () in
+let add_sentinal p =
+  let sentinal = Var.fresh () in
+  let instr, loc = Let (sentinal, Constant (Int 0l)), Before 0 in
+  Code.prepend p [ instr, loc ], sentinal
+
+let f p sentinal global_info =
+  let t = Timer.make () in
   let nv = Var.count () in
   (* Compute definitions *)
   let defs = definitions nv p in
@@ -411,11 +412,14 @@ let f p global_info =
   let vars = variables uses in
   let live_table = solver vars uses defs live_vars in
   (* Zero out dead fields *)
-  (* let p = zero p sentinal live_table in *)
+  let p = zero p sentinal live_table in
   if debug ()
   then (
+    Code.Print.program (fun _ _ -> "") p;
+    Print.print_liveness live_vars;
     Print.print_uses uses;
     Print.print_live_tbl live_table;
     Format.eprintf "After Elimination:\n";
     Code.Print.program (fun _ _ -> "") p);
+  if times () then Format.eprintf "  deadcode dgraph.: %a@." Timer.print t;
   p
diff --git a/compiler/lib/deadcode_dgraph.mli b/compiler/lib/deadcode_dgraph.mli
index aba550ed69..ccb1b6c0b6 100644
--- a/compiler/lib/deadcode_dgraph.mli
+++ b/compiler/lib/deadcode_dgraph.mli
@@ -16,4 +16,6 @@
  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  *)
 
-val f : Code.program -> Global_flow.info -> Code.program
\ No newline at end of file
+val add_sentinal : Code.program -> Code.program * Code.Var.t
+
+val f : Code.program -> Code.Var.t -> Global_flow.info -> Code.program
\ No newline at end of file

From 2a3462f3e16f598649cdea2d79a9eb0696a61765 Mon Sep 17 00:00:00 2001
From: Micah Cantor <micahcantor01@gmail.com>
Date: Wed, 26 Jul 2023 15:26:27 +0200
Subject: [PATCH 037/112] pull out sentinal

---
 compiler/lib/driver.ml | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/compiler/lib/driver.ml b/compiler/lib/driver.ml
index b1c2b93b57..a9cf59779f 100644
--- a/compiler/lib/driver.ml
+++ b/compiler/lib/driver.ml
@@ -104,7 +104,9 @@ let exact_calls profile p =
       | O3 -> false
       | O1 | O2 -> true
     in
+    let p, sentinal = Deadcode_dgraph.add_sentinal p in
     let info = Global_flow.f ~fast p in
+    let p = Deadcode_dgraph.f p sentinal info in
     Specialize.f ~function_arity:(fun f -> Global_flow.function_arity info f) p
   else p
 

From efc617c8147ca74fc81dd40c6bc64bf4bcbd20fb Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=A9r=C3=B4me=20Vouillon?= <jerome.vouillon@gmail.com>
Date: Wed, 26 Jul 2023 17:51:48 +0200
Subject: [PATCH 038/112] Fix global flow analysis

In fast mode, we don't track function arguments, so we should consider them as escaping.
---
 CHANGES.md                  |  1 +
 compiler/lib/global_flow.ml | 17 ++++++++++++++---
 2 files changed, 15 insertions(+), 3 deletions(-)

diff --git a/CHANGES.md b/CHANGES.md
index 8826a18745..d640ae8ee9 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -1,6 +1,7 @@
 # Dev (2023-??-??) - ??
 
 * Runtime: fix Dom_html.onIE (#1493)
+* Compiler: fix global flow analysis (#1494)
 
 # 5.4.0 (2023-07-06) - Lille
 
diff --git a/compiler/lib/global_flow.ml b/compiler/lib/global_flow.ml
index 849b3456c6..17e84d54b4 100644
--- a/compiler/lib/global_flow.ml
+++ b/compiler/lib/global_flow.ml
@@ -215,7 +215,9 @@ let expr_deps blocks st x e =
       match st.defs.(Var.idx f) with
       | Expr (Closure (params, _)) when List.length args = List.length params ->
           Hashtbl.add st.applied_functions (x, f) ();
-          if not st.fast then List.iter2 ~f:(fun p a -> add_assign_def st p a) params args;
+          if st.fast
+          then List.iter ~f:(fun a -> do_escape st Escape a) args
+          else List.iter2 ~f:(fun p a -> add_assign_def st p a) params args;
           Var.Set.iter (fun y -> add_dep st x y) (Var.Map.find f st.return_values)
       | _ -> ())
   | Closure (l, cont) ->
@@ -470,8 +472,13 @@ let propagate st ~update approx x =
                       if not (Hashtbl.mem st.applied_functions (x, g))
                       then (
                         Hashtbl.add st.applied_functions (x, g) ();
-                        if not st.fast
+                        if st.fast
                         then
+                          List.iter
+                            ~f:(fun y ->
+                              Domain.variable_escape ~update ~st ~approx Escape y)
+                            args
+                        else
                           List.iter2
                             ~f:(fun p a ->
                               add_assign_def st p a;
@@ -593,7 +600,7 @@ let f ~fast p =
               | Values { known; others } ->
                   Format.fprintf
                     f
-                    "{%a/%b} mut:%b vmut:%b esc:%s"
+                    "{%a/%b} mut:%b vmut:%b vesc:%s esc:%s"
                     (Format.pp_print_list
                        ~pp_sep:(fun f () -> Format.fprintf f ", ")
                        (fun f x ->
@@ -615,6 +622,10 @@ let f ~fast p =
                     others
                     st.possibly_mutable.(Var.idx x)
                     st.variable_possibly_mutable.(Var.idx x)
+                    (match st.variable_may_escape.(Var.idx x) with
+                    | Escape -> "Y"
+                    | Escape_constant -> "y"
+                    | No -> "n")
                     (match st.may_escape.(Var.idx x) with
                     | Escape -> "Y"
                     | Escape_constant -> "y"

From d73622c0f5f4ae0880c60a5e345e0ef1eceecd8d Mon Sep 17 00:00:00 2001
From: Micah Cantor <micahcantor01@gmail.com>
Date: Thu, 27 Jul 2023 11:00:39 +0200
Subject: [PATCH 039/112] add disable globaldeadcode flag, fix tests

---
 compiler/lib/config.ml            |  2 ++
 compiler/lib/config.mli           |  2 ++
 compiler/lib/driver.ml            | 12 ++++++++----
 compiler/tests-compiler/gh1349.ml |  1 +
 compiler/tests-compiler/gh1354.ml |  3 +++
 5 files changed, 16 insertions(+), 4 deletions(-)

diff --git a/compiler/lib/config.ml b/compiler/lib/config.ml
index 95193f49c3..9385a063ba 100644
--- a/compiler/lib/config.ml
+++ b/compiler/lib/config.ml
@@ -58,6 +58,8 @@ module Flag = struct
 
   let deadcode = o ~name:"deadcode" ~default:true
 
+  let globaldeadcode = o ~name:"globaldeadcode" ~default:true
+
   let shortvar = o ~name:"shortvar" ~default:true
 
   let compact = o ~name:"compact" ~default:true
diff --git a/compiler/lib/config.mli b/compiler/lib/config.mli
index ac1672bdef..e4c86d37b0 100644
--- a/compiler/lib/config.mli
+++ b/compiler/lib/config.mli
@@ -25,6 +25,8 @@ module Flag : sig
 
   val deadcode : unit -> bool
 
+  val globaldeadcode : unit -> bool
+
   val optcall : unit -> bool
 
   val shortvar : unit -> bool
diff --git a/compiler/lib/driver.ml b/compiler/lib/driver.ml
index a9cf59779f..f72320508e 100644
--- a/compiler/lib/driver.ml
+++ b/compiler/lib/driver.ml
@@ -104,10 +104,14 @@ let exact_calls profile p =
       | O3 -> false
       | O1 | O2 -> true
     in
-    let p, sentinal = Deadcode_dgraph.add_sentinal p in
-    let info = Global_flow.f ~fast p in
-    let p = Deadcode_dgraph.f p sentinal info in
-    Specialize.f ~function_arity:(fun f -> Global_flow.function_arity info f) p
+    if Config.Flag.globaldeadcode () then
+      let p, sentinal = Deadcode_dgraph.add_sentinal p in
+      let info = Global_flow.f ~fast p in
+      let p = Deadcode_dgraph.f p sentinal info in
+      Specialize.f ~function_arity:(fun f -> Global_flow.function_arity info f) p
+    else 
+      let info = Global_flow.f ~fast p in
+      Specialize.f ~function_arity:(fun f -> Global_flow.function_arity info f) p
   else p
 
 let print p =
diff --git a/compiler/tests-compiler/gh1349.ml b/compiler/tests-compiler/gh1349.ml
index aff3e46862..c385023520 100644
--- a/compiler/tests-compiler/gh1349.ml
+++ b/compiler/tests-compiler/gh1349.ml
@@ -35,6 +35,7 @@ let%expect_test _ =
         (List.concat
            [ [ "--disable"; "inline" ]
            ; [ "--disable"; "deadcode" ]
+           ; [ "--disable"; "globaldeadcode" ]
            ; [ "--disable"; "staticeval" ]
            ; [ "--enable"; "shortvar" ]
            ; [ "--debug"; "shortvar" ]
diff --git a/compiler/tests-compiler/gh1354.ml b/compiler/tests-compiler/gh1354.ml
index 16789258ba..122686d07b 100644
--- a/compiler/tests-compiler/gh1354.ml
+++ b/compiler/tests-compiler/gh1354.ml
@@ -37,6 +37,7 @@ with Exit ->
         (List.concat
            [ [ "--disable"; "inline" ]
            ; [ "--disable"; "deadcode" ]
+           ; [ "--disable"; "globaldeadcode" ]
            ; [ "--disable"; "staticeval" ]
            ])
       prog
@@ -100,6 +101,7 @@ with Exit ->
         (List.concat
            [ [ "--disable"; "inline" ]
            ; [ "--disable"; "deadcode" ]
+           ; [ "--disable"; "globaldeadcode" ]
            ; [ "--disable"; "staticeval" ]
            ])
       prog
@@ -186,6 +188,7 @@ with Exit ->
         (List.concat
            [ [ "--disable"; "inline" ]
            ; [ "--disable"; "deadcode" ]
+           ; [ "--disable"; "globaldeadcode" ]
            ; [ "--disable"; "staticeval" ]
            ])
       prog

From b901fdedfd1b2020ce5bff4e26bd14d49c707088 Mon Sep 17 00:00:00 2001
From: Micah Cantor <micahcantor01@gmail.com>
Date: Thu, 27 Jul 2023 11:00:57 +0200
Subject: [PATCH 040/112] expose variable_may_escape

---
 compiler/lib/global_flow.ml  | 3 +++
 compiler/lib/global_flow.mli | 6 ++++++
 2 files changed, 9 insertions(+)

diff --git a/compiler/lib/global_flow.ml b/compiler/lib/global_flow.ml
index 90727665d6..4895530044 100644
--- a/compiler/lib/global_flow.ml
+++ b/compiler/lib/global_flow.ml
@@ -547,6 +547,7 @@ type info =
   { info_defs : def array
   ; info_approximation : Domain.t Var.Tbl.t
   ; info_may_escape : Var.ISet.t
+  ; info_variable_may_escape : escape_status array
   ; info_return_vals : Var.Set.t Var.Map.t
   }
 
@@ -633,12 +634,14 @@ let f ~fast p =
                     | No -> "n"))
             s)
       vars;
+  let info_variable_may_escape = variable_may_escape in
   let info_may_escape = Var.ISet.empty () in
   Array.iteri
     ~f:(fun i s -> if Poly.(s <> No) then Var.ISet.add info_may_escape (Var.of_idx i))
     may_escape;
   { info_defs = defs
   ; info_approximation = approximation
+  ; info_variable_may_escape
   ; info_may_escape
   ; info_return_vals = rets
   }
diff --git a/compiler/lib/global_flow.mli b/compiler/lib/global_flow.mli
index 65d9cbfb59..61f5dbfb6a 100644
--- a/compiler/lib/global_flow.mli
+++ b/compiler/lib/global_flow.mli
@@ -31,10 +31,16 @@ type approx =
       ; others : bool (* Whether other values are possible *)
       }
 
+type escape_status =
+  | Escape
+  | Escape_constant (* Escapes but we know the value is not modified *)
+  | No
+
 type info =
   { info_defs : def array
   ; info_approximation : approx Var.Tbl.t
   ; info_may_escape : Var.ISet.t
+  ; info_variable_may_escape : escape_status array
   ; info_return_vals : Var.Set.t Var.Map.t
   }
 

From aa2c32dd817e71fb00ecb7f0eb3a1bd8b9ec437d Mon Sep 17 00:00:00 2001
From: Micah Cantor <micahcantor01@gmail.com>
Date: Thu, 27 Jul 2023 11:01:17 +0200
Subject: [PATCH 041/112] use variable_may_escape

---
 compiler/lib/deadcode_dgraph.ml | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/compiler/lib/deadcode_dgraph.ml b/compiler/lib/deadcode_dgraph.ml
index fa9eabcea5..96d76d0b4b 100644
--- a/compiler/lib/deadcode_dgraph.ml
+++ b/compiler/lib/deadcode_dgraph.ml
@@ -184,6 +184,10 @@ let liveness nv prog pure_funs (global_info : Global_flow.info) =
     | Live fields -> live_vars.(idx) <- Live (IntSet.add i fields)
     | _ -> live_vars.(idx) <- Live (IntSet.singleton i)
   in
+  let variable_may_escape x = match global_info.info_variable_may_escape.(Var.idx x) with
+    | Escape | Escape_constant -> true
+    | No -> false
+  in
   let live_instruction i =
     match i with
     | Let (x, e) ->
@@ -195,7 +199,7 @@ let liveness nv prog pure_funs (global_info : Global_flow.info) =
           match e with
           | Apply { args; _ } ->
               List.iter
-                ~f:(fun x -> if Var.ISet.mem global_info.info_may_escape x then add_top x)
+                ~f:(fun x -> if variable_may_escape x then add_top x)
                 args
           | _ -> ())
     | Assign (_, _) -> ()
@@ -212,7 +216,7 @@ let liveness nv prog pure_funs (global_info : Global_flow.info) =
     List.iter ~f:(fun (i, _) -> live_instruction i) block.body;
     match fst block.branch with
     | Stop -> ()
-    | Return x -> if Var.ISet.mem global_info.info_may_escape x then add_top x
+    | Return x -> if variable_may_escape x then add_top x
     | Raise (x, _) -> add_top x
     | Cond (x, _, _) -> add_top x
     | Switch (x, _, _) -> add_top x

From 938c8af3994fc3ddf7b1f81f346ceb0c056f85b8 Mon Sep 17 00:00:00 2001
From: Micah Cantor <micahcantor01@gmail.com>
Date: Thu, 27 Jul 2023 15:41:39 +0200
Subject: [PATCH 042/112] fix infinite loop bug

---
 compiler/lib/deadcode_dgraph.ml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/compiler/lib/deadcode_dgraph.ml b/compiler/lib/deadcode_dgraph.ml
index 96d76d0b4b..d84c8475ea 100644
--- a/compiler/lib/deadcode_dgraph.ml
+++ b/compiler/lib/deadcode_dgraph.ml
@@ -262,7 +262,7 @@ let propagate uses defs live_vars live_table x =
   Var.Map.fold
     (fun y usage_kind live -> Domain.join (contribution y usage_kind) live)
     uses.(idx)
-    live_vars.(idx)
+    (Domain.join live_vars.(idx) (Var.Tbl.get live_table x))
 
 let solver vars uses defs live_vars =
   let g =

From 264cb33dc99b9c4c1ae0d84048ee3864ec85e394 Mon Sep 17 00:00:00 2001
From: Micah Cantor <micahcantor01@gmail.com>
Date: Fri, 28 Jul 2023 11:48:22 +0200
Subject: [PATCH 043/112] change sentinal to undefined

---
 compiler/lib/deadcode_dgraph.ml | 3 ++-
 compiler/lib/generate.ml        | 3 +++
 2 files changed, 5 insertions(+), 1 deletion(-)

diff --git a/compiler/lib/deadcode_dgraph.ml b/compiler/lib/deadcode_dgraph.ml
index d84c8475ea..4f3d1c56b8 100644
--- a/compiler/lib/deadcode_dgraph.ml
+++ b/compiler/lib/deadcode_dgraph.ml
@@ -399,7 +399,8 @@ end
 
 let add_sentinal p =
   let sentinal = Var.fresh () in
-  let instr, loc = Let (sentinal, Constant (Int 0l)), Before 0 in
+  let undefined = Prim (Extern "%undefined", []) in
+  let instr, loc = Let (sentinal, undefined), Before 0 in
   Code.prepend p [ instr, loc ], sentinal
 
 let f p sentinal global_info =
diff --git a/compiler/lib/generate.ml b/compiler/lib/generate.ml
index 367e2041f2..d8d9f7bed4 100644
--- a/compiler/lib/generate.ml
+++ b/compiler/lib/generate.ml
@@ -1318,6 +1318,9 @@ let rec translate_expr ctx queue loc x e level : _ * J.statement_list =
             let prim = Share.get_prim (runtime_fun ctx) name ctx.Ctx.share in
             prim, const_p, queue
         | Extern "%closure", _ -> assert false
+        | Extern "%undefined", [] ->
+            J.(EVar (ident (Utf8_string.of_string_exn "undefined"))), const_p, queue
+        | Extern "%undefined", _ -> assert false
         | Extern "%caml_js_opt_call", f :: o :: l ->
             let (pf, cf), queue = access_queue' ~ctx queue f in
             let (po, co), queue = access_queue' ~ctx queue o in

From 9c4c80d37c546683678de5a049400a0d1a08daa3 Mon Sep 17 00:00:00 2001
From: Micah Cantor <micahcantor01@gmail.com>
Date: Fri, 28 Jul 2023 14:28:45 +0200
Subject: [PATCH 044/112] begin adding unit tests

---
 compiler/tests-compiler/global_deadcode.ml | 42 +++++++++++++++++++---
 1 file changed, 37 insertions(+), 5 deletions(-)

diff --git a/compiler/tests-compiler/global_deadcode.ml b/compiler/tests-compiler/global_deadcode.ml
index a367ca0b1b..95068d53c0 100644
--- a/compiler/tests-compiler/global_deadcode.ml
+++ b/compiler/tests-compiler/global_deadcode.ml
@@ -1,13 +1,45 @@
 open Util
 
-let%expect_test "" =
+let%expect_test "Eliminates unused functions from functor" =
   let program =
-    compile_and_parse
+    compile_and_parse_whole_program
       {|
+      module Int_set = Set.Make (Int);;
+
+      let set = Int_set.singleton 1 in
+      let set = Int_set.add 2 set in
+      print_endline (string_of_int (Int_set.find 1 set + Int_set.find 2 set))
       |}
   in
-  print_fun_decl program (Some "");
+  (* Expect: compiles functor members used in the program *)
+  print_fun_decl program (Some "find");
   [%expect
     {|
-    
-    //end |}]
\ No newline at end of file
+    function find(x, param){
+     var param$0 = param;
+     for(;;){
+      if(! param$0) throw caml_maybe_attach_backtrace(Not_found, 1);
+      var
+       r = param$0[3],
+       v = param$0[2],
+       l = param$0[1],
+       c = caml_int_compare(x, v);
+      if(0 === c) return v;
+      var r$0 = 0 <= c ? r : l, param$0 = r$0;
+     }
+    }
+    //end |}];
+  print_fun_decl program (Some "add");
+  [%expect {|
+    function add(x, t){
+     if(! t) return [0, 0, x, 0, 1];
+     var r = t[3], v = t[2], l = t[1], c = caml_int_compare(x, v);
+     if(0 === c) return t;
+     if(0 <= c){var rr = add(x, r); return r === rr ? t : bal(l, v, rr);}
+     var ll = add(x, l);
+     return l === ll ? t : bal(ll, v, r);
+    }
+    //end |}];
+  (* Expect: does not compile unused functor member *)
+  print_fun_decl program (Some "union");
+  [%expect {| not found |}]
\ No newline at end of file

From 16606a68164eed4ae8e79df48fd139ece15dd7f6 Mon Sep 17 00:00:00 2001
From: Micah Cantor <micahcantor01@gmail.com>
Date: Mon, 31 Jul 2023 11:53:33 +0200
Subject: [PATCH 045/112] add new test

---
 compiler/tests-compiler/global_deadcode.ml | 42 ++++++++++++++++++----
 1 file changed, 36 insertions(+), 6 deletions(-)

diff --git a/compiler/tests-compiler/global_deadcode.ml b/compiler/tests-compiler/global_deadcode.ml
index 95068d53c0..883fc31da5 100644
--- a/compiler/tests-compiler/global_deadcode.ml
+++ b/compiler/tests-compiler/global_deadcode.ml
@@ -2,13 +2,16 @@ open Util
 
 let%expect_test "Eliminates unused functions from functor" =
   let program =
+    (* Create two instances of Set functor so compiler can't inline one implementation. *)
     compile_and_parse_whole_program
       {|
       module Int_set = Set.Make (Int);;
+      module String_set = Set.Make (String);;
 
-      let set = Int_set.singleton 1 in
-      let set = Int_set.add 2 set in
-      print_endline (string_of_int (Int_set.find 1 set + Int_set.find 2 set))
+      let int_set = Int_set.singleton 1 in
+      let string_set = String_set.empty in
+      let string_set = String_set.add "hello" string_set in
+      print_endline (string_of_int (Int_set.find 1 int_set) ^ (String_set.find "hello" string_set))
       |}
   in
   (* Expect: compiles functor members used in the program *)
@@ -23,7 +26,7 @@ let%expect_test "Eliminates unused functions from functor" =
        r = param$0[3],
        v = param$0[2],
        l = param$0[1],
-       c = caml_int_compare(x, v);
+       c = caml_call2(Ord[1], x, v);
       if(0 === c) return v;
       var r$0 = 0 <= c ? r : l, param$0 = r$0;
      }
@@ -33,7 +36,7 @@ let%expect_test "Eliminates unused functions from functor" =
   [%expect {|
     function add(x, t){
      if(! t) return [0, 0, x, 0, 1];
-     var r = t[3], v = t[2], l = t[1], c = caml_int_compare(x, v);
+     var r = t[3], v = t[2], l = t[1], c = caml_call2(Ord[1], x, v);
      if(0 === c) return t;
      if(0 <= c){var rr = add(x, r); return r === rr ? t : bal(l, v, rr);}
      var ll = add(x, l);
@@ -42,4 +45,31 @@ let%expect_test "Eliminates unused functions from functor" =
     //end |}];
   (* Expect: does not compile unused functor member *)
   print_fun_decl program (Some "union");
-  [%expect {| not found |}]
\ No newline at end of file
+  [%expect {| not found |}];
+  print_fun_decl program (Some "inter");
+  [%expect {| not found |}]
+
+let%expect_test "Substitutes unused fields with undefined" =
+  let program =
+    compile_and_parse
+      {|
+      let f b x =
+        let t = if b then (1, 2, x) else (3, x, 4) in
+        let (u, _, v) = t in
+        (u, v)
+      in print_int (fst (f true 1) + snd (f false 2))
+      |}
+  in 
+  (* Expect second field in each triple to be replaced by a sentinal variable. *)
+  print_fun_decl program (Some "f");
+  [%expect {|
+    function f(b, x){
+     var t = b ? [0, 1, _c_, x] : [0, 3, _c_, 4], v = t[3], u = t[1];
+     return [0, u, v];
+    }
+    //end |}];
+  (* And that variable is defined as `undefined` *)
+  print_var_decl program "_c_";
+  [%expect {|
+    var _c_ = undefined;
+    //end |}]
\ No newline at end of file

From a6ee4f9b3c04ac1e7d39479c81e4d0abfc26c2d1 Mon Sep 17 00:00:00 2001
From: Micah Cantor <micahcantor01@gmail.com>
Date: Mon, 31 Jul 2023 12:33:51 +0200
Subject: [PATCH 046/112] small change to stdlib

---
 compiler/tests-full/stdlib.cma.expected.js | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/compiler/tests-full/stdlib.cma.expected.js b/compiler/tests-full/stdlib.cma.expected.js
index 498240028e..e47097c652 100644
--- a/compiler/tests-full/stdlib.cma.expected.js
+++ b/compiler/tests-full/stdlib.cma.expected.js
@@ -18068,9 +18068,9 @@
     /*<<camlinternalFormat.ml:2018:62>>*/ }
    function make_padprec_fmt_ebb(pad, prec, fmt){
      /*<<camlinternalFormat.ml:2038:2>>*/ if(typeof prec === "number")
-     var match = prec ? [0, 1, fmt] : [0, 0, fmt];
+     var match = prec ? [0, 1] : [0, 0];
     else
-     var p = prec[1], match = [0, [0, p], fmt];
+     var p = prec[1], match = [0, [0, p]];
     var prec$0 = match[1];
      /*<<camlinternalFormat.ml:2039:2>>*/ if(typeof pad === "number")
       /*<<camlinternalFormat.ml:2040:26>>*/ return [0, 0, prec$0, fmt];

From 4f0c0a09e14d6d6fff327e0189d978369e828f75 Mon Sep 17 00:00:00 2001
From: Micah Cantor <micahcantor01@gmail.com>
Date: Mon, 31 Jul 2023 15:04:36 +0200
Subject: [PATCH 047/112] documentation

---
 compiler/lib/deadcode_dgraph.ml | 80 +++++++++++++++++++++++----------
 1 file changed, 56 insertions(+), 24 deletions(-)

diff --git a/compiler/lib/deadcode_dgraph.ml b/compiler/lib/deadcode_dgraph.ml
index 4f3d1c56b8..8bc101f6ac 100644
--- a/compiler/lib/deadcode_dgraph.ml
+++ b/compiler/lib/deadcode_dgraph.ml
@@ -14,6 +14,16 @@
  * You should have received a copy of the GNU Lesser General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+
+ This module provides a global liveness analysis more powerful than that found in [deadcode.ml]. In particular,
+ this analysis annotates blocks with the specific fields that are live. It also uses [global_flow.ml] to determine
+ the liveness of function return values. It first computes an initial liveness of each variable by traversing the program IR.
+ Then it propagates this information to the dependencies of each variable using a flow analysis solver. Lastly it replaces
+ dead variables with a sentinal zero variable.
+
+ Although this module does not perform any dead-code elimination itself, it is designed to be used to identify and substitute 
+ dead variables that are then removed by [deadcode.ml]. In particular it can allow the elimination of unused functions defined 
+ in functors, which the original deadcode elimination cannot. 
  *)
 
 open Code
@@ -23,14 +33,16 @@ let debug = Debug.find "globaldeadcode"
 
 let times = Debug.find "times"
 
+(** Definition of a variable [x]. *)
 type def =
-  | Expr of expr
-  | Param
+  | Expr of expr (** [x] is defined by an expression. *)
+  | Param (** [x] is a block or closure parameter. *)
 
+(** Liveness of a variable [x], forming a lattice structure. *)
 type live =
-  | Top
-  | Live of IntSet.t
-  | Dead
+  | Top (** [x] is live and not a block. *)
+  | Live of IntSet.t (** [x] is a live block with a (non-empty) set of live fields. *)
+  | Dead (** [x] is dead. *)
 
 module G = Dgraph.Make_Imperative (Var) (Var.ISet) (Var.Tbl)
 
@@ -45,6 +57,7 @@ module Domain = struct
 
   let bot = Dead
 
+  (** Join the liveness according to lattice structure. *)
   let join l1 l2 =
     match l1, l2 with
     | _, Top | Top, _ -> Top
@@ -73,10 +86,17 @@ let definitions nv prog =
     prog.blocks;
   defs
 
+(** Type of variable usage. *)  
 type usage_kind =
-  | Compute (* variable y is used to compute x *)
-  | Propagate (* values of y propagate to x *)
+  | Compute (** variable y is used to compute x *)
+  | Propagate (** values of y propagate to x *)
 
+(** Compute the adjacency list for the dependency graph of given program. An edge between
+    variables [x] and [y] is marked [Compute] if [x] is used in the definition of [y]. It is marked
+    as [Propagate] if [x] is applied as a closure or block argument the parameter [y]. 
+    
+    We use information from global flow to try to add edges between function calls and their return values
+    at known call sites. *)
 let usages nv prog (global_info : Global_flow.info) : usage_kind Var.Map.t array =
   let uses = Array.make nv Var.Map.empty in
   let add_use kind x y = uses.(Var.idx y) <- Var.Map.add x kind uses.(Var.idx y) in
@@ -132,7 +152,6 @@ let usages nv prog (global_info : Global_flow.info) : usage_kind Var.Map.t array
           match i with
           | Let (x, e) -> add_expr_uses x e
           | Assign (x, y) -> add_use Compute x y
-          (* TODO: These? *)
           | Set_field (_, _, _) | Offset_ref (_, _) | Array_set (_, _, _) -> ())
         block.body;
       (* Add deps from block branch *)
@@ -152,7 +171,7 @@ let usages nv prog (global_info : Global_flow.info) : usage_kind Var.Map.t array
     prog.blocks;
   uses
 
-(* Return the set of variables used in a given expression *)
+(** Return the set of variables used in a given expression *)
 let expr_vars e =
   let vars = Var.ISet.empty () in
   (match e with
@@ -172,6 +191,16 @@ let expr_vars e =
         args);
   vars
 
+(** Compute the initial liveness of each variable in the program. 
+
+    A variable [x] is marked as [Top] if 
+    + It is used in an impure expression (as defined by [pure_expr]);
+    + Is used in a conditonal/switch;
+    + Is raised by an exception;
+    + Is used in another stateful instruction (like setting a block or array field);
+    + Or, it is returned or applied to a function and the global flow analysis marked it as escaping.
+    
+    A variable [x[i]] is marked as [Live {i}] if it is used in an instruction where field [i] is referenced or set. *)
 let liveness nv prog pure_funs (global_info : Global_flow.info) =
   let live_vars = Array.make nv Dead in
   let add_top v =
@@ -184,7 +213,8 @@ let liveness nv prog pure_funs (global_info : Global_flow.info) =
     | Live fields -> live_vars.(idx) <- Live (IntSet.add i fields)
     | _ -> live_vars.(idx) <- Live (IntSet.singleton i)
   in
-  let variable_may_escape x = match global_info.info_variable_may_escape.(Var.idx x) with
+  let variable_may_escape x =
+    match global_info.info_variable_may_escape.(Var.idx x) with
     | Escape | Escape_constant -> true
     | No -> false
   in
@@ -198,9 +228,7 @@ let liveness nv prog pure_funs (global_info : Global_flow.info) =
           add_top x;
           match e with
           | Apply { args; _ } ->
-              List.iter
-                ~f:(fun x -> if variable_may_escape x then add_top x)
-                args
+              List.iter ~f:(fun x -> if variable_may_escape x then add_top x) args
           | _ -> ())
     | Assign (_, _) -> ()
     | Set_field (x, i, y) ->
@@ -231,8 +259,14 @@ let variables deps =
   Array.iteri ~f:(fun i _ -> Var.ISet.add vars (Var.of_idx i)) deps;
   vars
 
+(** Propagate liveness of the usages of a variable [x] to [x]. The liveness of [x] is
+    defined by joining its current liveness and the contribution of each vairable [y]
+    that uses [x]. *)
 let propagate uses defs live_vars live_table x =
   let idx = Var.idx x in
+  (** Variable [y] uses [x] either in its definition ([Compute]) or as a closure/block parameter
+      ([Propagate]). In the latter case, the contribution is simply the liveness of [y]. In the former,
+       the contribution depends on the liveness of [y] and its definition. *)
   let contribution y usage_kind =
     match usage_kind with
     (* If x is used to compute y, we consider the liveness of y *)
@@ -272,6 +306,13 @@ let solver vars uses defs live_vars =
   in
   Solver.f () (G.invert () g) (propagate uses defs live_vars)
 
+(** Replace each instance of a dead variable with a sentinal value. 
+  Blocks that end in dead variables are compacted to the first live entry. 
+  Dead variables are replaced when
+    + They appear in a dead field of a block; or
+    + They are returned; or
+    + They are applied to a function. 
+ *)
 let zero prog sentinal live_table =
   let compact_vars vars =
     let i = ref (Array.length vars - 1) in
@@ -357,17 +398,6 @@ module Print = struct
     | Top -> "top"
     | Dead -> "dead"
 
-  let print_defs defs =
-    Format.eprintf "Definitions:\n";
-    Array.iteri
-      ~f:(fun i def ->
-        Format.eprintf "v%d: " i;
-        (match def with
-        | Expr e -> Format.eprintf "%a " Print.expr e
-        | Param -> Format.eprintf "param");
-        Format.eprintf "\n")
-      defs
-
   let print_uses uses =
     Format.eprintf "Usages:\n";
     Array.iteri
@@ -397,12 +427,14 @@ module Print = struct
       live_table
 end
 
+(** Add a sentinal variable declaration to the IR. The fresh variable is assigned to `undefined`. *)
 let add_sentinal p =
   let sentinal = Var.fresh () in
   let undefined = Prim (Extern "%undefined", []) in
   let instr, loc = Let (sentinal, undefined), Before 0 in
   Code.prepend p [ instr, loc ], sentinal
 
+(** Run the liveness analysis and replace dead variables with the given sentinal. *)
 let f p sentinal global_info =
   let t = Timer.make () in
   let nv = Var.count () in

From 50bcd077b0eb44ed4222484ddbdfd9c786e2aa21 Mon Sep 17 00:00:00 2001
From: Micah Cantor <micahcantor01@gmail.com>
Date: Tue, 1 Aug 2023 14:51:34 +0200
Subject: [PATCH 048/112] update comment

---
 compiler/lib/deadcode_dgraph.ml | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/compiler/lib/deadcode_dgraph.ml b/compiler/lib/deadcode_dgraph.ml
index 8bc101f6ac..697a1fb794 100644
--- a/compiler/lib/deadcode_dgraph.ml
+++ b/compiler/lib/deadcode_dgraph.ml
@@ -195,9 +195,9 @@ let expr_vars e =
 
     A variable [x] is marked as [Top] if 
     + It is used in an impure expression (as defined by [pure_expr]);
-    + Is used in a conditonal/switch;
-    + Is raised by an exception;
-    + Is used in another stateful instruction (like setting a block or array field);
+    + It is used in a conditonal/switch;
+    + It is raised by an exception;
+    + It is used in another stateful instruction (like setting a block or array field);
     + Or, it is returned or applied to a function and the global flow analysis marked it as escaping.
     
     A variable [x[i]] is marked as [Live {i}] if it is used in an instruction where field [i] is referenced or set. *)

From 0c8f8612cf97058585418a6841860d965bee139c Mon Sep 17 00:00:00 2001
From: Micah Cantor <micahcantor01@gmail.com>
Date: Fri, 4 Aug 2023 11:58:38 +0200
Subject: [PATCH 049/112] changing how args are handled

---
 compiler/lib/deadcode_dgraph.ml | 46 +++++++--------------------------
 1 file changed, 10 insertions(+), 36 deletions(-)

diff --git a/compiler/lib/deadcode_dgraph.ml b/compiler/lib/deadcode_dgraph.ml
index 697a1fb794..b45497df29 100644
--- a/compiler/lib/deadcode_dgraph.ml
+++ b/compiler/lib/deadcode_dgraph.ml
@@ -35,14 +35,14 @@ let times = Debug.find "times"
 
 (** Definition of a variable [x]. *)
 type def =
-  | Expr of expr (** [x] is defined by an expression. *)
-  | Param (** [x] is a block or closure parameter. *)
+  | Expr of expr (* [x] is defined by an expression. *)
+  | Param (* [x] is a block or closure parameter. *)
 
 (** Liveness of a variable [x], forming a lattice structure. *)
 type live =
-  | Top (** [x] is live and not a block. *)
-  | Live of IntSet.t (** [x] is a live block with a (non-empty) set of live fields. *)
-  | Dead (** [x] is dead. *)
+  | Top (* [x] is live and not a block. *)
+  | Live of IntSet.t (* [x] is a live block with a (non-empty) set of live fields. *)
+  | Dead (* [x] is dead. *)
 
 module G = Dgraph.Make_Imperative (Var) (Var.ISet) (Var.Tbl)
 
@@ -131,7 +131,7 @@ let usages nv prog (global_info : Global_flow.info) : usage_kind Var.Map.t array
                 | _ -> ())
               known);
         add_use Compute x f;
-        List.iter ~f:(add_use Compute x) args
+        (* List.iter ~f:(add_use Compute x) args *)
     | Block (_, vars, _) -> Array.iter ~f:(add_use Compute x) vars
     | Field (z, _) -> add_use Compute x z
     | Constant _ -> ()
@@ -171,26 +171,6 @@ let usages nv prog (global_info : Global_flow.info) : usage_kind Var.Map.t array
     prog.blocks;
   uses
 
-(** Return the set of variables used in a given expression *)
-let expr_vars e =
-  let vars = Var.ISet.empty () in
-  (match e with
-  | Apply { f; args; _ } ->
-      Var.ISet.add vars f;
-      List.iter ~f:(Var.ISet.add vars) args
-  | Block (_, params, _) -> Array.iter ~f:(Var.ISet.add vars) params
-  | Field (z, _) -> Var.ISet.add vars z
-  | Constant _ -> ()
-  | Closure (params, _) -> List.iter ~f:(Var.ISet.add vars) params
-  | Prim (_, args) ->
-      List.iter
-        ~f:(fun v ->
-          match v with
-          | Pv v -> Var.ISet.add vars v
-          | Pc _ -> ())
-        args);
-  vars
-
 (** Compute the initial liveness of each variable in the program. 
 
     A variable [x] is marked as [Top] if 
@@ -222,14 +202,7 @@ let liveness nv prog pure_funs (global_info : Global_flow.info) =
     match i with
     | Let (x, e) ->
         if not (pure_expr pure_funs e)
-        then (
-          let vars = expr_vars e in
-          Var.ISet.iter add_top vars;
-          add_top x;
-          match e with
-          | Apply { args; _ } ->
-              List.iter ~f:(fun x -> if variable_may_escape x then add_top x) args
-          | _ -> ())
+        then add_top x
     | Assign (_, _) -> ()
     | Set_field (x, i, y) ->
         add_live x i;
@@ -284,6 +257,7 @@ let propagate uses defs live_vars live_table x =
                     if Var.equal v x && IntSet.mem i fields then found := true)
                   vars;
                 if !found then Top else Dead
+            | Expr (Field (_, i)) -> Live (IntSet.singleton i)
             | _ -> Top)
         (* If y is top and y is a field access, x depends only on that field *)
         | Top -> (
@@ -402,7 +376,7 @@ module Print = struct
     Format.eprintf "Usages:\n";
     Array.iteri
       ~f:(fun i ds ->
-        Format.eprintf "v%d: { " i;
+        Format.eprintf "%a: { " Var.print (Var.of_idx i);
         Var.Map.iter
           (fun d k ->
             Format.eprintf
@@ -418,7 +392,7 @@ module Print = struct
 
   let print_liveness live_vars =
     Format.eprintf "Liveness:\n";
-    Array.iteri ~f:(fun i l -> Format.eprintf "v%d: %s\n" i (live_to_string l)) live_vars
+    Array.iteri ~f:(fun i l -> Format.eprintf "%a: %s\n" Var.print (Var.of_idx i) (live_to_string l)) live_vars
 
   let print_live_tbl live_table =
     Format.eprintf "Liveness with dependencies:\n";

From 05080cdd2f61da7764620d4eb443e0ff8977ec4b Mon Sep 17 00:00:00 2001
From: Micah Cantor <micahcantor01@gmail.com>
Date: Fri, 4 Aug 2023 13:48:41 +0200
Subject: [PATCH 050/112] Revert "changing how args are handled"

This reverts commit 0c8f8612cf97058585418a6841860d965bee139c.
---
 compiler/lib/deadcode_dgraph.ml | 46 ++++++++++++++++++++++++++-------
 1 file changed, 36 insertions(+), 10 deletions(-)

diff --git a/compiler/lib/deadcode_dgraph.ml b/compiler/lib/deadcode_dgraph.ml
index b45497df29..697a1fb794 100644
--- a/compiler/lib/deadcode_dgraph.ml
+++ b/compiler/lib/deadcode_dgraph.ml
@@ -35,14 +35,14 @@ let times = Debug.find "times"
 
 (** Definition of a variable [x]. *)
 type def =
-  | Expr of expr (* [x] is defined by an expression. *)
-  | Param (* [x] is a block or closure parameter. *)
+  | Expr of expr (** [x] is defined by an expression. *)
+  | Param (** [x] is a block or closure parameter. *)
 
 (** Liveness of a variable [x], forming a lattice structure. *)
 type live =
-  | Top (* [x] is live and not a block. *)
-  | Live of IntSet.t (* [x] is a live block with a (non-empty) set of live fields. *)
-  | Dead (* [x] is dead. *)
+  | Top (** [x] is live and not a block. *)
+  | Live of IntSet.t (** [x] is a live block with a (non-empty) set of live fields. *)
+  | Dead (** [x] is dead. *)
 
 module G = Dgraph.Make_Imperative (Var) (Var.ISet) (Var.Tbl)
 
@@ -131,7 +131,7 @@ let usages nv prog (global_info : Global_flow.info) : usage_kind Var.Map.t array
                 | _ -> ())
               known);
         add_use Compute x f;
-        (* List.iter ~f:(add_use Compute x) args *)
+        List.iter ~f:(add_use Compute x) args
     | Block (_, vars, _) -> Array.iter ~f:(add_use Compute x) vars
     | Field (z, _) -> add_use Compute x z
     | Constant _ -> ()
@@ -171,6 +171,26 @@ let usages nv prog (global_info : Global_flow.info) : usage_kind Var.Map.t array
     prog.blocks;
   uses
 
+(** Return the set of variables used in a given expression *)
+let expr_vars e =
+  let vars = Var.ISet.empty () in
+  (match e with
+  | Apply { f; args; _ } ->
+      Var.ISet.add vars f;
+      List.iter ~f:(Var.ISet.add vars) args
+  | Block (_, params, _) -> Array.iter ~f:(Var.ISet.add vars) params
+  | Field (z, _) -> Var.ISet.add vars z
+  | Constant _ -> ()
+  | Closure (params, _) -> List.iter ~f:(Var.ISet.add vars) params
+  | Prim (_, args) ->
+      List.iter
+        ~f:(fun v ->
+          match v with
+          | Pv v -> Var.ISet.add vars v
+          | Pc _ -> ())
+        args);
+  vars
+
 (** Compute the initial liveness of each variable in the program. 
 
     A variable [x] is marked as [Top] if 
@@ -202,7 +222,14 @@ let liveness nv prog pure_funs (global_info : Global_flow.info) =
     match i with
     | Let (x, e) ->
         if not (pure_expr pure_funs e)
-        then add_top x
+        then (
+          let vars = expr_vars e in
+          Var.ISet.iter add_top vars;
+          add_top x;
+          match e with
+          | Apply { args; _ } ->
+              List.iter ~f:(fun x -> if variable_may_escape x then add_top x) args
+          | _ -> ())
     | Assign (_, _) -> ()
     | Set_field (x, i, y) ->
         add_live x i;
@@ -257,7 +284,6 @@ let propagate uses defs live_vars live_table x =
                     if Var.equal v x && IntSet.mem i fields then found := true)
                   vars;
                 if !found then Top else Dead
-            | Expr (Field (_, i)) -> Live (IntSet.singleton i)
             | _ -> Top)
         (* If y is top and y is a field access, x depends only on that field *)
         | Top -> (
@@ -376,7 +402,7 @@ module Print = struct
     Format.eprintf "Usages:\n";
     Array.iteri
       ~f:(fun i ds ->
-        Format.eprintf "%a: { " Var.print (Var.of_idx i);
+        Format.eprintf "v%d: { " i;
         Var.Map.iter
           (fun d k ->
             Format.eprintf
@@ -392,7 +418,7 @@ module Print = struct
 
   let print_liveness live_vars =
     Format.eprintf "Liveness:\n";
-    Array.iteri ~f:(fun i l -> Format.eprintf "%a: %s\n" Var.print (Var.of_idx i) (live_to_string l)) live_vars
+    Array.iteri ~f:(fun i l -> Format.eprintf "v%d: %s\n" i (live_to_string l)) live_vars
 
   let print_live_tbl live_table =
     Format.eprintf "Liveness with dependencies:\n";

From 40bfbe87d0eaf346774b37e08137a84df9fab7d4 Mon Sep 17 00:00:00 2001
From: Micah Cantor <micahcantor01@gmail.com>
Date: Fri, 4 Aug 2023 14:56:08 +0200
Subject: [PATCH 051/112] improve argument initial liveness/usage

---
 compiler/lib/deadcode_dgraph.ml | 28 ++++++++++++++--------------
 1 file changed, 14 insertions(+), 14 deletions(-)

diff --git a/compiler/lib/deadcode_dgraph.ml b/compiler/lib/deadcode_dgraph.ml
index 697a1fb794..5d9dc203a2 100644
--- a/compiler/lib/deadcode_dgraph.ml
+++ b/compiler/lib/deadcode_dgraph.ml
@@ -85,6 +85,11 @@ let definitions nv prog =
         block.body)
     prog.blocks;
   defs
+  
+let variable_may_escape x (global_info : Global_flow.info) =
+  match global_info.info_variable_may_escape.(Var.idx x) with
+  | Escape | Escape_constant -> true
+  | No -> false
 
 (** Type of variable usage. *)  
 type usage_kind =
@@ -131,7 +136,7 @@ let usages nv prog (global_info : Global_flow.info) : usage_kind Var.Map.t array
                 | _ -> ())
               known);
         add_use Compute x f;
-        List.iter ~f:(add_use Compute x) args
+        List.iter ~f:(fun a -> if variable_may_escape a global_info then add_use Compute x a) args
     | Block (_, vars, _) -> Array.iter ~f:(add_use Compute x) vars
     | Field (z, _) -> add_use Compute x z
     | Constant _ -> ()
@@ -213,23 +218,18 @@ let liveness nv prog pure_funs (global_info : Global_flow.info) =
     | Live fields -> live_vars.(idx) <- Live (IntSet.add i fields)
     | _ -> live_vars.(idx) <- Live (IntSet.singleton i)
   in
-  let variable_may_escape x =
-    match global_info.info_variable_may_escape.(Var.idx x) with
-    | Escape | Escape_constant -> true
-    | No -> false
-  in
   let live_instruction i =
     match i with
-    | Let (x, e) ->
+    | Let (_x, e) ->
         if not (pure_expr pure_funs e)
         then (
           let vars = expr_vars e in
-          Var.ISet.iter add_top vars;
-          add_top x;
-          match e with
-          | Apply { args; _ } ->
-              List.iter ~f:(fun x -> if variable_may_escape x then add_top x) args
-          | _ -> ())
+          Var.ISet.iter add_top vars;)
+        else (match e with
+          | Apply { f; args; _} ->
+              add_top f;
+              List.iter ~f:(fun x -> if variable_may_escape x global_info then add_top x) args
+          | _ -> ()) 
     | Assign (_, _) -> ()
     | Set_field (x, i, y) ->
         add_live x i;
@@ -244,7 +244,7 @@ let liveness nv prog pure_funs (global_info : Global_flow.info) =
     List.iter ~f:(fun (i, _) -> live_instruction i) block.body;
     match fst block.branch with
     | Stop -> ()
-    | Return x -> if variable_may_escape x then add_top x
+    | Return x -> if variable_may_escape x global_info then add_top x
     | Raise (x, _) -> add_top x
     | Cond (x, _, _) -> add_top x
     | Switch (x, _, _) -> add_top x

From d67e8ea723a2b50b7962e1d584c2b15c7e1dae2f Mon Sep 17 00:00:00 2001
From: Micah Cantor <micahcantor01@gmail.com>
Date: Fri, 4 Aug 2023 15:04:47 +0200
Subject: [PATCH 052/112] promote var renaming changes

---
 compiler/tests-compiler/direct_calls.ml    |   20 +-
 compiler/tests-compiler/gh1007.ml          |  102 +-
 compiler/tests-full/stdlib.cma.expected.js | 4633 ++++++++++----------
 3 files changed, 2402 insertions(+), 2353 deletions(-)

diff --git a/compiler/tests-compiler/direct_calls.ml b/compiler/tests-compiler/direct_calls.ml
index 30fdcc82fd..98b7a4249c 100644
--- a/compiler/tests-compiler/direct_calls.ml
+++ b/compiler/tests-compiler/direct_calls.ml
@@ -57,26 +57,26 @@ let%expect_test "direct calls without --enable effects" =
   [%expect
     {|
     function test1(param){
-     function f(g, x){return caml_call1(g, x);}
-     var _d_ = 7;
-     f(function(x){return x + 1 | 0;}, _d_);
-     var _e_ = 4.;
-     f(function(x){return x * 2.;}, _e_);
+     function f(g, x){caml_call1(g, x); return _b_;}
+     var _e_ = 7;
+     f(function(x){return x + 1 | 0;}, _e_);
+     var _f_ = 4.;
+     f(function(x){return x * 2.;}, _f_);
      return 0;
     }
     //end
     function test2(param){
-     function f(g, x){return caml_call1(g, x);}
-     var _c_ = 7;
-     f(function(x){return x + 1 | 0;}, _c_);
+     function f(g, x){caml_call1(g, x); return _b_;}
+     var _d_ = 7;
+     f(function(x){return x + 1 | 0;}, _d_);
      f(function(x){return caml_call2(Stdlib[28], x, cst_a$0);}, cst_a);
      return 0;
     }
     //end
     function test3(x){
      function F(symbol){function f(x){return x + 1 | 0;} return [0, f];}
-     var M1 = F([0]), M2 = F([0]), _b_ = M2[1].call(null, 2);
-     return [0, M1[1].call(null, 1), _b_];
+     var M1 = F([0]), M2 = F([0]), _c_ = M2[1].call(null, 2);
+     return [0, M1[1].call(null, 1), _c_];
     }
     //end
     function test4(x){
diff --git a/compiler/tests-compiler/gh1007.ml b/compiler/tests-compiler/gh1007.ml
index 4b96b037f1..03f0f6a170 100644
--- a/compiler/tests-compiler/gh1007.ml
+++ b/compiler/tests-compiler/gh1007.ml
@@ -372,30 +372,34 @@ let ()  = M.run ()
       var
        even =
          function(n){
-          if(2 < n >>> 0) return 1 - (1 - odd(n - 1 | 0));
-          switch(n){
-            case 0:
-             return 1;
-            case 1:
-             return 1 - (1 - odd(0));
-            default: return 1 - (1 - odd(1));
-          }
+          if(2 >= n >>> 0)
+           switch(n){
+             case 0:
+              return _a_;
+             case 1:
+              odd(0); return _a_;
+             default: odd(1); return _a_;
+           }
+          odd(n - 1 | 0);
+          return _a_;
          },
        odd =
          function(n){
-          if(2 < n >>> 0) return 1 - (1 - even(n - 1 | 0));
-          switch(n){
-            case 0:
-             return 0;
-            case 1:
-             return 1 - (1 - even(0));
-            default: return 1 - (1 - even(1));
-          }
+          if(2 >= n >>> 0)
+           switch(n){
+             case 0:
+              return _a_;
+             case 1:
+              even(0); return _a_;
+             default: even(1); return _a_;
+           }
+          even(n - 1 | 0);
+          return _a_;
          };
       even(i);
-      var _a_ = i + 1 | 0;
+      var _b_ = i + 1 | 0;
       if(4 === i) return 0;
-      var i = _a_;
+      var i = _b_;
      }
     }
     //end |}]
@@ -462,32 +466,36 @@ let ()  = M.run ()
        closures =
          function(i){
           function even(n){
-           if(2 < n >>> 0) return 1 - (1 - odd(n - 1 | 0));
-           switch(n){
-             case 0:
-              var
-               f = function(param){return caml_call2(Stdlib_Printf[2], _b_, i);};
-              delayed[1] = [0, f, delayed[1]];
-              f(0);
-              return 1;
-             case 1:
-              return 1 - (1 - odd(0));
-             default: return 1 - (1 - odd(1));
-           }
+           if(2 >= n >>> 0)
+            switch(n){
+              case 0:
+               var
+                f = function(param){return caml_call2(Stdlib_Printf[2], _b_, i);};
+               delayed[1] = [0, f, delayed[1]];
+               f(0);
+               return _c_;
+              case 1:
+               odd(0); return _c_;
+              default: odd(1); return _c_;
+            }
+           odd(n - 1 | 0);
+           return _c_;
           }
           function odd(n){
-           if(2 < n >>> 0) return 1 - (1 - even(n - 1 | 0));
-           switch(n){
-             case 0:
-              var
-               f = function(param){return caml_call2(Stdlib_Printf[2], _a_, i);};
-              delayed[1] = [0, f, delayed[1]];
-              f(0);
-              return 0;
-             case 1:
-              return 1 - (1 - even(0));
-             default: return 1 - (1 - even(1));
-           }
+           if(2 >= n >>> 0)
+            switch(n){
+              case 0:
+               var
+                f = function(param){return caml_call2(Stdlib_Printf[2], _a_, i);};
+               delayed[1] = [0, f, delayed[1]];
+               f(0);
+               return _c_;
+              case 1:
+               even(0); return _c_;
+              default: even(1); return _c_;
+            }
+           even(n - 1 | 0);
+           return _c_;
           }
           var block = [0, even, odd];
           return block;
@@ -495,12 +503,12 @@ let ()  = M.run ()
        closures$0 = closures(i),
        even = closures$0[1];
       even(i);
-      var _e_ = i + 1 | 0;
-      if(4 !== i){var i = _e_; continue;}
+      var _f_ = i + 1 | 0;
+      if(4 !== i){var i = _f_; continue;}
       var
-       _c_ = caml_call1(Stdlib_List[9], delayed[1]),
-       _d_ = function(f){return caml_call1(f, 0);};
-      return caml_call2(Stdlib_List[17], _d_, _c_);
+       _d_ = caml_call1(Stdlib_List[9], delayed[1]),
+       _e_ = function(f){return caml_call1(f, 0);};
+      return caml_call2(Stdlib_List[17], _e_, _d_);
      }
     }
     //end |}]
diff --git a/compiler/tests-full/stdlib.cma.expected.js b/compiler/tests-full/stdlib.cma.expected.js
index e47097c652..93f4d1f54d 100644
--- a/compiler/tests-full/stdlib.cma.expected.js
+++ b/compiler/tests-full/stdlib.cma.expected.js
@@ -1255,6 +1255,7 @@
     Stdlib = global_data.Stdlib,
     Assert_failure = global_data.Assert_failure,
     Stdlib_Sys = global_data.Stdlib__Sys,
+    _b_ = undefined,
     cst_Obj_Ephemeron_blit_key = "Obj.Ephemeron.blit_key",
     cst_Obj_Ephemeron_check_key = "Obj.Ephemeron.check_key",
     cst_Obj_Ephemeron_unset_key = "Obj.Ephemeron.unset_key",
@@ -1329,9 +1330,9 @@
     max_ephe_length = Stdlib_Sys[13] - 2 | 0;
    function create(l){
      /*<<obj.ml:135:4>>*/ var
-     _g_ = 0 <= l ? 1 : 0,
-     _h_ = _g_ ? l <= max_ephe_length ? 1 : 0 : _g_;
-    if(1 - _h_)
+     _h_ = 0 <= l ? 1 : 0,
+     _i_ = _h_ ? l <= max_ephe_length ? 1 : 0 : _h_;
+    if(1 - _i_)
       /*<<obj.ml:136:6>>*/  /*<<obj.ml:136:6>>*/ caml_call1
       (Stdlib[1], cst_Obj_Ephemeron_create);
      /*<<obj.ml:137:4>>*/ return  /*<<obj.ml:137:4>>*/ runtime.caml_ephe_create
@@ -1342,10 +1343,10 @@
     /*<<obj.ml:139:49>>*/ }
    function raise_if_invalid_offset(e, o, msg){
      /*<<obj.ml:142:4>>*/ var
-     _d_ = 0 <= o ? 1 : 0,
-     _e_ = _d_ ? o < length(e) ? 1 : 0 : _d_,
-     _f_ = 1 - _e_;
-    return _f_ ?  /*<<obj.ml:143:6>>*/ caml_call1(Stdlib[1], msg) : _f_;
+     _e_ = 0 <= o ? 1 : 0,
+     _f_ = _e_ ? o < length(e) ? 1 : 0 : _e_,
+     _g_ = 1 - _f_;
+    return _g_ ? ( /*<<obj.ml:143:6>>*/ caml_call1(Stdlib[1], msg), _b_) : _g_;
     /*<<obj.ml:143:21>>*/ }
    function get_key(e, o){
      /*<<obj.ml:147:4>>*/ raise_if_invalid_offset
@@ -1384,13 +1385,13 @@
        0 <= o1
        && (length(e1) - l | 0) >= o1 && 0 <= o2 && (length(e2) - l | 0) >= o2){
      var
-      _b_ = 0 !== l ? 1 : 0,
-      _c_ =
-        _b_
+      _c_ = 0 !== l ? 1 : 0,
+      _d_ =
+        _c_
          ?  /*<<obj.ml:177:24>>*/ runtime.caml_ephe_blit_key
            (e1, o1, e2, o2, l)
-         : _b_;
-      /*<<obj.ml:177:24>>*/ return _c_;
+         : _c_;
+      /*<<obj.ml:177:24>>*/ return _d_;
     }
      /*<<obj.ml:176:9>>*/ return  /*<<obj.ml:176:9>>*/ caml_call1
             (Stdlib[1], cst_Obj_Ephemeron_blit_key);
@@ -4551,6 +4552,7 @@
             : runtime.caml_call_gen(f, [a0, a1]);
    }
    var
+    _g_ = undefined,
     global_data = runtime.caml_get_global_data(),
     Stdlib = global_data.Stdlib,
     Stdlib_Uchar = global_data.Stdlib__Uchar,
@@ -4595,14 +4597,14 @@
    function init(n, f){
      /*<<bytes.ml:47:2>>*/ var
       /*<<bytes.ml:47:10>>*/ s =  /*<<bytes.ml:47:10>>*/ caml_create_bytes(n),
-      /*<<bytes.ml:48:2>>*/ _aq_ = n - 1 | 0,
-      /*<<bytes.ml:47:10>>*/ _ap_ = 0;
-    if(_aq_ >= 0){
-     var i = _ap_;
+      /*<<bytes.ml:48:2>>*/ _ar_ = n - 1 | 0,
+      /*<<bytes.ml:47:10>>*/ _aq_ = 0;
+    if(_ar_ >= 0){
+     var i = _aq_;
      for(;;){
       caml_bytes_unsafe_set(s, i,  /*<<bytes.ml:49:19>>*/ caml_call1(f, i));
-       /*<<bytes.ml:48:2>>*/  /*<<bytes.ml:48:2>>*/ var _ar_ = i + 1 | 0;
-      if(_aq_ !== i){var i = _ar_; continue;}
+       /*<<bytes.ml:48:2>>*/  /*<<bytes.ml:48:2>>*/ var _as_ = i + 1 | 0;
+      if(_ar_ !== i){var i = _as_; continue;}
       break;
      }
     }
@@ -4645,13 +4647,13 @@
    function symbol(a, b){
      /*<<bytes.ml:77:2>>*/ var
      c = a + b | 0,
-     _ao_ = b < 0 ? 1 : 0,
+     _ap_ = b < 0 ? 1 : 0,
      match = c < 0 ? 1 : 0,
      switch$0 = 0;
     if(a < 0){
-     if(_ao_ && ! match) switch$0 = 1;
+     if(_ap_ && ! match) switch$0 = 1;
     }
-    else if(! _ao_ && match) switch$0 = 1;
+    else if(! _ap_ && match) switch$0 = 1;
     return switch$0
             ?  /*<<bytes.ml:80:27>>*/ caml_call1(Stdlib[1], cst_Bytes_extend)
             : c;
@@ -4713,15 +4715,15 @@
     /*<<bytes.ml:106:45>>*/ }
    function iter(f, a){
      /*<<bytes.ml:110:2>>*/ var
-     _am_ = caml_ml_bytes_length(a) - 1 | 0,
-      /*<<bytes.ml:110:2>>*/ _al_ = 0;
-    if(_am_ >= 0){
-     var i = _al_;
+     _an_ = caml_ml_bytes_length(a) - 1 | 0,
+      /*<<bytes.ml:110:2>>*/ _am_ = 0;
+    if(_an_ >= 0){
+     var i = _am_;
      for(;;){
        /*<<bytes.ml:110:31>>*/  /*<<bytes.ml:110:31>>*/ caml_call1
        (f, caml_bytes_unsafe_get(a, i));
-       /*<<bytes.ml:110:31>>*/  /*<<bytes.ml:110:31>>*/ var _an_ = i + 1 | 0;
-      if(_am_ !== i){var i = _an_; continue;}
+       /*<<bytes.ml:110:31>>*/  /*<<bytes.ml:110:31>>*/ var _ao_ = i + 1 | 0;
+      if(_an_ !== i){var i = _ao_; continue;}
       break;
      }
     }
@@ -4729,15 +4731,15 @@
     /*<<bytes.ml:110:53>>*/ }
    function iteri(f, a){
      /*<<bytes.ml:114:2>>*/ var
-     _aj_ = caml_ml_bytes_length(a) - 1 | 0,
-      /*<<bytes.ml:114:2>>*/ _ai_ = 0;
-    if(_aj_ >= 0){
-     var i = _ai_;
+     _ak_ = caml_ml_bytes_length(a) - 1 | 0,
+      /*<<bytes.ml:114:2>>*/ _aj_ = 0;
+    if(_ak_ >= 0){
+     var i = _aj_;
      for(;;){
        /*<<bytes.ml:114:31>>*/  /*<<bytes.ml:114:31>>*/ caml_call2
        (f, i, caml_bytes_unsafe_get(a, i));
-       /*<<bytes.ml:114:31>>*/  /*<<bytes.ml:114:31>>*/ var _ak_ = i + 1 | 0;
-      if(_aj_ !== i){var i = _ak_; continue;}
+       /*<<bytes.ml:114:31>>*/  /*<<bytes.ml:114:31>>*/ var _al_ = i + 1 | 0;
+      if(_ak_ !== i){var i = _al_; continue;}
       break;
      }
     }
@@ -4761,13 +4763,13 @@
         param = tl;
        continue;
       }
-      var _ah_ = caml_ml_bytes_length(hd) + acc | 0;
+      var _ai_ = caml_ml_bytes_length(hd) + acc | 0;
      }
      else
-      var _ah_ = acc;
+      var _ai_ = acc;
       /*<<bytes.ml:136:12>>*/ var
        /*<<bytes.ml:136:12>>*/ dst =
-         /*<<bytes.ml:136:12>>*/ caml_create_bytes(_ah_),
+         /*<<bytes.ml:136:12>>*/ caml_create_bytes(_ai_),
       pos = pos$1,
       param$0 = l;
      for(;;){
@@ -4810,12 +4812,12 @@
     /*<<bytes.ml:145:3>>*/ }
    function is_space(param){
      /*<<bytes.ml:151:15>>*/ var
-      /*<<bytes.ml:151:15>>*/ _ag_ = param - 9 | 0,
+      /*<<bytes.ml:151:15>>*/ _ah_ = param - 9 | 0,
      switch$0 = 0;
-    if(4 < _ag_ >>> 0){
-     if(23 === _ag_) switch$0 = 1;
+    if(4 < _ah_ >>> 0){
+     if(23 === _ah_) switch$0 = 1;
     }
-    else if(2 !== _ag_) switch$0 = 1;
+    else if(2 !== _ah_) switch$0 = 1;
     return switch$0 ? 1 : 0;
     /*<<bytes.ml:153:14>>*/ }
    function trim(s){
@@ -4837,19 +4839,19 @@
    function unsafe_escape(s){
      /*<<bytes.ml:184:2>>*/ var
       /*<<bytes.ml:184:10>>*/ n = [0, 0],
-     _$_ = caml_ml_bytes_length(s) - 1 | 0,
-      /*<<bytes.ml:184:10>>*/ ___ = 0;
-    if(_$_ >= 0){
-     var i$0 = ___;
+     _aa_ = caml_ml_bytes_length(s) - 1 | 0,
+      /*<<bytes.ml:184:10>>*/ _$_ = 0;
+    if(_aa_ >= 0){
+     var i$0 = _$_;
      for(;;){
       var match = caml_bytes_unsafe_get(s, i$0), switch$0 = 0;
       if(32 <= match){
-       var _ad_ = match - 34 | 0, switch$1 = 0;
-       if(58 < _ad_ >>> 0){
-        if(93 > _ad_) switch$1 = 1;
+       var _ae_ = match - 34 | 0, switch$1 = 0;
+       if(58 < _ae_ >>> 0){
+        if(93 > _ae_) switch$1 = 1;
        }
-       else if(56 < _ad_ - 1 >>> 0) switch$0 = 1; else switch$1 = 1;
-       if(switch$1){var _ae_ = 1; switch$0 = 2;}
+       else if(56 < _ae_ - 1 >>> 0) switch$0 = 1; else switch$1 = 1;
+       if(switch$1){var _af_ = 1; switch$0 = 2;}
       }
       else
        if(11 <= match){
@@ -4858,13 +4860,13 @@
        else if(8 <= match) switch$0 = 1;
       switch(switch$0){
         case 0:
-         var _ae_ = 4; break;
+         var _af_ = 4; break;
         case 1:
-         var _ae_ = 2; break;
+         var _af_ = 2; break;
       }
-      n[1] = n[1] + _ae_ | 0;
-       /*<<bytes.ml:185:2>>*/  /*<<bytes.ml:185:2>>*/ var _af_ = i$0 + 1 | 0;
-      if(_$_ !== i$0){var i$0 = _af_; continue;}
+      n[1] = n[1] + _af_ | 0;
+       /*<<bytes.ml:185:2>>*/  /*<<bytes.ml:185:2>>*/ var _ag_ = i$0 + 1 | 0;
+      if(_aa_ !== i$0){var i$0 = _ag_; continue;}
       break;
      }
     }
@@ -4873,10 +4875,10 @@
      s$0 =  /*<<bytes.ml:194:13>>*/ caml_create_bytes(n[1]);
     n[1] = 0;
      /*<<bytes.ml:196:4>>*/ var
-     _ab_ = caml_ml_bytes_length(s) - 1 | 0,
-      /*<<bytes.ml:196:4>>*/ _aa_ = 0;
-    if(_ab_ >= 0){
-     var i = _aa_;
+     _ac_ = caml_ml_bytes_length(s) - 1 | 0,
+      /*<<bytes.ml:196:4>>*/ _ab_ = 0;
+    if(_ac_ >= 0){
+     var i = _ab_;
      for(;;){
       var c = caml_bytes_unsafe_get(s, i), switch$2 = 0;
       if(35 <= c)
@@ -4930,8 +4932,8 @@
          caml_bytes_unsafe_set(s$0, n[1], c); break;
       }
       n[1]++;
-       /*<<bytes.ml:196:4>>*/  /*<<bytes.ml:196:4>>*/ var _ac_ = i + 1 | 0;
-      if(_ab_ !== i){var i = _ac_; continue;}
+       /*<<bytes.ml:196:4>>*/  /*<<bytes.ml:196:4>>*/ var _ad_ = i + 1 | 0;
+      if(_ac_ !== i){var i = _ad_; continue;}
       break;
      }
     }
@@ -4947,17 +4949,17 @@
      /*<<bytes.ml:233:12>>*/ var
       /*<<bytes.ml:233:12>>*/ r =
         /*<<bytes.ml:233:12>>*/ caml_create_bytes(l),
-      /*<<bytes.ml:234:4>>*/ _Y_ = l - 1 | 0,
-      /*<<bytes.ml:233:12>>*/ _X_ = 0;
-    if(_Y_ >= 0){
-     var i = _X_;
+      /*<<bytes.ml:234:4>>*/ _Z_ = l - 1 | 0,
+      /*<<bytes.ml:233:12>>*/ _Y_ = 0;
+    if(_Z_ >= 0){
+     var i = _Y_;
      for(;;){
       caml_bytes_unsafe_set
        (r,
         i,
          /*<<bytes.ml:234:41>>*/ caml_call1(f, caml_bytes_unsafe_get(s, i)));
-       /*<<bytes.ml:234:4>>*/  /*<<bytes.ml:234:4>>*/ var _Z_ = i + 1 | 0;
-      if(_Y_ !== i){var i = _Z_; continue;}
+       /*<<bytes.ml:234:4>>*/  /*<<bytes.ml:234:4>>*/ var ___ = i + 1 | 0;
+      if(_Z_ !== i){var i = ___; continue;}
       break;
      }
     }
@@ -4969,17 +4971,17 @@
      /*<<bytes.ml:241:12>>*/ var
       /*<<bytes.ml:241:12>>*/ r =
         /*<<bytes.ml:241:12>>*/ caml_create_bytes(l),
-      /*<<bytes.ml:242:4>>*/ _V_ = l - 1 | 0,
-      /*<<bytes.ml:241:12>>*/ _U_ = 0;
-    if(_V_ >= 0){
-     var i = _U_;
+      /*<<bytes.ml:242:4>>*/ _W_ = l - 1 | 0,
+      /*<<bytes.ml:241:12>>*/ _V_ = 0;
+    if(_W_ >= 0){
+     var i = _V_;
      for(;;){
       caml_bytes_unsafe_set
        (r,
         i,
          /*<<bytes.ml:242:41>>*/ caml_call2(f, i, caml_bytes_unsafe_get(s, i)));
-       /*<<bytes.ml:242:4>>*/  /*<<bytes.ml:242:4>>*/ var _W_ = i + 1 | 0;
-      if(_V_ !== i){var i = _W_; continue;}
+       /*<<bytes.ml:242:4>>*/  /*<<bytes.ml:242:4>>*/ var _X_ = i + 1 | 0;
+      if(_W_ !== i){var i = _X_; continue;}
       break;
      }
     }
@@ -4988,16 +4990,16 @@
    function fold_left(f, x, a){
      /*<<bytes.ml:247:2>>*/ var
       /*<<bytes.ml:247:10>>*/ r = [0, x],
-     _S_ = caml_ml_bytes_length(a) - 1 | 0,
-      /*<<bytes.ml:247:10>>*/ _R_ = 0;
-    if(_S_ >= 0){
-     var i = _R_;
+     _T_ = caml_ml_bytes_length(a) - 1 | 0,
+      /*<<bytes.ml:247:10>>*/ _S_ = 0;
+    if(_T_ >= 0){
+     var i = _S_;
      for(;;){
       r[1] =
         /*<<bytes.ml:249:9>>*/ caml_call2
         (f, r[1], caml_bytes_unsafe_get(a, i));
-       /*<<bytes.ml:248:2>>*/  /*<<bytes.ml:248:2>>*/ var _T_ = i + 1 | 0;
-      if(_S_ !== i){var i = _T_; continue;}
+       /*<<bytes.ml:248:2>>*/  /*<<bytes.ml:248:2>>*/ var _U_ = i + 1 | 0;
+      if(_T_ !== i){var i = _U_; continue;}
       break;
      }
     }
@@ -5006,16 +5008,16 @@
    function fold_right(f, a, x){
      /*<<bytes.ml:254:2>>*/ var
       /*<<bytes.ml:254:10>>*/ r = [0, x],
-      /*<<bytes.ml:255:2>>*/ _P_ =
+      /*<<bytes.ml:255:2>>*/ _Q_ =
         /*<<bytes.ml:255:2>>*/ caml_ml_bytes_length(a) - 1 | 0;
-    if(_P_ >= 0){
-     var i = _P_;
+    if(_Q_ >= 0){
+     var i = _Q_;
      for(;;){
       r[1] =
         /*<<bytes.ml:256:9>>*/ caml_call2
         (f, caml_bytes_unsafe_get(a, i), r[1]);
-       /*<<bytes.ml:255:2>>*/  /*<<bytes.ml:255:2>>*/ var _Q_ = i - 1 | 0;
-      if(0 !== i){var i = _Q_; continue;}
+       /*<<bytes.ml:255:2>>*/  /*<<bytes.ml:255:2>>*/ var _R_ = i - 1 | 0;
+      if(0 !== i){var i = _R_; continue;}
       break;
      }
     }
@@ -5071,8 +5073,8 @@
      /*<<bytes.ml:291:2>>*/ var
      len_s = caml_ml_bytes_length(s),
      len_pre = caml_ml_bytes_length(prefix),
-     _O_ = len_pre <= len_s ? 1 : 0;
-    if(! _O_) return _O_;
+     _P_ = len_pre <= len_s ? 1 : 0;
+    if(! _P_) return _P_;
     var i = 0;
      /*<<bytes.ml:294:4>>*/ for(;;){
      if(i === len_pre)  /*<<bytes.ml:294:24>>*/ return 1;
@@ -5088,8 +5090,8 @@
      len_s = caml_ml_bytes_length(s),
      len_suf = caml_ml_bytes_length(suffix),
      diff = len_s - len_suf | 0,
-     _N_ = 0 <= diff ? 1 : 0;
-    if(! _N_) return _N_;
+     _O_ = 0 <= diff ? 1 : 0;
+    if(! _O_) return _O_;
     var i = 0;
      /*<<bytes.ml:305:4>>*/ for(;;){
      if(i === len_suf)  /*<<bytes.ml:305:24>>*/ return 1;
@@ -5188,13 +5190,13 @@
     if(0 <= i && l >= i)
       /*<<bytes.ml:377:4>>*/ try{
        /*<<bytes.ml:377:15>>*/ index_rec(s, l, i, c);
-       /*<<bytes.ml:377:36>>*/  /*<<bytes.ml:377:36>>*/ var _L_ = 1;
-       /*<<bytes.ml:377:36>>*/ return _L_;
+       /*<<bytes.ml:377:36>>*/  /*<<bytes.ml:377:36>>*/ var _M_ = 1;
+       /*<<bytes.ml:377:36>>*/ return _M_;
      }
-     catch(_M_){
-      var _K_ = caml_wrap_exception(_M_);
-      if(_K_ === Stdlib[8])  /*<<bytes.ml:377:59>>*/ return 0;
-      throw caml_maybe_attach_backtrace(_K_, 0);
+     catch(_N_){
+      var _L_ = caml_wrap_exception(_N_);
+      if(_L_ === Stdlib[8])  /*<<bytes.ml:377:59>>*/ return 0;
+      throw caml_maybe_attach_backtrace(_L_, 0);
      }
      /*<<bytes.ml:375:4>>*/ return  /*<<bytes.ml:375:4>>*/ caml_call1
             (Stdlib[1], cst_String_contains_from_Bytes);
@@ -5206,13 +5208,13 @@
      /*<<bytes.ml:385:2>>*/ if(0 <= i && caml_ml_bytes_length(s) > i)
       /*<<bytes.ml:388:4>>*/ try{
        /*<<bytes.ml:388:15>>*/ rindex_rec(s, i, c);
-       /*<<bytes.ml:388:35>>*/  /*<<bytes.ml:388:35>>*/ var _I_ = 1;
-       /*<<bytes.ml:388:35>>*/ return _I_;
+       /*<<bytes.ml:388:35>>*/  /*<<bytes.ml:388:35>>*/ var _J_ = 1;
+       /*<<bytes.ml:388:35>>*/ return _J_;
      }
-     catch(_J_){
-      var _H_ = caml_wrap_exception(_J_);
-      if(_H_ === Stdlib[8])  /*<<bytes.ml:388:58>>*/ return 0;
-      throw caml_maybe_attach_backtrace(_H_, 0);
+     catch(_K_){
+      var _I_ = caml_wrap_exception(_K_);
+      if(_I_ === Stdlib[8])  /*<<bytes.ml:388:58>>*/ return 0;
+      throw caml_maybe_attach_backtrace(_I_, 0);
      }
      /*<<bytes.ml:386:4>>*/ return  /*<<bytes.ml:386:4>>*/ caml_call1
             (Stdlib[1], cst_String_rcontains_from_Byte);
@@ -5223,23 +5225,23 @@
       /*<<bytes.ml:398:10>>*/ r = [0, 0],
       /*<<bytes.ml:399:10>>*/ j =
        [0,  /*<<bytes.ml:399:2>>*/ caml_ml_bytes_length(s)],
-      /*<<bytes.ml:400:2>>*/ _D_ =
+      /*<<bytes.ml:400:2>>*/ _E_ =
         /*<<bytes.ml:400:2>>*/ caml_ml_bytes_length(s) - 1 | 0;
-    if(_D_ >= 0){
-     var i = _D_;
+    if(_E_ >= 0){
+     var i = _E_;
      for(;;){
       if(caml_bytes_unsafe_get(s, i) === sep){
-       var _F_ = r[1];
-       r[1] = [0, sub(s, i + 1 | 0, (j[1] - i | 0) - 1 | 0), _F_];
+       var _G_ = r[1];
+       r[1] = [0, sub(s, i + 1 | 0, (j[1] - i | 0) - 1 | 0), _G_];
        j[1] = i;
       }
-       /*<<bytes.ml:400:2>>*/  /*<<bytes.ml:400:2>>*/ var _G_ = i - 1 | 0;
-      if(0 !== i){var i = _G_; continue;}
+       /*<<bytes.ml:400:2>>*/  /*<<bytes.ml:400:2>>*/ var _H_ = i - 1 | 0;
+      if(0 !== i){var i = _H_; continue;}
       break;
      }
     }
-    var _E_ = r[1];
-     /*<<bytes.ml:406:2>>*/ return [0, sub(s, 0, j[1]), _E_];
+    var _F_ = r[1];
+     /*<<bytes.ml:406:2>>*/ return [0, sub(s, 0, j[1]), _F_];
     /*<<bytes.ml:406:18>>*/ }
    function to_seq(s){
     function aux(i, param){
@@ -5248,14 +5250,14 @@
       /*<<bytes.ml:414:14>>*/ var
        /*<<bytes.ml:414:14>>*/ x =
          /*<<bytes.ml:414:14>>*/ caml_bytes_get(s, i),
-       /*<<bytes.ml:414:14>>*/ _B_ = i + 1 | 0;
+       /*<<bytes.ml:414:14>>*/ _C_ = i + 1 | 0;
       /*<<bytes.ml:415:6>>*/ return [0,
              x,
-             function(_C_){ /*<<?>>*/ return aux(_B_, _C_);}];
+             function(_D_){ /*<<?>>*/ return aux(_C_, _D_);}];
      /*<<bytes.ml:415:29>>*/ }
-     /*<<bytes.ml:417:2>>*/  /*<<bytes.ml:417:2>>*/ var _z_ = 0;
-     /*<<bytes.ml:417:2>>*/ return function(_A_){
-      /*<<?>>*/ return aux(_z_, _A_);};
+     /*<<bytes.ml:417:2>>*/  /*<<bytes.ml:417:2>>*/ var _A_ = 0;
+     /*<<bytes.ml:417:2>>*/ return function(_B_){
+      /*<<?>>*/ return aux(_A_, _B_);};
     /*<<bytes.ml:417:7>>*/ }
    function to_seqi(s){
     function aux(i, param){
@@ -5264,20 +5266,20 @@
       /*<<bytes.ml:423:14>>*/ var
        /*<<bytes.ml:423:14>>*/ x =
          /*<<bytes.ml:423:14>>*/ caml_bytes_get(s, i),
-       /*<<bytes.ml:423:14>>*/ _x_ = i + 1 | 0;
+       /*<<bytes.ml:423:14>>*/ _y_ = i + 1 | 0;
       /*<<bytes.ml:424:6>>*/ return [0,
              [0, i, x],
-             function(_y_){ /*<<?>>*/ return aux(_x_, _y_);}];
+             function(_z_){ /*<<?>>*/ return aux(_y_, _z_);}];
      /*<<bytes.ml:424:33>>*/ }
-     /*<<bytes.ml:426:2>>*/  /*<<bytes.ml:426:2>>*/ var _v_ = 0;
-     /*<<bytes.ml:426:2>>*/ return function(_w_){
-      /*<<?>>*/ return aux(_v_, _w_);};
+     /*<<bytes.ml:426:2>>*/  /*<<bytes.ml:426:2>>*/ var _w_ = 0;
+     /*<<bytes.ml:426:2>>*/ return function(_x_){
+      /*<<?>>*/ return aux(_w_, _x_);};
     /*<<bytes.ml:426:7>>*/ }
    function of_seq(i){
      /*<<bytes.ml:429:2>>*/ var
       /*<<bytes.ml:429:10>>*/ n = [0, 0],
       /*<<bytes.ml:430:12>>*/ buf = [0, make(256, 0)];
-    function _u_(c){
+    function _v_(c){
       /*<<bytes.ml:441:7>>*/ if(n[1] === caml_ml_bytes_length(buf[1])){
        /*<<bytes.ml:433:18>>*/  /*<<bytes.ml:433:18>>*/ var
        new_len =
@@ -5299,7 +5301,7 @@
      return 0;
      /*<<bytes.ml:443:13>>*/ }
      /*<<bytes.ml:439:2>>*/  /*<<bytes.ml:439:2>>*/ caml_call2
-     (Stdlib_Seq[4], _u_, i);
+     (Stdlib_Seq[4], _v_, i);
     return sub(buf[1], 0, n[1]);
     /*<<bytes.ml:445:15>>*/ }
    function unsafe_get_uint16_le(b, i){
@@ -5316,9 +5318,9 @@
     /*<<bytes.ml:477:40>>*/ }
    function get_int8(b, i){
      /*<<bytes.ml:480:2>>*/ var
-      /*<<bytes.ml:480:2>>*/ _s_ = Stdlib_Sys[10] - 8 | 0,
-     _t_ = Stdlib_Sys[10] - 8 | 0;
-    return  /*<<bytes.ml:480:3>>*/ caml_bytes_get(b, i) << _t_ >> _s_;
+      /*<<bytes.ml:480:2>>*/ _t_ = Stdlib_Sys[10] - 8 | 0,
+     _u_ = Stdlib_Sys[10] - 8 | 0;
+    return  /*<<bytes.ml:480:3>>*/ caml_bytes_get(b, i) << _u_ >> _t_;
     /*<<bytes.ml:480:65>>*/ }
    function get_uint16_le(b, i){
      /*<<bytes.ml:483:2>>*/ return Stdlib_Sys[11]
@@ -5334,21 +5336,21 @@
     /*<<bytes.ml:488:24>>*/ }
    function get_int16_ne(b, i){
      /*<<bytes.ml:491:2>>*/ var
-      /*<<bytes.ml:491:2>>*/ _q_ = Stdlib_Sys[10] - 16 | 0,
-     _r_ = Stdlib_Sys[10] - 16 | 0;
-    return  /*<<bytes.ml:491:3>>*/ caml_bytes_get16(b, i) << _r_ >> _q_;
+      /*<<bytes.ml:491:2>>*/ _r_ = Stdlib_Sys[10] - 16 | 0,
+     _s_ = Stdlib_Sys[10] - 16 | 0;
+    return  /*<<bytes.ml:491:3>>*/ caml_bytes_get16(b, i) << _s_ >> _r_;
     /*<<bytes.ml:491:71>>*/ }
    function get_int16_le(b, i){
      /*<<bytes.ml:494:2>>*/ var
-      /*<<bytes.ml:494:2>>*/ _o_ = Stdlib_Sys[10] - 16 | 0,
-     _p_ = Stdlib_Sys[10] - 16 | 0;
-    return get_uint16_le(b, i) << _p_ >> _o_;
+      /*<<bytes.ml:494:2>>*/ _p_ = Stdlib_Sys[10] - 16 | 0,
+     _q_ = Stdlib_Sys[10] - 16 | 0;
+    return get_uint16_le(b, i) << _q_ >> _p_;
     /*<<bytes.ml:494:71>>*/ }
    function get_int16_be(b, i){
      /*<<bytes.ml:497:2>>*/ var
-      /*<<bytes.ml:497:2>>*/ _m_ = Stdlib_Sys[10] - 16 | 0,
-     _n_ = Stdlib_Sys[10] - 16 | 0;
-    return get_uint16_be(b, i) << _n_ >> _m_;
+      /*<<bytes.ml:497:2>>*/ _n_ = Stdlib_Sys[10] - 16 | 0,
+     _o_ = Stdlib_Sys[10] - 16 | 0;
+    return get_uint16_be(b, i) << _o_ >> _n_;
     /*<<bytes.ml:497:71>>*/ }
    function get_int32_le(b, i){
      /*<<bytes.ml:500:2>>*/ return Stdlib_Sys[11]
@@ -5376,13 +5378,17 @@
     /*<<bytes.ml:513:23>>*/ }
    function unsafe_set_uint16_le(b, i, x){
      /*<<bytes.ml:516:2>>*/ return Stdlib_Sys[11]
-            ?  /*<<bytes.ml:517:7>>*/ caml_bytes_set16(b, i, caml_bswap16(x))
-            :  /*<<bytes.ml:518:7>>*/ caml_bytes_set16(b, i, x);
+            ? ( /*<<bytes.ml:517:7>>*/ caml_bytes_set16
+               (b, i, caml_bswap16(x)),
+              _g_)
+            : ( /*<<bytes.ml:518:7>>*/ caml_bytes_set16(b, i, x), _g_);
     /*<<bytes.ml:518:33>>*/ }
    function unsafe_set_uint16_be(b, i, x){
      /*<<bytes.ml:521:2>>*/ return Stdlib_Sys[11]
-            ?  /*<<bytes.ml:522:7>>*/ caml_bytes_set16(b, i, x)
-            :  /*<<bytes.ml:523:2>>*/ caml_bytes_set16(b, i, caml_bswap16(x));
+            ? ( /*<<bytes.ml:522:7>>*/ caml_bytes_set16(b, i, x), _g_)
+            : ( /*<<bytes.ml:523:2>>*/ caml_bytes_set16
+               (b, i, caml_bswap16(x)),
+              _g_);
     /*<<bytes.ml:523:37>>*/ }
    function set_int16_le(b, i, x){
      /*<<bytes.ml:526:2>>*/ return Stdlib_Sys[11]
@@ -5424,9 +5430,9 @@
     dec_invalid = Stdlib_Uchar[22];
    function dec_ret(n, u){
      /*<<bytes.ml:557:27>>*/  /*<<bytes.ml:557:46>>*/ var
-     _l_ =  /*<<bytes.ml:557:46>>*/ caml_call1(Stdlib_Uchar[9], u);
+     _m_ =  /*<<bytes.ml:557:46>>*/ caml_call1(Stdlib_Uchar[9], u);
      /*<<bytes.ml:557:46>>*/ return  /*<<bytes.ml:557:46>>*/ caml_call2
-            (Stdlib_Uchar[21], n, _l_);
+            (Stdlib_Uchar[21], n, _m_);
     /*<<bytes.ml:557:69>>*/ }
    function not_in_x80_to_xBF(b){
      /*<<bytes.ml:575:35>>*/ return 2 !== (b >>> 6 | 0) ? 1 : 0;
@@ -5439,9 +5445,9 @@
     /*<<bytes.ml:577:51>>*/ }
    function not_in_x90_to_xBF(b){
      /*<<bytes.ml:578:35>>*/ var
-     _j_ = b < 144 ? 1 : 0,
-     _k_ = _j_ || (191 < b ? 1 : 0);
-    return _k_;
+     _k_ = b < 144 ? 1 : 0,
+     _l_ = _k_ || (191 < b ? 1 : 0);
+    return _l_;
     /*<<bytes.ml:578:55>>*/ }
    function not_in_x80_to_x8F(b){
      /*<<bytes.ml:579:35>>*/ return 8 !== (b >>> 4 | 0) ? 1 : 0;
@@ -5644,9 +5650,9 @@
             (dec_invalid, 1);
     /*<<bytes.ml:648:22>>*/ }
    function set_utf_8_uchar(b, i, u){
-     /*<<bytes.ml:651:2>>*/ function set(_i_, _h_, _g_){
-      /*<<?>>*/ caml_bytes_unsafe_set(_i_, _h_, _g_);
-     return 0;
+     /*<<bytes.ml:651:2>>*/ function set(_j_, _i_, _h_){
+      /*<<?>>*/ caml_bytes_unsafe_set(_j_, _i_, _h_);
+     return _g_;
     }
      /*<<bytes.ml:652:2>>*/ var
       /*<<bytes.ml:652:2>>*/ max =
@@ -6867,6 +6873,7 @@
             : runtime.caml_call_gen(f, [a0, a1, a2]);
    }
     /*<<array.ml:37:20>>*/ var
+    _b_ = undefined,
     global_data = runtime.caml_get_global_data(),
     Stdlib_Seq = global_data.Stdlib__Seq,
     Assert_failure = global_data.Assert_failure,
@@ -6894,15 +6901,15 @@
       /*<<array.ml:53:13>>*/ res =
         /*<<array.ml:53:13>>*/ caml_make_vect
         (l,  /*<<array.ml:53:22>>*/ caml_call1(f, 0)),
-      /*<<array.ml:54:3>>*/ _as_ = l - 1 | 0,
-      /*<<array.ml:53:13>>*/ _ar_ = 1;
-    if(_as_ >= 1){
-     var i = _ar_;
+      /*<<array.ml:54:3>>*/ _at_ = l - 1 | 0,
+      /*<<array.ml:53:13>>*/ _as_ = 1;
+    if(_at_ >= 1){
+     var i = _as_;
      for(;;){
        /*<<array.ml:55:5>>*/ res[1 + i] =
         /*<<array.ml:55:22>>*/ caml_call1(f, i);
-       /*<<array.ml:55:5>>*/  /*<<array.ml:55:5>>*/ var _at_ = i + 1 | 0;
-      if(_as_ !== i){var i = _at_; continue;}
+       /*<<array.ml:55:5>>*/  /*<<array.ml:55:5>>*/ var _au_ = i + 1 | 0;
+      if(_at_ !== i){var i = _au_; continue;}
       break;
      }
     }
@@ -6912,14 +6919,14 @@
      /*<<array.ml:60:2>>*/ var
       /*<<array.ml:60:12>>*/ res =
         /*<<array.ml:60:12>>*/ caml_make_vect(sx, [0]),
-      /*<<array.ml:61:2>>*/ _ap_ = sx - 1 | 0,
-      /*<<array.ml:60:12>>*/ _ao_ = 0;
-    if(_ap_ >= 0){
-     var x = _ao_;
+      /*<<array.ml:61:2>>*/ _aq_ = sx - 1 | 0,
+      /*<<array.ml:60:12>>*/ _ap_ = 0;
+    if(_aq_ >= 0){
+     var x = _ap_;
      for(;;){
       res[1 + x] =  /*<<array.ml:62:21>>*/ caml_make_vect(sy, init);
-       /*<<array.ml:61:2>>*/  /*<<array.ml:61:2>>*/ var _aq_ = x + 1 | 0;
-      if(_ap_ !== x){var x = _aq_; continue;}
+       /*<<array.ml:61:2>>*/  /*<<array.ml:61:2>>*/ var _ar_ = x + 1 | 0;
+      if(_aq_ !== x){var x = _ar_; continue;}
       break;
      }
     }
@@ -6971,14 +6978,14 @@
     /*<<array.ml:89:38>>*/ }
    function iter(f, a){
      /*<<array.ml:92:2>>*/ var
-     _am_ = a.length - 1 - 1 | 0,
-      /*<<array.ml:92:2>>*/ _al_ = 0;
-    if(_am_ >= 0){
-     var i = _al_;
+     _an_ = a.length - 1 - 1 | 0,
+      /*<<array.ml:92:2>>*/ _am_ = 0;
+    if(_an_ >= 0){
+     var i = _am_;
      for(;;){
        /*<<array.ml:92:31>>*/  /*<<array.ml:92:31>>*/ caml_call1(f, a[1 + i]);
-       /*<<array.ml:92:31>>*/  /*<<array.ml:92:31>>*/ var _an_ = i + 1 | 0;
-      if(_am_ !== i){var i = _an_; continue;}
+       /*<<array.ml:92:31>>*/  /*<<array.ml:92:31>>*/ var _ao_ = i + 1 | 0;
+      if(_an_ !== i){var i = _ao_; continue;}
       break;
      }
     }
@@ -6989,15 +6996,15 @@
       /*<<array.ml:96:4>>*/ return  /*<<array.ml:96:4>>*/ caml_call1
              (Stdlib[1], cst_Array_iter2_arrays_must_ha);
      /*<<array.ml:98:4>>*/ var
-     _aj_ = a.length - 1 - 1 | 0,
-      /*<<array.ml:98:4>>*/ _ai_ = 0;
-    if(_aj_ >= 0){
-     var i = _ai_;
+     _ak_ = a.length - 1 - 1 | 0,
+      /*<<array.ml:98:4>>*/ _aj_ = 0;
+    if(_ak_ >= 0){
+     var i = _aj_;
      for(;;){
        /*<<array.ml:98:33>>*/  /*<<array.ml:98:33>>*/ caml_call2
        (f, a[1 + i], b[1 + i]);
-       /*<<array.ml:98:33>>*/  /*<<array.ml:98:33>>*/ var _ak_ = i + 1 | 0;
-      if(_aj_ !== i){var i = _ak_; continue;}
+       /*<<array.ml:98:33>>*/  /*<<array.ml:98:33>>*/ var _al_ = i + 1 | 0;
+      if(_ak_ !== i){var i = _al_; continue;}
       break;
      }
     }
@@ -7010,15 +7017,15 @@
       /*<<array.ml:103:12>>*/ r =
         /*<<array.ml:103:12>>*/ caml_make_vect
         (l,  /*<<array.ml:103:21>>*/ caml_call1(f, a[1])),
-      /*<<array.ml:104:4>>*/ _ag_ = l - 1 | 0,
-      /*<<array.ml:103:12>>*/ _af_ = 1;
-    if(_ag_ >= 1){
-     var i = _af_;
+      /*<<array.ml:104:4>>*/ _ah_ = l - 1 | 0,
+      /*<<array.ml:103:12>>*/ _ag_ = 1;
+    if(_ah_ >= 1){
+     var i = _ag_;
      for(;;){
        /*<<array.ml:105:6>>*/ r[1 + i] =
         /*<<array.ml:105:21>>*/ caml_call1(f, a[1 + i]);
-       /*<<array.ml:105:6>>*/  /*<<array.ml:105:6>>*/ var _ah_ = i + 1 | 0;
-      if(_ag_ !== i){var i = _ah_; continue;}
+       /*<<array.ml:105:6>>*/  /*<<array.ml:105:6>>*/ var _ai_ = i + 1 | 0;
+      if(_ah_ !== i){var i = _ai_; continue;}
       break;
      }
     }
@@ -7036,15 +7043,15 @@
       /*<<array.ml:117:14>>*/ r =
         /*<<array.ml:117:14>>*/ caml_make_vect
         (la,  /*<<array.ml:117:24>>*/ caml_call2(f, a[1], b[1])),
-      /*<<array.ml:118:6>>*/ _ad_ = la - 1 | 0,
-      /*<<array.ml:117:14>>*/ _ac_ = 1;
-    if(_ad_ >= 1){
-     var i = _ac_;
+      /*<<array.ml:118:6>>*/ _ae_ = la - 1 | 0,
+      /*<<array.ml:117:14>>*/ _ad_ = 1;
+    if(_ae_ >= 1){
+     var i = _ad_;
      for(;;){
        /*<<array.ml:119:8>>*/ r[1 + i] =
         /*<<array.ml:119:23>>*/ caml_call2(f, a[1 + i], b[1 + i]);
-       /*<<array.ml:119:8>>*/  /*<<array.ml:119:8>>*/ var _ae_ = i + 1 | 0;
-      if(_ad_ !== i){var i = _ae_; continue;}
+       /*<<array.ml:119:8>>*/  /*<<array.ml:119:8>>*/ var _af_ = i + 1 | 0;
+      if(_ae_ !== i){var i = _af_; continue;}
       break;
      }
     }
@@ -7052,15 +7059,15 @@
     /*<<array.ml:123:5>>*/ }
    function iteri(f, a){
      /*<<array.ml:126:2>>*/ var
-     _aa_ = a.length - 1 - 1 | 0,
-      /*<<array.ml:126:2>>*/ _$_ = 0;
-    if(_aa_ >= 0){
-     var i = _$_;
+     _ab_ = a.length - 1 - 1 | 0,
+      /*<<array.ml:126:2>>*/ _aa_ = 0;
+    if(_ab_ >= 0){
+     var i = _aa_;
      for(;;){
        /*<<array.ml:126:31>>*/  /*<<array.ml:126:31>>*/ caml_call2
        (f, i, a[1 + i]);
-       /*<<array.ml:126:31>>*/  /*<<array.ml:126:31>>*/ var _ab_ = i + 1 | 0;
-      if(_aa_ !== i){var i = _ab_; continue;}
+       /*<<array.ml:126:31>>*/  /*<<array.ml:126:31>>*/ var _ac_ = i + 1 | 0;
+      if(_ab_ !== i){var i = _ac_; continue;}
       break;
      }
     }
@@ -7073,15 +7080,15 @@
       /*<<array.ml:131:12>>*/ r =
         /*<<array.ml:131:12>>*/ caml_make_vect
         (l,  /*<<array.ml:131:21>>*/ caml_call2(f, 0, a[1])),
-      /*<<array.ml:132:4>>*/ _Z_ = l - 1 | 0,
-      /*<<array.ml:131:12>>*/ _Y_ = 1;
-    if(_Z_ >= 1){
-     var i = _Y_;
+      /*<<array.ml:132:4>>*/ ___ = l - 1 | 0,
+      /*<<array.ml:131:12>>*/ _Z_ = 1;
+    if(___ >= 1){
+     var i = _Z_;
      for(;;){
        /*<<array.ml:133:6>>*/ r[1 + i] =
         /*<<array.ml:133:21>>*/ caml_call2(f, i, a[1 + i]);
-       /*<<array.ml:133:6>>*/  /*<<array.ml:133:6>>*/ var ___ = i + 1 | 0;
-      if(_Z_ !== i){var i = ___; continue;}
+       /*<<array.ml:133:6>>*/  /*<<array.ml:133:6>>*/ var _$_ = i + 1 | 0;
+      if(___ !== i){var i = _$_; continue;}
       break;
      }
     }
@@ -7131,14 +7138,14 @@
    function fold_left(f, x, a){
      /*<<array.ml:158:2>>*/ var
       /*<<array.ml:158:10>>*/ r = [0, x],
-     _W_ = a.length - 1 - 1 | 0,
-      /*<<array.ml:158:10>>*/ _V_ = 0;
-    if(_W_ >= 0){
-     var i = _V_;
+     _X_ = a.length - 1 - 1 | 0,
+      /*<<array.ml:158:10>>*/ _W_ = 0;
+    if(_X_ >= 0){
+     var i = _W_;
      for(;;){
       r[1] =  /*<<array.ml:160:9>>*/ caml_call2(f, r[1], a[1 + i]);
-       /*<<array.ml:159:2>>*/  /*<<array.ml:159:2>>*/ var _X_ = i + 1 | 0;
-      if(_W_ !== i){var i = _X_; continue;}
+       /*<<array.ml:159:2>>*/  /*<<array.ml:159:2>>*/ var _Y_ = i + 1 | 0;
+      if(_X_ !== i){var i = _Y_; continue;}
       break;
      }
     }
@@ -7156,10 +7163,10 @@
       /*<<array.ml:168:23>>*/ output_array =
         /*<<array.ml:168:23>>*/ caml_make_vect(len, elt),
       /*<<array.ml:169:14>>*/ acc$1 = [0, acc$0],
-      /*<<array.ml:170:4>>*/ _T_ = len - 1 | 0,
-      /*<<array.ml:169:14>>*/ _S_ = 1;
-    if(_T_ >= 1){
-     var i = _S_;
+      /*<<array.ml:170:4>>*/ _U_ = len - 1 | 0,
+      /*<<array.ml:169:14>>*/ _T_ = 1;
+    if(_U_ >= 1){
+     var i = _T_;
      for(;;){
        /*<<array.ml:171:22>>*/ var
         /*<<array.ml:171:22>>*/ match$0 =
@@ -7168,8 +7175,8 @@
        acc$2 = match$0[1];
       acc$1[1] = acc$2;
        /*<<array.ml:173:6>>*/ output_array[1 + i] = elt$0;
-       /*<<array.ml:170:4>>*/  /*<<array.ml:170:4>>*/ var _U_ = i + 1 | 0;
-      if(_T_ !== i){var i = _U_; continue;}
+       /*<<array.ml:170:4>>*/  /*<<array.ml:170:4>>*/ var _V_ = i + 1 | 0;
+      if(_U_ !== i){var i = _V_; continue;}
       break;
      }
     }
@@ -7178,13 +7185,13 @@
    function fold_right(f, a, x){
      /*<<array.ml:179:2>>*/ var
       /*<<array.ml:179:10>>*/ r = [0, x],
-      /*<<array.ml:180:2>>*/ _Q_ = a.length - 1 - 1 | 0;
-    if(_Q_ >= 0){
-     var i = _Q_;
+      /*<<array.ml:180:2>>*/ _R_ = a.length - 1 - 1 | 0;
+    if(_R_ >= 0){
+     var i = _R_;
      for(;;){
       r[1] =  /*<<array.ml:181:9>>*/ caml_call2(f, a[1 + i], r[1]);
-       /*<<array.ml:180:2>>*/  /*<<array.ml:180:2>>*/ var _R_ = i - 1 | 0;
-      if(0 !== i){var i = _R_; continue;}
+       /*<<array.ml:180:2>>*/  /*<<array.ml:180:2>>*/ var _S_ = i - 1 | 0;
+      if(0 !== i){var i = _S_; continue;}
       break;
      }
     }
@@ -7305,16 +7312,16 @@
         /*<<array.ml:264:12>>*/ caml_make_vect(n, a0),
       /*<<array.ml:265:12>>*/ b =
         /*<<array.ml:265:12>>*/ caml_make_vect(n, b0),
-      /*<<array.ml:266:4>>*/ _O_ = n - 1 | 0,
-      /*<<array.ml:265:12>>*/ _N_ = 1;
-    if(_O_ >= 1){
-     var i = _N_;
+      /*<<array.ml:266:4>>*/ _P_ = n - 1 | 0,
+      /*<<array.ml:265:12>>*/ _O_ = 1;
+    if(_P_ >= 1){
+     var i = _O_;
      for(;;){
       var match$0 = x[1 + i], bi = match$0[2], ai = match$0[1];
        /*<<array.ml:268:6>>*/ a[1 + i] = ai;
        /*<<array.ml:269:6>>*/ b[1 + i] = bi;
-       /*<<array.ml:266:4>>*/  /*<<array.ml:266:4>>*/ var _P_ = i + 1 | 0;
-      if(_O_ !== i){var i = _P_; continue;}
+       /*<<array.ml:266:4>>*/  /*<<array.ml:266:4>>*/ var _Q_ = i + 1 | 0;
+      if(_P_ !== i){var i = _Q_; continue;}
       break;
      }
     }
@@ -7331,14 +7338,14 @@
      /*<<array.ml:280:12>>*/ var
       /*<<array.ml:280:12>>*/ x =
         /*<<array.ml:280:12>>*/ caml_make_vect(na, [0, a[1], b[1]]),
-      /*<<array.ml:281:4>>*/ _L_ = na - 1 | 0,
-      /*<<array.ml:280:12>>*/ _K_ = 1;
-    if(_L_ >= 1){
-     var i = _K_;
+      /*<<array.ml:281:4>>*/ _M_ = na - 1 | 0,
+      /*<<array.ml:280:12>>*/ _L_ = 1;
+    if(_M_ >= 1){
+     var i = _L_;
      for(;;){
       x[1 + i] = [0, a[1 + i], b[1 + i]];
-       /*<<array.ml:281:4>>*/  /*<<array.ml:281:4>>*/ var _M_ = i + 1 | 0;
-      if(_L_ !== i){var i = _M_; continue;}
+       /*<<array.ml:281:4>>*/  /*<<array.ml:281:4>>*/ var _N_ = i + 1 | 0;
+      if(_M_ !== i){var i = _N_; continue;}
       break;
      }
     }
@@ -7353,42 +7360,42 @@
        /*<<array.ml:291:12>>*/ x = [0, i31];
      if((i31 + 2 | 0) < l){
        /*<<array.ml:292:22>>*/ var
-        /*<<array.ml:292:22>>*/ _D_ = i31 + 1 | 0,
-        /*<<array.ml:293:25>>*/ _E_ = caml_check_bound(a, _D_)[1 + _D_];
+        /*<<array.ml:292:22>>*/ _E_ = i31 + 1 | 0,
+        /*<<array.ml:293:25>>*/ _F_ = caml_check_bound(a, _E_)[1 + _E_];
       if
        ( /*<<array.ml:293:9>>*/ caml_call2
-         (cmp, caml_check_bound(a, i31)[1 + i31], _E_)
+         (cmp, caml_check_bound(a, i31)[1 + i31], _F_)
         < 0)
        x[1] = i31 + 1 | 0;
        /*<<array.ml:294:6>>*/ var
-        /*<<array.ml:294:6>>*/ _F_ = i31 + 2 | 0,
-        /*<<array.ml:294:24>>*/ _G_ = caml_check_bound(a, _F_)[1 + _F_],
-       _H_ = x[1];
+        /*<<array.ml:294:6>>*/ _G_ = i31 + 2 | 0,
+        /*<<array.ml:294:24>>*/ _H_ = caml_check_bound(a, _G_)[1 + _G_],
+       _I_ = x[1];
       if
        ( /*<<array.ml:294:9>>*/ caml_call2
-         (cmp, caml_check_bound(a, _H_)[1 + _H_], _G_)
+         (cmp, caml_check_bound(a, _I_)[1 + _I_], _H_)
         < 0)
        x[1] = i31 + 2 | 0;
       return x[1];
      }
      if((i31 + 1 | 0) < l){
        /*<<array.ml:297:38>>*/ var
-       _I_ = i31 + 1 | 0,
-        /*<<array.ml:297:38>>*/ _J_ = caml_check_bound(a, _I_)[1 + _I_];
+       _J_ = i31 + 1 | 0,
+        /*<<array.ml:297:38>>*/ _K_ = caml_check_bound(a, _J_)[1 + _J_];
        /*<<array.ml:297:22>>*/ if
        (0
         >
           /*<<array.ml:297:22>>*/ caml_call2
-          (cmp, caml_check_bound(a, i31)[1 + i31], _J_))
+          (cmp, caml_check_bound(a, i31)[1 + i31], _K_))
         /*<<array.ml:298:11>>*/ return i31 + 1 | 0;
      }
      if(i31 < l)  /*<<array.ml:299:27>>*/ return i31;
       /*<<array.ml:299:36>>*/ throw  /*<<array.ml:299:36>>*/ caml_maybe_attach_backtrace
             ([0, Bottom, i], 1);
      /*<<array.ml:299:52>>*/ }
-    var l = a.length - 1, _x_ = ((l + 1 | 0) / 3 | 0) - 1 | 0;
-    if(_x_ >= 0){
-     var i$6 = _x_;
+    var l = a.length - 1, _y_ = ((l + 1 | 0) / 3 | 0) - 1 | 0;
+    if(_y_ >= 0){
+     var i$6 = _y_;
      for(;;){
        /*<<array.ml:328:50>>*/  /*<<array.ml:328:50>>*/ var
        e$1 = caml_check_bound(a, i$6)[1 + i$6];
@@ -7403,8 +7410,8 @@
             /*<<array.ml:303:7>>*/ caml_call2
             (cmp, caml_check_bound(a, j)[1 + j], e$1)){
           /*<<array.ml:304:14>>*/  /*<<array.ml:304:14>>*/ var
-          _u_ = caml_check_bound(a, j)[1 + j];
-          /*<<array.ml:304:6>>*/ caml_check_bound(a, i)[1 + i] = _u_;
+          _v_ = caml_check_bound(a, j)[1 + j];
+          /*<<array.ml:304:6>>*/ caml_check_bound(a, i)[1 + i] = _v_;
          var i = j;
          continue;
         }
@@ -7418,14 +7425,14 @@
        var i$0 = exn[2];
         /*<<array.ml:310:61>>*/ caml_check_bound(a, i$0)[1 + i$0] = e$1;
       }
-       /*<<array.ml:328:38>>*/  /*<<array.ml:328:38>>*/ var _C_ = i$6 - 1 | 0;
-      if(0 !== i$6){var i$6 = _C_; continue;}
+       /*<<array.ml:328:38>>*/  /*<<array.ml:328:38>>*/ var _D_ = i$6 - 1 | 0;
+      if(0 !== i$6){var i$6 = _D_; continue;}
       break;
      }
     }
-     /*<<array.ml:329:2>>*/  /*<<array.ml:329:2>>*/ var _y_ = l - 1 | 0;
-    if(_y_ >= 2){
-     var i$4 = _y_;
+     /*<<array.ml:329:2>>*/  /*<<array.ml:329:2>>*/ var _z_ = l - 1 | 0;
+    if(_z_ >= 2){
+     var i$4 = _z_;
      a:
      for(;;){
        /*<<array.ml:330:12>>*/  /*<<array.ml:330:12>>*/ var
@@ -7437,8 +7444,8 @@
         /*<<array.ml:312:4>>*/ for(;;){
          /*<<array.ml:312:12>>*/ var
           /*<<array.ml:312:12>>*/ j$0 = maxson(i$4, i$1),
-          /*<<array.ml:313:12>>*/ _v_ = caml_check_bound(a, j$0)[1 + j$0];
-         /*<<array.ml:313:4>>*/ caml_check_bound(a, i$1)[1 + i$1] = _v_;
+          /*<<array.ml:313:12>>*/ _w_ = caml_check_bound(a, j$0)[1 + j$0];
+         /*<<array.ml:313:4>>*/ caml_check_bound(a, i$1)[1 + i$1] = _w_;
         var i$1 = j$0;
        }
       }
@@ -7459,30 +7466,30 @@
           /*<<array.ml:323:13>>*/ caml_check_bound(a, i$3)[1 + i$3] = e$0;
         else{
           /*<<array.ml:321:14>>*/  /*<<array.ml:321:14>>*/ var
-          _w_ = caml_check_bound(a, father)[1 + father];
-          /*<<array.ml:321:6>>*/ caml_check_bound(a, i$3)[1 + i$3] = _w_;
+          _x_ = caml_check_bound(a, father)[1 + father];
+          /*<<array.ml:321:6>>*/ caml_check_bound(a, i$3)[1 + i$3] = _x_;
          if(0 < father){var i$3 = father; continue;}
           /*<<array.ml:322:49>>*/ caml_check_bound(a, 0)[1] = e$0;
         }
-         /*<<array.ml:329:2>>*/  /*<<array.ml:329:2>>*/ var _B_ = i$4 - 1 | 0;
-        if(2 !== i$4){var i$4 = _B_; continue a;}
+         /*<<array.ml:329:2>>*/  /*<<array.ml:329:2>>*/ var _C_ = i$4 - 1 | 0;
+        if(2 !== i$4){var i$4 = _C_; continue a;}
         break;
        }
       }
       break;
      }
     }
-    var _z_ = 1 < l ? 1 : 0;
-    if(_z_){
+    var _A_ = 1 < l ? 1 : 0;
+    if(_A_){
       /*<<array.ml:334:25>>*/  /*<<array.ml:334:25>>*/ var
       e = caml_check_bound(a, 1)[2];
       /*<<array.ml:334:38>>*/ a[2] = caml_check_bound(a, 0)[1];
       /*<<array.ml:334:57>>*/ a[1] = e;
-     var _A_ = 0;
+     var _B_ = 0;
     }
     else
-     var _A_ = _z_;
-     /*<<array.ml:334:57>>*/ return _A_;
+     var _B_ = _A_;
+     /*<<array.ml:334:57>>*/ return _B_;
     /*<<array.ml:334:67>>*/ }
    function stable_sort(cmp, a){
     function merge(src1ofs, src1len, src2, src2ofs, src2len, dst, dstofs){
@@ -7525,37 +7532,37 @@
      /*<<array.ml:357:70>>*/ }
     function isortto(srcofs, dst, dstofs, len){
       /*<<array.ml:360:4>>*/ var
-      _m_ = len - 1 | 0,
-       /*<<array.ml:360:4>>*/ _l_ = 0;
-     if(_m_ >= 0){
-      var i = _l_;
+      _n_ = len - 1 | 0,
+       /*<<array.ml:360:4>>*/ _m_ = 0;
+     if(_n_ >= 0){
+      var i = _m_;
       a:
       for(;;){
         /*<<array.ml:361:14>>*/ var
-        _n_ = srcofs + i | 0,
-         /*<<array.ml:361:14>>*/ e = caml_check_bound(a, _n_)[1 + _n_],
+        _o_ = srcofs + i | 0,
+         /*<<array.ml:361:14>>*/ e = caml_check_bound(a, _o_)[1 + _o_],
          /*<<array.ml:362:14>>*/ j = [0, (dstofs + i | 0) - 1 | 0];
        for(;;){
         if(dstofs <= j[1]){
-         var _o_ = j[1];
+         var _p_ = j[1];
           /*<<array.ml:363:29>>*/ if
           (0
            <
              /*<<array.ml:363:29>>*/ caml_call2
-             (cmp, caml_check_bound(dst, _o_)[1 + _o_], e)){
+             (cmp, caml_check_bound(dst, _p_)[1 + _p_], e)){
            /*<<array.ml:364:25>>*/ var
-           _p_ = j[1],
-            /*<<array.ml:364:25>>*/ _q_ = caml_check_bound(dst, _p_)[1 + _p_],
-           _r_ = j[1] + 1 | 0;
-           /*<<array.ml:364:8>>*/ caml_check_bound(dst, _r_)[1 + _r_] = _q_;
+           _q_ = j[1],
+            /*<<array.ml:364:25>>*/ _r_ = caml_check_bound(dst, _q_)[1 + _q_],
+           _s_ = j[1] + 1 | 0;
+           /*<<array.ml:364:8>>*/ caml_check_bound(dst, _s_)[1 + _s_] = _r_;
           j[1] += -1;
           continue;
          }
         }
-        var _s_ = j[1] + 1 | 0;
-         /*<<array.ml:367:6>>*/ caml_check_bound(dst, _s_)[1 + _s_] = e;
-         /*<<array.ml:360:4>>*/  /*<<array.ml:360:4>>*/ var _t_ = i + 1 | 0;
-        if(_m_ !== i){var i = _t_; continue a;}
+        var _t_ = j[1] + 1 | 0;
+         /*<<array.ml:367:6>>*/ caml_check_bound(dst, _t_)[1 + _t_] = e;
+         /*<<array.ml:360:4>>*/  /*<<array.ml:360:4>>*/ var _u_ = i + 1 | 0;
+        if(_n_ !== i){var i = _u_; continue a;}
         break;
        }
        break;
@@ -7564,13 +7571,16 @@
      return 0;
      /*<<array.ml:368:8>>*/ }
     function sortto(srcofs, dst, dstofs, len){
-      /*<<array.ml:371:4>>*/ if(len <= 5)
-       /*<<array.ml:371:26>>*/ return isortto(srcofs, dst, dstofs, len);
+      /*<<array.ml:371:4>>*/ if(len <= 5){
+       /*<<array.ml:371:26>>*/ isortto(srcofs, dst, dstofs, len);
+       /*<<array.ml:371:26>>*/ return _b_;
+     }
      var l1 = len / 2 | 0, l2 = len - l1 | 0;
       /*<<array.ml:374:6>>*/ sortto(srcofs + l1 | 0, dst, dstofs + l1 | 0, l2);
       /*<<array.ml:375:6>>*/ sortto(srcofs, a, srcofs + l2 | 0, l1);
-      /*<<array.ml:375:6>>*/ return merge
-             (srcofs + l2 | 0, l1, dst, dstofs + l1 | 0, l2, dst, dstofs);
+      /*<<array.ml:375:6>>*/ merge
+      (srcofs + l2 | 0, l1, dst, dstofs + l1 | 0, l2, dst, dstofs);
+      /*<<array.ml:375:6>>*/ return _b_;
      /*<<array.ml:377:7>>*/ }
     var l = a.length - 1;
     if(l <= 5)  /*<<array.ml:380:22>>*/ return isortto(0, a, 0, l);
@@ -7589,14 +7599,14 @@
        /*<<array.ml:400:9>>*/ return 0;
       /*<<array.ml:398:14>>*/ var
        /*<<array.ml:398:14>>*/ x = a[1 + i],
-       /*<<array.ml:398:14>>*/ _j_ = i + 1 | 0;
+       /*<<array.ml:398:14>>*/ _k_ = i + 1 | 0;
       /*<<array.ml:399:6>>*/ return [0,
              x,
-             function(_k_){ /*<<?>>*/ return aux(_j_, _k_);}];
+             function(_l_){ /*<<?>>*/ return aux(_k_, _l_);}];
      /*<<array.ml:400:16>>*/ }
-     /*<<array.ml:402:2>>*/  /*<<array.ml:402:2>>*/ var _h_ = 0;
-     /*<<array.ml:402:2>>*/ return function(_i_){
-      /*<<?>>*/ return aux(_h_, _i_);};
+     /*<<array.ml:402:2>>*/  /*<<array.ml:402:2>>*/ var _i_ = 0;
+     /*<<array.ml:402:2>>*/ return function(_j_){
+      /*<<?>>*/ return aux(_i_, _j_);};
     /*<<array.ml:402:7>>*/ }
    function to_seqi(a){
     function aux(i, param){
@@ -7604,22 +7614,22 @@
        /*<<array.ml:410:9>>*/ return 0;
       /*<<array.ml:408:14>>*/ var
        /*<<array.ml:408:14>>*/ x = a[1 + i],
-       /*<<array.ml:408:14>>*/ _f_ = i + 1 | 0;
+       /*<<array.ml:408:14>>*/ _g_ = i + 1 | 0;
       /*<<array.ml:409:6>>*/ return [0,
              [0, i, x],
-             function(_g_){ /*<<?>>*/ return aux(_f_, _g_);}];
+             function(_h_){ /*<<?>>*/ return aux(_g_, _h_);}];
      /*<<array.ml:410:16>>*/ }
-     /*<<array.ml:412:2>>*/  /*<<array.ml:412:2>>*/ var _d_ = 0;
-     /*<<array.ml:412:2>>*/ return function(_e_){
-      /*<<?>>*/ return aux(_d_, _e_);};
+     /*<<array.ml:412:2>>*/  /*<<array.ml:412:2>>*/ var _e_ = 0;
+     /*<<array.ml:412:2>>*/ return function(_f_){
+      /*<<?>>*/ return aux(_e_, _f_);};
     /*<<array.ml:412:7>>*/ }
    function of_seq(i$2){
-     /*<<array.ml:426:2>>*/ var _b_ = 0;
-    function _c_(acc, x){
+     /*<<array.ml:426:2>>*/ var _c_ = 0;
+    function _d_(acc, x){
       /*<<array.ml:426:38>>*/ return [0, x, acc];
      /*<<array.ml:426:44>>*/ }
      /*<<array.ml:426:10>>*/  /*<<array.ml:426:10>>*/ var
-     l =  /*<<array.ml:426:10>>*/ caml_call3(Stdlib_Seq[5], _c_, _b_, i$2);
+     l =  /*<<array.ml:426:10>>*/ caml_call3(Stdlib_Seq[5], _d_, _c_, i$2);
     if(! l)  /*<<array.ml:415:10>>*/ return [0];
      /*<<array.ml:417:16>>*/ var
      tl = l[2],
@@ -7718,6 +7728,7 @@
             : runtime.caml_call_gen(f, [a0, a1, a2]);
    }
    var
+    _j_ = undefined,
     global_data = runtime.caml_get_global_data(),
     Stdlib_Seq = global_data.Stdlib__Seq,
     Stdlib_List = global_data.Stdlib__List,
@@ -7760,8 +7771,8 @@
     pi = 3.141592653589793;
    function is_integer(x){
      /*<<float.ml:111:19>>*/ var
-     _aq_ = x ==  /*<<float.ml:111:23>>*/ runtime.caml_trunc_float(x) ? 1 : 0;
-    return _aq_ ? is_finite(x) : _aq_;
+     _ar_ = x ==  /*<<float.ml:111:23>>*/ runtime.caml_trunc_float(x) ? 1 : 0;
+    return _ar_ ? is_finite(x) : _ar_;
     /*<<float.ml:111:45>>*/ }
    function succ(x){
      /*<<float.ml:116:13>>*/ return  /*<<float.ml:116:13>>*/ caml_nextafter_float
@@ -7858,32 +7869,34 @@
             (10, 100, 0, x);
     /*<<float.ml:164:41>>*/ }
    function unsafe_fill(a, ofs, len, v){
-     /*<<float.ml:178:4>>*/ var _ao_ = (ofs + len | 0) - 1 | 0;
-    if(_ao_ >= ofs){
+     /*<<float.ml:178:4>>*/ var _ap_ = (ofs + len | 0) - 1 | 0;
+    if(_ap_ >= ofs){
      var i = ofs;
      for(;;){
        /*<<float.ml:178:36>>*/ a[1 + i] = v;
-       /*<<float.ml:178:36>>*/  /*<<float.ml:178:36>>*/ var _ap_ = i + 1 | 0;
-      if(_ao_ !== i){var i = _ap_; continue;}
+       /*<<float.ml:178:36>>*/  /*<<float.ml:178:36>>*/ var _aq_ = i + 1 | 0;
+      if(_ap_ !== i){var i = _aq_; continue;}
       break;
      }
     }
     return 0;
     /*<<float.ml:178:57>>*/ }
    function check(a, ofs, len, msg){
-     /*<<float.ml:184:4>>*/ var _ak_ = ofs < 0 ? 1 : 0;
-    if(_ak_)
-     var _al_ = _ak_;
+     /*<<float.ml:184:4>>*/ var _al_ = ofs < 0 ? 1 : 0;
+    if(_al_)
+     var _am_ = _al_;
     else{
-     var _am_ = len < 0 ? 1 : 0;
-     if(_am_)
-      var _al_ = _am_;
+     var _an_ = len < 0 ? 1 : 0;
+     if(_an_)
+      var _am_ = _an_;
      else
       var
-       _an_ = (ofs + len | 0) < 0 ? 1 : 0,
-       _al_ = _an_ || (a.length - 1 < (ofs + len | 0) ? 1 : 0);
+       _ao_ = (ofs + len | 0) < 0 ? 1 : 0,
+       _am_ = _ao_ || (a.length - 1 < (ofs + len | 0) ? 1 : 0);
     }
-    return _al_ ?  /*<<float.ml:185:6>>*/ caml_call1(Stdlib[1], msg) : _al_;
+    return _am_
+            ? ( /*<<float.ml:185:6>>*/ caml_call1(Stdlib[1], msg), _j_)
+            : _am_;
     /*<<float.ml:185:21>>*/ }
    function make(n, v){
      /*<<float.ml:188:4>>*/  /*<<float.ml:188:17>>*/ var
@@ -7898,15 +7911,15 @@
      /*<<float.ml:195:16>>*/ var
       /*<<float.ml:195:16>>*/ res =
         /*<<float.ml:195:16>>*/ caml_floatarray_create(l),
-      /*<<float.ml:196:6>>*/ _ai_ = l - 1 | 0,
-      /*<<float.ml:195:16>>*/ _ah_ = 0;
-    if(_ai_ >= 0){
-     var i = _ah_;
+      /*<<float.ml:196:6>>*/ _aj_ = l - 1 | 0,
+      /*<<float.ml:195:16>>*/ _ai_ = 0;
+    if(_aj_ >= 0){
+     var i = _ai_;
      for(;;){
        /*<<float.ml:197:8>>*/ res[1 + i] =
         /*<<float.ml:197:25>>*/ caml_call1(f, i);
-       /*<<float.ml:197:8>>*/  /*<<float.ml:197:8>>*/ var _aj_ = i + 1 | 0;
-      if(_ai_ !== i){var i = _aj_; continue;}
+       /*<<float.ml:197:8>>*/  /*<<float.ml:197:8>>*/ var _ak_ = i + 1 | 0;
+      if(_aj_ !== i){var i = _ak_; continue;}
       break;
      }
     }
@@ -7991,11 +8004,11 @@
             (src, sofs, dst, dofs, len);
     /*<<float.ml:250:37>>*/ }
    function to_list(a){
-     /*<<float.ml:253:25>>*/ function _af_(_ag_){
-      /*<<?>>*/ return a[1 + _ag_];
+     /*<<float.ml:253:25>>*/ function _ag_(_ah_){
+      /*<<?>>*/ return a[1 + _ah_];
     }
      /*<<float.ml:253:25>>*/ return  /*<<float.ml:253:25>>*/ caml_call2
-            (Stdlib_List[10], a.length - 1, _af_);
+            (Stdlib_List[10], a.length - 1, _ag_);
     /*<<float.ml:253:39>>*/ }
    function of_list(l){
      /*<<float.ml:256:4>>*/ var
@@ -8016,15 +8029,15 @@
     /*<<float.ml:262:12>>*/ }
    function iter(f, a){
      /*<<float.ml:266:4>>*/ var
-     _ad_ = a.length - 1 - 1 | 0,
-      /*<<float.ml:266:4>>*/ _ac_ = 0;
-    if(_ad_ >= 0){
-     var i = _ac_;
+     _ae_ = a.length - 1 - 1 | 0,
+      /*<<float.ml:266:4>>*/ _ad_ = 0;
+    if(_ae_ >= 0){
+     var i = _ad_;
      for(;;){
        /*<<float.ml:266:33>>*/  /*<<float.ml:266:33>>*/ caml_call1
        (f, a[1 + i]);
-       /*<<float.ml:266:33>>*/  /*<<float.ml:266:33>>*/ var _ae_ = i + 1 | 0;
-      if(_ad_ !== i){var i = _ae_; continue;}
+       /*<<float.ml:266:33>>*/  /*<<float.ml:266:33>>*/ var _af_ = i + 1 | 0;
+      if(_ae_ !== i){var i = _af_; continue;}
       break;
      }
     }
@@ -8035,15 +8048,15 @@
       /*<<float.ml:271:6>>*/ return  /*<<float.ml:271:6>>*/ caml_call1
              (Stdlib[1], cst_Float_Array_iter2_arrays_m);
      /*<<float.ml:273:6>>*/ var
-     _aa_ = a.length - 1 - 1 | 0,
-      /*<<float.ml:273:6>>*/ _$_ = 0;
-    if(_aa_ >= 0){
-     var i = _$_;
+     _ab_ = a.length - 1 - 1 | 0,
+      /*<<float.ml:273:6>>*/ _aa_ = 0;
+    if(_ab_ >= 0){
+     var i = _aa_;
      for(;;){
        /*<<float.ml:273:35>>*/  /*<<float.ml:273:35>>*/ caml_call2
        (f, a[1 + i], b[1 + i]);
-       /*<<float.ml:273:35>>*/  /*<<float.ml:273:35>>*/ var _ab_ = i + 1 | 0;
-      if(_aa_ !== i){var i = _ab_; continue;}
+       /*<<float.ml:273:35>>*/  /*<<float.ml:273:35>>*/ var _ac_ = i + 1 | 0;
+      if(_ab_ !== i){var i = _ac_; continue;}
       break;
      }
     }
@@ -8054,15 +8067,15 @@
      l = a.length - 1,
       /*<<float.ml:277:12>>*/ r =
         /*<<float.ml:277:12>>*/ caml_floatarray_create(l),
-      /*<<float.ml:278:4>>*/ _Z_ = l - 1 | 0,
-      /*<<float.ml:277:12>>*/ _Y_ = 0;
-    if(_Z_ >= 0){
-     var i = _Y_;
+      /*<<float.ml:278:4>>*/ ___ = l - 1 | 0,
+      /*<<float.ml:277:12>>*/ _Z_ = 0;
+    if(___ >= 0){
+     var i = _Z_;
      for(;;){
        /*<<float.ml:279:6>>*/ r[1 + i] =
         /*<<float.ml:279:21>>*/ caml_call1(f, a[1 + i]);
-       /*<<float.ml:279:6>>*/  /*<<float.ml:279:6>>*/ var ___ = i + 1 | 0;
-      if(_Z_ !== i){var i = ___; continue;}
+       /*<<float.ml:279:6>>*/  /*<<float.ml:279:6>>*/ var _$_ = i + 1 | 0;
+      if(___ !== i){var i = _$_; continue;}
       break;
      }
     }
@@ -8078,15 +8091,15 @@
      /*<<float.ml:289:14>>*/ var
       /*<<float.ml:289:14>>*/ r =
         /*<<float.ml:289:14>>*/ caml_floatarray_create(la),
-      /*<<float.ml:290:6>>*/ _W_ = la - 1 | 0,
-      /*<<float.ml:289:14>>*/ _V_ = 0;
-    if(_W_ >= 0){
-     var i = _V_;
+      /*<<float.ml:290:6>>*/ _X_ = la - 1 | 0,
+      /*<<float.ml:289:14>>*/ _W_ = 0;
+    if(_X_ >= 0){
+     var i = _W_;
      for(;;){
        /*<<float.ml:291:8>>*/ r[1 + i] =
         /*<<float.ml:291:23>>*/ caml_call2(f, a[1 + i], b[1 + i]);
-       /*<<float.ml:291:8>>*/  /*<<float.ml:291:8>>*/ var _X_ = i + 1 | 0;
-      if(_W_ !== i){var i = _X_; continue;}
+       /*<<float.ml:291:8>>*/  /*<<float.ml:291:8>>*/ var _Y_ = i + 1 | 0;
+      if(_X_ !== i){var i = _Y_; continue;}
       break;
      }
     }
@@ -8094,15 +8107,15 @@
     /*<<float.ml:294:7>>*/ }
    function iteri(f, a){
      /*<<float.ml:298:4>>*/ var
-     _T_ = a.length - 1 - 1 | 0,
-      /*<<float.ml:298:4>>*/ _S_ = 0;
-    if(_T_ >= 0){
-     var i = _S_;
+     _U_ = a.length - 1 - 1 | 0,
+      /*<<float.ml:298:4>>*/ _T_ = 0;
+    if(_U_ >= 0){
+     var i = _T_;
      for(;;){
        /*<<float.ml:298:33>>*/  /*<<float.ml:298:33>>*/ caml_call2
        (f, i, a[1 + i]);
-       /*<<float.ml:298:33>>*/  /*<<float.ml:298:33>>*/ var _U_ = i + 1 | 0;
-      if(_T_ !== i){var i = _U_; continue;}
+       /*<<float.ml:298:33>>*/  /*<<float.ml:298:33>>*/ var _V_ = i + 1 | 0;
+      if(_U_ !== i){var i = _V_; continue;}
       break;
      }
     }
@@ -8113,15 +8126,15 @@
      l = a.length - 1,
       /*<<float.ml:302:12>>*/ r =
         /*<<float.ml:302:12>>*/ caml_floatarray_create(l),
-      /*<<float.ml:303:4>>*/ _Q_ = l - 1 | 0,
-      /*<<float.ml:302:12>>*/ _P_ = 0;
-    if(_Q_ >= 0){
-     var i = _P_;
+      /*<<float.ml:303:4>>*/ _R_ = l - 1 | 0,
+      /*<<float.ml:302:12>>*/ _Q_ = 0;
+    if(_R_ >= 0){
+     var i = _Q_;
      for(;;){
        /*<<float.ml:304:6>>*/ r[1 + i] =
         /*<<float.ml:304:21>>*/ caml_call2(f, i, a[1 + i]);
-       /*<<float.ml:304:6>>*/  /*<<float.ml:304:6>>*/ var _R_ = i + 1 | 0;
-      if(_Q_ !== i){var i = _R_; continue;}
+       /*<<float.ml:304:6>>*/  /*<<float.ml:304:6>>*/ var _S_ = i + 1 | 0;
+      if(_R_ !== i){var i = _S_; continue;}
       break;
      }
     }
@@ -8130,14 +8143,14 @@
    function fold_left(f, x, a){
      /*<<float.ml:310:4>>*/ var
       /*<<float.ml:310:12>>*/ r = [0, x],
-     _N_ = a.length - 1 - 1 | 0,
-      /*<<float.ml:310:12>>*/ _M_ = 0;
-    if(_N_ >= 0){
-     var i = _M_;
+     _O_ = a.length - 1 - 1 | 0,
+      /*<<float.ml:310:12>>*/ _N_ = 0;
+    if(_O_ >= 0){
+     var i = _N_;
      for(;;){
       r[1] =  /*<<float.ml:312:11>>*/ caml_call2(f, r[1], a[1 + i]);
-       /*<<float.ml:311:4>>*/  /*<<float.ml:311:4>>*/ var _O_ = i + 1 | 0;
-      if(_N_ !== i){var i = _O_; continue;}
+       /*<<float.ml:311:4>>*/  /*<<float.ml:311:4>>*/ var _P_ = i + 1 | 0;
+      if(_O_ !== i){var i = _P_; continue;}
       break;
      }
     }
@@ -8146,13 +8159,13 @@
    function fold_right(f, a, x){
      /*<<float.ml:318:4>>*/ var
       /*<<float.ml:318:12>>*/ r = [0, x],
-      /*<<float.ml:319:4>>*/ _K_ = a.length - 1 - 1 | 0;
-    if(_K_ >= 0){
-     var i = _K_;
+      /*<<float.ml:319:4>>*/ _L_ = a.length - 1 - 1 | 0;
+    if(_L_ >= 0){
+     var i = _L_;
      for(;;){
       r[1] =  /*<<float.ml:320:11>>*/ caml_call2(f, a[1 + i], r[1]);
-       /*<<float.ml:319:4>>*/  /*<<float.ml:319:4>>*/ var _L_ = i - 1 | 0;
-      if(0 !== i){var i = _L_; continue;}
+       /*<<float.ml:319:4>>*/  /*<<float.ml:319:4>>*/ var _M_ = i - 1 | 0;
+      if(0 !== i){var i = _M_; continue;}
       break;
      }
     }
@@ -8241,9 +8254,9 @@
       /*<<float.ml:375:38>>*/ throw  /*<<float.ml:375:38>>*/ caml_maybe_attach_backtrace
             ([0, Bottom, i], 1);
      /*<<float.ml:375:54>>*/ }
-    var l = a.length - 1, _E_ = ((l + 1 | 0) / 3 | 0) - 1 | 0;
-    if(_E_ >= 0){
-     var i$6 = _E_;
+    var l = a.length - 1, _F_ = ((l + 1 | 0) / 3 | 0) - 1 | 0;
+    if(_F_ >= 0){
+     var i$6 = _F_;
      for(;;){
        /*<<float.ml:404:52>>*/  /*<<float.ml:404:52>>*/ var
        e$1 =  /*<<float.ml:404:52>>*/ caml_array_get(a, i$6);
@@ -8274,14 +8287,14 @@
         /*<<float.ml:386:63>>*/  /*<<float.ml:386:63>>*/ caml_array_set
         (a, i$0, e$1);
       }
-       /*<<float.ml:404:40>>*/  /*<<float.ml:404:40>>*/ var _J_ = i$6 - 1 | 0;
-      if(0 !== i$6){var i$6 = _J_; continue;}
+       /*<<float.ml:404:40>>*/  /*<<float.ml:404:40>>*/ var _K_ = i$6 - 1 | 0;
+      if(0 !== i$6){var i$6 = _K_; continue;}
       break;
      }
     }
-     /*<<float.ml:405:4>>*/  /*<<float.ml:405:4>>*/ var _F_ = l - 1 | 0;
-    if(_F_ >= 2){
-     var i$4 = _F_;
+     /*<<float.ml:405:4>>*/  /*<<float.ml:405:4>>*/ var _G_ = l - 1 | 0;
+    if(_G_ >= 2){
+     var i$4 = _G_;
      a:
      for(;;){
        /*<<float.ml:406:14>>*/  /*<<float.ml:406:14>>*/ var
@@ -8322,25 +8335,25 @@
           /*<<float.ml:398:51>>*/  /*<<float.ml:398:51>>*/ caml_array_set
           (a, 0, e$0);
         }
-         /*<<float.ml:405:4>>*/  /*<<float.ml:405:4>>*/ var _I_ = i$4 - 1 | 0;
-        if(2 !== i$4){var i$4 = _I_; continue a;}
+         /*<<float.ml:405:4>>*/  /*<<float.ml:405:4>>*/ var _J_ = i$4 - 1 | 0;
+        if(2 !== i$4){var i$4 = _J_; continue a;}
         break;
        }
       }
       break;
      }
     }
-    var _G_ = 1 < l ? 1 : 0;
-    if(_G_){
+    var _H_ = 1 < l ? 1 : 0;
+    if(_H_){
       /*<<float.ml:410:27>>*/  /*<<float.ml:410:27>>*/ var
       e =  /*<<float.ml:410:27>>*/ caml_array_get(a, 1);
       /*<<float.ml:410:40>>*/  /*<<float.ml:410:40>>*/ caml_array_set
       (a, 1,  /*<<float.ml:410:48>>*/ caml_array_get(a, 0));
-     var _H_ =  /*<<float.ml:410:59>>*/ caml_array_set(a, 0, e);
+     var _I_ =  /*<<float.ml:410:59>>*/ caml_array_set(a, 0, e);
     }
     else
-     var _H_ = _G_;
-     /*<<float.ml:410:59>>*/ return _H_;
+     var _I_ = _H_;
+     /*<<float.ml:410:59>>*/ return _I_;
     /*<<float.ml:410:69>>*/ }
    function stable_sort(cmp, a){
     function merge(src1ofs, src1len, src2, src2ofs, src2len, dst, dstofs){
@@ -8388,10 +8401,10 @@
      /*<<float.ml:433:72>>*/ }
     function isortto(srcofs, dst, dstofs, len){
       /*<<float.ml:436:6>>*/ var
-      _C_ = len - 1 | 0,
-       /*<<float.ml:436:6>>*/ _B_ = 0;
-     if(_C_ >= 0){
-      var i = _B_;
+      _D_ = len - 1 | 0,
+       /*<<float.ml:436:6>>*/ _C_ = 0;
+     if(_D_ >= 0){
+      var i = _C_;
       a:
       for(;;){
         /*<<float.ml:437:16>>*/ var
@@ -8415,8 +8428,8 @@
         }
          /*<<float.ml:443:8>>*/  /*<<float.ml:443:8>>*/ caml_array_set
          (dst, j[1] + 1 | 0, e);
-         /*<<float.ml:436:6>>*/  /*<<float.ml:436:6>>*/ var _D_ = i + 1 | 0;
-        if(_C_ !== i){var i = _D_; continue a;}
+         /*<<float.ml:436:6>>*/  /*<<float.ml:436:6>>*/ var _E_ = i + 1 | 0;
+        if(_D_ !== i){var i = _E_; continue a;}
         break;
        }
        break;
@@ -8425,13 +8438,16 @@
      return 0;
      /*<<float.ml:444:10>>*/ }
     function sortto(srcofs, dst, dstofs, len){
-      /*<<float.ml:447:6>>*/ if(len <= 5)
-       /*<<float.ml:447:28>>*/ return isortto(srcofs, dst, dstofs, len);
+      /*<<float.ml:447:6>>*/ if(len <= 5){
+       /*<<float.ml:447:28>>*/ isortto(srcofs, dst, dstofs, len);
+       /*<<float.ml:447:28>>*/ return _j_;
+     }
      var l1 = len / 2 | 0, l2 = len - l1 | 0;
       /*<<float.ml:450:8>>*/ sortto(srcofs + l1 | 0, dst, dstofs + l1 | 0, l2);
       /*<<float.ml:451:8>>*/ sortto(srcofs, a, srcofs + l2 | 0, l1);
-      /*<<float.ml:451:8>>*/ return merge
-             (srcofs + l2 | 0, l1, dst, dstofs + l1 | 0, l2, dst, dstofs);
+      /*<<float.ml:451:8>>*/ merge
+      (srcofs + l2 | 0, l1, dst, dstofs + l1 | 0, l2, dst, dstofs);
+      /*<<float.ml:451:8>>*/ return _j_;
      /*<<float.ml:453:9>>*/ }
     var l = a.length - 1;
     if(l <= 5)  /*<<float.ml:456:24>>*/ return isortto(0, a, 0, l);
@@ -8450,14 +8466,14 @@
        /*<<float.ml:474:11>>*/ return 0;
       /*<<float.ml:472:16>>*/ var
        /*<<float.ml:472:16>>*/ x = a[1 + i],
-       /*<<float.ml:472:16>>*/ _z_ = i + 1 | 0;
+       /*<<float.ml:472:16>>*/ _A_ = i + 1 | 0;
       /*<<float.ml:473:8>>*/ return [0,
              x,
-             function(_A_){ /*<<?>>*/ return aux(_z_, _A_);}];
+             function(_B_){ /*<<?>>*/ return aux(_A_, _B_);}];
      /*<<float.ml:474:18>>*/ }
-     /*<<float.ml:476:4>>*/  /*<<float.ml:476:4>>*/ var _x_ = 0;
-     /*<<float.ml:476:4>>*/ return function(_y_){
-      /*<<?>>*/ return aux(_x_, _y_);};
+     /*<<float.ml:476:4>>*/  /*<<float.ml:476:4>>*/ var _y_ = 0;
+     /*<<float.ml:476:4>>*/ return function(_z_){
+      /*<<?>>*/ return aux(_y_, _z_);};
     /*<<float.ml:476:9>>*/ }
    function to_seqi(a){
     function aux(i, param){
@@ -8465,23 +8481,23 @@
        /*<<float.ml:485:11>>*/ return 0;
       /*<<float.ml:483:16>>*/ var
        /*<<float.ml:483:16>>*/ x = a[1 + i],
-       /*<<float.ml:483:16>>*/ _v_ = i + 1 | 0;
+       /*<<float.ml:483:16>>*/ _w_ = i + 1 | 0;
       /*<<float.ml:484:8>>*/ return [0,
              [0, i, x],
-             function(_w_){ /*<<?>>*/ return aux(_v_, _w_);}];
+             function(_x_){ /*<<?>>*/ return aux(_w_, _x_);}];
      /*<<float.ml:485:18>>*/ }
-     /*<<float.ml:487:4>>*/  /*<<float.ml:487:4>>*/ var _t_ = 0;
-     /*<<float.ml:487:4>>*/ return function(_u_){
-      /*<<?>>*/ return aux(_t_, _u_);};
+     /*<<float.ml:487:4>>*/  /*<<float.ml:487:4>>*/ var _u_ = 0;
+     /*<<float.ml:487:4>>*/ return function(_v_){
+      /*<<?>>*/ return aux(_u_, _v_);};
     /*<<float.ml:487:9>>*/ }
    function of_seq(i$2){
-     /*<<float.ml:501:4>>*/ var _r_ = 0;
-    function _s_(acc, x){
+     /*<<float.ml:501:4>>*/ var _s_ = 0;
+    function _t_(acc, x){
       /*<<float.ml:501:40>>*/ return [0, x, acc];
      /*<<float.ml:501:46>>*/ }
      /*<<float.ml:501:12>>*/ var
       /*<<float.ml:501:12>>*/ l =
-        /*<<float.ml:501:12>>*/ caml_call3(Stdlib_Seq[5], _s_, _r_, i$2),
+        /*<<float.ml:501:12>>*/ caml_call3(Stdlib_Seq[5], _t_, _s_, i$2),
       /*<<float.ml:491:14>>*/ len =
         /*<<float.ml:491:14>>*/ caml_call1(Stdlib_List[1], l),
       /*<<float.ml:492:12>>*/ a =
@@ -8506,15 +8522,15 @@
       /*<<float.ml:508:14>>*/ r =
         /*<<float.ml:508:14>>*/ runtime.caml_make_vect
         (l,  /*<<float.ml:508:27>>*/ caml_call1(f, a[1])),
-      /*<<float.ml:509:6>>*/ _p_ = l - 1 | 0,
-      /*<<float.ml:508:14>>*/ _o_ = 1;
-    if(_p_ >= 1){
-     var i = _o_;
+      /*<<float.ml:509:6>>*/ _q_ = l - 1 | 0,
+      /*<<float.ml:508:14>>*/ _p_ = 1;
+    if(_q_ >= 1){
+     var i = _p_;
      for(;;){
        /*<<float.ml:510:8>>*/ r[1 + i] =
         /*<<float.ml:510:29>>*/ caml_call1(f, a[1 + i]);
-       /*<<float.ml:510:8>>*/  /*<<float.ml:510:8>>*/ var _q_ = i + 1 | 0;
-      if(_p_ !== i){var i = _q_; continue;}
+       /*<<float.ml:510:8>>*/  /*<<float.ml:510:8>>*/ var _r_ = i + 1 | 0;
+      if(_q_ !== i){var i = _r_; continue;}
       break;
      }
     }
@@ -8525,15 +8541,15 @@
      l = a.length - 1,
       /*<<float.ml:517:12>>*/ r =
         /*<<float.ml:517:12>>*/ caml_floatarray_create(l),
-      /*<<float.ml:518:4>>*/ _m_ = l - 1 | 0,
-      /*<<float.ml:517:12>>*/ _l_ = 0;
-    if(_m_ >= 0){
-     var i = _l_;
+      /*<<float.ml:518:4>>*/ _n_ = l - 1 | 0,
+      /*<<float.ml:517:12>>*/ _m_ = 0;
+    if(_n_ >= 0){
+     var i = _m_;
      for(;;){
        /*<<float.ml:519:6>>*/ r[1 + i] =
         /*<<float.ml:519:21>>*/ caml_call1(f, a[1 + i]);
-       /*<<float.ml:519:6>>*/  /*<<float.ml:519:6>>*/ var _n_ = i + 1 | 0;
-      if(_m_ !== i){var i = _n_; continue;}
+       /*<<float.ml:519:6>>*/  /*<<float.ml:519:6>>*/ var _o_ = i + 1 | 0;
+      if(_n_ !== i){var i = _o_; continue;}
       break;
      }
     }
@@ -8545,7 +8561,7 @@
     _e_ = caml_array_get,
     _f_ =
       [0,
-       function(_k_){ /*<<?>>*/ return _k_.length - 1;},
+       function(_l_){ /*<<?>>*/ return _l_.length - 1;},
        _e_,
        _d_,
        make,
@@ -8612,7 +8628,7 @@
        min_max_num,
        hash,
        [0,
-        function(_j_){ /*<<?>>*/ return _j_.length - 1;},
+        function(_k_){ /*<<?>>*/ return _k_.length - 1;},
         _i_,
         _h_,
         make,
@@ -9437,6 +9453,7 @@
        0,
        0,
        0],
+    _a_ = undefined,
     cst_syntax_error = "syntax error";
    function grow_stacks(param){
      /*<<parsing.ml:108:2>>*/ var
@@ -9463,7 +9480,7 @@
      (Stdlib_Array[8], env[4], 0, new_end, 0, oldsize);
     env[4] = new_end;
     env[5] = newsize;
-    return 0;
+    return _a_;
     /*<<parsing.ml:122:28>>*/ }
    function clear_parser(param){
      /*<<parsing.ml:125:2>>*/  /*<<parsing.ml:125:2>>*/ caml_call4
@@ -9516,17 +9533,17 @@
         case 4:
          try{
            /*<<parsing.ml:143:39>>*/ var
-           _i_ = env[13],
-            /*<<parsing.ml:143:39>>*/ _j_ =
+           _j_ = env[13],
+            /*<<parsing.ml:143:39>>*/ _k_ =
               /*<<parsing.ml:143:39>>*/ caml_call1
-              (caml_check_bound(tables[1], _i_)[1 + _i_], env),
-            /*<<parsing.ml:143:39>>*/ _k_ = 4,
-           value = _j_,
-           action = _k_;
+              (caml_check_bound(tables[1], _j_)[1 + _j_], env),
+            /*<<parsing.ml:143:39>>*/ _l_ = 4,
+           value = _k_,
+           action = _l_;
          }
-         catch(_m_){
-          var _h_ = caml_wrap_exception(_m_);
-          if(_h_ !== Parse_error) throw caml_maybe_attach_backtrace(_h_, 0);
+         catch(_n_){
+          var _i_ = caml_wrap_exception(_n_);
+          if(_i_ !== Parse_error) throw caml_maybe_attach_backtrace(_i_, 0);
           var value = 0, action = 5;
          }
          var cmd = action, arg = value;
@@ -9563,9 +9580,9 @@
                 ? 1
                 : 0;
         /*<<parsing.ml:182:38>>*/  /*<<parsing.ml:182:38>>*/ var
-        _l_ =  /*<<parsing.ml:182:38>>*/ runtime.caml_obj_tag(tok);
-        /*<<parsing.ml:182:17>>*/ return caml_check_bound(tables[3], _l_)
-                [1 + _l_]
+        _m_ =  /*<<parsing.ml:182:38>>*/ runtime.caml_obj_tag(tok);
+        /*<<parsing.ml:182:17>>*/ return caml_check_bound(tables[3], _m_)
+                [1 + _m_]
                === curr_char
                ? 1
                : 0;
@@ -9575,21 +9592,21 @@
     }
     /*<<parsing.ml:184:17>>*/ }
    function peek_val(env, n){
-     /*<<parsing.ml:187:2>>*/ var _g_ = env[11] - n | 0;
-     /*<<parsing.ml:187:12>>*/ return caml_check_bound(env[2], _g_)[1 + _g_];
+     /*<<parsing.ml:187:2>>*/ var _h_ = env[11] - n | 0;
+     /*<<parsing.ml:187:12>>*/ return caml_check_bound(env[2], _h_)[1 + _h_];
     /*<<parsing.ml:187:37>>*/ }
    function symbol_start_pos(param){
      /*<<parsing.ml:190:2>>*/ var i$1 = env[12], i = i$1;
      /*<<parsing.ml:191:4>>*/ for(;;){
      if(0 >= i){
-      var _f_ = env[11];
-       /*<<parsing.ml:191:19>>*/ return caml_check_bound(env[4], _f_)[1 + _f_];
+      var _g_ = env[11];
+       /*<<parsing.ml:191:19>>*/ return caml_check_bound(env[4], _g_)[1 + _g_];
      }
       /*<<parsing.ml:193:15>>*/ var
-      _d_ = (env[11] - i | 0) + 1 | 0,
-       /*<<parsing.ml:193:15>>*/ st = caml_check_bound(env[3], _d_)[1 + _d_],
       _e_ = (env[11] - i | 0) + 1 | 0,
-       /*<<parsing.ml:194:15>>*/ en = caml_check_bound(env[4], _e_)[1 + _e_];
+       /*<<parsing.ml:193:15>>*/ st = caml_check_bound(env[3], _e_)[1 + _e_],
+      _f_ = (env[11] - i | 0) + 1 | 0,
+       /*<<parsing.ml:194:15>>*/ en = caml_check_bound(env[4], _f_)[1 + _f_];
       /*<<parsing.ml:195:9>>*/ if
       ( /*<<parsing.ml:195:9>>*/ runtime.caml_notequal(st, en))
        /*<<parsing.ml:195:23>>*/ return st;
@@ -9599,16 +9616,16 @@
     }
     /*<<parsing.ml:198:19>>*/ }
    function symbol_end_pos(param){
-     /*<<parsing.ml:200:24>>*/ var _c_ = env[11];
-     /*<<parsing.ml:200:24>>*/ return caml_check_bound(env[4], _c_)[1 + _c_];
+     /*<<parsing.ml:200:24>>*/ var _d_ = env[11];
+     /*<<parsing.ml:200:24>>*/ return caml_check_bound(env[4], _d_)[1 + _d_];
     /*<<parsing.ml:200:52>>*/ }
    function rhs_start_pos(n){
-     /*<<parsing.ml:201:22>>*/ var _b_ = env[11] - (env[12] - n | 0) | 0;
-     /*<<parsing.ml:201:22>>*/ return caml_check_bound(env[3], _b_)[1 + _b_];
+     /*<<parsing.ml:201:22>>*/ var _c_ = env[11] - (env[12] - n | 0) | 0;
+     /*<<parsing.ml:201:22>>*/ return caml_check_bound(env[3], _c_)[1 + _c_];
     /*<<parsing.ml:201:73>>*/ }
    function rhs_end_pos(n){
-     /*<<parsing.ml:202:20>>*/ var _a_ = env[11] - (env[12] - n | 0) | 0;
-     /*<<parsing.ml:202:20>>*/ return caml_check_bound(env[4], _a_)[1 + _a_];
+     /*<<parsing.ml:202:20>>*/ var _b_ = env[11] - (env[12] - n | 0) | 0;
+     /*<<parsing.ml:202:20>>*/ return caml_check_bound(env[4], _b_)[1 + _b_];
     /*<<parsing.ml:202:69>>*/ }
    function symbol_start(param){
      /*<<parsing.ml:204:22>>*/ return symbol_start_pos(0)[4];
@@ -11973,6 +11990,7 @@
     Stdlib = global_data.Stdlib,
     Stdlib_String = global_data.Stdlib__String,
     Assert_failure = global_data.Assert_failure,
+    _b_ = undefined,
     cst_Buffer_truncate = "Buffer.truncate",
     _a_ = [0, "buffer.ml", 220, 9],
     cst_Buffer_add_channel = "Buffer.add_channel",
@@ -12064,7 +12082,7 @@
       /*<<buffer.ml:99:2>>*/  /*<<buffer.ml:99:2>>*/ caml_call5
       (Stdlib_Bytes[11], b[1][1], 0, new_buffer, 0, b[2]);
      b[1] = [0, new_buffer, new_len[1]];
-     return 0;
+     return _b_;
     }
     /*<<buffer.ml:100:55>>*/ }
    function add_char(b, c){
@@ -12136,14 +12154,14 @@
     }
     /*<<buffer.ml:147:30>>*/ }
    function add_substring(b, s, offset, len){
-     /*<<buffer.ml:150:2>>*/ var _r_ = offset < 0 ? 1 : 0;
-    if(_r_)
-     var _s_ = _r_;
+     /*<<buffer.ml:150:2>>*/ var _s_ = offset < 0 ? 1 : 0;
+    if(_s_)
+     var _t_ = _s_;
     else
      var
-      _t_ = len < 0 ? 1 : 0,
-      _s_ = _t_ || ((caml_ml_string_length(s) - len | 0) < offset ? 1 : 0);
-    if(_s_)
+      _u_ = len < 0 ? 1 : 0,
+      _t_ = _u_ || ((caml_ml_string_length(s) - len | 0) < offset ? 1 : 0);
+    if(_t_)
       /*<<buffer.ml:151:7>>*/  /*<<buffer.ml:151:7>>*/ caml_call1
       (Stdlib[1], cst_Buffer_add_substring_add_s);
      /*<<buffer.ml:153:2>>*/ var
@@ -12198,9 +12216,9 @@
     /*<<buffer.ml:180:46>>*/ }
    function add_channel(b, ic, to_read$1){
      /*<<buffer.ml:206:2>>*/ var
-     _p_ = to_read$1 < 0 ? 1 : 0,
-     _q_ = _p_ || (Stdlib_Sys[12] < to_read$1 ? 1 : 0);
-    if(_q_)
+     _q_ = to_read$1 < 0 ? 1 : 0,
+     _r_ = _q_ || (Stdlib_Sys[12] < to_read$1 ? 1 : 0);
+    if(_r_)
       /*<<buffer.ml:207:4>>*/  /*<<buffer.ml:207:4>>*/ caml_call1
       (Stdlib[1], cst_Buffer_add_channel);
     if(b[1][2] < (b[2] + to_read$1 | 0))
@@ -12246,8 +12264,8 @@
      i$4 = 0;
      /*<<buffer.ml:262:4>>*/ for(;;){
      if(i$4 >= lim$1){
-      var _o_ = 92 === previous ? 1 : 0;
-      return _o_ ? add_char(b, previous) : _o_;
+      var _p_ = 92 === previous ? 1 : 0;
+      return _p_ ? add_char(b, previous) : _p_;
      }
       /*<<buffer.ml:263:12>>*/  /*<<buffer.ml:263:12>>*/ var
       previous$0 =  /*<<buffer.ml:263:12>>*/ caml_string_get(s, i$4);
@@ -12382,14 +12400,14 @@
       /*<<buffer.ml:298:14>>*/ var
        /*<<buffer.ml:298:14>>*/ x =
          /*<<buffer.ml:298:14>>*/ caml_bytes_get(b[1][1], i),
-       /*<<buffer.ml:298:14>>*/ _m_ = i + 1 | 0;
+       /*<<buffer.ml:298:14>>*/ _n_ = i + 1 | 0;
       /*<<buffer.ml:299:6>>*/ return [0,
              x,
-             function(_n_){ /*<<?>>*/ return aux(_m_, _n_);}];
+             function(_o_){ /*<<?>>*/ return aux(_n_, _o_);}];
      /*<<buffer.ml:299:29>>*/ }
-     /*<<buffer.ml:301:2>>*/  /*<<buffer.ml:301:2>>*/ var _k_ = 0;
-     /*<<buffer.ml:301:2>>*/ return function(_l_){
-      /*<<?>>*/ return aux(_k_, _l_);};
+     /*<<buffer.ml:301:2>>*/  /*<<buffer.ml:301:2>>*/ var _l_ = 0;
+     /*<<buffer.ml:301:2>>*/ return function(_m_){
+      /*<<?>>*/ return aux(_l_, _m_);};
     /*<<buffer.ml:301:7>>*/ }
    function to_seqi(b){
     function aux(i, param){
@@ -12398,21 +12416,21 @@
       /*<<buffer.ml:308:14>>*/ var
        /*<<buffer.ml:308:14>>*/ x =
          /*<<buffer.ml:308:14>>*/ caml_bytes_get(b[1][1], i),
-       /*<<buffer.ml:308:14>>*/ _i_ = i + 1 | 0;
+       /*<<buffer.ml:308:14>>*/ _j_ = i + 1 | 0;
       /*<<buffer.ml:309:6>>*/ return [0,
              [0, i, x],
-             function(_j_){ /*<<?>>*/ return aux(_i_, _j_);}];
+             function(_k_){ /*<<?>>*/ return aux(_j_, _k_);}];
      /*<<buffer.ml:309:33>>*/ }
-     /*<<buffer.ml:311:2>>*/  /*<<buffer.ml:311:2>>*/ var _g_ = 0;
-     /*<<buffer.ml:311:2>>*/ return function(_h_){
-      /*<<?>>*/ return aux(_g_, _h_);};
+     /*<<buffer.ml:311:2>>*/  /*<<buffer.ml:311:2>>*/ var _h_ = 0;
+     /*<<buffer.ml:311:2>>*/ return function(_i_){
+      /*<<?>>*/ return aux(_h_, _i_);};
     /*<<buffer.ml:311:7>>*/ }
    function add_seq(b, seq){
-     /*<<buffer.ml:313:29>>*/ function _e_(_f_){
-      /*<<?>>*/ return add_char(b, _f_);
+     /*<<buffer.ml:313:29>>*/ function _f_(_g_){
+      /*<<?>>*/ return add_char(b, _g_);
     }
      /*<<buffer.ml:313:20>>*/ return  /*<<buffer.ml:313:20>>*/ caml_call2
-            (Stdlib_Seq[4], _e_, seq);
+            (Stdlib_Seq[4], _f_, seq);
     /*<<buffer.ml:313:45>>*/ }
    function of_seq(i){
      /*<<buffer.ml:316:2>>*/  /*<<buffer.ml:316:10>>*/ var b = create(32);
@@ -12491,8 +12509,8 @@
     return 0;
     /*<<buffer.ml:378:28>>*/ }
    function add_int16_le(b, x){
-     /*<<buffer.ml:381:2>>*/ var _d_ = Stdlib_Sys[11] ? caml_bswap16(x) : x;
-    return add_int16_ne(b, _d_);
+     /*<<buffer.ml:381:2>>*/ var _e_ = Stdlib_Sys[11] ? caml_bswap16(x) : x;
+    return add_int16_ne(b, _e_);
     /*<<buffer.ml:381:57>>*/ }
    function add_int16_be(b, x){
      /*<<buffer.ml:384:2>>*/ var x$0 = Stdlib_Sys[11] ? x : caml_bswap16(x);
@@ -12500,8 +12518,8 @@
     /*<<buffer.ml:384:57>>*/ }
    function add_int32_le(b, x){
      /*<<buffer.ml:387:2>>*/ var
-     _c_ = Stdlib_Sys[11] ?  /*<<buffer.ml:387:41>>*/ caml_int32_bswap(x) : x;
-     /*<<buffer.ml:387:41>>*/ return add_int32_ne(b, _c_);
+     _d_ = Stdlib_Sys[11] ?  /*<<buffer.ml:387:41>>*/ caml_int32_bswap(x) : x;
+     /*<<buffer.ml:387:41>>*/ return add_int32_ne(b, _d_);
     /*<<buffer.ml:387:57>>*/ }
    function add_int32_be(b, x){
      /*<<buffer.ml:390:2>>*/ var
@@ -12510,8 +12528,8 @@
     /*<<buffer.ml:390:57>>*/ }
    function add_int64_le(b, x){
      /*<<buffer.ml:393:2>>*/ var
-     _b_ = Stdlib_Sys[11] ?  /*<<buffer.ml:393:41>>*/ caml_int64_bswap(x) : x;
-     /*<<buffer.ml:393:41>>*/ return add_int64_ne(b, _b_);
+     _c_ = Stdlib_Sys[11] ?  /*<<buffer.ml:393:41>>*/ caml_int64_bswap(x) : x;
+     /*<<buffer.ml:393:41>>*/ return add_int64_ne(b, _c_);
     /*<<buffer.ml:393:57>>*/ }
    function add_int64_be(b, x){
      /*<<buffer.ml:396:2>>*/ var
@@ -12757,6 +12775,7 @@
             : runtime.caml_call_gen(f, [a0, a1, a2, a3, a4]);
    }
    var
+    _a_ = undefined,
     global_data = runtime.caml_get_global_data(),
     Stdlib_Mutex = global_data.Stdlib__Mutex,
     Stdlib_Condition = global_data.Stdlib__Condition,
@@ -12775,8 +12794,8 @@
    function create_dls(param){
      /*<<domain.ml:59:4>>*/  /*<<domain.ml:59:13>>*/ var
      st =  /*<<domain.ml:59:13>>*/ caml_make_vect(8, unique_value);
-     /*<<domain.ml:60:4>>*/ return  /*<<domain.ml:60:4>>*/ caml_domain_dls_set
-            (st);
+     /*<<domain.ml:60:4>>*/  /*<<domain.ml:60:4>>*/ caml_domain_dls_set(st);
+     /*<<domain.ml:60:4>>*/ return _a_;
     /*<<domain.ml:60:20>>*/ }
     /*<<domain.ml:62:10>>*/ create_dls(0);
     /*<<domain.ml:66:20>>*/ var
@@ -12865,7 +12884,7 @@
      /*<<domain.ml:147:27>>*/ first_spawn_function =
       [0,
        function(param){
-         /*<<domain.ml:147:42>>*/ return 0;
+         /*<<domain.ml:147:42>>*/ return _a_;
         /*<<domain.ml:147:44>>*/ }];
    function before_first_spawn(f){
      /*<<domain.ml:150:2>>*/ if
@@ -12886,7 +12905,7 @@
     at_exit_key =
       new_key
        (0,
-        function(param, _e_){
+        function(param, _f_){
           /*<<domain.ml:166:52>>*/ return 0;
          /*<<domain.ml:166:54>>*/ });
    function at_exit(f){
@@ -12921,8 +12940,8 @@
        /*<<domain.ml:163:41>>*/ };
     }
      /*<<domain.ml:124:6>>*/  /*<<domain.ml:124:6>>*/ var
-     _a_ =  /*<<domain.ml:124:6>>*/ caml_call1(Stdlib_Atomic[2], parent_keys);
-    function _b_(param){
+     _b_ =  /*<<domain.ml:124:6>>*/ caml_call1(Stdlib_Atomic[2], parent_keys);
+    function _c_(param){
       /*<<domain.ml:122:6>>*/ var split = param[2], k = param[1], idx = k[1];
       /*<<domain.ml:123:11>>*/ return [0,
              idx,
@@ -12930,7 +12949,7 @@
      /*<<domain.ml:123:43>>*/ }
      /*<<domain.ml:124:6>>*/ var
       /*<<domain.ml:124:6>>*/ pk =
-        /*<<domain.ml:124:6>>*/ caml_call2(Stdlib_List[19], _b_, _a_),
+        /*<<domain.ml:124:6>>*/ caml_call2(Stdlib_List[19], _c_, _b_),
       /*<<domain.ml:193:19>>*/ term_mutex =
         /*<<domain.ml:193:19>>*/ caml_call1(Stdlib_Mutex[1], 0),
       /*<<domain.ml:194:23>>*/ term_condition =
@@ -12941,7 +12960,7 @@
       /*<<domain.ml:198:4>>*/ try{
        /*<<domain.ml:200:8>>*/ create_dls(0);
       var
-       _c_ =
+       _d_ =
          function(param){
            /*<<domain.ml:128:6>>*/ var
            v = param[2],
@@ -12951,7 +12970,7 @@
            /*<<domain.ml:129:35>>*/ return 0;
           /*<<domain.ml:129:49>>*/ };
        /*<<domain.ml:127:4>>*/  /*<<domain.ml:127:4>>*/ caml_call2
-       (Stdlib_List[17], _c_, pk);
+       (Stdlib_List[17], _d_, pk);
        /*<<domain.ml:202:18>>*/  /*<<domain.ml:202:18>>*/ var
        res =  /*<<domain.ml:202:18>>*/ caml_call1(f, 0);
      }
@@ -12967,8 +12986,8 @@
      catch(ex){
        /*<<domain.ml:215:10>>*/ var
        ex$0 = caml_wrap_exception(ex),
-        /*<<domain.ml:215:10>>*/ _d_ = 0 === result[0] ? [1, ex$0] : result,
-       result$0 = _d_;
+        /*<<domain.ml:215:10>>*/ _e_ = 0 === result[0] ? [1, ex$0] : result,
+       result$0 = _e_;
      }
       /*<<domain.ml:230:4>>*/  /*<<domain.ml:230:4>>*/ caml_call1
       (Stdlib_Mutex[2], term_mutex);
@@ -13100,6 +13119,7 @@
             : runtime.caml_call_gen(f, [a0, a1, a2, a3, a4]);
    }
    var
+    _$_ = undefined,
     global_data = runtime.caml_get_global_data(),
     cst$9 = "%{",
     cst$10 = "%}",
@@ -13426,14 +13446,14 @@
      /*<<camlinternalFormat.ml:28:2>>*/ var
      str_ind = c >>> 3 | 0,
      mask = 1 << (c & 7),
-      /*<<camlinternalFormat.ml:31:30>>*/ _dU_ =
+      /*<<camlinternalFormat.ml:31:30>>*/ _dT_ =
         /*<<camlinternalFormat.ml:31:30>>*/ runtime.caml_bytes_get
         (char_set, str_ind)
        | mask;
      /*<<camlinternalFormat.ml:30:2>>*/ return  /*<<camlinternalFormat.ml:30:2>>*/ caml_bytes_set
             (char_set,
              str_ind,
-              /*<<camlinternalFormat.ml:31:4>>*/ caml_call1(Stdlib[29], _dU_));
+              /*<<camlinternalFormat.ml:31:4>>*/ caml_call1(Stdlib[29], _dT_));
     /*<<camlinternalFormat.ml:31:69>>*/ }
    function freeze_char_set(char_set){
      /*<<camlinternalFormat.ml:34:2>>*/ return  /*<<camlinternalFormat.ml:34:2>>*/ caml_call1
@@ -13445,19 +13465,19 @@
      i = 0;
     for(;;){
       /*<<camlinternalFormat.ml:41:32>>*/  /*<<camlinternalFormat.ml:41:32>>*/ var
-      _dS_ =
+      _dR_ =
          /*<<camlinternalFormat.ml:41:32>>*/ caml_string_get(char_set, i)
         ^ 255;
       /*<<camlinternalFormat.ml:40:4>>*/  /*<<camlinternalFormat.ml:40:4>>*/ caml_bytes_set
       (char_set$0,
        i,
-        /*<<camlinternalFormat.ml:41:6>>*/ caml_call1(Stdlib[29], _dS_));
+        /*<<camlinternalFormat.ml:41:6>>*/ caml_call1(Stdlib[29], _dR_));
       /*<<camlinternalFormat.ml:40:4>>*/  /*<<camlinternalFormat.ml:40:4>>*/ var
-      _dT_ = i + 1 | 0;
+      _dS_ = i + 1 | 0;
      if(31 === i)
        /*<<camlinternalFormat.ml:43:2>>*/ return  /*<<camlinternalFormat.ml:43:2>>*/ caml_call1
               (Stdlib_Bytes[44], char_set$0);
-     var i = _dT_;
+     var i = _dS_;
     }
     /*<<camlinternalFormat.ml:43:34>>*/ }
    function is_in_char_set(char_set, c){
@@ -13517,11 +13537,11 @@
       case 6:
        var prec_opt = ign[2], pad_opt$5 = ign[1];
        if(prec_opt)
-        var ndec = prec_opt[1], _dR_ = [0, ndec];
+        var ndec = prec_opt[1], _dQ_ = [0, ndec];
        else
-        var _dR_ = 0;
+        var _dQ_ = 0;
         /*<<camlinternalFormat.ml:97:4>>*/ return [0,
-               [8, _a_, pad_of_pad_opt(pad_opt$5), _dR_, fmt]];
+               [8, _a_, pad_of_pad_opt(pad_opt$5), _dQ_, fmt]];
       case 7:
        var pad_opt$6 = ign[1];
         /*<<camlinternalFormat.ml:101:4>>*/ return [0,
@@ -13554,9 +13574,8 @@
    function buffer_check_size(buf, overhead){
      /*<<camlinternalFormat.ml:260:2>>*/ var
      len = runtime.caml_ml_bytes_length(buf[2]),
-     min_len = buf[1] + overhead | 0,
-     _dP_ = len < min_len ? 1 : 0;
-    if(_dP_){
+     min_len = buf[1] + overhead | 0;
+    if(len < min_len){
       /*<<camlinternalFormat.ml:263:18>>*/ var
        /*<<camlinternalFormat.ml:263:18>>*/ new_len =
          /*<<camlinternalFormat.ml:263:18>>*/ caml_call2
@@ -13566,18 +13585,15 @@
       /*<<camlinternalFormat.ml:265:4>>*/  /*<<camlinternalFormat.ml:265:4>>*/ caml_call5
       (Stdlib_Bytes[11], buf[2], 0, new_str, 0, len);
      buf[2] = new_str;
-     var _dQ_ = 0;
     }
-    else
-     var _dQ_ = _dP_;
-    return _dQ_;
+    return _$_;
     /*<<camlinternalFormat.ml:267:3>>*/ }
    function buffer_add_char(buf, c){
      /*<<camlinternalFormat.ml:271:2>>*/ buffer_check_size(buf, 1);
      /*<<camlinternalFormat.ml:272:2>>*/  /*<<camlinternalFormat.ml:272:2>>*/ caml_bytes_set
      (buf[2], buf[1], c);
     buf[1] = buf[1] + 1 | 0;
-    return 0;
+    return _$_;
     /*<<camlinternalFormat.ml:273:24>>*/ }
    function buffer_add_string(buf, s){
      /*<<camlinternalFormat.ml:277:2>>*/ var
@@ -13586,7 +13602,7 @@
      /*<<camlinternalFormat.ml:279:2>>*/  /*<<camlinternalFormat.ml:279:2>>*/ caml_call5
      (Stdlib_String[48], s, 0, buf[2], buf[1], str_len);
     buf[1] = buf[1] + str_len | 0;
-    return 0;
+    return _$_;
     /*<<camlinternalFormat.ml:280:30>>*/ }
    function buffer_contents(buf){
      /*<<camlinternalFormat.ml:284:2>>*/ return caml_call3
@@ -13642,68 +13658,74 @@
    function bprint_padty(buf, padty){
      /*<<camlinternalFormat.ml:374:29>>*/ switch(padty){
       case 0:
-        /*<<camlinternalFormat.ml:375:13>>*/ return buffer_add_char(buf, 45);
+        /*<<camlinternalFormat.ml:375:13>>*/ buffer_add_char(buf, 45);
+        /*<<camlinternalFormat.ml:375:13>>*/ return _$_;
       case 1:
-        /*<<camlinternalFormat.ml:376:13>>*/ return 0;
+        /*<<camlinternalFormat.ml:376:13>>*/ return _$_;
       default:
-        /*<<camlinternalFormat.ml:377:13>>*/ return buffer_add_char(buf, 48);
+        /*<<camlinternalFormat.ml:377:13>>*/ buffer_add_char(buf, 48);
+        /*<<camlinternalFormat.ml:377:13>>*/ return _$_;
     }
     /*<<camlinternalFormat.ml:377:36>>*/ }
    function bprint_ignored_flag(buf, ign_flag){
      /*<<camlinternalFormat.ml:381:2>>*/ return ign_flag
-            ? buffer_add_char(buf, 95)
+            ? (buffer_add_char(buf, 95), _$_)
             : ign_flag;
     /*<<camlinternalFormat.ml:381:42>>*/ }
    function bprint_pad_opt(buf, pad_opt){
      /*<<camlinternalFormat.ml:385:33>>*/ if(! pad_opt)
-      /*<<camlinternalFormat.ml:386:12>>*/ return 0;
+      /*<<camlinternalFormat.ml:386:12>>*/ return _$_;
     var width = pad_opt[1];
-     /*<<camlinternalFormat.ml:387:40>>*/ return buffer_add_string
-            (buf,
-              /*<<camlinternalFormat.ml:387:40>>*/ caml_call1
-              (Stdlib_Int[12], width));
+     /*<<camlinternalFormat.ml:387:40>>*/ buffer_add_string
+     (buf,
+       /*<<camlinternalFormat.ml:387:40>>*/ caml_call1(Stdlib_Int[12], width));
+     /*<<camlinternalFormat.ml:387:40>>*/ return _$_;
     /*<<camlinternalFormat.ml:387:61>>*/ }
    function bprint_padding(buf, pad){
      /*<<camlinternalFormat.ml:393:15>>*/ if(typeof pad === "number")
-      /*<<camlinternalFormat.ml:394:18>>*/ return 0;
+      /*<<camlinternalFormat.ml:394:18>>*/ return _$_;
     if(0 === pad[0]){
      var n = pad[2], padty = pad[1];
       /*<<camlinternalFormat.ml:396:4>>*/ bprint_padty(buf, padty);
-      /*<<camlinternalFormat.ml:397:26>>*/ return buffer_add_string
-             (buf,
-               /*<<camlinternalFormat.ml:397:26>>*/ caml_call1
-               (Stdlib_Int[12], n));
+      /*<<camlinternalFormat.ml:397:26>>*/ buffer_add_string
+      (buf,
+        /*<<camlinternalFormat.ml:397:26>>*/ caml_call1(Stdlib_Int[12], n));
+      /*<<camlinternalFormat.ml:397:26>>*/ return _$_;
     }
     var padty$0 = pad[1];
      /*<<camlinternalFormat.ml:399:4>>*/ bprint_padty(buf, padty$0);
-     /*<<camlinternalFormat.ml:399:4>>*/ return buffer_add_char(buf, 42);
+     /*<<camlinternalFormat.ml:399:4>>*/ buffer_add_char(buf, 42);
+     /*<<camlinternalFormat.ml:399:4>>*/ return _$_;
     /*<<camlinternalFormat.ml:400:27>>*/ }
    function bprint_precision(buf, prec){
      /*<<camlinternalFormat.ml:404:18>>*/ if(typeof prec === "number")
-     return prec ? buffer_add_string(buf, cst) : 0;
+     return prec ? (buffer_add_string(buf, cst), _$_) : _$_;
     var n = prec[1];
      /*<<camlinternalFormat.ml:407:4>>*/ buffer_add_char(buf, 46);
-     /*<<camlinternalFormat.ml:408:26>>*/ return buffer_add_string
-            (buf,
-              /*<<camlinternalFormat.ml:408:26>>*/ caml_call1
-              (Stdlib_Int[12], n));
+     /*<<camlinternalFormat.ml:408:26>>*/ buffer_add_string
+     (buf,
+       /*<<camlinternalFormat.ml:408:26>>*/ caml_call1(Stdlib_Int[12], n));
+     /*<<camlinternalFormat.ml:408:26>>*/ return _$_;
     /*<<camlinternalFormat.ml:410:30>>*/ }
    function bprint_iconv_flag(buf, iconv){
      /*<<camlinternalFormat.ml:415:34>>*/ switch(iconv){
       case 1:
       case 4:
-        /*<<camlinternalFormat.ml:416:23>>*/ return buffer_add_char(buf, 43);
+        /*<<camlinternalFormat.ml:416:23>>*/ buffer_add_char(buf, 43);
+        /*<<camlinternalFormat.ml:416:23>>*/ return _$_;
       case 2:
       case 5:
-        /*<<camlinternalFormat.ml:417:23>>*/ return buffer_add_char(buf, 32);
+        /*<<camlinternalFormat.ml:417:23>>*/ buffer_add_char(buf, 32);
+        /*<<camlinternalFormat.ml:417:23>>*/ return _$_;
       case 7:
       case 9:
       case 11:
       case 13:
       case 14:
       case 15:
-        /*<<camlinternalFormat.ml:419:6>>*/ return buffer_add_char(buf, 35);
-      default:  /*<<camlinternalFormat.ml:420:53>>*/ return 0;
+        /*<<camlinternalFormat.ml:419:6>>*/ buffer_add_char(buf, 35);
+        /*<<camlinternalFormat.ml:419:6>>*/ return _$_;
+      default:  /*<<camlinternalFormat.ml:420:53>>*/ return _$_;
     }
     /*<<camlinternalFormat.ml:420:55>>*/ }
    function bprint_altint_fmt(buf, ign_flag, iconv, pad, prec, c){
@@ -13713,8 +13735,9 @@
      /*<<camlinternalFormat.ml:436:2>>*/ bprint_padding(buf, pad);
      /*<<camlinternalFormat.ml:437:2>>*/ bprint_precision(buf, prec);
      /*<<camlinternalFormat.ml:438:2>>*/ buffer_add_char(buf, c);
-     /*<<camlinternalFormat.ml:439:22>>*/ return buffer_add_char
-            (buf, char_of_iconv(iconv));
+     /*<<camlinternalFormat.ml:439:22>>*/ buffer_add_char
+     (buf, char_of_iconv(iconv));
+     /*<<camlinternalFormat.ml:439:22>>*/ return _$_;
     /*<<camlinternalFormat.ml:439:43>>*/ }
    function bprint_fconv_flag(buf, fconv){
      /*<<camlinternalFormat.ml:445:2>>*/ switch(fconv[1]){
@@ -13723,7 +13746,7 @@
         /*<<camlinternalFormat.ml:446:20>>*/ buffer_add_char(buf, 43); break;
       default:  /*<<camlinternalFormat.ml:447:20>>*/ buffer_add_char(buf, 32);
     }
-    return 8 <= fconv[2] ? buffer_add_char(buf, 35) : 0;
+    return 8 <= fconv[2] ? (buffer_add_char(buf, 35), _$_) : _$_;
     /*<<camlinternalFormat.ml:452:37>>*/ }
    function string_of_formatting_lit(formatting_lit){
      /*<<camlinternalFormat.ml:465:46>>*/ if
@@ -13753,40 +13776,40 @@
       default:
         /*<<camlinternalFormat.ml:475:26>>*/ var
         c = formatting_lit[1],
-         /*<<camlinternalFormat.ml:475:26>>*/ _dO_ =
+         /*<<camlinternalFormat.ml:475:26>>*/ _dP_ =
            /*<<camlinternalFormat.ml:475:26>>*/ caml_call2
            (Stdlib_String[1], 1, c);
         /*<<camlinternalFormat.ml:475:26>>*/ return  /*<<camlinternalFormat.ml:475:26>>*/ caml_call2
-               (Stdlib[28], cst$7, _dO_);
+               (Stdlib[28], cst$7, _dP_);
     }
     /*<<camlinternalFormat.ml:475:43>>*/ }
    function bprint_char_literal(buf, chr){
      /*<<camlinternalFormat.ml:480:34>>*/ return 37 === chr
-            ? buffer_add_string(buf, cst$8)
-            : buffer_add_char(buf, chr);
+            ? (buffer_add_string(buf, cst$8), _$_)
+            : (buffer_add_char(buf, chr), _$_);
     /*<<camlinternalFormat.ml:482:32>>*/ }
    function bprint_string_literal(buf, str){
      /*<<camlinternalFormat.ml:486:2>>*/ var
-     _dM_ = caml_ml_string_length(str) - 1 | 0,
-      /*<<camlinternalFormat.ml:486:2>>*/ _dL_ = 0;
-    if(_dM_ >= 0){
-     var i = _dL_;
+     _dN_ = caml_ml_string_length(str) - 1 | 0,
+      /*<<camlinternalFormat.ml:486:2>>*/ _dM_ = 0;
+    if(_dN_ >= 0){
+     var i = _dM_;
      for(;;){
        /*<<camlinternalFormat.ml:487:4>>*/ bprint_char_literal
        (buf,  /*<<camlinternalFormat.ml:487:28>>*/ caml_string_get(str, i));
        /*<<camlinternalFormat.ml:487:4>>*/  /*<<camlinternalFormat.ml:487:4>>*/ var
-       _dN_ = i + 1 | 0;
-      if(_dM_ !== i){var i = _dN_; continue;}
+       _dO_ = i + 1 | 0;
+      if(_dN_ !== i){var i = _dO_; continue;}
       break;
      }
     }
-    return 0;
+    return _$_;
     /*<<camlinternalFormat.ml:488:6>>*/ }
    function bprint_fmtty(buf, fmtty){
      /*<<camlinternalFormat.ml:496:17>>*/ var fmtty$0 = fmtty;
      /*<<camlinternalFormat.ml:496:17>>*/ for(;;){
      if(typeof fmtty$0 === "number")
-       /*<<camlinternalFormat.ml:521:20>>*/ return 0;
+       /*<<camlinternalFormat.ml:521:20>>*/ return _$_;
      switch(fmtty$0[0]){
        case 0:
         var fmtty$1 = fmtty$0[1];
@@ -13886,7 +13909,7 @@
      a:
       /*<<camlinternalFormat.ml:535:22>>*/ for(;;){
       if(typeof fmt$0 === "number")
-        /*<<camlinternalFormat.ml:636:23>>*/ return 0;
+        /*<<camlinternalFormat.ml:636:23>>*/ return _$_;
       switch(fmt$0[0]){
         case 0:
          var rest = fmt$0[1];
@@ -14090,11 +14113,11 @@
                  /*<<camlinternalFormat.ml:358:31>>*/ caml_call1
                  (Stdlib[29], i);
              return 37 === c
-                     ? (buffer_add_char(buf, 37), buffer_add_char(buf, 37))
+                     ? (buffer_add_char(buf, 37), buffer_add_char(buf, 37), _$_)
                      : 64
                        === c
-                       ? (buffer_add_char(buf, 37), buffer_add_char(buf, 64))
-                       : buffer_add_char(buf, c);
+                       ? (buffer_add_char(buf, 37), buffer_add_char(buf, 64), _$_)
+                       : (buffer_add_char(buf, c), _$_);
              /*<<camlinternalFormat.ml:361:35>>*/ };
           /*<<camlinternalFormat.ml:363:2>>*/ buffer_add_char(buf, 91);
           /*<<camlinternalFormat.ml:365:7>>*/ var
@@ -14112,18 +14135,18 @@
                 /*<<camlinternalFormat.ml:316:32>>*/ before =
                   /*<<camlinternalFormat.ml:316:32>>*/ caml_call1
                   (Stdlib_Char[1], c - 1 | 0),
-                /*<<camlinternalFormat.ml:317:6>>*/ _dH_ =
+                /*<<camlinternalFormat.ml:317:6>>*/ _dI_ =
                  is_in_char_set(set, c);
-               /*<<camlinternalFormat.ml:317:6>>*/ if(_dH_)
+               /*<<camlinternalFormat.ml:317:6>>*/ if(_dI_)
                 /*<<camlinternalFormat.ml:318:14>>*/ var
-                 /*<<camlinternalFormat.ml:318:14>>*/ _dI_ =
-                  is_in_char_set(set, before),
                  /*<<camlinternalFormat.ml:318:14>>*/ _dJ_ =
-                  _dI_ ? is_in_char_set(set, after) : _dI_,
-                _dK_ = 1 - _dJ_;
+                  is_in_char_set(set, before),
+                 /*<<camlinternalFormat.ml:318:14>>*/ _dK_ =
+                  _dJ_ ? is_in_char_set(set, after) : _dJ_,
+                _dL_ = 1 - _dK_;
               else
-               var _dK_ = _dH_;
-               /*<<camlinternalFormat.ml:318:43>>*/ return _dK_;
+               var _dL_ = _dI_;
+               /*<<camlinternalFormat.ml:318:43>>*/ return _dL_;
               /*<<camlinternalFormat.ml:318:68>>*/ }
              return is_alone;
             },
@@ -14267,12 +14290,12 @@
           (buf, ign_flag$0);
          switch(counter){
            case 0:
-            var _dD_ = 108; break;
+            var _dE_ = 108; break;
            case 1:
-            var _dD_ = 110; break;
-           default: var _dD_ = 78;
+            var _dE_ = 110; break;
+           default: var _dE_ = 78;
          }
-          /*<<camlinternalFormat.ml:614:6>>*/ buffer_add_char(buf, _dD_);
+          /*<<camlinternalFormat.ml:614:6>>*/ buffer_add_char(buf, _dE_);
          var fmt$0 = rest$20, ign_flag$0 = 0;
          continue;
         case 22:
@@ -14296,19 +14319,19 @@
           /*<<camlinternalFormat.ml:578:20>>*/ var
           rest$23 = fmt$0[3],
           arity = fmt$0[1],
-           /*<<camlinternalFormat.ml:578:20>>*/ _dF_ =
+           /*<<camlinternalFormat.ml:578:20>>*/ _dG_ =
             int_of_custom_arity(arity),
-          _dE_ = 1;
-         if(_dF_ >= 1){
-          var i$8 = _dE_;
+          _dF_ = 1;
+         if(_dG_ >= 1){
+          var i$8 = _dF_;
           for(;;){
             /*<<camlinternalFormat.ml:579:8>>*/ buffer_add_char(buf, 37);
             /*<<camlinternalFormat.ml:579:33>>*/ bprint_ignored_flag
             (buf, ign_flag$0);
             /*<<camlinternalFormat.ml:580:8>>*/ buffer_add_char(buf, 63);
             /*<<camlinternalFormat.ml:580:8>>*/  /*<<camlinternalFormat.ml:580:8>>*/ var
-            _dG_ = i$8 + 1 | 0;
-           if(_dF_ !== i$8){var i$8 = _dG_; continue;}
+            _dH_ = i$8 + 1 | 0;
+           if(_dG_ !== i$8){var i$8 = _dH_; continue;}
            break;
           }
          }
@@ -14382,17 +14405,17 @@
          ed = match[3],
          af = match[2],
          fa = match[1],
-         _di_ =
+         _dj_ =
            function(param){
              /*<<camlinternalFormat.ml:698:17>>*/ af(0);
-             /*<<camlinternalFormat.ml:698:39>>*/ return 0;
+             /*<<camlinternalFormat.ml:698:39>>*/ return _$_;
             /*<<camlinternalFormat.ml:698:43>>*/ };
          /*<<camlinternalFormat.ml:697:4>>*/ return [0,
                 function(param){
                   /*<<camlinternalFormat.ml:697:17>>*/ fa(0);
-                  /*<<camlinternalFormat.ml:697:39>>*/ return 0;
+                  /*<<camlinternalFormat.ml:697:39>>*/ return _$_;
                  /*<<camlinternalFormat.ml:697:43>>*/ },
-                _di_,
+                _dj_,
                 ed,
                 de];
        case 1:
@@ -14403,17 +14426,17 @@
          ed$0 = match$0[3],
          af$0 = match$0[2],
          fa$0 = match$0[1],
-         _dj_ =
+         _dk_ =
            function(param){
              /*<<camlinternalFormat.ml:703:17>>*/ af$0(0);
-             /*<<camlinternalFormat.ml:703:39>>*/ return 0;
+             /*<<camlinternalFormat.ml:703:39>>*/ return _$_;
             /*<<camlinternalFormat.ml:703:43>>*/ };
          /*<<camlinternalFormat.ml:702:4>>*/ return [0,
                 function(param){
                   /*<<camlinternalFormat.ml:702:17>>*/ fa$0(0);
-                  /*<<camlinternalFormat.ml:702:39>>*/ return 0;
+                  /*<<camlinternalFormat.ml:702:39>>*/ return _$_;
                  /*<<camlinternalFormat.ml:702:43>>*/ },
-                _dj_,
+                _dk_,
                 ed$0,
                 de$0];
        case 2:
@@ -14424,17 +14447,17 @@
          ed$1 = match$1[3],
          af$1 = match$1[2],
          fa$1 = match$1[1],
-         _dk_ =
+         _dl_ =
            function(param){
              /*<<camlinternalFormat.ml:708:17>>*/ af$1(0);
-             /*<<camlinternalFormat.ml:708:39>>*/ return 0;
+             /*<<camlinternalFormat.ml:708:39>>*/ return _$_;
             /*<<camlinternalFormat.ml:708:43>>*/ };
          /*<<camlinternalFormat.ml:707:4>>*/ return [0,
                 function(param){
                   /*<<camlinternalFormat.ml:707:17>>*/ fa$1(0);
-                  /*<<camlinternalFormat.ml:707:39>>*/ return 0;
+                  /*<<camlinternalFormat.ml:707:39>>*/ return _$_;
                  /*<<camlinternalFormat.ml:707:43>>*/ },
-                _dk_,
+                _dl_,
                 ed$1,
                 de$1];
        case 3:
@@ -14445,17 +14468,17 @@
          ed$2 = match$2[3],
          af$2 = match$2[2],
          fa$2 = match$2[1],
-         _dl_ =
+         _dm_ =
            function(param){
              /*<<camlinternalFormat.ml:713:17>>*/ af$2(0);
-             /*<<camlinternalFormat.ml:713:39>>*/ return 0;
+             /*<<camlinternalFormat.ml:713:39>>*/ return _$_;
             /*<<camlinternalFormat.ml:713:43>>*/ };
          /*<<camlinternalFormat.ml:712:4>>*/ return [0,
                 function(param){
                   /*<<camlinternalFormat.ml:712:17>>*/ fa$2(0);
-                  /*<<camlinternalFormat.ml:712:39>>*/ return 0;
+                  /*<<camlinternalFormat.ml:712:39>>*/ return _$_;
                  /*<<camlinternalFormat.ml:712:43>>*/ },
-                _dl_,
+                _dm_,
                 ed$2,
                 de$2];
        case 4:
@@ -14466,17 +14489,17 @@
          ed$3 = match$3[3],
          af$3 = match$3[2],
          fa$3 = match$3[1],
-         _dm_ =
+         _dn_ =
            function(param){
              /*<<camlinternalFormat.ml:723:17>>*/ af$3(0);
-             /*<<camlinternalFormat.ml:723:39>>*/ return 0;
+             /*<<camlinternalFormat.ml:723:39>>*/ return _$_;
             /*<<camlinternalFormat.ml:723:43>>*/ };
          /*<<camlinternalFormat.ml:722:4>>*/ return [0,
                 function(param){
                   /*<<camlinternalFormat.ml:722:17>>*/ fa$3(0);
-                  /*<<camlinternalFormat.ml:722:39>>*/ return 0;
+                  /*<<camlinternalFormat.ml:722:39>>*/ return _$_;
                  /*<<camlinternalFormat.ml:722:43>>*/ },
-                _dm_,
+                _dn_,
                 ed$3,
                 de$3];
        case 5:
@@ -14487,17 +14510,17 @@
          ed$4 = match$4[3],
          af$4 = match$4[2],
          fa$4 = match$4[1],
-         _dn_ =
+         _do_ =
            function(param){
              /*<<camlinternalFormat.ml:718:17>>*/ af$4(0);
-             /*<<camlinternalFormat.ml:718:39>>*/ return 0;
+             /*<<camlinternalFormat.ml:718:39>>*/ return _$_;
             /*<<camlinternalFormat.ml:718:43>>*/ };
          /*<<camlinternalFormat.ml:717:4>>*/ return [0,
                 function(param){
                   /*<<camlinternalFormat.ml:717:17>>*/ fa$4(0);
-                  /*<<camlinternalFormat.ml:717:39>>*/ return 0;
+                  /*<<camlinternalFormat.ml:717:39>>*/ return _$_;
                  /*<<camlinternalFormat.ml:717:43>>*/ },
-                _dn_,
+                _do_,
                 ed$4,
                 de$4];
        case 6:
@@ -14508,17 +14531,17 @@
          ed$5 = match$5[3],
          af$5 = match$5[2],
          fa$5 = match$5[1],
-         _do_ =
+         _dp_ =
            function(param){
              /*<<camlinternalFormat.ml:728:17>>*/ af$5(0);
-             /*<<camlinternalFormat.ml:728:39>>*/ return 0;
+             /*<<camlinternalFormat.ml:728:39>>*/ return _$_;
             /*<<camlinternalFormat.ml:728:43>>*/ };
          /*<<camlinternalFormat.ml:727:4>>*/ return [0,
                 function(param){
                   /*<<camlinternalFormat.ml:727:17>>*/ fa$5(0);
-                  /*<<camlinternalFormat.ml:727:39>>*/ return 0;
+                  /*<<camlinternalFormat.ml:727:39>>*/ return _$_;
                  /*<<camlinternalFormat.ml:727:43>>*/ },
-                _do_,
+                _dp_,
                 ed$5,
                 de$5];
        case 7:
@@ -14529,17 +14552,17 @@
          ed$6 = match$6[3],
          af$6 = match$6[2],
          fa$6 = match$6[1],
-         _dp_ =
+         _dq_ =
            function(param){
              /*<<camlinternalFormat.ml:733:17>>*/ af$6(0);
-             /*<<camlinternalFormat.ml:733:39>>*/ return 0;
+             /*<<camlinternalFormat.ml:733:39>>*/ return _$_;
             /*<<camlinternalFormat.ml:733:43>>*/ };
          /*<<camlinternalFormat.ml:732:4>>*/ return [0,
                 function(param){
                   /*<<camlinternalFormat.ml:732:17>>*/ fa$6(0);
-                  /*<<camlinternalFormat.ml:732:39>>*/ return 0;
+                  /*<<camlinternalFormat.ml:732:39>>*/ return _$_;
                  /*<<camlinternalFormat.ml:732:43>>*/ },
-                _dp_,
+                _dq_,
                 ed$6,
                 de$6];
        case 8:
@@ -14550,17 +14573,17 @@
          ed$7 = match$7[3],
          af$7 = match$7[2],
          fa$7 = match$7[1],
-         _dq_ =
+         _dr_ =
            function(param){
              /*<<camlinternalFormat.ml:766:17>>*/ af$7(0);
-             /*<<camlinternalFormat.ml:766:39>>*/ return 0;
+             /*<<camlinternalFormat.ml:766:39>>*/ return _$_;
             /*<<camlinternalFormat.ml:766:43>>*/ };
          /*<<camlinternalFormat.ml:765:4>>*/ return [0,
                 function(param){
                   /*<<camlinternalFormat.ml:765:17>>*/ fa$7(0);
-                  /*<<camlinternalFormat.ml:765:39>>*/ return 0;
+                  /*<<camlinternalFormat.ml:765:39>>*/ return _$_;
                  /*<<camlinternalFormat.ml:765:43>>*/ },
-                _dq_,
+                _dr_,
                 ed$7,
                 de$7];
        case 9:
@@ -14579,33 +14602,33 @@
          dj = match$9[3],
          ga = match$9[2],
          ag = match$9[1],
-         _dr_ =
+         _ds_ =
            function(param){
              /*<<camlinternalFormat.ml:775:17>>*/ jd(0);
              /*<<camlinternalFormat.ml:775:50>>*/ de$8(0);
-             /*<<camlinternalFormat.ml:775:61>>*/ return 0;
+             /*<<camlinternalFormat.ml:775:61>>*/ return _$_;
             /*<<camlinternalFormat.ml:775:65>>*/ },
-         _ds_ =
+         _dt_ =
            function(param){
              /*<<camlinternalFormat.ml:774:17>>*/ ed$8(0);
              /*<<camlinternalFormat.ml:774:50>>*/ dj(0);
-             /*<<camlinternalFormat.ml:774:61>>*/ return 0;
+             /*<<camlinternalFormat.ml:774:61>>*/ return _$_;
             /*<<camlinternalFormat.ml:774:65>>*/ },
-         _dt_ =
+         _du_ =
            function(param){
              /*<<camlinternalFormat.ml:773:17>>*/ ga(0);
              /*<<camlinternalFormat.ml:773:50>>*/ af$8(0);
-             /*<<camlinternalFormat.ml:773:61>>*/ return 0;
+             /*<<camlinternalFormat.ml:773:61>>*/ return _$_;
             /*<<camlinternalFormat.ml:773:65>>*/ };
          /*<<camlinternalFormat.ml:772:4>>*/ return [0,
                 function(param){
                   /*<<camlinternalFormat.ml:772:17>>*/ fa$8(0);
                   /*<<camlinternalFormat.ml:772:50>>*/ ag(0);
-                  /*<<camlinternalFormat.ml:772:61>>*/ return 0;
+                  /*<<camlinternalFormat.ml:772:61>>*/ return _$_;
                  /*<<camlinternalFormat.ml:772:65>>*/ },
+                _du_,
                 _dt_,
-                _ds_,
-                _dr_];
+                _ds_];
        case 10:
          /*<<camlinternalFormat.ml:742:25>>*/ var
          rest$9 = param[1],
@@ -14615,17 +14638,17 @@
          ed$9 = match$10[3],
          af$9 = match$10[2],
          fa$9 = match$10[1],
-         _du_ =
+         _dv_ =
            function(param){
              /*<<camlinternalFormat.ml:744:17>>*/ af$9(0);
-             /*<<camlinternalFormat.ml:744:39>>*/ return 0;
+             /*<<camlinternalFormat.ml:744:39>>*/ return _$_;
             /*<<camlinternalFormat.ml:744:43>>*/ };
          /*<<camlinternalFormat.ml:743:4>>*/ return [0,
                 function(param){
                   /*<<camlinternalFormat.ml:743:17>>*/ fa$9(0);
-                  /*<<camlinternalFormat.ml:743:39>>*/ return 0;
+                  /*<<camlinternalFormat.ml:743:39>>*/ return _$_;
                  /*<<camlinternalFormat.ml:743:43>>*/ },
-                _du_,
+                _dv_,
                 ed$9,
                 de$9];
        case 11:
@@ -14637,17 +14660,17 @@
          ed$10 = match$11[3],
          af$10 = match$11[2],
          fa$10 = match$11[1],
-         _dv_ =
+         _dw_ =
            function(param){
              /*<<camlinternalFormat.ml:739:17>>*/ af$10(0);
-             /*<<camlinternalFormat.ml:739:39>>*/ return 0;
+             /*<<camlinternalFormat.ml:739:39>>*/ return _$_;
             /*<<camlinternalFormat.ml:739:43>>*/ };
          /*<<camlinternalFormat.ml:738:4>>*/ return [0,
                 function(param){
                   /*<<camlinternalFormat.ml:738:17>>*/ fa$10(0);
-                  /*<<camlinternalFormat.ml:738:39>>*/ return 0;
+                  /*<<camlinternalFormat.ml:738:39>>*/ return _$_;
                  /*<<camlinternalFormat.ml:738:43>>*/ },
-                _dv_,
+                _dw_,
                 ed$10,
                 de$10];
        case 12:
@@ -14659,17 +14682,17 @@
          ed$11 = match$12[3],
          af$11 = match$12[2],
          fa$11 = match$12[1],
-         _dw_ =
+         _dx_ =
            function(param){
              /*<<camlinternalFormat.ml:749:17>>*/ af$11(0);
-             /*<<camlinternalFormat.ml:749:39>>*/ return 0;
+             /*<<camlinternalFormat.ml:749:39>>*/ return _$_;
             /*<<camlinternalFormat.ml:749:43>>*/ };
          /*<<camlinternalFormat.ml:748:4>>*/ return [0,
                 function(param){
                   /*<<camlinternalFormat.ml:748:17>>*/ fa$11(0);
-                  /*<<camlinternalFormat.ml:748:39>>*/ return 0;
+                  /*<<camlinternalFormat.ml:748:39>>*/ return _$_;
                  /*<<camlinternalFormat.ml:748:43>>*/ },
-                _dw_,
+                _dx_,
                 ed$11,
                 de$11];
        case 13:
@@ -14681,29 +14704,29 @@
          ed$12 = match$13[3],
          af$12 = match$13[2],
          fa$12 = match$13[1],
-          /*<<camlinternalFormat.ml:753:4>>*/ _dx_ =
+          /*<<camlinternalFormat.ml:753:4>>*/ _dy_ =
            function(param){
              /*<<camlinternalFormat.ml:756:17>>*/ de$12(0);
-             /*<<camlinternalFormat.ml:756:39>>*/ return 0;
+             /*<<camlinternalFormat.ml:756:39>>*/ return _$_;
             /*<<camlinternalFormat.ml:756:43>>*/ },
-         _dy_ =
+         _dz_ =
            function(param){
              /*<<camlinternalFormat.ml:755:17>>*/ ed$12(0);
-             /*<<camlinternalFormat.ml:755:39>>*/ return 0;
+             /*<<camlinternalFormat.ml:755:39>>*/ return _$_;
             /*<<camlinternalFormat.ml:755:43>>*/ },
-         _dz_ =
+         _dA_ =
            function(param){
              /*<<camlinternalFormat.ml:754:17>>*/ af$12(0);
-             /*<<camlinternalFormat.ml:754:39>>*/ return 0;
+             /*<<camlinternalFormat.ml:754:39>>*/ return _$_;
             /*<<camlinternalFormat.ml:754:43>>*/ };
          /*<<camlinternalFormat.ml:753:4>>*/ return [0,
                 function(param){
                   /*<<camlinternalFormat.ml:753:17>>*/ fa$12(0);
-                  /*<<camlinternalFormat.ml:753:39>>*/ return 0;
+                  /*<<camlinternalFormat.ml:753:39>>*/ return _$_;
                  /*<<camlinternalFormat.ml:753:43>>*/ },
+                _dA_,
                 _dz_,
-                _dy_,
-                _dx_];
+                _dy_];
        default:
          /*<<camlinternalFormat.ml:758:25>>*/ var
          rest$13 = param[1],
@@ -14713,46 +14736,46 @@
          ed$13 = match$14[3],
          af$13 = match$14[2],
          fa$13 = match$14[1],
-          /*<<camlinternalFormat.ml:759:4>>*/ _dA_ =
+          /*<<camlinternalFormat.ml:759:4>>*/ _dB_ =
            function(param){
              /*<<camlinternalFormat.ml:762:17>>*/ de$13(0);
-             /*<<camlinternalFormat.ml:762:39>>*/ return 0;
+             /*<<camlinternalFormat.ml:762:39>>*/ return _$_;
             /*<<camlinternalFormat.ml:762:43>>*/ },
-         _dB_ =
+         _dC_ =
            function(param){
              /*<<camlinternalFormat.ml:761:17>>*/ ed$13(0);
-             /*<<camlinternalFormat.ml:761:39>>*/ return 0;
+             /*<<camlinternalFormat.ml:761:39>>*/ return _$_;
             /*<<camlinternalFormat.ml:761:43>>*/ },
-         _dC_ =
+         _dD_ =
            function(param){
              /*<<camlinternalFormat.ml:760:17>>*/ af$13(0);
-             /*<<camlinternalFormat.ml:760:39>>*/ return 0;
+             /*<<camlinternalFormat.ml:760:39>>*/ return _$_;
             /*<<camlinternalFormat.ml:760:43>>*/ };
          /*<<camlinternalFormat.ml:759:4>>*/ return [0,
                 function(param){
                   /*<<camlinternalFormat.ml:759:17>>*/ fa$13(0);
-                  /*<<camlinternalFormat.ml:759:39>>*/ return 0;
+                  /*<<camlinternalFormat.ml:759:39>>*/ return _$_;
                  /*<<camlinternalFormat.ml:759:43>>*/ },
+                _dD_,
                 _dC_,
-                _dB_,
-                _dA_];
+                _dB_];
      }
-     /*<<camlinternalFormat.ml:691:4>>*/ function _df_(param){
-      /*<<camlinternalFormat.ml:694:17>>*/ return 0;
+     /*<<camlinternalFormat.ml:691:4>>*/ function _dg_(param){
+      /*<<camlinternalFormat.ml:694:17>>*/ return _$_;
      /*<<camlinternalFormat.ml:694:21>>*/ }
-    function _dg_(param){
-      /*<<camlinternalFormat.ml:693:17>>*/ return 0;
-     /*<<camlinternalFormat.ml:693:21>>*/ }
     function _dh_(param){
-      /*<<camlinternalFormat.ml:692:17>>*/ return 0;
+      /*<<camlinternalFormat.ml:693:17>>*/ return _$_;
+     /*<<camlinternalFormat.ml:693:21>>*/ }
+    function _di_(param){
+      /*<<camlinternalFormat.ml:692:17>>*/ return _$_;
      /*<<camlinternalFormat.ml:692:21>>*/ }
      /*<<camlinternalFormat.ml:691:4>>*/ return [0,
             function(param){
-              /*<<camlinternalFormat.ml:691:17>>*/ return 0;
+              /*<<camlinternalFormat.ml:691:17>>*/ return _$_;
              /*<<camlinternalFormat.ml:691:21>>*/ },
+            _di_,
             _dh_,
-            _dg_,
-            _df_];
+            _dg_];
     /*<<camlinternalFormat.ml:775:66>>*/ }
    function trans(ty1, ty2){
      /*<<camlinternalFormat.ml:803:17>>*/ var switch$0 = 0;
@@ -15006,11 +15029,11 @@
              /*<<camlinternalFormat.ml:835:34>>*/ var
              rest2$7 = ty2[2],
              ty2$0 = ty2[1],
-              /*<<camlinternalFormat.ml:835:34>>*/ _de_ =
+              /*<<camlinternalFormat.ml:835:34>>*/ _df_ =
                trans(rest1$7, rest2$7);
              /*<<camlinternalFormat.ml:835:4>>*/ return [8,
                     trans(ty1$0, ty2$0),
-                    _de_];
+                    _df_];
            case 10: break;
            case 11:
             switch$0 = 1; break;
@@ -15302,13 +15325,13 @@
          /*<<camlinternalFormat.ml:914:54>>*/ var
          rest$13 = fmtty$0[2],
          formatting_gen = fmtty$0[1],
-          /*<<camlinternalFormat.ml:914:54>>*/ _db_ = fmtty_of_fmt(rest$13);
+          /*<<camlinternalFormat.ml:914:54>>*/ _dc_ = fmtty_of_fmt(rest$13);
         if(0 === formatting_gen[0])
-         var fmt = formatting_gen[1][1], _dc_ = fmtty_of_fmt(fmt);
+         var fmt = formatting_gen[1][1], _dd_ = fmtty_of_fmt(fmt);
         else
-         var fmt$0 = formatting_gen[1][1], _dc_ = fmtty_of_fmt(fmt$0);
+         var fmt$0 = formatting_gen[1][1], _dd_ = fmtty_of_fmt(fmt$0);
          /*<<camlinternalFormat.ml:914:54>>*/ return  /*<<camlinternalFormat.ml:914:54>>*/ caml_call2
-                (CamlinternalFormatBasics[1], _dc_, _db_);
+                (CamlinternalFormatBasics[1], _dd_, _dc_);
        case 19:
         var rest$14 = fmtty$0[1];
          /*<<camlinternalFormat.ml:897:34>>*/ return [13,
@@ -15360,9 +15383,9 @@
           case 9:
             /*<<camlinternalFormat.ml:943:58>>*/ var
             fmtty$6 = ign[2],
-             /*<<camlinternalFormat.ml:943:58>>*/ _dd_ = fmtty_of_fmt(fmtty$5);
+             /*<<camlinternalFormat.ml:943:58>>*/ _de_ = fmtty_of_fmt(fmtty$5);
             /*<<camlinternalFormat.ml:943:58>>*/ return  /*<<camlinternalFormat.ml:943:58>>*/ caml_call2
-                   (CamlinternalFormatBasics[1], fmtty$6, _dd_);
+                   (CamlinternalFormatBasics[1], fmtty$6, _de_);
           case 10:
            var fmtty$0 = fmtty$5; continue;
           default: var fmtty$0 = fmtty$5; continue;
@@ -15417,11 +15440,11 @@
     /*<<camlinternalFormat.ml:996:54>>*/ }
    function type_format(fmt, fmtty){
      /*<<camlinternalFormat.ml:1008:19>>*/  /*<<camlinternalFormat.ml:1008:25>>*/ var
-     _da_ = type_format_gen(fmt, fmtty);
-    if(typeof _da_[2] !== "number")
+     _db_ = type_format_gen(fmt, fmtty);
+    if(typeof _db_[2] !== "number")
       /*<<camlinternalFormat.ml:1010:9>>*/ throw  /*<<camlinternalFormat.ml:1010:9>>*/ caml_maybe_attach_backtrace
             (Type_mismatch, 1);
-    var fmt$0 = _da_[1];
+    var fmt$0 = _db_[1];
      /*<<camlinternalFormat.ml:1009:42>>*/ return fmt$0;
     /*<<camlinternalFormat.ml:1010:28>>*/ }
    function type_ignored_param_one(ign, fmt, fmtty){
@@ -15706,7 +15729,7 @@
          fmt_rest$13 = fmt[3],
          sub_fmtty$1 = fmt[2],
          pad_opt$0 = fmt[1],
-          /*<<camlinternalFormat.ml:1099:42>>*/ _c__ =
+          /*<<camlinternalFormat.ml:1099:42>>*/ _c$_ =
            [0,
              /*<<camlinternalFormat.ml:1099:52>>*/ caml_call1
              (CamlinternalFormatBasics[2], sub_fmtty1)];
@@ -15715,7 +15738,7 @@
            ([0,
               /*<<camlinternalFormat.ml:1099:17>>*/ caml_call1
               (CamlinternalFormatBasics[2], sub_fmtty$1)],
-            _c__))
+            _c$_))
           /*<<camlinternalFormat.ml:1100:6>>*/ throw  /*<<camlinternalFormat.ml:1100:6>>*/ caml_maybe_attach_backtrace
                 (Type_mismatch, 1);
          /*<<camlinternalFormat.ml:1102:6>>*/ var
@@ -15885,12 +15908,12 @@
             /*<<camlinternalFormat.ml:1176:6>>*/ var
             sub_fmtty$3 = ign[2],
             pad_opt$2 = ign[1],
-             /*<<camlinternalFormat.ml:1176:6>>*/ _c$_ =
+             /*<<camlinternalFormat.ml:1176:6>>*/ _da_ =
               type_ignored_format_substituti(sub_fmtty$3, rest, fmtty0),
-            match$43 = _c$_[2],
+            match$43 = _da_[2],
             fmtty$21 = match$43[2],
             fmt$22 = match$43[1],
-            sub_fmtty$4 = _c$_[1];
+            sub_fmtty$4 = _da_[1];
             /*<<camlinternalFormat.ml:1177:4>>*/ return [0,
                    [23, [9, pad_opt$2, sub_fmtty$4], fmt$22],
                    fmtty$21];
@@ -16082,7 +16105,7 @@
          sub_fmtty_rest$17 = sub_fmtty[3],
          sub2_fmtty$2 = sub_fmtty[2],
          sub1_fmtty$0 = sub_fmtty[1],
-          /*<<camlinternalFormat.ml:1261:43>>*/ _c8_ =
+          /*<<camlinternalFormat.ml:1261:43>>*/ _c9_ =
            [0,
              /*<<camlinternalFormat.ml:1261:53>>*/ caml_call1
              (CamlinternalFormatBasics[2], sub1_fmtty)];
@@ -16091,11 +16114,11 @@
            ([0,
               /*<<camlinternalFormat.ml:1261:17>>*/ caml_call1
               (CamlinternalFormatBasics[2], sub1_fmtty$0)],
-            _c8_))
+            _c9_))
           /*<<camlinternalFormat.ml:1262:9>>*/ throw  /*<<camlinternalFormat.ml:1262:9>>*/ caml_maybe_attach_backtrace
                 (Type_mismatch, 1);
          /*<<camlinternalFormat.ml:1263:43>>*/  /*<<camlinternalFormat.ml:1263:43>>*/ var
-         _c9_ =
+         _c__ =
            [0,
              /*<<camlinternalFormat.ml:1263:53>>*/ caml_call1
              (CamlinternalFormatBasics[2], sub2_fmtty$1)];
@@ -16104,7 +16127,7 @@
            ([0,
               /*<<camlinternalFormat.ml:1263:17>>*/ caml_call1
               (CamlinternalFormatBasics[2], sub2_fmtty$2)],
-            _c9_))
+            _c__))
           /*<<camlinternalFormat.ml:1264:9>>*/ throw  /*<<camlinternalFormat.ml:1264:9>>*/ caml_maybe_attach_backtrace
                 (Type_mismatch, 1);
          /*<<camlinternalFormat.ml:1265:21>>*/ var
@@ -16196,11 +16219,11 @@
     /*<<camlinternalFormat.ml:1277:28>>*/ }
    function recast(fmt, fmtty){
      /*<<camlinternalFormat.ml:1312:2>>*/  /*<<camlinternalFormat.ml:1312:29>>*/ var
-     _c7_ = symm(fmtty);
+     _c8_ = symm(fmtty);
      /*<<camlinternalFormat.ml:1312:18>>*/ return type_format
             (fmt,
               /*<<camlinternalFormat.ml:1312:18>>*/ caml_call1
-              (CamlinternalFormatBasics[2], _c7_));
+              (CamlinternalFormatBasics[2], _c8_));
     /*<<camlinternalFormat.ml:1312:42>>*/ }
    function fix_padding(padty, width, str){
      /*<<camlinternalFormat.ml:1319:2>>*/ var
@@ -16210,10 +16233,10 @@
         /*<<camlinternalFormat.ml:1321:4>>*/ caml_call1(Stdlib[18], width);
     if(width$0 <= len)  /*<<camlinternalFormat.ml:1332:23>>*/ return str;
      /*<<camlinternalFormat.ml:1333:14>>*/ var
-     _c6_ = 2 === padty$0 ? 48 : 32,
+     _c7_ = 2 === padty$0 ? 48 : 32,
       /*<<camlinternalFormat.ml:1333:14>>*/ res =
         /*<<camlinternalFormat.ml:1333:14>>*/ caml_call2
-        (Stdlib_Bytes[1], width$0, _c6_);
+        (Stdlib_Bytes[1], width$0, _c7_);
      /*<<camlinternalFormat.ml:1334:4>>*/ switch(padty$0){
       case 0:
         /*<<camlinternalFormat.ml:1335:15>>*/  /*<<camlinternalFormat.ml:1335:15>>*/ caml_call5
@@ -16418,15 +16441,15 @@
       /*<<camlinternalFormat.ml:1447:9>>*/ return s;
      /*<<camlinternalFormat.ml:1428:14>>*/ var
       /*<<camlinternalFormat.ml:1428:14>>*/ n = [0, 0],
-     _c1_ = caml_ml_string_length(s) - 1 | 0,
-      /*<<camlinternalFormat.ml:1428:14>>*/ _c0_ = 0;
-    if(_c1_ >= 0){
-     var i$0 = _c0_;
+     _c2_ = caml_ml_string_length(s) - 1 | 0,
+      /*<<camlinternalFormat.ml:1428:14>>*/ _c1_ = 0;
+    if(_c2_ >= 0){
+     var i$0 = _c1_;
      for(;;){
       if(9 >= caml_string_unsafe_get(s, i$0) - 48 >>> 0) n[1]++;
        /*<<camlinternalFormat.ml:1429:6>>*/  /*<<camlinternalFormat.ml:1429:6>>*/ var
-       _c5_ = i$0 + 1 | 0;
-      if(_c1_ !== i$0){var i$0 = _c5_; continue;}
+       _c6_ = i$0 + 1 | 0;
+      if(_c2_ !== i$0){var i$0 = _c6_; continue;}
       break;
      }
     }
@@ -16440,15 +16463,15 @@
       /*<<camlinternalFormat.ml:1438:16>>*/  /*<<camlinternalFormat.ml:1438:16>>*/ caml_bytes_set
       (buf, pos[1], c);
      pos[1]++;
-     return 0;
+     return _$_;
      /*<<camlinternalFormat.ml:1438:46>>*/ }
      /*<<camlinternalFormat.ml:1439:15>>*/ var
       /*<<camlinternalFormat.ml:1439:15>>*/ left =
        [0, ((digits - 1 | 0) % 3 | 0) + 1 | 0],
-     _c3_ = caml_ml_string_length(s) - 1 | 0,
-      /*<<camlinternalFormat.ml:1439:15>>*/ _c2_ = 0;
-    if(_c3_ >= 0){
-     var i = _c2_;
+     _c4_ = caml_ml_string_length(s) - 1 | 0,
+      /*<<camlinternalFormat.ml:1439:15>>*/ _c3_ = 0;
+    if(_c4_ >= 0){
+     var i = _c3_;
      for(;;){
       var c = caml_string_unsafe_get(s, i);
       if(9 < c - 48 >>> 0)
@@ -16462,8 +16485,8 @@
         /*<<camlinternalFormat.ml:1443:61>>*/ put(c);
       }
        /*<<camlinternalFormat.ml:1440:4>>*/  /*<<camlinternalFormat.ml:1440:4>>*/ var
-       _c4_ = i + 1 | 0;
-      if(_c3_ !== i){var i = _c4_; continue;}
+       _c5_ = i + 1 | 0;
+      if(_c4_ !== i){var i = _c5_; continue;}
       break;
      }
     }
@@ -16473,139 +16496,139 @@
    function convert_int(iconv, n){
      /*<<camlinternalFormat.ml:1451:2>>*/ switch(iconv){
       case 1:
-       var _cZ_ = cst_d$0; break;
+       var _c0_ = cst_d$0; break;
       case 2:
-       var _cZ_ = cst_d$1; break;
+       var _c0_ = cst_d$1; break;
       case 4:
-       var _cZ_ = cst_i$1; break;
+       var _c0_ = cst_i$1; break;
       case 5:
-       var _cZ_ = cst_i$2; break;
+       var _c0_ = cst_i$2; break;
       case 6:
-       var _cZ_ = cst_x; break;
+       var _c0_ = cst_x; break;
       case 7:
-       var _cZ_ = cst_x$0; break;
+       var _c0_ = cst_x$0; break;
       case 8:
-       var _cZ_ = cst_X; break;
+       var _c0_ = cst_X; break;
       case 9:
-       var _cZ_ = cst_X$0; break;
+       var _c0_ = cst_X$0; break;
       case 10:
-       var _cZ_ = cst_o; break;
+       var _c0_ = cst_o; break;
       case 11:
-       var _cZ_ = cst_o$0; break;
+       var _c0_ = cst_o$0; break;
       case 0:
       case 13:
-       var _cZ_ = cst_d; break;
+       var _c0_ = cst_d; break;
       case 3:
       case 14:
-       var _cZ_ = cst_i$0; break;
-      default: var _cZ_ = cst_u;
+       var _c0_ = cst_i$0; break;
+      default: var _c0_ = cst_u;
     }
      /*<<camlinternalFormat.ml:1451:26>>*/ return transform_int_alt
             (iconv,
-              /*<<camlinternalFormat.ml:1451:26>>*/ caml_format_int(_cZ_, n));
+              /*<<camlinternalFormat.ml:1451:26>>*/ caml_format_int(_c0_, n));
     /*<<camlinternalFormat.ml:1451:64>>*/ }
    function convert_int32(iconv, n){
      /*<<camlinternalFormat.ml:1453:2>>*/ switch(iconv){
       case 1:
-       var _cY_ = cst_ld$0; break;
+       var _cZ_ = cst_ld$0; break;
       case 2:
-       var _cY_ = cst_ld$1; break;
+       var _cZ_ = cst_ld$1; break;
       case 4:
-       var _cY_ = cst_li$1; break;
+       var _cZ_ = cst_li$1; break;
       case 5:
-       var _cY_ = cst_li$2; break;
+       var _cZ_ = cst_li$2; break;
       case 6:
-       var _cY_ = cst_lx; break;
+       var _cZ_ = cst_lx; break;
       case 7:
-       var _cY_ = cst_lx$0; break;
+       var _cZ_ = cst_lx$0; break;
       case 8:
-       var _cY_ = cst_lX; break;
+       var _cZ_ = cst_lX; break;
       case 9:
-       var _cY_ = cst_lX$0; break;
+       var _cZ_ = cst_lX$0; break;
       case 10:
-       var _cY_ = cst_lo; break;
+       var _cZ_ = cst_lo; break;
       case 11:
-       var _cY_ = cst_lo$0; break;
+       var _cZ_ = cst_lo$0; break;
       case 0:
       case 13:
-       var _cY_ = cst_ld; break;
+       var _cZ_ = cst_ld; break;
       case 3:
       case 14:
-       var _cY_ = cst_li$0; break;
-      default: var _cY_ = cst_lu;
+       var _cZ_ = cst_li$0; break;
+      default: var _cZ_ = cst_lu;
     }
      /*<<camlinternalFormat.ml:1453:26>>*/ return transform_int_alt
             (iconv,
-              /*<<camlinternalFormat.ml:1453:26>>*/ caml_format_int(_cY_, n));
+              /*<<camlinternalFormat.ml:1453:26>>*/ caml_format_int(_cZ_, n));
     /*<<camlinternalFormat.ml:1453:67>>*/ }
    function convert_nativeint(iconv, n){
      /*<<camlinternalFormat.ml:1455:2>>*/ switch(iconv){
       case 1:
-       var _cX_ = cst_nd$0; break;
+       var _cY_ = cst_nd$0; break;
       case 2:
-       var _cX_ = cst_nd$1; break;
+       var _cY_ = cst_nd$1; break;
       case 4:
-       var _cX_ = cst_ni$1; break;
+       var _cY_ = cst_ni$1; break;
       case 5:
-       var _cX_ = cst_ni$2; break;
+       var _cY_ = cst_ni$2; break;
       case 6:
-       var _cX_ = cst_nx; break;
+       var _cY_ = cst_nx; break;
       case 7:
-       var _cX_ = cst_nx$0; break;
+       var _cY_ = cst_nx$0; break;
       case 8:
-       var _cX_ = cst_nX; break;
+       var _cY_ = cst_nX; break;
       case 9:
-       var _cX_ = cst_nX$0; break;
+       var _cY_ = cst_nX$0; break;
       case 10:
-       var _cX_ = cst_no; break;
+       var _cY_ = cst_no; break;
       case 11:
-       var _cX_ = cst_no$0; break;
+       var _cY_ = cst_no$0; break;
       case 0:
       case 13:
-       var _cX_ = cst_nd; break;
+       var _cY_ = cst_nd; break;
       case 3:
       case 14:
-       var _cX_ = cst_ni$0; break;
-      default: var _cX_ = cst_nu;
+       var _cY_ = cst_ni$0; break;
+      default: var _cY_ = cst_nu;
     }
      /*<<camlinternalFormat.ml:1455:26>>*/ return transform_int_alt
             (iconv,
-              /*<<camlinternalFormat.ml:1455:26>>*/ caml_format_int(_cX_, n));
+              /*<<camlinternalFormat.ml:1455:26>>*/ caml_format_int(_cY_, n));
     /*<<camlinternalFormat.ml:1455:71>>*/ }
    function convert_int64(iconv, n){
      /*<<camlinternalFormat.ml:1457:2>>*/ switch(iconv){
       case 1:
-       var _cW_ = cst_Ld$0; break;
+       var _cX_ = cst_Ld$0; break;
       case 2:
-       var _cW_ = cst_Ld$1; break;
+       var _cX_ = cst_Ld$1; break;
       case 4:
-       var _cW_ = cst_Li$1; break;
+       var _cX_ = cst_Li$1; break;
       case 5:
-       var _cW_ = cst_Li$2; break;
+       var _cX_ = cst_Li$2; break;
       case 6:
-       var _cW_ = cst_Lx; break;
+       var _cX_ = cst_Lx; break;
       case 7:
-       var _cW_ = cst_Lx$0; break;
+       var _cX_ = cst_Lx$0; break;
       case 8:
-       var _cW_ = cst_LX; break;
+       var _cX_ = cst_LX; break;
       case 9:
-       var _cW_ = cst_LX$0; break;
+       var _cX_ = cst_LX$0; break;
       case 10:
-       var _cW_ = cst_Lo; break;
+       var _cX_ = cst_Lo; break;
       case 11:
-       var _cW_ = cst_Lo$0; break;
+       var _cX_ = cst_Lo$0; break;
       case 0:
       case 13:
-       var _cW_ = cst_Ld; break;
+       var _cX_ = cst_Ld; break;
       case 3:
       case 14:
-       var _cW_ = cst_Li$0; break;
-      default: var _cW_ = cst_Lu;
+       var _cX_ = cst_Li$0; break;
+      default: var _cX_ = cst_Lu;
     }
      /*<<camlinternalFormat.ml:1457:26>>*/ return transform_int_alt
             (iconv,
               /*<<camlinternalFormat.ml:1457:26>>*/ runtime.caml_int64_format
-              (_cW_, n));
+              (_cX_, n));
     /*<<camlinternalFormat.ml:1457:67>>*/ }
    function convert_float(fconv, prec, x){
     function hex(param){
@@ -16637,41 +16660,41 @@
         i = 0;
         /*<<camlinternalFormat.ml:1472:6>>*/ for(;;){
         if(i === len)
-         var _cT_ = 0;
+         var _cU_ = 0;
         else{
           /*<<camlinternalFormat.ml:1473:14>>*/ var
-           /*<<camlinternalFormat.ml:1473:14>>*/ _cS_ =
+           /*<<camlinternalFormat.ml:1473:14>>*/ _cT_ =
              /*<<camlinternalFormat.ml:1473:14>>*/ caml_string_get(str, i)
             - 46
             | 0,
           switch$0 = 0;
-         if(23 < _cS_ >>> 0){
-          if(55 === _cS_) switch$0 = 1;
+         if(23 < _cT_ >>> 0){
+          if(55 === _cT_) switch$0 = 1;
          }
-         else if(21 < _cS_ - 1 >>> 0) switch$0 = 1;
+         else if(21 < _cT_ - 1 >>> 0) switch$0 = 1;
          if(! switch$0){
            /*<<camlinternalFormat.ml:1475:15>>*/ var
             /*<<camlinternalFormat.ml:1475:15>>*/ i$0 = i + 1 | 0,
            i = i$0;
           continue;
          }
-         var _cT_ = 1;
+         var _cU_ = 1;
         }
          /*<<camlinternalFormat.ml:1476:7>>*/  /*<<camlinternalFormat.ml:1476:7>>*/ var
-         _cU_ =
-           _cT_
+         _cV_ =
+           _cU_
             ? str
             :  /*<<camlinternalFormat.ml:1476:32>>*/ caml_call2
               (Stdlib[28], str, cst$17);
-         /*<<camlinternalFormat.ml:1487:21>>*/ return caml_special_val(_cU_);
+         /*<<camlinternalFormat.ml:1487:21>>*/ return caml_special_val(_cV_);
        }
       case 6:
         /*<<camlinternalFormat.ml:1482:15>>*/ return hex(0);
       case 7:
         /*<<camlinternalFormat.ml:1483:38>>*/  /*<<camlinternalFormat.ml:1483:38>>*/ var
-        _cV_ = hex(0);
+        _cW_ = hex(0);
         /*<<camlinternalFormat.ml:1483:38>>*/ return  /*<<camlinternalFormat.ml:1483:38>>*/ caml_call1
-               (Stdlib_String[25], _cV_);
+               (Stdlib_String[25], _cW_);
       case 8:
         /*<<camlinternalFormat.ml:1484:33>>*/ return caml_special_val(hex(0));
       default:
@@ -17056,12 +17079,12 @@
          /*<<camlinternalFormat.ml:1573:4>>*/ return function(param){
           /*<<camlinternalFormat.ml:1573:4>>*/ var
           fmt = param[1],
-           /*<<camlinternalFormat.ml:1574:18>>*/ _cR_ = recast(fmt, fmtty);
+           /*<<camlinternalFormat.ml:1574:18>>*/ _cS_ = recast(fmt, fmtty);
           /*<<camlinternalFormat.ml:1574:6>>*/ return make_printf
                  (k$0,
                   acc$0,
                    /*<<camlinternalFormat.ml:1574:6>>*/ caml_call2
-                   (CamlinternalFormatBasics[3], _cR_, rest$13)); /*<<camlinternalFormat.ml:1574:42>>*/ };
+                   (CamlinternalFormatBasics[3], _cS_, rest$13)); /*<<camlinternalFormat.ml:1574:42>>*/ };
        case 15:
         var rest$14 = fmt$0[1];
          /*<<camlinternalFormat.ml:1544:4>>*/ return function(f, x){
@@ -17088,11 +17111,11 @@
          fmt$0 = rest$16;
         continue;
        case 18:
-        var _cP_ = fmt$0[1];
-        if(0 === _cP_[0]){
+        var _cQ_ = fmt$0[1];
+        if(0 === _cQ_[0]){
          var
           rest$17 = fmt$0[2],
-          fmt$1 = _cP_[1][1],
+          fmt$1 = _cQ_[1][1],
           k$3 =
             function(acc, k, rest){
              function k$0(kacc){
@@ -17109,7 +17132,7 @@
         }
         var
          rest$18 = fmt$0[2],
-         fmt$2 = _cP_[1][1],
+         fmt$2 = _cQ_[1][1],
          k$4 =
            function(acc, k, rest){
             function k$0(kacc){
@@ -17165,14 +17188,14 @@
          rest$23 = fmt$0[3],
          f = fmt$0[2],
          arity = fmt$0[1],
-          /*<<camlinternalFormat.ml:1548:33>>*/ _cQ_ =
+          /*<<camlinternalFormat.ml:1548:33>>*/ _cR_ =
             /*<<camlinternalFormat.ml:1548:33>>*/ caml_call1(f, 0);
          /*<<camlinternalFormat.ml:1548:33>>*/ if(counter >= 50)
           /*<<camlinternalFormat.ml:1548:33>>*/ return  /*<<camlinternalFormat.ml:1548:33>>*/ caml_trampoline_return
-                 (make_custom$0, [0, k$0, acc$0, rest$23, arity, _cQ_]);
+                 (make_custom$0, [0, k$0, acc$0, rest$23, arity, _cR_]);
         var counter$0 = counter + 1 | 0;
          /*<<camlinternalFormat.ml:1548:33>>*/ return make_custom$0
-                (counter$0, k$0, acc$0, rest$23, arity, _cQ_);
+                (counter$0, k$0, acc$0, rest$23, arity, _cR_);
      }
     }
     /*<<camlinternalFormat.ml:1605:9>>*/ }
@@ -17355,7 +17378,7 @@
                   fmt); /*<<camlinternalFormat.ml:1655:61>>*/ };
        case 10:
         var rest$9 = fmtty[1];
-         /*<<camlinternalFormat.ml:1646:31>>*/ return function(param, _cO_){
+         /*<<camlinternalFormat.ml:1646:31>>*/ return function(param, _cP_){
           /*<<camlinternalFormat.ml:1646:42>>*/ return make_from_fmtty
                  (k, acc, rest$9, fmt); /*<<camlinternalFormat.ml:1646:72>>*/ };
        case 11:
@@ -17384,13 +17407,13 @@
     /*<<camlinternalFormat.ml:1655:61>>*/ }
    function make_invalid_arg(counter, k, acc, fmt){
      /*<<camlinternalFormat.ml:1663:2>>*/  /*<<camlinternalFormat.ml:1663:16>>*/ var
-     _cN_ = [8, acc, cst_Printf_bad_conversion$0];
+     _cO_ = [8, acc, cst_Printf_bad_conversion$0];
      /*<<camlinternalFormat.ml:1663:2>>*/ if(counter >= 50)
       /*<<camlinternalFormat.ml:1663:2>>*/ return  /*<<camlinternalFormat.ml:1663:2>>*/ caml_trampoline_return
-             (make_printf$0, [0, k, _cN_, fmt]);
+             (make_printf$0, [0, k, _cO_, fmt]);
     var counter$0 = counter + 1 | 0;
      /*<<camlinternalFormat.ml:1663:2>>*/ return make_printf$0
-            (counter$0, k, _cN_, fmt);
+            (counter$0, k, _cO_, fmt);
     /*<<camlinternalFormat.ml:1663:72>>*/ }
    function make_custom$0(counter, k, acc, rest, arity, f){
      /*<<camlinternalFormat.ml:1778:28>>*/ if(arity){
@@ -17404,13 +17427,13 @@
                 /*<<camlinternalFormat.ml:1782:35>>*/ caml_call1(f, x)); /*<<camlinternalFormat.ml:1782:40>>*/ };
     }
      /*<<camlinternalFormat.ml:1779:33>>*/  /*<<camlinternalFormat.ml:1779:33>>*/ var
-     _cM_ = [4, acc, f];
+     _cN_ = [4, acc, f];
      /*<<camlinternalFormat.ml:1779:19>>*/ if(counter >= 50)
       /*<<camlinternalFormat.ml:1779:19>>*/ return  /*<<camlinternalFormat.ml:1779:19>>*/ caml_trampoline_return
-             (make_printf$0, [0, k, _cM_, rest]);
+             (make_printf$0, [0, k, _cN_, rest]);
     var counter$0 = counter + 1 | 0;
      /*<<camlinternalFormat.ml:1779:19>>*/ return make_printf$0
-            (counter$0, k, _cM_, rest);
+            (counter$0, k, _cN_, rest);
     /*<<camlinternalFormat.ml:1782:40>>*/ }
    function make_printf(k, acc, fmt){
      /*<<?>>*/ return caml_trampoline(make_printf$0(0, k, acc, fmt));
@@ -17431,68 +17454,68 @@
      /*<<camlinternalFormat.ml:1863:26>>*/ if(typeof pad === "number"){
      if(typeof prec !== "number"){
        /*<<camlinternalFormat.ml:1867:14>>*/  /*<<camlinternalFormat.ml:1867:14>>*/ var
-       _cl_ = make_iprintf(k, o, fmt);
-       /*<<camlinternalFormat.ml:1867:14>>*/ return function(_cL_){
-        /*<<?>>*/ return _cl_;};
+       _cm_ = make_iprintf(k, o, fmt);
+       /*<<camlinternalFormat.ml:1867:14>>*/ return function(_cM_){
+        /*<<?>>*/ return _cm_;};
      }
      if(prec){
        /*<<camlinternalFormat.ml:1869:21>>*/ var
-        /*<<camlinternalFormat.ml:1869:21>>*/ _ci_ = make_iprintf(k, o, fmt),
-        /*<<camlinternalFormat.ml:1869:14>>*/ _cj_ =
-         function(_cK_){ /*<<?>>*/ return _ci_;};
-       /*<<camlinternalFormat.ml:1869:14>>*/ return function(_cJ_){
-        /*<<?>>*/ return _cj_;};
+        /*<<camlinternalFormat.ml:1869:21>>*/ _cj_ = make_iprintf(k, o, fmt),
+        /*<<camlinternalFormat.ml:1869:14>>*/ _ck_ =
+         function(_cL_){ /*<<?>>*/ return _cj_;};
+       /*<<camlinternalFormat.ml:1869:14>>*/ return function(_cK_){
+        /*<<?>>*/ return _ck_;};
      }
       /*<<camlinternalFormat.ml:1865:14>>*/  /*<<camlinternalFormat.ml:1865:14>>*/ var
-      _ck_ = make_iprintf(k, o, fmt);
-      /*<<camlinternalFormat.ml:1865:14>>*/ return function(_cI_){
-       /*<<?>>*/ return _ck_;};
+      _cl_ = make_iprintf(k, o, fmt);
+      /*<<camlinternalFormat.ml:1865:14>>*/ return function(_cJ_){
+       /*<<?>>*/ return _cl_;};
     }
     if(0 === pad[0]){
      if(typeof prec !== "number"){
        /*<<camlinternalFormat.ml:1873:14>>*/  /*<<camlinternalFormat.ml:1873:14>>*/ var
-       _cp_ = make_iprintf(k, o, fmt);
-       /*<<camlinternalFormat.ml:1873:14>>*/ return function(_cH_){
-        /*<<?>>*/ return _cp_;};
+       _cq_ = make_iprintf(k, o, fmt);
+       /*<<camlinternalFormat.ml:1873:14>>*/ return function(_cI_){
+        /*<<?>>*/ return _cq_;};
      }
      if(prec){
        /*<<camlinternalFormat.ml:1875:21>>*/ var
-        /*<<camlinternalFormat.ml:1875:21>>*/ _cm_ = make_iprintf(k, o, fmt),
-        /*<<camlinternalFormat.ml:1875:14>>*/ _cn_ =
-         function(_cG_){ /*<<?>>*/ return _cm_;};
-       /*<<camlinternalFormat.ml:1875:14>>*/ return function(_cF_){
-        /*<<?>>*/ return _cn_;};
+        /*<<camlinternalFormat.ml:1875:21>>*/ _cn_ = make_iprintf(k, o, fmt),
+        /*<<camlinternalFormat.ml:1875:14>>*/ _co_ =
+         function(_cH_){ /*<<?>>*/ return _cn_;};
+       /*<<camlinternalFormat.ml:1875:14>>*/ return function(_cG_){
+        /*<<?>>*/ return _co_;};
      }
       /*<<camlinternalFormat.ml:1871:14>>*/  /*<<camlinternalFormat.ml:1871:14>>*/ var
-      _co_ = make_iprintf(k, o, fmt);
-      /*<<camlinternalFormat.ml:1871:14>>*/ return function(_cE_){
-       /*<<?>>*/ return _co_;};
+      _cp_ = make_iprintf(k, o, fmt);
+      /*<<camlinternalFormat.ml:1871:14>>*/ return function(_cF_){
+       /*<<?>>*/ return _cp_;};
     }
     if(typeof prec !== "number"){
       /*<<camlinternalFormat.ml:1879:21>>*/ var
-       /*<<camlinternalFormat.ml:1879:21>>*/ _cv_ = make_iprintf(k, o, fmt),
-       /*<<camlinternalFormat.ml:1879:14>>*/ _cw_ =
-        function(_cD_){ /*<<?>>*/ return _cv_;};
-      /*<<camlinternalFormat.ml:1879:14>>*/ return function(_cC_){
-       /*<<?>>*/ return _cw_;};
+       /*<<camlinternalFormat.ml:1879:21>>*/ _cw_ = make_iprintf(k, o, fmt),
+       /*<<camlinternalFormat.ml:1879:14>>*/ _cx_ =
+        function(_cE_){ /*<<?>>*/ return _cw_;};
+      /*<<camlinternalFormat.ml:1879:14>>*/ return function(_cD_){
+       /*<<?>>*/ return _cx_;};
     }
     if(prec){
       /*<<camlinternalFormat.ml:1881:28>>*/ var
-       /*<<camlinternalFormat.ml:1881:28>>*/ _cq_ = make_iprintf(k, o, fmt),
-       /*<<camlinternalFormat.ml:1881:21>>*/ _cr_ =
-        function(_cB_){ /*<<?>>*/ return _cq_;},
-       /*<<camlinternalFormat.ml:1881:14>>*/ _cs_ =
-        function(_cA_){ /*<<?>>*/ return _cr_;};
-      /*<<camlinternalFormat.ml:1881:14>>*/ return function(_cz_){
-       /*<<?>>*/ return _cs_;};
+       /*<<camlinternalFormat.ml:1881:28>>*/ _cr_ = make_iprintf(k, o, fmt),
+       /*<<camlinternalFormat.ml:1881:21>>*/ _cs_ =
+        function(_cC_){ /*<<?>>*/ return _cr_;},
+       /*<<camlinternalFormat.ml:1881:14>>*/ _ct_ =
+        function(_cB_){ /*<<?>>*/ return _cs_;};
+      /*<<camlinternalFormat.ml:1881:14>>*/ return function(_cA_){
+       /*<<?>>*/ return _ct_;};
     }
      /*<<camlinternalFormat.ml:1877:21>>*/  /*<<camlinternalFormat.ml:1877:21>>*/ var
-     _ct_ = make_iprintf(k, o, fmt);
-     /*<<camlinternalFormat.ml:1877:14>>*/ function _cu_(_cy_){
-      /*<<?>>*/ return _ct_;
+     _cu_ = make_iprintf(k, o, fmt);
+     /*<<camlinternalFormat.ml:1877:14>>*/ function _cv_(_cz_){
+      /*<<?>>*/ return _cu_;
     }
-     /*<<camlinternalFormat.ml:1877:14>>*/ return function(_cx_){
-      /*<<?>>*/ return _cu_;};
+     /*<<camlinternalFormat.ml:1877:14>>*/ return function(_cy_){
+      /*<<?>>*/ return _cv_;};
     /*<<camlinternalFormat.ml:1881:52>>*/ }
    function make_iprintf$0(counter, k, o, fmt){
      /*<<camlinternalFormat.ml:1788:17>>*/ var k$0 = k, fmt$0 = fmt;
@@ -17504,69 +17527,69 @@
        case 0:
          /*<<camlinternalFormat.ml:1790:14>>*/ var
          rest = fmt$0[1],
-          /*<<camlinternalFormat.ml:1790:14>>*/ _by_ =
+          /*<<camlinternalFormat.ml:1790:14>>*/ _bz_ =
            make_iprintf(k$0, o, rest);
-         /*<<camlinternalFormat.ml:1790:14>>*/ return function(_ch_){
-          /*<<?>>*/ return _by_;};
+         /*<<camlinternalFormat.ml:1790:14>>*/ return function(_ci_){
+          /*<<?>>*/ return _bz_;};
        case 1:
          /*<<camlinternalFormat.ml:1792:14>>*/ var
          rest$0 = fmt$0[1],
-          /*<<camlinternalFormat.ml:1792:14>>*/ _bz_ =
+          /*<<camlinternalFormat.ml:1792:14>>*/ _bA_ =
            make_iprintf(k$0, o, rest$0);
-         /*<<camlinternalFormat.ml:1792:14>>*/ return function(_cg_){
-          /*<<?>>*/ return _bz_;};
+         /*<<camlinternalFormat.ml:1792:14>>*/ return function(_ch_){
+          /*<<?>>*/ return _bA_;};
        case 2:
-        var _bA_ = fmt$0[1];
-        if(typeof _bA_ === "number"){
+        var _bB_ = fmt$0[1];
+        if(typeof _bB_ === "number"){
           /*<<camlinternalFormat.ml:1794:14>>*/ var
           rest$1 = fmt$0[2],
-           /*<<camlinternalFormat.ml:1794:14>>*/ _bB_ =
+           /*<<camlinternalFormat.ml:1794:14>>*/ _bC_ =
             make_iprintf(k$0, o, rest$1);
-          /*<<camlinternalFormat.ml:1794:14>>*/ return function(_cf_){
-           /*<<?>>*/ return _bB_;};
+          /*<<camlinternalFormat.ml:1794:14>>*/ return function(_cg_){
+           /*<<?>>*/ return _bC_;};
         }
-        if(0 === _bA_[0]){
+        if(0 === _bB_[0]){
           /*<<camlinternalFormat.ml:1796:14>>*/ var
           rest$2 = fmt$0[2],
-           /*<<camlinternalFormat.ml:1796:14>>*/ _bC_ =
+           /*<<camlinternalFormat.ml:1796:14>>*/ _bD_ =
             make_iprintf(k$0, o, rest$2);
-          /*<<camlinternalFormat.ml:1796:14>>*/ return function(_ce_){
-           /*<<?>>*/ return _bC_;};
+          /*<<camlinternalFormat.ml:1796:14>>*/ return function(_cf_){
+           /*<<?>>*/ return _bD_;};
         }
          /*<<camlinternalFormat.ml:1798:21>>*/ var
          rest$3 = fmt$0[2],
-          /*<<camlinternalFormat.ml:1798:21>>*/ _bD_ =
+          /*<<camlinternalFormat.ml:1798:21>>*/ _bE_ =
            make_iprintf(k$0, o, rest$3),
-          /*<<camlinternalFormat.ml:1798:14>>*/ _bE_ =
-           function(_cd_){ /*<<?>>*/ return _bD_;};
-         /*<<camlinternalFormat.ml:1798:14>>*/ return function(_cc_){
-          /*<<?>>*/ return _bE_;};
+          /*<<camlinternalFormat.ml:1798:14>>*/ _bF_ =
+           function(_ce_){ /*<<?>>*/ return _bE_;};
+         /*<<camlinternalFormat.ml:1798:14>>*/ return function(_cd_){
+          /*<<?>>*/ return _bF_;};
        case 3:
-        var _bF_ = fmt$0[1];
-        if(typeof _bF_ === "number"){
+        var _bG_ = fmt$0[1];
+        if(typeof _bG_ === "number"){
           /*<<camlinternalFormat.ml:1800:14>>*/ var
           rest$4 = fmt$0[2],
-           /*<<camlinternalFormat.ml:1800:14>>*/ _bG_ =
+           /*<<camlinternalFormat.ml:1800:14>>*/ _bH_ =
             make_iprintf(k$0, o, rest$4);
-          /*<<camlinternalFormat.ml:1800:14>>*/ return function(_cb_){
-           /*<<?>>*/ return _bG_;};
+          /*<<camlinternalFormat.ml:1800:14>>*/ return function(_cc_){
+           /*<<?>>*/ return _bH_;};
         }
-        if(0 === _bF_[0]){
+        if(0 === _bG_[0]){
           /*<<camlinternalFormat.ml:1802:14>>*/ var
           rest$5 = fmt$0[2],
-           /*<<camlinternalFormat.ml:1802:14>>*/ _bH_ =
+           /*<<camlinternalFormat.ml:1802:14>>*/ _bI_ =
             make_iprintf(k$0, o, rest$5);
-          /*<<camlinternalFormat.ml:1802:14>>*/ return function(_ca_){
-           /*<<?>>*/ return _bH_;};
+          /*<<camlinternalFormat.ml:1802:14>>*/ return function(_cb_){
+           /*<<?>>*/ return _bI_;};
         }
          /*<<camlinternalFormat.ml:1804:21>>*/ var
          rest$6 = fmt$0[2],
-          /*<<camlinternalFormat.ml:1804:21>>*/ _bI_ =
+          /*<<camlinternalFormat.ml:1804:21>>*/ _bJ_ =
            make_iprintf(k$0, o, rest$6),
-          /*<<camlinternalFormat.ml:1804:14>>*/ _bJ_ =
-           function(_b$_){ /*<<?>>*/ return _bI_;};
-         /*<<camlinternalFormat.ml:1804:14>>*/ return function(_b__){
-          /*<<?>>*/ return _bJ_;};
+          /*<<camlinternalFormat.ml:1804:14>>*/ _bK_ =
+           function(_ca_){ /*<<?>>*/ return _bJ_;};
+         /*<<camlinternalFormat.ml:1804:14>>*/ return function(_b$_){
+          /*<<?>>*/ return _bK_;};
        case 4:
         var rest$7 = fmt$0[4], prec = fmt$0[3], pad = fmt$0[2];
          /*<<camlinternalFormat.ml:1806:8>>*/ return fn_of_padding_precision
@@ -17588,31 +17611,31 @@
          /*<<camlinternalFormat.ml:1814:8>>*/ return fn_of_padding_precision
                 (k$0, o, rest$11, pad$3, prec$3);
        case 9:
-        var _bK_ = fmt$0[1];
-        if(typeof _bK_ === "number"){
+        var _bL_ = fmt$0[1];
+        if(typeof _bL_ === "number"){
           /*<<camlinternalFormat.ml:1816:14>>*/ var
           rest$12 = fmt$0[2],
-           /*<<camlinternalFormat.ml:1816:14>>*/ _bL_ =
+           /*<<camlinternalFormat.ml:1816:14>>*/ _bM_ =
             make_iprintf(k$0, o, rest$12);
-          /*<<camlinternalFormat.ml:1816:14>>*/ return function(_b9_){
-           /*<<?>>*/ return _bL_;};
+          /*<<camlinternalFormat.ml:1816:14>>*/ return function(_b__){
+           /*<<?>>*/ return _bM_;};
         }
-        if(0 === _bK_[0]){
+        if(0 === _bL_[0]){
           /*<<camlinternalFormat.ml:1818:14>>*/ var
           rest$13 = fmt$0[2],
-           /*<<camlinternalFormat.ml:1818:14>>*/ _bM_ =
+           /*<<camlinternalFormat.ml:1818:14>>*/ _bN_ =
             make_iprintf(k$0, o, rest$13);
-          /*<<camlinternalFormat.ml:1818:14>>*/ return function(_b8_){
-           /*<<?>>*/ return _bM_;};
+          /*<<camlinternalFormat.ml:1818:14>>*/ return function(_b9_){
+           /*<<?>>*/ return _bN_;};
         }
          /*<<camlinternalFormat.ml:1820:21>>*/ var
          rest$14 = fmt$0[2],
-          /*<<camlinternalFormat.ml:1820:21>>*/ _bN_ =
+          /*<<camlinternalFormat.ml:1820:21>>*/ _bO_ =
            make_iprintf(k$0, o, rest$14),
-          /*<<camlinternalFormat.ml:1820:14>>*/ _bO_ =
-           function(_b7_){ /*<<?>>*/ return _bN_;};
-         /*<<camlinternalFormat.ml:1820:14>>*/ return function(_b6_){
-          /*<<?>>*/ return _bO_;};
+          /*<<camlinternalFormat.ml:1820:14>>*/ _bP_ =
+           function(_b8_){ /*<<?>>*/ return _bO_;};
+         /*<<camlinternalFormat.ml:1820:14>>*/ return function(_b7_){
+          /*<<?>>*/ return _bP_;};
        case 10:
         var rest$15 = fmt$0[1], fmt$0 = rest$15; continue;
        case 11:
@@ -17622,45 +17645,45 @@
        case 13:
          /*<<camlinternalFormat.ml:1838:14>>*/ var
          rest$18 = fmt$0[3],
-          /*<<camlinternalFormat.ml:1838:14>>*/ _bP_ =
+          /*<<camlinternalFormat.ml:1838:14>>*/ _bQ_ =
            make_iprintf(k$0, o, rest$18);
-         /*<<camlinternalFormat.ml:1838:14>>*/ return function(_b5_){
-          /*<<?>>*/ return _bP_;};
+         /*<<camlinternalFormat.ml:1838:14>>*/ return function(_b6_){
+          /*<<?>>*/ return _bQ_;};
        case 14:
         var rest$19 = fmt$0[3], fmtty = fmt$0[2];
          /*<<camlinternalFormat.ml:1840:8>>*/ return function(param){
           /*<<camlinternalFormat.ml:1840:8>>*/ var
           fmt = param[1],
-           /*<<camlinternalFormat.ml:1842:24>>*/ _b4_ = recast(fmt, fmtty);
+           /*<<camlinternalFormat.ml:1842:24>>*/ _b5_ = recast(fmt, fmtty);
           /*<<camlinternalFormat.ml:1842:12>>*/ return make_iprintf
                  (k$0,
                   o,
                    /*<<camlinternalFormat.ml:1842:12>>*/ caml_call2
-                   (CamlinternalFormatBasics[3], _b4_, rest$19)); /*<<camlinternalFormat.ml:1842:48>>*/ };
+                   (CamlinternalFormatBasics[3], _b5_, rest$19)); /*<<camlinternalFormat.ml:1842:48>>*/ };
        case 15:
          /*<<camlinternalFormat.ml:1822:21>>*/ var
          rest$20 = fmt$0[1],
-          /*<<camlinternalFormat.ml:1822:21>>*/ _bQ_ =
+          /*<<camlinternalFormat.ml:1822:21>>*/ _bR_ =
            make_iprintf(k$0, o, rest$20),
-          /*<<camlinternalFormat.ml:1822:14>>*/ _bR_ =
-           function(_b3_){ /*<<?>>*/ return _bQ_;};
-         /*<<camlinternalFormat.ml:1822:14>>*/ return function(_b2_){
-          /*<<?>>*/ return _bR_;};
+          /*<<camlinternalFormat.ml:1822:14>>*/ _bS_ =
+           function(_b4_){ /*<<?>>*/ return _bR_;};
+         /*<<camlinternalFormat.ml:1822:14>>*/ return function(_b3_){
+          /*<<?>>*/ return _bS_;};
        case 16:
          /*<<camlinternalFormat.ml:1824:14>>*/ var
          rest$21 = fmt$0[1],
-          /*<<camlinternalFormat.ml:1824:14>>*/ _bS_ =
+          /*<<camlinternalFormat.ml:1824:14>>*/ _bT_ =
            make_iprintf(k$0, o, rest$21);
-         /*<<camlinternalFormat.ml:1824:14>>*/ return function(_b1_){
-          /*<<?>>*/ return _bS_;};
+         /*<<camlinternalFormat.ml:1824:14>>*/ return function(_b2_){
+          /*<<?>>*/ return _bT_;};
        case 17:
         var rest$22 = fmt$0[2], fmt$0 = rest$22; continue;
        case 18:
-        var _bT_ = fmt$0[1];
-        if(0 === _bT_[0]){
+        var _bU_ = fmt$0[1];
+        if(0 === _bU_[0]){
          var
           rest$23 = fmt$0[2],
-          fmt$1 = _bT_[1][1],
+          fmt$1 = _bU_[1][1],
           k$3 =
             function(k, rest){
              function k$0(koc){
@@ -17676,7 +17699,7 @@
         }
         var
          rest$24 = fmt$0[2],
-         fmt$2 = _bT_[1][1],
+         fmt$2 = _bU_[1][1],
          k$4 =
            function(k, rest){
             function k$0(koc){
@@ -17695,32 +17718,32 @@
        case 20:
          /*<<camlinternalFormat.ml:1844:14>>*/ var
          rest$25 = fmt$0[3],
-          /*<<camlinternalFormat.ml:1844:14>>*/ _bU_ =
+          /*<<camlinternalFormat.ml:1844:14>>*/ _bV_ =
            make_iprintf(k$0, o, rest$25);
-         /*<<camlinternalFormat.ml:1844:14>>*/ return function(_b0_){
-          /*<<?>>*/ return _bU_;};
+         /*<<camlinternalFormat.ml:1844:14>>*/ return function(_b1_){
+          /*<<?>>*/ return _bV_;};
        case 21:
          /*<<camlinternalFormat.ml:1846:14>>*/ var
          rest$26 = fmt$0[2],
-          /*<<camlinternalFormat.ml:1846:14>>*/ _bV_ =
+          /*<<camlinternalFormat.ml:1846:14>>*/ _bW_ =
            make_iprintf(k$0, o, rest$26);
-         /*<<camlinternalFormat.ml:1846:14>>*/ return function(_bZ_){
-          /*<<?>>*/ return _bV_;};
+         /*<<camlinternalFormat.ml:1846:14>>*/ return function(_b0_){
+          /*<<?>>*/ return _bW_;};
        case 22:
          /*<<camlinternalFormat.ml:1848:14>>*/ var
          rest$27 = fmt$0[1],
-          /*<<camlinternalFormat.ml:1848:14>>*/ _bW_ =
+          /*<<camlinternalFormat.ml:1848:14>>*/ _bX_ =
            make_iprintf(k$0, o, rest$27);
-         /*<<camlinternalFormat.ml:1848:14>>*/ return function(_bY_){
-          /*<<?>>*/ return _bW_;};
+         /*<<camlinternalFormat.ml:1848:14>>*/ return function(_bZ_){
+          /*<<?>>*/ return _bX_;};
        case 23:
-        var rest$28 = fmt$0[2], ign = fmt$0[1], _bX_ = 0;
+        var rest$28 = fmt$0[2], ign = fmt$0[1], _bY_ = 0;
          /*<<camlinternalFormat.ml:1850:8>>*/ return make_ignored_param
                 (function(param){
                    /*<<camlinternalFormat.ml:1850:37>>*/ return caml_call1
                           (k$0, o);
                   /*<<camlinternalFormat.ml:1850:40>>*/ },
-                 _bX_,
+                 _bY_,
                  ign,
                  rest$28);
        default:
@@ -17738,10 +17761,10 @@
      /*<<camlinternalFormat.ml:1882:4>>*/ if(param){
       /*<<camlinternalFormat.ml:1889:14>>*/ var
       arity = param[1],
-       /*<<camlinternalFormat.ml:1889:14>>*/ _bw_ =
+       /*<<camlinternalFormat.ml:1889:14>>*/ _bx_ =
         fn_of_custom_arity(k, o, fmt, arity);
-      /*<<camlinternalFormat.ml:1889:14>>*/ return function(_bx_){
-       /*<<?>>*/ return _bw_;};
+      /*<<camlinternalFormat.ml:1889:14>>*/ return function(_by_){
+       /*<<?>>*/ return _bx_;};
     }
      /*<<camlinternalFormat.ml:1887:8>>*/ if(counter >= 50)
       /*<<camlinternalFormat.ml:1887:8>>*/ return  /*<<camlinternalFormat.ml:1887:8>>*/ caml_trampoline_return
@@ -17909,9 +17932,9 @@
         var f = acc$0[2], p$3 = acc$0[1];
          /*<<camlinternalFormat.ml:1950:32>>*/ strput_acc(b, p$3);
          /*<<camlinternalFormat.ml:1950:68>>*/  /*<<camlinternalFormat.ml:1950:68>>*/ var
-         _bv_ =  /*<<camlinternalFormat.ml:1950:68>>*/ caml_call1(f, 0);
+         _bw_ =  /*<<camlinternalFormat.ml:1950:68>>*/ caml_call1(f, 0);
          /*<<camlinternalFormat.ml:1950:68>>*/ return  /*<<camlinternalFormat.ml:1950:68>>*/ caml_call2
-                (Stdlib_Buffer[16], b, _bv_);
+                (Stdlib_Buffer[16], b, _bw_);
        case 7:
         var acc$3 = acc$0[1], acc$0 = acc$3; continue;
        case 8:
@@ -17942,11 +17965,11 @@
     function k(acc){
       /*<<camlinternalFormat.ml:1961:14>>*/ strput_acc(buf, acc);
       /*<<camlinternalFormat.ml:1961:43>>*/  /*<<camlinternalFormat.ml:1961:43>>*/ var
-      _bu_ =
+      _bv_ =
          /*<<camlinternalFormat.ml:1961:43>>*/ caml_call1
          (Stdlib_Buffer[2], buf);
       /*<<camlinternalFormat.ml:1961:43>>*/ return  /*<<camlinternalFormat.ml:1961:43>>*/ caml_call1
-             (Stdlib[2], _bu_);
+             (Stdlib[2], _bv_);
      /*<<camlinternalFormat.ml:1961:64>>*/ }
      /*<<camlinternalFormat.ml:1962:2>>*/ return make_printf(k, 0, fmt);
    }
@@ -18019,15 +18042,15 @@
       else
         /*<<camlinternalFormat.ml:1994:8>>*/ try{
          /*<<camlinternalFormat.ml:1994:12>>*/ var
-          /*<<camlinternalFormat.ml:1994:12>>*/ _bs_ =
+          /*<<camlinternalFormat.ml:1994:12>>*/ _bt_ =
             /*<<camlinternalFormat.ml:1994:12>>*/ runtime.caml_int_of_string
             ( /*<<camlinternalFormat.ml:1994:26>>*/ caml_call3
               (Stdlib_String[15], str, nstart, nend - nstart | 0)),
-         indent = _bs_;
+         indent = _bt_;
        }
-       catch(_bt_){
-        var _br_ = caml_wrap_exception(_bt_);
-        if(_br_[1] !== Stdlib[7]) throw caml_maybe_attach_backtrace(_br_, 0);
+       catch(_bu_){
+        var _bs_ = caml_wrap_exception(_bu_);
+        if(_bs_[1] !== Stdlib[7]) throw caml_maybe_attach_backtrace(_bs_, 0);
         var indent = invalid_box(0);
        }
        /*<<camlinternalFormat.ml:1996:18>>*/  /*<<camlinternalFormat.ml:1996:18>>*/ var
@@ -18092,8 +18115,9 @@
      /*<<camlinternalFormat.ml:2086:21>>*/ }
      /*<<camlinternalFormat.ml:2091:2>>*/ function unexpected_end_of_format
     (end_ind){
-      /*<<camlinternalFormat.ml:2092:4>>*/ return invalid_format_message
-             (end_ind, cst_unexpected_end_of_format);
+      /*<<camlinternalFormat.ml:2092:4>>*/ invalid_format_message
+      (end_ind, cst_unexpected_end_of_format);
+      /*<<camlinternalFormat.ml:2092:4>>*/ return _$_;
      /*<<camlinternalFormat.ml:2093:32>>*/ }
     function invalid_format_without(str_ind, c, s){
       /*<<camlinternalFormat.ml:2104:4>>*/ return  /*<<camlinternalFormat.ml:2104:4>>*/ caml_call4
@@ -18235,9 +18259,9 @@
            var str_ind$3 = str_ind$0 + 1 | 0;
            try{
             var
-             _bg_ = str_ind$3 === end_ind ? 1 : 0,
-             _bh_ =
-               _bg_
+             _bh_ = str_ind$3 === end_ind ? 1 : 0,
+             _bi_ =
+               _bh_
                ||
                 (60
                   !==
@@ -18245,7 +18269,7 @@
                     (str, str_ind$3)
                   ? 1
                   : 0);
-            if(_bh_)
+            if(_bi_)
               /*<<camlinternalFormat.ml:2666:58>>*/ throw  /*<<camlinternalFormat.ml:2666:58>>*/ caml_maybe_attach_backtrace
                     (Stdlib[8], 1);
              /*<<camlinternalFormat.ml:2667:24>>*/ var
@@ -18284,10 +18308,10 @@
                    str,
                    str_ind$3 - 2 | 0,
                    (str_ind_3 - str_ind$3 | 0) + 3 | 0),
-                /*<<camlinternalFormat.ml:2675:31>>*/ _bi_ = [0, s, width, 0],
-                /*<<camlinternalFormat.ml:2675:31>>*/ _bj_ = str_ind_3 + 1 | 0,
-               formatting_lit$0 = _bi_,
-               next_ind = _bj_;
+                /*<<camlinternalFormat.ml:2675:31>>*/ _bj_ = [0, s, width, 0],
+                /*<<camlinternalFormat.ml:2675:31>>*/ _bk_ = str_ind_3 + 1 | 0,
+               formatting_lit$0 = _bj_,
+               next_ind = _bk_;
              else
               switch$3 = 1;
             else if(1 < switcher$0 - 1 >>> 0){
@@ -18312,11 +18336,11 @@
                   str,
                   str_ind$3 - 2 | 0,
                   (str_ind_5 - str_ind$3 | 0) + 3 | 0),
-               /*<<camlinternalFormat.ml:2681:31>>*/ _bk_ =
+               /*<<camlinternalFormat.ml:2681:31>>*/ _bl_ =
                 [0, s$0, width, offset],
-               /*<<camlinternalFormat.ml:2681:31>>*/ _bl_ = str_ind_5 + 1 | 0,
-              formatting_lit$0 = _bk_,
-              next_ind = _bl_;
+               /*<<camlinternalFormat.ml:2681:31>>*/ _bm_ = str_ind_5 + 1 | 0,
+              formatting_lit$0 = _bl_,
+              next_ind = _bm_;
             }
             else
              switch$3 = 1;
@@ -18324,10 +18348,10 @@
               /*<<camlinternalFormat.ml:2682:21>>*/ throw  /*<<camlinternalFormat.ml:2682:21>>*/ caml_maybe_attach_backtrace
                     (Stdlib[8], 1);
            }
-           catch(_bq_){
-            var _bf_ = caml_wrap_exception(_bq_);
-            if(_bf_ !== Stdlib[8] && _bf_[1] !== Stdlib[7])
-             throw caml_maybe_attach_backtrace(_bf_, 0);
+           catch(_br_){
+            var _bg_ = caml_wrap_exception(_br_);
+            if(_bg_ !== Stdlib[8] && _bg_[1] !== Stdlib[7])
+             throw caml_maybe_attach_backtrace(_bg_, 0);
             var formatting_lit$0 = formatting_lit, next_ind = str_ind$3;
            }
            var
@@ -18370,30 +18394,30 @@
                   str,
                   str_ind$4 - 2 | 0,
                   (str_ind_3$0 - str_ind$4 | 0) + 3 | 0),
-              _bo_ = [0, [0, str_ind_3$0 + 1 | 0, [1, s$1, size]]];
+              _bp_ = [0, [0, str_ind_3$0 + 1 | 0, [1, s$1, size]]];
             }
             else
-             var _bo_ = 0;
-            var _bn_ = _bo_;
+             var _bp_ = 0;
+            var _bo_ = _bp_;
            }
-           catch(_bp_){
-            var _bm_ = caml_wrap_exception(_bp_);
-            if(_bm_ !== Stdlib[8] && _bm_[1] !== Stdlib[7])
-             throw caml_maybe_attach_backtrace(_bm_, 0);
-            var _bn_ = 0;
+           catch(_bq_){
+            var _bn_ = caml_wrap_exception(_bq_);
+            if(_bn_ !== Stdlib[8] && _bn_[1] !== Stdlib[7])
+             throw caml_maybe_attach_backtrace(_bn_, 0);
+            var _bo_ = 0;
            }
-           if(_bn_)
+           if(_bo_)
             var
-             match$5 = _bn_[1],
+             match$5 = _bo_[1],
              formatting_lit$1 = match$5[2],
              next_ind$0 = match$5[1],
              fmt_rest$13 = parse(next_ind$0, end_ind)[1],
-             _be_ = [0, [17, formatting_lit$1, fmt_rest$13]];
+             _bf_ = [0, [17, formatting_lit$1, fmt_rest$13]];
            else
             var
              fmt_rest$14 = parse(str_ind$4, end_ind)[1],
-             _be_ = [0, [17, _Q_, fmt_rest$14]];
-           var match$0 = _be_;
+             _bf_ = [0, [17, _Q_, fmt_rest$14]];
+           var match$0 = _bf_;
            break;
           case 31:
            var
@@ -18553,29 +18577,29 @@
            /*<<camlinternalFormat.ml:2536:22>>*/ var
             /*<<camlinternalFormat.ml:2536:22>>*/ ignored$2 =
              [9, get_pad_opt(95), sub_fmtty],
-           _aN_ = [0, [23, ignored$2, fmt_rest$7]];
+           _aO_ = [0, [23, ignored$2, fmt_rest$7]];
          else
-          var _aN_ = [0, [14, get_pad_opt(40), sub_fmtty, fmt_rest$7]];
-         var fmt_result = _aN_;
+          var _aO_ = [0, [14, get_pad_opt(40), sub_fmtty, fmt_rest$7]];
+         var fmt_result = _aO_;
          break;
         case 44:
          var fmt_result = parse(str_ind, end_ind); break;
         case 67:
           /*<<camlinternalFormat.ml:2397:9>>*/ var
           fmt_rest$10 = parse(str_ind, end_ind)[1],
-           /*<<camlinternalFormat.ml:2397:9>>*/ _aP_ =
+           /*<<camlinternalFormat.ml:2397:9>>*/ _aQ_ =
             get_ign(0) ? [0, [23, 1, fmt_rest$10]] : [0, [1, fmt_rest$10]],
-          fmt_result = _aP_;
+          fmt_result = _aQ_;
          break;
         case 78:
          var fmt_rest$14 = parse(str_ind, end_ind)[1], counter$0 = 2;
           /*<<camlinternalFormat.ml:2433:9>>*/ if(get_ign(0))
            /*<<camlinternalFormat.ml:2434:22>>*/ var
             /*<<camlinternalFormat.ml:2434:22>>*/ ignored$6 = [11, counter$0],
-           _aV_ = [0, [23, ignored$6, fmt_rest$14]];
+           _aW_ = [0, [23, ignored$6, fmt_rest$14]];
          else
-          var _aV_ = [0, [21, counter$0, fmt_rest$14]];
-         var fmt_result = _aV_;
+          var _aW_ = [0, [21, counter$0, fmt_rest$14]];
+         var fmt_result = _aW_;
          break;
         case 83:
           /*<<camlinternalFormat.ml:2410:16>>*/ var
@@ -18586,15 +18610,15 @@
            /*<<camlinternalFormat.ml:2413:22>>*/ var
             /*<<camlinternalFormat.ml:2413:22>>*/ ignored$7 =
              [1, get_padprec_opt(95)],
-           _aW_ = [0, [23, ignored$7, fmt_rest$15]];
+           _aX_ = [0, [23, ignored$7, fmt_rest$15]];
          else
            /*<<camlinternalFormat.ml:2417:10>>*/ var
             /*<<camlinternalFormat.ml:2417:10>>*/ match$5 =
              make_padding_fmt_ebb(pad$6, fmt_rest$15),
            fmt_rest$16 = match$5[2],
            pad$7 = match$5[1],
-           _aW_ = [0, [3, pad$7, fmt_rest$16]];
-         var fmt_result = _aW_;
+           _aX_ = [0, [3, pad$7, fmt_rest$16]];
+         var fmt_result = _aX_;
          break;
         case 91:
          if(str_ind === end_ind)
@@ -18604,8 +18628,9 @@
            /*<<camlinternalFormat.ml:2719:19>>*/ char_set = create_char_set(0),
           add_char =
             function(c){
-              /*<<camlinternalFormat.ml:2721:6>>*/ return add_in_char_set
-                     (char_set, c);
+              /*<<camlinternalFormat.ml:2721:6>>*/ add_in_char_set
+              (char_set, c);
+              /*<<camlinternalFormat.ml:2721:6>>*/ return _$_;
              /*<<camlinternalFormat.ml:2721:32>>*/ },
           add_range =
             function(c$0, c){
@@ -18617,12 +18642,12 @@
                   /*<<camlinternalFormat.ml:2725:33>>*/ caml_call1
                   (Stdlib[29], i));
                 /*<<camlinternalFormat.ml:2725:8>>*/  /*<<camlinternalFormat.ml:2725:8>>*/ var
-                _bd_ = i + 1 | 0;
-               if(c !== i){var i = _bd_; continue;}
+                _be_ = i + 1 | 0;
+               if(c !== i){var i = _be_; continue;}
                break;
               }
              }
-             return 0;
+             return _$_;
              /*<<camlinternalFormat.ml:2726:10>>*/ },
           fail_single_percent =
             function(str_ind){
@@ -18647,13 +18672,13 @@
               }
               if(93 === c)
                 /*<<camlinternalFormat.ml:2746:8>>*/ return str_ind$0 + 1 | 0;
-              var _bc_ = str_ind$0 + 1 | 0;
+              var _bd_ = str_ind$0 + 1 | 0;
                /*<<camlinternalFormat.ml:2751:8>>*/ if(counter >= 50)
                 /*<<camlinternalFormat.ml:2751:8>>*/ return  /*<<camlinternalFormat.ml:2751:8>>*/ caml_trampoline_return
-                       (parse_char_set_after_char$0, [0, _bc_, end_ind, c]);
+                       (parse_char_set_after_char$0, [0, _bd_, end_ind, c]);
               var counter$0 = counter + 1 | 0;
                /*<<camlinternalFormat.ml:2751:8>>*/ return parse_char_set_after_char$0
-                      (counter$0, _bc_, end_ind, c);
+                      (counter$0, _bd_, end_ind, c);
              }
              /*<<camlinternalFormat.ml:2751:57>>*/ },
           parse_char_set_after_char$0 =
@@ -18701,13 +18726,13 @@
                   /*<<camlinternalFormat.ml:2787:17>>*/ return fail_single_percent
                          (str_ind$2);
                  /*<<camlinternalFormat.ml:2785:12>>*/ add_range(c$0, c$3);
-                var _ba_ = str_ind$2 + 2 | 0;
+                var _bb_ = str_ind$2 + 2 | 0;
                  /*<<camlinternalFormat.ml:2785:12>>*/ if(counter >= 50)
                   /*<<camlinternalFormat.ml:2785:12>>*/ return  /*<<camlinternalFormat.ml:2785:12>>*/ caml_trampoline_return
-                         (parse_char_set_content, [0, _ba_, end_ind]);
+                         (parse_char_set_content, [0, _bb_, end_ind]);
                 var counter$2 = counter + 1 | 0;
                  /*<<camlinternalFormat.ml:2785:12>>*/ return parse_char_set_content
-                        (counter$2, _ba_, end_ind);
+                        (counter$2, _bb_, end_ind);
                }
                if(93 === c$2){
                  /*<<camlinternalFormat.ml:2778:8>>*/ add_char(c$0);
@@ -18715,23 +18740,23 @@
                  /*<<camlinternalFormat.ml:2779:8>>*/ return str_ind$2 + 1 | 0;
                }
                 /*<<camlinternalFormat.ml:2790:8>>*/ add_range(c$0, c$2);
-               var _bb_ = str_ind$2 + 1 | 0;
+               var _bc_ = str_ind$2 + 1 | 0;
                 /*<<camlinternalFormat.ml:2790:8>>*/ if(counter >= 50)
                  /*<<camlinternalFormat.ml:2790:8>>*/ return  /*<<camlinternalFormat.ml:2790:8>>*/ caml_trampoline_return
-                        (parse_char_set_content, [0, _bb_, end_ind]);
+                        (parse_char_set_content, [0, _bc_, end_ind]);
                var counter$1 = counter + 1 | 0;
                 /*<<camlinternalFormat.ml:2790:8>>*/ return parse_char_set_content
-                       (counter$1, _bb_, end_ind);
+                       (counter$1, _bc_, end_ind);
               }
               if(switch$0 && 37 === c$0){
                 /*<<camlinternalFormat.ml:2763:8>>*/ add_char(c$1);
-               var _a$_ = str_ind$0 + 1 | 0;
+               var _ba_ = str_ind$0 + 1 | 0;
                 /*<<camlinternalFormat.ml:2763:8>>*/ if(counter >= 50)
                  /*<<camlinternalFormat.ml:2763:8>>*/ return  /*<<camlinternalFormat.ml:2763:8>>*/ caml_trampoline_return
-                        (parse_char_set_content, [0, _a$_, end_ind]);
+                        (parse_char_set_content, [0, _ba_, end_ind]);
                var counter$0 = counter + 1 | 0;
                 /*<<camlinternalFormat.ml:2763:8>>*/ return parse_char_set_content
-                       (counter$0, _a$_, end_ind);
+                       (counter$0, _ba_, end_ind);
               }
               if(37 === c$0)
                 /*<<camlinternalFormat.ml:2766:24>>*/ fail_single_percent
@@ -18777,10 +18802,10 @@
            /*<<camlinternalFormat.ml:2544:22>>*/ var
             /*<<camlinternalFormat.ml:2544:22>>*/ ignored$9 =
              [10, get_pad_opt(95), char_set$1],
-           _a1_ = [0, [23, ignored$9, fmt_rest$19]];
+           _a2_ = [0, [23, ignored$9, fmt_rest$19]];
          else
-          var _a1_ = [0, [20, get_pad_opt(91), char_set$1, fmt_rest$19]];
-         var fmt_result = _a1_;
+          var _a2_ = [0, [20, get_pad_opt(91), char_set$1, fmt_rest$19]];
+         var fmt_result = _a2_;
          break;
         case 97:
          var
@@ -18800,28 +18825,28 @@
          if(match$7){
           if(0 === match$7[1])
             /*<<camlinternalFormat.ml:2382:11>>*/ var
-             /*<<camlinternalFormat.ml:2382:11>>*/ _a2_ =
+             /*<<camlinternalFormat.ml:2382:11>>*/ _a3_ =
               get_ign(0) ? [0, [23, 3, fmt_rest$21]] : [0, [22, fmt_rest$21]],
-            _a3_ = _a2_;
+            _a4_ = _a3_;
           else
            var
-            _a3_ =
+            _a4_ =
               legacy_behavior$0
                ? char_format(fmt_rest$21)
                : invalid_format_message
                  (str_ind, cst_non_zero_widths_are_unsupp);
-          var _a4_ = _a3_;
+          var _a5_ = _a4_;
          }
          else
-          var _a4_ = char_format(fmt_rest$21);
-         var fmt_result = _a4_;
+          var _a5_ = char_format(fmt_rest$21);
+         var fmt_result = _a5_;
          break;
         case 114:
           /*<<camlinternalFormat.ml:2512:9>>*/ var
           fmt_rest$22 = parse(str_ind, end_ind)[1],
-           /*<<camlinternalFormat.ml:2512:9>>*/ _a5_ =
+           /*<<camlinternalFormat.ml:2512:9>>*/ _a6_ =
             get_ign(0) ? [0, [23, 2, fmt_rest$22]] : [0, [19, fmt_rest$22]],
-          fmt_result = _a5_;
+          fmt_result = _a6_;
          break;
         case 115:
           /*<<camlinternalFormat.ml:2400:16>>*/ var
@@ -18832,15 +18857,15 @@
            /*<<camlinternalFormat.ml:2403:22>>*/ var
             /*<<camlinternalFormat.ml:2403:22>>*/ ignored$10 =
              [0, get_padprec_opt(95)],
-           _a6_ = [0, [23, ignored$10, fmt_rest$23]];
+           _a7_ = [0, [23, ignored$10, fmt_rest$23]];
          else
            /*<<camlinternalFormat.ml:2407:10>>*/ var
             /*<<camlinternalFormat.ml:2407:10>>*/ match$8 =
              make_padding_fmt_ebb(pad$9, fmt_rest$23),
            fmt_rest$24 = match$8[2],
            pad$10 = match$8[1],
-           _a6_ = [0, [2, pad$10, fmt_rest$24]];
-         var fmt_result = _a6_;
+           _a7_ = [0, [2, pad$10, fmt_rest$24]];
+         var fmt_result = _a7_;
          break;
         case 116:
          var
@@ -18859,10 +18884,10 @@
            /*<<camlinternalFormat.ml:2526:22>>*/ var
             /*<<camlinternalFormat.ml:2526:22>>*/ ignored$11 =
              [8, get_pad_opt(95), sub_fmtty$0],
-           _a7_ = [0, [23, ignored$11, fmt_rest$26]];
+           _a8_ = [0, [23, ignored$11, fmt_rest$26]];
          else
-          var _a7_ = [0, [13, get_pad_opt(123), sub_fmtty$0, fmt_rest$26]];
-         var fmt_result = _a7_;
+          var _a8_ = [0, [13, get_pad_opt(123), sub_fmtty$0, fmt_rest$26]];
+         var fmt_result = _a8_;
          break;
         case 66:
         case 98:
@@ -18874,15 +18899,15 @@
            /*<<camlinternalFormat.ml:2498:22>>*/ var
             /*<<camlinternalFormat.ml:2498:22>>*/ ignored$3 =
              [7, get_padprec_opt(95)],
-           _aO_ = [0, [23, ignored$3, fmt_rest$8]];
+           _aP_ = [0, [23, ignored$3, fmt_rest$8]];
          else
            /*<<camlinternalFormat.ml:2502:10>>*/ var
             /*<<camlinternalFormat.ml:2502:10>>*/ match$3 =
              make_padding_fmt_ebb(pad$3, fmt_rest$8),
            fmt_rest$9 = match$3[2],
            pad$4 = match$3[1],
-           _aO_ = [0, [9, pad$4, fmt_rest$9]];
-         var fmt_result = _aO_;
+           _aP_ = [0, [9, pad$4, fmt_rest$9]];
+         var fmt_result = _aP_;
          break;
         case 37:
         case 64:
@@ -18901,20 +18926,20 @@
             /*<<camlinternalFormat.ml:2438:63>>*/ symb$0 =
               /*<<camlinternalFormat.ml:2438:63>>*/ caml_string_get
               (str, str_ind),
-            /*<<camlinternalFormat.ml:2892:25>>*/ _a8_ = symb$0 - 88 | 0,
+            /*<<camlinternalFormat.ml:2892:25>>*/ _a9_ = symb$0 - 88 | 0,
            switch$2 = 0;
-          if(32 >= _a8_ >>> 0)
-           switch(_a8_){
+          if(32 >= _a9_ >>> 0)
+           switch(_a9_){
              case 0:
              case 12:
              case 17:
              case 23:
              case 29:
              case 32:
-              var _aU_ = 1; switch$2 = 1; break;
+              var _aV_ = 1; switch$2 = 1; break;
            }
-          if(! switch$2) var _aU_ = 0;
-           /*<<camlinternalFormat.ml:2438:50>>*/ if(_aU_)
+          if(! switch$2) var _aV_ = 0;
+           /*<<camlinternalFormat.ml:2438:50>>*/ if(_aV_)
            switch$0 = 1;
           else
            switch$1 = 1;
@@ -18937,10 +18962,10 @@
            /*<<camlinternalFormat.ml:2441:9>>*/ if(get_ign(0))
             /*<<camlinternalFormat.ml:2442:22>>*/ var
              /*<<camlinternalFormat.ml:2442:22>>*/ ignored$5 = [11, counter],
-            _aT_ = [0, [23, ignored$5, fmt_rest$13]];
+            _aU_ = [0, [23, ignored$5, fmt_rest$13]];
           else
-           var _aT_ = [0, [21, counter, fmt_rest$13]];
-          var fmt_result = _aT_;
+           var _aU_ = [0, [21, counter, fmt_rest$13]];
+          var fmt_result = _aU_;
          }
          break;
         case 32:
@@ -18960,26 +18985,26 @@
         case 117:
         case 120:
           /*<<camlinternalFormat.ml:2421:8>>*/ var
-           /*<<camlinternalFormat.ml:2421:8>>*/ _aX_ = get_space(0),
-           /*<<camlinternalFormat.ml:2420:65>>*/ _aY_ = get_hash(0),
+           /*<<camlinternalFormat.ml:2421:8>>*/ _aY_ = get_space(0),
+           /*<<camlinternalFormat.ml:2420:65>>*/ _aZ_ = get_hash(0),
            /*<<camlinternalFormat.ml:2420:18>>*/ iconv$2 =
-            compute_int_conv(pct_ind, str_ind, get_plus(0), _aY_, _aX_, symb),
+            compute_int_conv(pct_ind, str_ind, get_plus(0), _aZ_, _aY_, symb),
           fmt_rest$17 = parse(str_ind, end_ind)[1];
           /*<<camlinternalFormat.ml:2423:9>>*/ if(get_ign(0))
            /*<<camlinternalFormat.ml:2424:22>>*/ var
             /*<<camlinternalFormat.ml:2424:22>>*/ ignored$8 =
              [2, iconv$2, get_pad_opt(95)],
-           _aZ_ = [0, [23, ignored$8, fmt_rest$17]];
+           _a0_ = [0, [23, ignored$8, fmt_rest$17]];
          else
            /*<<camlinternalFormat.ml:2428:48>>*/ var
-            /*<<camlinternalFormat.ml:2428:48>>*/ _a0_ = get_prec(0),
+            /*<<camlinternalFormat.ml:2428:48>>*/ _a1_ = get_prec(0),
             /*<<camlinternalFormat.ml:2428:10>>*/ match$6 =
-             make_padprec_fmt_ebb(get_int_pad(0), _a0_, fmt_rest$17),
+             make_padprec_fmt_ebb(get_int_pad(0), _a1_, fmt_rest$17),
            fmt_rest$18 = match$6[3],
            prec$4 = match$6[2],
            pad$8 = match$6[1],
-           _aZ_ = [0, [4, iconv$2, pad$8, prec$4, fmt_rest$18]];
-         var fmt_result = _aZ_;
+           _a0_ = [0, [4, iconv$2, pad$8, prec$4, fmt_rest$18]];
+         var fmt_result = _a0_;
          break;
         case 69:
         case 70:
@@ -19009,28 +19034,28 @@
           else{
            switch(switcher){
              case 0:
-              var _a9_ = 1; break;
+              var _a__ = 1; break;
              case 1:
-              var _a9_ = 0; break;
+              var _a__ = 0; break;
              case 2:
-              var _a9_ = 3; break;
-             default: var _a9_ = 6;
+              var _a__ = 3; break;
+             default: var _a__ = 6;
            }
-           var kind = _a9_;
+           var kind = _a__;
           }
          }
          else if(69 <= symb){
           var switch$5 = 0;
           switch(symb - 69 | 0){
             case 0:
-             var _a__ = 2; break;
+             var _a$_ = 2; break;
             case 1:
              switch$4 = 1; switch$5 = 1; break;
             case 2:
-             var _a__ = 4; break;
-            default: var _a__ = 7;
+             var _a$_ = 4; break;
+            default: var _a$_ = 7;
           }
-          if(! switch$5) var kind = _a__;
+          if(! switch$5) var kind = _a$_;
          }
          else
           switch$4 = 1;
@@ -19052,24 +19077,24 @@
            match = get_prec(0);
           if(typeof match === "number")
            var
-            _aQ_ = match ? incompatible_flag(pct_ind, str_ind, 95, cst$26) : 0;
+            _aR_ = match ? incompatible_flag(pct_ind, str_ind, 95, cst$26) : 0;
           else
-           var ndec = match[1], _aQ_ = [0, ndec];
+           var ndec = match[1], _aR_ = [0, ndec];
            /*<<camlinternalFormat.ml:2488:22>>*/ var
             /*<<camlinternalFormat.ml:2488:22>>*/ ignored$4 =
-             [6, get_pad_opt(95), _aQ_],
-           _aR_ = [0, [23, ignored$4, fmt_rest$11]];
+             [6, get_pad_opt(95), _aR_],
+           _aS_ = [0, [23, ignored$4, fmt_rest$11]];
          }
          else
            /*<<camlinternalFormat.ml:2492:44>>*/ var
-            /*<<camlinternalFormat.ml:2492:44>>*/ _aS_ = get_prec(0),
+            /*<<camlinternalFormat.ml:2492:44>>*/ _aT_ = get_prec(0),
             /*<<camlinternalFormat.ml:2492:10>>*/ match$4 =
-             make_padprec_fmt_ebb(get_pad(0), _aS_, fmt_rest$11),
+             make_padprec_fmt_ebb(get_pad(0), _aT_, fmt_rest$11),
            fmt_rest$12 = match$4[3],
            prec$3 = match$4[2],
            pad$5 = match$4[1],
-           _aR_ = [0, [8, fconv, pad$5, prec$3, fmt_rest$12]];
-         var fmt_result = _aR_;
+           _aS_ = [0, [8, fconv, pad$5, prec$3, fmt_rest$12]];
+         var fmt_result = _aS_;
          break;
         default: switch$0 = 1;
       }
@@ -19081,89 +19106,89 @@
         switch(symb - 108 | 0){
           case 0:
             /*<<camlinternalFormat.ml:2449:25>>*/ var
-             /*<<camlinternalFormat.ml:2449:25>>*/ _ax_ =
+             /*<<camlinternalFormat.ml:2449:25>>*/ _ay_ =
                /*<<camlinternalFormat.ml:2449:25>>*/ caml_string_get
                (str, str_ind),
-             /*<<camlinternalFormat.ml:2449:10>>*/ _ay_ = get_space(0),
-             /*<<camlinternalFormat.ml:2448:61>>*/ _az_ = get_hash(0),
+             /*<<camlinternalFormat.ml:2449:10>>*/ _az_ = get_space(0),
+             /*<<camlinternalFormat.ml:2448:61>>*/ _aA_ = get_hash(0),
              /*<<camlinternalFormat.ml:2448:8>>*/ iconv =
               compute_int_conv
-               (pct_ind, str_ind + 1 | 0, get_plus(0), _az_, _ay_, _ax_),
+               (pct_ind, str_ind + 1 | 0, get_plus(0), _aA_, _az_, _ay_),
             fmt_rest = parse(str_ind + 1 | 0, end_ind)[1];
             /*<<camlinternalFormat.ml:2451:9>>*/ if(get_ign(0))
              /*<<camlinternalFormat.ml:2452:22>>*/ var
               /*<<camlinternalFormat.ml:2452:22>>*/ ignored =
                [3, iconv, get_pad_opt(95)],
-             _aA_ = [0, [23, ignored, fmt_rest]];
+             _aB_ = [0, [23, ignored, fmt_rest]];
            else
              /*<<camlinternalFormat.ml:2456:48>>*/ var
-              /*<<camlinternalFormat.ml:2456:48>>*/ _aC_ = get_prec(0),
+              /*<<camlinternalFormat.ml:2456:48>>*/ _aD_ = get_prec(0),
               /*<<camlinternalFormat.ml:2456:10>>*/ match$0 =
-               make_padprec_fmt_ebb(get_int_pad(0), _aC_, fmt_rest),
+               make_padprec_fmt_ebb(get_int_pad(0), _aD_, fmt_rest),
              fmt_rest$0 = match$0[3],
              prec$0 = match$0[2],
              pad$0 = match$0[1],
-             _aA_ = [0, [5, iconv, pad$0, prec$0, fmt_rest$0]];
-           var _aB_ = _aA_;
+             _aB_ = [0, [5, iconv, pad$0, prec$0, fmt_rest$0]];
+           var _aC_ = _aB_;
            switch$8 = 1;
            break;
           case 1: break;
           default:
             /*<<camlinternalFormat.ml:2461:39>>*/ var
-             /*<<camlinternalFormat.ml:2461:39>>*/ _aD_ =
+             /*<<camlinternalFormat.ml:2461:39>>*/ _aE_ =
                /*<<camlinternalFormat.ml:2461:39>>*/ caml_string_get
                (str, str_ind),
-             /*<<camlinternalFormat.ml:2461:24>>*/ _aE_ = get_space(0),
-             /*<<camlinternalFormat.ml:2461:10>>*/ _aF_ = get_hash(0),
+             /*<<camlinternalFormat.ml:2461:24>>*/ _aF_ = get_space(0),
+             /*<<camlinternalFormat.ml:2461:10>>*/ _aG_ = get_hash(0),
              /*<<camlinternalFormat.ml:2460:8>>*/ iconv$0 =
               compute_int_conv
-               (pct_ind, str_ind + 1 | 0, get_plus(0), _aF_, _aE_, _aD_),
+               (pct_ind, str_ind + 1 | 0, get_plus(0), _aG_, _aF_, _aE_),
             fmt_rest$1 = parse(str_ind + 1 | 0, end_ind)[1];
             /*<<camlinternalFormat.ml:2463:9>>*/ if(get_ign(0))
              /*<<camlinternalFormat.ml:2464:22>>*/ var
               /*<<camlinternalFormat.ml:2464:22>>*/ ignored$0 =
                [4, iconv$0, get_pad_opt(95)],
-             _aG_ = [0, [23, ignored$0, fmt_rest$1]];
+             _aH_ = [0, [23, ignored$0, fmt_rest$1]];
            else
              /*<<camlinternalFormat.ml:2468:48>>*/ var
-              /*<<camlinternalFormat.ml:2468:48>>*/ _aH_ = get_prec(0),
+              /*<<camlinternalFormat.ml:2468:48>>*/ _aI_ = get_prec(0),
               /*<<camlinternalFormat.ml:2468:10>>*/ match$1 =
-               make_padprec_fmt_ebb(get_int_pad(0), _aH_, fmt_rest$1),
+               make_padprec_fmt_ebb(get_int_pad(0), _aI_, fmt_rest$1),
              fmt_rest$2 = match$1[3],
              prec$1 = match$1[2],
              pad$1 = match$1[1],
-             _aG_ = [0, [6, iconv$0, pad$1, prec$1, fmt_rest$2]];
-           var _aB_ = _aG_;
+             _aH_ = [0, [6, iconv$0, pad$1, prec$1, fmt_rest$2]];
+           var _aC_ = _aH_;
            switch$8 = 1;
         }
-        if(switch$8){var fmt_result = _aB_; switch$7 = 1;}
+        if(switch$8){var fmt_result = _aC_; switch$7 = 1;}
        }
       }
       else if(76 === symb){
         /*<<camlinternalFormat.ml:2473:25>>*/ var
-         /*<<camlinternalFormat.ml:2473:25>>*/ _aI_ =
+         /*<<camlinternalFormat.ml:2473:25>>*/ _aJ_ =
            /*<<camlinternalFormat.ml:2473:25>>*/ caml_string_get(str, str_ind),
-         /*<<camlinternalFormat.ml:2473:10>>*/ _aJ_ = get_space(0),
-         /*<<camlinternalFormat.ml:2472:61>>*/ _aK_ = get_hash(0),
+         /*<<camlinternalFormat.ml:2473:10>>*/ _aK_ = get_space(0),
+         /*<<camlinternalFormat.ml:2472:61>>*/ _aL_ = get_hash(0),
          /*<<camlinternalFormat.ml:2472:8>>*/ iconv$1 =
           compute_int_conv
-           (pct_ind, str_ind + 1 | 0, get_plus(0), _aK_, _aJ_, _aI_),
+           (pct_ind, str_ind + 1 | 0, get_plus(0), _aL_, _aK_, _aJ_),
         fmt_rest$3 = parse(str_ind + 1 | 0, end_ind)[1];
         /*<<camlinternalFormat.ml:2475:9>>*/ if(get_ign(0))
          /*<<camlinternalFormat.ml:2476:22>>*/ var
           /*<<camlinternalFormat.ml:2476:22>>*/ ignored$1 =
            [5, iconv$1, get_pad_opt(95)],
-         _aL_ = [0, [23, ignored$1, fmt_rest$3]];
+         _aM_ = [0, [23, ignored$1, fmt_rest$3]];
        else
          /*<<camlinternalFormat.ml:2480:48>>*/ var
-          /*<<camlinternalFormat.ml:2480:48>>*/ _aM_ = get_prec(0),
+          /*<<camlinternalFormat.ml:2480:48>>*/ _aN_ = get_prec(0),
           /*<<camlinternalFormat.ml:2480:10>>*/ match$2 =
-           make_padprec_fmt_ebb(get_int_pad(0), _aM_, fmt_rest$3),
+           make_padprec_fmt_ebb(get_int_pad(0), _aN_, fmt_rest$3),
          fmt_rest$4 = match$2[3],
          prec$2 = match$2[2],
          pad$2 = match$2[1],
-         _aL_ = [0, [7, iconv$1, pad$2, prec$2, fmt_rest$4]];
-       var fmt_result = _aL_;
+         _aM_ = [0, [7, iconv$1, pad$2, prec$2, fmt_rest$4]];
+       var fmt_result = _aM_;
        switch$7 = 1;
       }
       if(! switch$7)
@@ -19173,46 +19198,46 @@
            (failwith_message(_J_), str, str_ind - 1 | 0, symb);
      }
      if(1 - legacy_behavior$0){
-      var _ao_ = 1 - plus_used[1], plus$0 = _ao_ ? plus : _ao_;
+      var _ap_ = 1 - plus_used[1], plus$0 = _ap_ ? plus : _ap_;
       if(plus$0)
         /*<<camlinternalFormat.ml:2564:6>>*/ incompatible_flag
         (pct_ind, str_ind, symb, cst$27);
-      var _ap_ = 1 - hash_used[1], hash$0 = _ap_ ? hash : _ap_;
+      var _aq_ = 1 - hash_used[1], hash$0 = _aq_ ? hash : _aq_;
       if(hash$0)
         /*<<camlinternalFormat.ml:2566:6>>*/ incompatible_flag
         (pct_ind, str_ind, symb, cst$28);
-      var _aq_ = 1 - space_used[1], space$0 = _aq_ ? space : _aq_;
+      var _ar_ = 1 - space_used[1], space$0 = _ar_ ? space : _ar_;
       if(space$0)
         /*<<camlinternalFormat.ml:2568:6>>*/ incompatible_flag
         (pct_ind, str_ind, symb, cst$29);
       var
-       _ar_ = 1 - pad_used[1],
-       _as_ =
-         _ar_
+       _as_ = 1 - pad_used[1],
+       _at_ =
+         _as_
           ?  /*<<camlinternalFormat.ml:2569:25>>*/ caml_notequal
             ([0, pad], _K_)
-          : _ar_;
-       /*<<camlinternalFormat.ml:2569:25>>*/ if(_as_)
+          : _as_;
+       /*<<camlinternalFormat.ml:2569:25>>*/ if(_at_)
         /*<<camlinternalFormat.ml:2570:6>>*/ incompatible_flag
         (pct_ind, str_ind, symb, cst_padding$0);
       var
-       _at_ = 1 - prec_used[1],
-       _au_ =
-         _at_
+       _au_ = 1 - prec_used[1],
+       _av_ =
+         _au_
           ?  /*<<camlinternalFormat.ml:2571:25>>*/ caml_notequal
             ([0, prec], _L_)
-          : _at_;
-       /*<<camlinternalFormat.ml:2571:25>>*/ if(_au_){
-       var _av_ = ign ? 95 : symb;
+          : _au_;
+       /*<<camlinternalFormat.ml:2571:25>>*/ if(_av_){
+       var _aw_ = ign ? 95 : symb;
         /*<<camlinternalFormat.ml:2572:6>>*/ incompatible_flag
-        (pct_ind, str_ind, _av_, cst_precision$2);
+        (pct_ind, str_ind, _aw_, cst_precision$2);
       }
       var plus$1 = ign ? plus : ign;
       if(plus$1)
         /*<<camlinternalFormat.ml:2574:24>>*/ incompatible_flag
         (pct_ind, str_ind, 95, cst$30);
      }
-     var _aw_ = 1 - ign_used[1], ign$0 = _aw_ ? ign : _aw_;
+     var _ax_ = 1 - ign_used[1], ign$0 = _ax_ ? ign : _ax_;
      if(ign$0){
       var switch$9 = 0;
       if(38 <= symb){
@@ -19328,10 +19353,10 @@
         case 3:
          if(legacy_behavior$0){
            /*<<camlinternalFormat.ml:2249:6>>*/ var
-            /*<<camlinternalFormat.ml:2249:6>>*/ _an_ = str_ind$0 + 1 | 0,
+            /*<<camlinternalFormat.ml:2249:6>>*/ _ao_ = str_ind$0 + 1 | 0,
            minus$0 = minus || (45 === symb$0 ? 1 : 0);
            /*<<camlinternalFormat.ml:2249:6>>*/ return parse_literal
-                  (minus$0, _an_);
+                  (minus$0, _ao_);
          }
          break;
       }
@@ -19358,17 +19383,17 @@
        /*<<camlinternalFormat.ml:2151:15>>*/ hash = [0, 0];
      function set_flag(str_ind, flag){
        /*<<camlinternalFormat.ml:2154:6>>*/ var
-       _ak_ = flag[1],
-       _al_ = _ak_ ? 1 - legacy_behavior$0 : _ak_;
-      if(_al_){
+       _al_ = flag[1],
+       _am_ = _al_ ? 1 - legacy_behavior$0 : _al_;
+      if(_am_){
         /*<<camlinternalFormat.ml:2157:22>>*/  /*<<camlinternalFormat.ml:2157:22>>*/ var
-        _am_ =
+        _an_ =
            /*<<camlinternalFormat.ml:2157:22>>*/ caml_string_get(str, str_ind);
         /*<<camlinternalFormat.ml:2155:8>>*/  /*<<camlinternalFormat.ml:2155:8>>*/ caml_call3
-        (failwith_message(_C_), str, str_ind, _am_);
+        (failwith_message(_C_), str, str_ind, _an_);
       }
       flag[1] = 1;
-      return 0;
+      return _$_;
       /*<<camlinternalFormat.ml:2158:19>>*/ }
      var str_ind$0 = str_ind;
       /*<<camlinternalFormat.ml:2161:6>>*/ for(;;){
@@ -19538,13 +19563,13 @@
          [0, sub_fmt, sub_str],
         /*<<camlinternalFormat.ml:2649:8>>*/ formatting$0 =
          is_open_tag ? [0, sub_format$0] : [1, sub_format$0],
-        /*<<camlinternalFormat.ml:2651:8>>*/ _ai_ =
+        /*<<camlinternalFormat.ml:2651:8>>*/ _aj_ =
          [0, [18, formatting$0, fmt_rest$0]];
-       /*<<camlinternalFormat.ml:2651:8>>*/ return _ai_;
+       /*<<camlinternalFormat.ml:2651:8>>*/ return _aj_;
      }
-     catch(_aj_){
-      var _ah_ = caml_wrap_exception(_aj_);
-      if(_ah_ !== Stdlib[8]) throw caml_maybe_attach_backtrace(_ah_, 0);
+     catch(_ak_){
+      var _ai_ = caml_wrap_exception(_ak_);
+      if(_ai_ !== Stdlib[8]) throw caml_maybe_attach_backtrace(_ai_, 0);
        /*<<camlinternalFormat.ml:2657:6>>*/ var
        fmt_rest = parse(str_ind, end_ind)[1],
         /*<<camlinternalFormat.ml:2657:6>>*/ formatting =
@@ -19584,9 +19609,9 @@
       var new_acc = (acc$0 * 10 | 0) + (c - 48 | 0) | 0;
       if(Stdlib_Sys[12] < new_acc){
         /*<<camlinternalFormat.ml:2815:8>>*/  /*<<camlinternalFormat.ml:2815:8>>*/ var
-        _ag_ = Stdlib_Sys[12];
+        _ah_ = Stdlib_Sys[12];
         /*<<camlinternalFormat.ml:2815:8>>*/ return  /*<<camlinternalFormat.ml:2815:8>>*/ caml_call3
-               (failwith_message(_S_), str, new_acc, _ag_);
+               (failwith_message(_S_), str, new_acc, _ah_);
       }
       var
        str_ind$1 = str_ind$0 + 1 | 0,
@@ -19839,16 +19864,16 @@
      fmt = fmt_ebb_of_string(0, str)[1];
      /*<<camlinternalFormat.ml:2978:2>>*/ try{
       /*<<camlinternalFormat.ml:2978:6>>*/  /*<<camlinternalFormat.ml:2978:6>>*/ var
-      _ae_ = [0, type_format(fmt, fmtty), str];
-      /*<<camlinternalFormat.ml:2978:6>>*/ return _ae_;
+      _af_ = [0, type_format(fmt, fmtty), str];
+      /*<<camlinternalFormat.ml:2978:6>>*/ return _af_;
     }
-    catch(_af_){
-     var _ac_ = caml_wrap_exception(_af_);
-     if(_ac_ !== Type_mismatch) throw caml_maybe_attach_backtrace(_ac_, 0);
+    catch(_ag_){
+     var _ad_ = caml_wrap_exception(_ag_);
+     if(_ad_ !== Type_mismatch) throw caml_maybe_attach_backtrace(_ad_, 0);
       /*<<camlinternalFormat.ml:2982:10>>*/  /*<<camlinternalFormat.ml:2982:10>>*/ var
-      _ad_ = string_of_fmtty(fmtty);
+      _ae_ = string_of_fmtty(fmtty);
       /*<<camlinternalFormat.ml:2982:10>>*/ return  /*<<camlinternalFormat.ml:2982:10>>*/ caml_call2
-             (failwith_message(_Z_), str, _ad_);
+             (failwith_message(_Z_), str, _ae_);
     }
     /*<<camlinternalFormat.ml:2982:33>>*/ }
    function format_of_string_format(str, param){
@@ -19858,15 +19883,15 @@
      fmt$0 = fmt_ebb_of_string(0, str)[1];
      /*<<camlinternalFormat.ml:2988:2>>*/ try{
       /*<<camlinternalFormat.ml:2988:6>>*/  /*<<camlinternalFormat.ml:2988:6>>*/ var
-      _aa_ = [0, type_format(fmt$0, fmtty_of_fmt(fmt)), str];
-      /*<<camlinternalFormat.ml:2988:6>>*/ return _aa_;
+      _ab_ = [0, type_format(fmt$0, fmtty_of_fmt(fmt)), str];
+      /*<<camlinternalFormat.ml:2988:6>>*/ return _ab_;
     }
-    catch(_ab_){
-     var _$_ = caml_wrap_exception(_ab_);
-     if(_$_ === Type_mismatch)
+    catch(_ac_){
+     var _aa_ = caml_wrap_exception(_ac_);
+     if(_aa_ === Type_mismatch)
        /*<<camlinternalFormat.ml:2990:4>>*/ return  /*<<camlinternalFormat.ml:2990:4>>*/ caml_call2
               (failwith_message(___), str, str$0);
-     throw caml_maybe_attach_backtrace(_$_, 0);
+     throw caml_maybe_attach_backtrace(_aa_, 0);
     }
    }
    var
@@ -20074,6 +20099,7 @@
             : runtime.caml_call_gen(f, [a0, a1, a2, a3, a4, a5]);
    }
     /*<<arg.ml:50:0>>*/ var
+    _y_ = undefined,
     global_data = runtime.caml_get_global_data(),
     cst$6 = "\n",
     cst$3 = cst$7,
@@ -20164,18 +20190,18 @@
      /*<<arg.ml:79:53>>*/ var
      t = l[2],
      h = l[1],
-      /*<<arg.ml:79:53>>*/ _aD_ =
+      /*<<arg.ml:79:53>>*/ _aE_ =
         /*<<arg.ml:79:53>>*/ caml_call2(Stdlib[28], prefix, h);
-    function _aE_(x, y){
+    function _aF_(x, y){
       /*<<arg.ml:79:40>>*/  /*<<arg.ml:79:44>>*/ var
-      _aG_ =  /*<<arg.ml:79:44>>*/ caml_call2(Stdlib[28], sep, y);
+      _aH_ =  /*<<arg.ml:79:44>>*/ caml_call2(Stdlib[28], sep, y);
       /*<<arg.ml:79:44>>*/ return  /*<<arg.ml:79:44>>*/ caml_call2
-             (Stdlib[28], x, _aG_);
+             (Stdlib[28], x, _aH_);
      /*<<arg.ml:79:51>>*/ }
      /*<<arg.ml:79:12>>*/  /*<<arg.ml:79:12>>*/ var
-     _aF_ =  /*<<arg.ml:79:12>>*/ caml_call3(Stdlib_List[25], _aE_, _aD_, t);
+     _aG_ =  /*<<arg.ml:79:12>>*/ caml_call3(Stdlib_List[25], _aF_, _aE_, t);
      /*<<arg.ml:79:12>>*/ return  /*<<arg.ml:79:12>>*/ caml_call2
-            (Stdlib[28], _aF_, suffix);
+            (Stdlib[28], _aG_, suffix);
     /*<<arg.ml:79:77>>*/ }
    function help_action(param){
      /*<<arg.ml:91:21>>*/ throw  /*<<arg.ml:91:21>>*/ caml_maybe_attach_backtrace
@@ -20184,11 +20210,11 @@
    function add_help(speclist){
      /*<<arg.ml:94:2>>*/ try{
       /*<<arg.ml:95:15>>*/ assoc3(cst_help$2, speclist);
-      /*<<arg.ml:95:42>>*/ var  /*<<arg.ml:95:42>>*/ _aA_ = 0, add1 = _aA_;
+      /*<<arg.ml:95:42>>*/ var  /*<<arg.ml:95:42>>*/ _aB_ = 0, add1 = _aB_;
     }
-    catch(_aC_){
-     var _aw_ = caml_wrap_exception(_aC_);
-     if(_aw_ !== Stdlib[8]) throw caml_maybe_attach_backtrace(_aw_, 0);
+    catch(_aD_){
+     var _ax_ = caml_wrap_exception(_aD_);
+     if(_ax_ !== Stdlib[8]) throw caml_maybe_attach_backtrace(_ax_, 0);
      var
       add1 =
         [0,
@@ -20197,11 +20223,11 @@
     }
     try{
       /*<<arg.ml:99:15>>*/ assoc3(cst_help$1, speclist);
-      /*<<arg.ml:99:43>>*/ var  /*<<arg.ml:99:43>>*/ _az_ = 0, add2 = _az_;
+      /*<<arg.ml:99:43>>*/ var  /*<<arg.ml:99:43>>*/ _aA_ = 0, add2 = _aA_;
     }
-    catch(_aB_){
-     var _ax_ = caml_wrap_exception(_aB_);
-     if(_ax_ !== Stdlib[8]) throw caml_maybe_attach_backtrace(_ax_, 0);
+    catch(_aC_){
+     var _ay_ = caml_wrap_exception(_aC_);
+     if(_ay_ !== Stdlib[8]) throw caml_maybe_attach_backtrace(_ay_, 0);
      var
       add2 =
         [0,
@@ -20209,33 +20235,34 @@
          0];
     }
      /*<<arg.ml:103:13>>*/  /*<<arg.ml:103:13>>*/ var
-     _ay_ =  /*<<arg.ml:103:13>>*/ caml_call2(Stdlib[37], add1, add2);
+     _az_ =  /*<<arg.ml:103:13>>*/ caml_call2(Stdlib[37], add1, add2);
      /*<<arg.ml:103:13>>*/ return  /*<<arg.ml:103:13>>*/ caml_call2
-            (Stdlib[37], speclist, _ay_);
+            (Stdlib[37], speclist, _az_);
     /*<<arg.ml:103:26>>*/ }
    function usage_b(buf, speclist, errmsg){
      /*<<arg.ml:107:2>>*/  /*<<arg.ml:107:2>>*/ caml_call3
      (Stdlib_Printf[5], buf, _d_, errmsg);
      /*<<arg.ml:108:29>>*/  /*<<arg.ml:108:29>>*/ var
-     _as_ = add_help(speclist);
-     /*<<arg.ml:108:12>>*/ function _at_(param){
+     _at_ = add_help(speclist);
+     /*<<arg.ml:108:12>>*/ function _au_(param){
      var
       doc = param[3],
       spec = param[2],
       key = param[1],
-      _au_ = 0 <  /*<<arg.ml:83:2>>*/ caml_ml_string_length(doc) ? 1 : 0;
-     if(! _au_) return _au_;
+      _av_ = 0 <  /*<<arg.ml:83:2>>*/ caml_ml_string_length(doc) ? 1 : 0;
+     if(! _av_) return _av_;
      if(11 !== spec[0])
        /*<<arg.ml:88:8>>*/ return  /*<<arg.ml:88:8>>*/ caml_call4
               (Stdlib_Printf[5], buf, _a_, key, doc);
       /*<<arg.ml:86:38>>*/ var
       l = spec[1],
-       /*<<arg.ml:86:38>>*/ _av_ = make_symlist(cst$1, cst$0, cst, l);
+       /*<<arg.ml:86:38>>*/ _aw_ = make_symlist(cst$1, cst$0, cst, l);
       /*<<arg.ml:86:8>>*/ return  /*<<arg.ml:86:8>>*/ caml_call5
-             (Stdlib_Printf[5], buf, _b_, key, _av_, doc);
+             (Stdlib_Printf[5], buf, _b_, key, _aw_, doc);
     }
-     /*<<arg.ml:108:29>>*/ return  /*<<arg.ml:108:29>>*/ caml_call2
-            (Stdlib_List[17], _at_, _as_);
+     /*<<arg.ml:108:29>>*/  /*<<arg.ml:108:29>>*/ caml_call2
+     (Stdlib_List[17], _au_, _at_);
+     /*<<arg.ml:108:29>>*/ return _y_;
     /*<<arg.ml:108:48>>*/ }
    function usage_string(speclist, errmsg){
      /*<<arg.ml:112:2>>*/  /*<<arg.ml:112:10>>*/ var
@@ -20246,33 +20273,33 @@
     /*<<arg.ml:114:19>>*/ }
    function usage(speclist, errmsg){
      /*<<arg.ml:118:2>>*/  /*<<arg.ml:118:15>>*/ var
-     _ar_ = usage_string(speclist, errmsg);
+     _as_ = usage_string(speclist, errmsg);
      /*<<arg.ml:118:15>>*/ return  /*<<arg.ml:118:15>>*/ caml_call2
-            (Stdlib_Printf[3], _e_, _ar_);
+            (Stdlib_Printf[3], _e_, _as_);
     /*<<arg.ml:118:45>>*/ }
     /*<<arg.ml:121:14>>*/  /*<<arg.ml:121:14>>*/ var current = [0, 0];
    function int_of_string_opt(x){
      /*<<arg.ml:128:2>>*/ try{
       /*<<arg.ml:128:6>>*/  /*<<arg.ml:128:6>>*/ var
-      _ap_ = [0,  /*<<arg.ml:128:11>>*/ runtime.caml_int_of_string(x)];
-      /*<<arg.ml:128:6>>*/ return _ap_;
+      _aq_ = [0,  /*<<arg.ml:128:11>>*/ runtime.caml_int_of_string(x)];
+      /*<<arg.ml:128:6>>*/ return _aq_;
     }
-    catch(_aq_){
-     var _ao_ = caml_wrap_exception(_aq_);
-     if(_ao_[1] === Stdlib[7])  /*<<arg.ml:129:20>>*/ return 0;
-     throw caml_maybe_attach_backtrace(_ao_, 0);
+    catch(_ar_){
+     var _ap_ = caml_wrap_exception(_ar_);
+     if(_ap_[1] === Stdlib[7])  /*<<arg.ml:129:20>>*/ return 0;
+     throw caml_maybe_attach_backtrace(_ap_, 0);
     }
     /*<<arg.ml:129:24>>*/ }
    function float_of_string_opt(x){
      /*<<arg.ml:132:2>>*/ try{
       /*<<arg.ml:132:6>>*/  /*<<arg.ml:132:6>>*/ var
-      _am_ = [0,  /*<<arg.ml:132:11>>*/ runtime.caml_float_of_string(x)];
-      /*<<arg.ml:132:6>>*/ return _am_;
+      _an_ = [0,  /*<<arg.ml:132:11>>*/ runtime.caml_float_of_string(x)];
+      /*<<arg.ml:132:6>>*/ return _an_;
     }
-    catch(_an_){
-     var _al_ = caml_wrap_exception(_an_);
-     if(_al_[1] === Stdlib[7])  /*<<arg.ml:133:20>>*/ return 0;
-     throw caml_maybe_attach_backtrace(_al_, 0);
+    catch(_ao_){
+     var _am_ = caml_wrap_exception(_ao_);
+     if(_am_[1] === Stdlib[7])  /*<<arg.ml:133:20>>*/ return 0;
+     throw caml_maybe_attach_backtrace(_am_, 0);
     }
     /*<<arg.ml:133:24>>*/ }
    function parse_and_expand_argv_dynamic_
@@ -20327,8 +20354,8 @@
      if(current[1] >= argv[1].length - 1) return 0;
       /*<<arg.ml:166:4>>*/ try{
        /*<<arg.ml:167:14>>*/ var
-       _Y_ = current[1],
-        /*<<arg.ml:167:14>>*/ s = caml_check_bound(argv[1], _Y_)[1 + _Y_],
+       _Z_ = current[1],
+        /*<<arg.ml:167:14>>*/ s = caml_check_bound(argv[1], _Z_)[1 + _Z_],
        switch$0 = 0;
        /*<<arg.ml:168:33>>*/ if
        (1 <=  /*<<arg.ml:168:6>>*/ caml_ml_string_length(s)
@@ -20336,13 +20363,13 @@
        try{
          /*<<arg.ml:170:14>>*/ var
          follow$1 = 0,
-          /*<<arg.ml:170:14>>*/ _aa_ = assoc3(s, speclist[1]),
+          /*<<arg.ml:170:14>>*/ _ab_ = assoc3(s, speclist[1]),
          follow$0 = follow$1,
-         action = _aa_;
+         action = _ab_;
        }
-       catch(_aj_){
-        var _Z_ = caml_wrap_exception(_aj_);
-        if(_Z_ !== Stdlib[8]) throw caml_maybe_attach_backtrace(_Z_, 0);
+       catch(_ak_){
+        var ___ = caml_wrap_exception(_ak_);
+        if(___ !== Stdlib[8]) throw caml_maybe_attach_backtrace(___, 0);
          /*<<arg.ml:172:10>>*/ try{
           /*<<arg.ml:71:10>>*/ var
            /*<<arg.ml:71:10>>*/ i =
@@ -20355,16 +20382,16 @@
            /*<<arg.ml:73:2>>*/ keyword =
              /*<<arg.ml:73:2>>*/ caml_call3(Stdlib_String[15], s, 0, i),
            /*<<arg.ml:174:38>>*/ follow = [0, arg],
-           /*<<arg.ml:174:12>>*/ _$_ = assoc3(keyword, speclist[1]),
+           /*<<arg.ml:174:12>>*/ _aa_ = assoc3(keyword, speclist[1]),
           follow$0 = follow,
-          action = _$_;
+          action = _aa_;
         }
-        catch(_ak_){
-         var ___ = caml_wrap_exception(_ak_);
-         if(___ === Stdlib[8])
+        catch(_al_){
+         var _$_ = caml_wrap_exception(_al_);
+         if(_$_ === Stdlib[8])
            /*<<arg.ml:175:28>>*/ throw  /*<<arg.ml:175:28>>*/ caml_maybe_attach_backtrace
                  ([0, Stop, [0, s]], 1);
-         throw caml_maybe_attach_backtrace(___, 0);
+         throw caml_maybe_attach_backtrace(_$_, 0);
         }
        }
        var
@@ -20372,7 +20399,7 @@
           function(s, follow){
            function no_arg(param){
              /*<<arg.ml:178:10>>*/ if(! follow)
-              /*<<arg.ml:179:20>>*/ return 0;
+              /*<<arg.ml:179:20>>*/ return _y_;
             var arg = follow[1];
              /*<<arg.ml:180:24>>*/ throw  /*<<arg.ml:180:24>>*/ caml_maybe_attach_backtrace
                    ([0, Stop, [1, s, arg, cst_no_argument]], 1);
@@ -20390,9 +20417,9 @@
             if((current[1] + 1 | 0) >= argv[1].length - 1)
               /*<<arg.ml:185:19>>*/ throw  /*<<arg.ml:185:19>>*/ caml_maybe_attach_backtrace
                     ([0, Stop, [2, s]], 1);
-            var _ai_ = current[1] + 1 | 0;
-             /*<<arg.ml:184:58>>*/ return caml_check_bound(argv[1], _ai_)
-                    [1 + _ai_];
+            var _aj_ = current[1] + 1 | 0;
+             /*<<arg.ml:184:58>>*/ return caml_check_bound(argv[1], _aj_)
+                    [1 + _aj_];
             /*<<arg.ml:186:27>>*/ }
            return get_arg;
           },
@@ -20420,14 +20447,14 @@
                  /*<<arg.ml:196:22>>*/ arg = get_arg(0);
                 /*<<arg.ml:124:2>>*/ try{
                  /*<<arg.ml:124:6>>*/ var
-                  /*<<arg.ml:124:6>>*/ _ac_ =
+                  /*<<arg.ml:124:6>>*/ _ad_ =
                    [0,  /*<<arg.ml:124:11>>*/ caml_call1(Stdlib[32], arg)],
-                 match = _ac_;
+                 match = _ad_;
                }
-               catch(_ah_){
-                var _ab_ = caml_wrap_exception(_ah_);
-                if(_ab_[1] !== Stdlib[6])
-                 throw caml_maybe_attach_backtrace(_ab_, 0);
+               catch(_ai_){
+                var _ac_ = caml_wrap_exception(_ai_);
+                if(_ac_[1] !== Stdlib[6])
+                 throw caml_maybe_attach_backtrace(_ac_, 0);
                 var match = 0;
                }
                if(! match)
@@ -20522,7 +20549,7 @@
                  /*<<arg.ml:211:14>>*/ return consume_arg(0);
                }
                 /*<<arg.ml:215:44>>*/  /*<<arg.ml:215:44>>*/ var
-                _ad_ = make_symlist(cst$5, cst$4, cst$3, symb);
+                _ae_ = make_symlist(cst$5, cst$4, cst$3, symb);
                 /*<<arg.ml:213:21>>*/ throw  /*<<arg.ml:213:21>>*/ caml_maybe_attach_backtrace
                       ([0,
                         Stop,
@@ -20530,16 +20557,16 @@
                          s,
                          arg$5,
                           /*<<arg.ml:214:42>>*/ caml_call2
-                          (Stdlib[28], cst_one_of, _ad_)]],
+                          (Stdlib[28], cst_one_of, _ae_)]],
                        1);
               case 12:
                var f$5 = param[1];
                 /*<<arg.ml:252:12>>*/ no_arg(0);
                 /*<<arg.ml:255:14>>*/ for(;;){
                 if(current[1] >= (argv[1].length - 1 - 1 | 0)) return 0;
-                var _ae_ = current[1] + 1 | 0;
+                var _af_ = current[1] + 1 | 0;
                  /*<<arg.ml:254:14>>*/  /*<<arg.ml:254:14>>*/ caml_call1
-                 (f$5, caml_check_bound(argv[1], _ae_)[1 + _ae_]);
+                 (f$5, caml_check_bound(argv[1], _af_)[1 + _af_]);
                  /*<<arg.ml:255:14>>*/ consume_arg(0);
                }
               case 13:
@@ -20551,8 +20578,8 @@
                   /*<<arg.ml:264:14>>*/ return  /*<<arg.ml:264:14>>*/ caml_call1
                          (f$6,
                            /*<<arg.ml:264:14>>*/ caml_call1(Stdlib_List[9], acc[1]));
-                var _ag_ = current[1] + 1 | 0, _af_ = acc[1];
-                acc[1] = [0, caml_check_bound(argv[1], _ag_)[1 + _ag_], _af_];
+                var _ah_ = current[1] + 1 | 0, _ag_ = acc[1];
+                acc[1] = [0, caml_check_bound(argv[1], _ah_)[1 + _ah_], _ag_];
                  /*<<arg.ml:262:14>>*/ consume_arg(0);
                }
               default:
@@ -20629,8 +20656,8 @@
    function parse(l, f, msg){
      /*<<arg.ml:299:2>>*/ try{
       /*<<arg.ml:300:4>>*/  /*<<arg.ml:300:4>>*/ var
-      _X_ = parse_argv(0, caml_sys_argv(0), l, f, msg);
-      /*<<arg.ml:300:4>>*/ return _X_;
+      _Y_ = parse_argv(0, caml_sys_argv(0), l, f, msg);
+      /*<<arg.ml:300:4>>*/ return _Y_;
     }
     catch(exn$0){
      var exn = caml_wrap_exception(exn$0);
@@ -20652,8 +20679,8 @@
    function parse_dynamic(l, f, msg){
      /*<<arg.ml:307:2>>*/ try{
       /*<<arg.ml:308:4>>*/  /*<<arg.ml:308:4>>*/ var
-      _W_ = parse_argv_dynamic(0, caml_sys_argv(0), l, f, msg);
-      /*<<arg.ml:308:4>>*/ return _W_;
+      _X_ = parse_argv_dynamic(0, caml_sys_argv(0), l, f, msg);
+      /*<<arg.ml:308:4>>*/ return _X_;
     }
     catch(exn$0){
      var exn = caml_wrap_exception(exn$0);
@@ -20678,9 +20705,9 @@
        /*<<arg.ml:315:15>>*/ argv = [0, caml_sys_argv(0)],
        /*<<arg.ml:316:15>>*/ spec = [0, l],
        /*<<arg.ml:317:18>>*/ current$0 = [0, current[1]],
-       /*<<arg.ml:318:4>>*/ _V_ =
+       /*<<arg.ml:318:4>>*/ _W_ =
         parse_and_expand_argv_dynamic(current$0, argv, spec, f, msg);
-      /*<<arg.ml:318:4>>*/ return _V_;
+      /*<<arg.ml:318:4>>*/ return _W_;
     }
     catch(exn$0){
      var exn = caml_wrap_exception(exn$0);
@@ -20717,17 +20744,17 @@
       /*<<arg.ml:331:8>>*/  /*<<arg.ml:331:8>>*/ var
       n$0 =  /*<<arg.ml:331:8>>*/ caml_call2(Stdlib_String[35], s, 9);
     }
-    catch(_T_){
-     var _R_ = caml_wrap_exception(_T_);
-     if(_R_ !== Stdlib[8]) throw caml_maybe_attach_backtrace(_R_, 0);
+    catch(_U_){
+     var _S_ = caml_wrap_exception(_U_);
+     if(_S_ !== Stdlib[8]) throw caml_maybe_attach_backtrace(_S_, 0);
       /*<<arg.ml:334:6>>*/ try{
        /*<<arg.ml:334:18>>*/  /*<<arg.ml:334:18>>*/ var
        n =  /*<<arg.ml:334:18>>*/ caml_call2(Stdlib_String[35], s, 32);
      }
-     catch(_U_){
-      var _S_ = caml_wrap_exception(_U_);
-      if(_S_ === Stdlib[8])  /*<<arg.ml:336:31>>*/ return len;
-      throw caml_maybe_attach_backtrace(_S_, 0);
+     catch(_V_){
+      var _T_ = caml_wrap_exception(_V_);
+      if(_T_ === Stdlib[8])  /*<<arg.ml:336:31>>*/ return len;
+      throw caml_maybe_attach_backtrace(_T_, 0);
      }
       /*<<arg.ml:334:18>>*/ return loop(n + 1 | 0);
     }
@@ -20737,12 +20764,12 @@
     var doc = param[3], spec = param[2], kwd = param[1];
      /*<<arg.ml:341:2>>*/ if(11 === spec[0])
      return caml_call2(Stdlib_Int[11], cur, caml_ml_string_length(kwd));
-    var _Q_ = caml_ml_string_length(kwd) + second_word(doc) | 0;
-    return caml_call2(Stdlib_Int[11], cur, _Q_);
+    var _R_ = caml_ml_string_length(kwd) + second_word(doc) | 0;
+    return caml_call2(Stdlib_Int[11], cur, _R_);
    }
    function replace_leading_tab(s){
      /*<<arg.ml:347:2>>*/  /*<<arg.ml:347:13>>*/ var seen = [0, 0];
-    function _P_(c){
+    function _Q_(c){
       /*<<arg.ml:348:13>>*/ if(9 === c && ! seen[1]){
       seen[1] = 1;
        /*<<arg.ml:348:60>>*/ return 32;
@@ -20750,7 +20777,7 @@
       /*<<arg.ml:348:71>>*/ return c;
      /*<<arg.ml:348:73>>*/ }
      /*<<arg.ml:348:2>>*/ return  /*<<arg.ml:348:2>>*/ caml_call2
-            (Stdlib_String[17], _P_, s);
+            (Stdlib_String[17], _Q_, s);
     /*<<arg.ml:348:75>>*/ }
    function align(opt, speclist){
      /*<<arg.ml:374:2>>*/ if(opt)
@@ -20764,7 +20791,7 @@
         (Stdlib_List[25], max_arg_len, 0, completed),
       /*<<arg.ml:376:12>>*/ len$0 =
         /*<<arg.ml:376:12>>*/ caml_call2(Stdlib_Int[10], len, limit);
-     /*<<arg.ml:377:11>>*/ function _J_(ksd){
+     /*<<arg.ml:377:11>>*/ function _K_(ksd){
      var kwd = ksd[1], spec = ksd[2];
      if(! caml_string_notequal(ksd[3], cst$7))
        /*<<arg.ml:355:6>>*/ return ksd;
@@ -20772,20 +20799,20 @@
        /*<<arg.ml:357:19>>*/ var
        msg$0 = ksd[3],
         /*<<arg.ml:357:19>>*/ cutcol$0 = second_word(msg$0),
-        /*<<arg.ml:358:32>>*/ _M_ =
+        /*<<arg.ml:358:32>>*/ _N_ =
           /*<<arg.ml:358:32>>*/ caml_call2
           (Stdlib_Int[11], 0, len$0 - cutcol$0 | 0)
          + 3
          | 0,
         /*<<arg.ml:358:19>>*/ spaces$0 =
-          /*<<arg.ml:358:19>>*/ caml_call2(Stdlib_String[1], _M_, 32),
-        /*<<arg.ml:359:34>>*/ _N_ = replace_leading_tab(msg$0),
-        /*<<arg.ml:359:25>>*/ _O_ =
-          /*<<arg.ml:359:25>>*/ caml_call2(Stdlib[28], spaces$0, _N_);
+          /*<<arg.ml:358:19>>*/ caml_call2(Stdlib_String[1], _N_, 32),
+        /*<<arg.ml:359:34>>*/ _O_ = replace_leading_tab(msg$0),
+        /*<<arg.ml:359:25>>*/ _P_ =
+          /*<<arg.ml:359:25>>*/ caml_call2(Stdlib[28], spaces$0, _O_);
        /*<<arg.ml:359:6>>*/ return [0,
               kwd,
               spec,
-               /*<<arg.ml:359:18>>*/ caml_call2(Stdlib[28], cst$6, _O_)];
+               /*<<arg.ml:359:18>>*/ caml_call2(Stdlib[28], cst$6, _P_)];
      }
       /*<<arg.ml:361:19>>*/ var
       msg = ksd[3],
@@ -20799,24 +20826,24 @@
       /*<<arg.ml:367:21>>*/ var
        /*<<arg.ml:367:21>>*/ spaces =
          /*<<arg.ml:367:21>>*/ caml_call2(Stdlib_String[1], diff, 32),
-       /*<<arg.ml:368:32>>*/ _K_ = replace_leading_tab(msg),
+       /*<<arg.ml:368:32>>*/ _L_ = replace_leading_tab(msg),
        /*<<arg.ml:368:21>>*/ prefix =
-         /*<<arg.ml:368:21>>*/ caml_call3(Stdlib_String[15], _K_, 0, cutcol),
+         /*<<arg.ml:368:21>>*/ caml_call3(Stdlib_String[15], _L_, 0, cutcol),
        /*<<arg.ml:369:21>>*/ suffix =
          /*<<arg.ml:369:21>>*/ caml_call3
          (Stdlib_String[15],
           msg,
           cutcol,
           caml_ml_string_length(msg) - cutcol | 0),
-       /*<<arg.ml:370:29>>*/ _L_ =
+       /*<<arg.ml:370:29>>*/ _M_ =
          /*<<arg.ml:370:29>>*/ caml_call2(Stdlib[28], spaces, suffix);
       /*<<arg.ml:370:8>>*/ return [0,
              kwd,
              spec$0,
-              /*<<arg.ml:370:20>>*/ caml_call2(Stdlib[28], prefix, _L_)];
+              /*<<arg.ml:370:20>>*/ caml_call2(Stdlib[28], prefix, _M_)];
     }
      /*<<arg.ml:377:2>>*/ return  /*<<arg.ml:377:2>>*/ caml_call2
-            (Stdlib_List[19], _J_, completed);
+            (Stdlib_List[19], _K_, completed);
     /*<<arg.ml:377:38>>*/ }
    function read_aux(trim, sep, file){
      /*<<arg.ml:387:2>>*/ var
@@ -20834,19 +20861,20 @@
        (0 < len
         && 13 ===  /*<<arg.ml:381:16>>*/ caml_string_get(word, len - 1 | 0)){
        var
-        _I_ =
+        _J_ =
            /*<<arg.ml:382:4>>*/ caml_call3
            (Stdlib_String[15], word, 0, len - 1 | 0);
        switch$0 = 1;
       }
-      if(! switch$0) var _I_ = word;
-      var word$0 = _I_;
+      if(! switch$0) var _J_ = word;
+      var word$0 = _J_;
      }
      else
       var word$0 = word;
      words[1] = [0, word$0, words[1]];
-      /*<<arg.ml:390:2>>*/ return  /*<<arg.ml:390:2>>*/ caml_call1
-             (Stdlib_Buffer[8], buf);
+      /*<<arg.ml:390:2>>*/  /*<<arg.ml:390:2>>*/ caml_call1
+      (Stdlib_Buffer[8], buf);
+      /*<<arg.ml:390:2>>*/ return _y_;
      /*<<arg.ml:394:20>>*/ }
      /*<<arg.ml:396:2>>*/ try{
      for(;;){
@@ -20859,45 +20887,45 @@
         (Stdlib_Buffer[12], buf, c);
      }
     }
-    catch(_H_){
-     var _F_ = caml_wrap_exception(_H_);
-     if(_F_ !== Stdlib[12]) throw caml_maybe_attach_backtrace(_F_, 0);
+    catch(_I_){
+     var _G_ = caml_wrap_exception(_I_);
+     if(_G_ !== Stdlib[12]) throw caml_maybe_attach_backtrace(_G_, 0);
      if(0 <  /*<<arg.ml:403:5>>*/ caml_call1(Stdlib_Buffer[7], buf))
        /*<<arg.ml:403:32>>*/ stash(0);
       /*<<arg.ml:404:2>>*/  /*<<arg.ml:404:2>>*/ caml_call1(Stdlib[93], ic);
       /*<<arg.ml:405:16>>*/  /*<<arg.ml:405:16>>*/ var
-      _G_ =  /*<<arg.ml:405:16>>*/ caml_call1(Stdlib_List[9], words[1]);
+      _H_ =  /*<<arg.ml:405:16>>*/ caml_call1(Stdlib_List[9], words[1]);
       /*<<arg.ml:405:16>>*/ return  /*<<arg.ml:405:16>>*/ caml_call1
-             (Stdlib_Array[10], _G_);
+             (Stdlib_Array[10], _H_);
     }
     /*<<arg.ml:405:33>>*/ }
    var _r_ = 10, _s_ = 1;
-    /*<<arg.ml:407:15>>*/ function read_arg(_E_){
-     /*<<?>>*/ return read_aux(_s_, _r_, _E_);
+    /*<<arg.ml:407:15>>*/ function read_arg(_F_){
+     /*<<?>>*/ return read_aux(_s_, _r_, _F_);
    }
     /*<<arg.ml:407:15>>*/ var  /*<<arg.ml:407:15>>*/ _t_ = 0, _u_ = 0;
-    /*<<arg.ml:409:16>>*/ function read_arg0(_D_){
-     /*<<?>>*/ return read_aux(_u_, _t_, _D_);
+    /*<<arg.ml:409:16>>*/ function read_arg0(_E_){
+     /*<<?>>*/ return read_aux(_u_, _t_, _E_);
    }
    function write_aux(sep, file, args){
      /*<<arg.ml:412:2>>*/  /*<<arg.ml:412:11>>*/ var
      oc =  /*<<arg.ml:412:11>>*/ caml_call1(Stdlib[61], file);
-    function _C_(s){
+    function _D_(s){
       /*<<arg.ml:413:23>>*/ return caml_call4
              (Stdlib_Printf[1], oc, _v_, s, sep);
      /*<<arg.ml:413:46>>*/ }
      /*<<arg.ml:413:2>>*/  /*<<arg.ml:413:2>>*/ caml_call2
-     (Stdlib_Array[11], _C_, args);
+     (Stdlib_Array[11], _D_, args);
      /*<<arg.ml:413:2>>*/ return  /*<<arg.ml:413:2>>*/ caml_call1
             (Stdlib[76], oc);
     /*<<arg.ml:414:14>>*/ }
    var _w_ = 10;
-    /*<<arg.ml:416:16>>*/ function write_arg(_A_, _B_){
-     /*<<?>>*/ return write_aux(_w_, _A_, _B_);
+    /*<<arg.ml:416:16>>*/ function write_arg(_B_, _C_){
+     /*<<?>>*/ return write_aux(_w_, _B_, _C_);
    }
     /*<<arg.ml:416:16>>*/  /*<<arg.ml:416:16>>*/ var _x_ = 0;
-    /*<<arg.ml:418:17>>*/ function write_arg0(_y_, _z_){
-     /*<<?>>*/ return write_aux(_x_, _y_, _z_);
+    /*<<arg.ml:418:17>>*/ function write_arg0(_z_, _A_){
+     /*<<?>>*/ return write_aux(_x_, _z_, _A_);
    }
    var
     Stdlib_Arg =
@@ -21564,6 +21592,7 @@
     global_data = runtime.caml_get_global_data(),
     Stdlib_Printexc = global_data.Stdlib__Printexc,
     Stdlib = global_data.Stdlib,
+    _b_ = undefined,
     cst_Fun_Finally_raised = "Fun.Finally_raised: ",
     cst_Stdlib_Fun_Finally_raised = "Stdlib.Fun.Finally_raised";
    function const$0(c, param){
@@ -21594,8 +21623,7 @@
    function protect(finally$0, work){
     function finally_no_exn(param){
       /*<<fun.ml:29:4>>*/ try{
-       /*<<fun.ml:29:8>>*/  /*<<fun.ml:29:8>>*/ var
-       _b_ =  /*<<fun.ml:29:8>>*/ caml_call1(finally$0, 0);
+       /*<<fun.ml:29:8>>*/  /*<<fun.ml:29:8>>*/ caml_call1(finally$0, 0);
        /*<<fun.ml:29:8>>*/ return _b_;
      }
      catch(e$0){
@@ -22054,6 +22082,7 @@
             : runtime.caml_call_gen(f, [a0, a1, a2]);
    }
    var
+    _a_ = undefined,
     global_data = runtime.caml_get_global_data(),
     Stdlib = global_data.Stdlib,
     Stdlib_Array = global_data.Stdlib__Array,
@@ -22112,45 +22141,49 @@
      /*<<bigarray.ml:73:4>>*/ c_layout = 0,
     fortran_layout = 1;
    function cloop(arr, idx, f, col, max){
-     /*<<bigarray.ml:104:4>>*/ if(col === idx.length - 1)
-      /*<<bigarray.ml:104:35>>*/ return  /*<<bigarray.ml:104:35>>*/ caml_ba_set_generic
-             (arr, idx,  /*<<bigarray.ml:104:47>>*/ caml_call1(f, idx));
+     /*<<bigarray.ml:104:4>>*/ if(col === idx.length - 1){
+      /*<<bigarray.ml:104:35>>*/  /*<<bigarray.ml:104:35>>*/ caml_ba_set_generic
+      (arr, idx,  /*<<bigarray.ml:104:47>>*/ caml_call1(f, idx));
+      /*<<bigarray.ml:104:35>>*/ return _a_;
+    }
      /*<<bigarray.ml:105:27>>*/ var
-      /*<<bigarray.ml:105:27>>*/ _am_ =
+      /*<<bigarray.ml:105:27>>*/ _an_ =
        caml_check_bound(max, col)[1 + col] - 1 | 0,
-      /*<<bigarray.ml:105:9>>*/ _al_ = 0;
-    if(_am_ >= 0){
-     var j = _al_;
+      /*<<bigarray.ml:105:9>>*/ _am_ = 0;
+    if(_an_ >= 0){
+     var j = _am_;
      for(;;){
        /*<<bigarray.ml:106:11>>*/ caml_check_bound(idx, col)[1 + col] = j;
        /*<<bigarray.ml:107:11>>*/ cloop(arr, idx, f, col + 1 | 0, max);
        /*<<bigarray.ml:107:11>>*/  /*<<bigarray.ml:107:11>>*/ var
-       _an_ = j + 1 | 0;
-      if(_am_ !== j){var j = _an_; continue;}
+       _ao_ = j + 1 | 0;
+      if(_an_ !== j){var j = _ao_; continue;}
       break;
      }
     }
-    return 0;
+    return _a_;
     /*<<bigarray.ml:108:13>>*/ }
    function floop(arr, idx, f, col, max){
-     /*<<bigarray.ml:110:4>>*/ if(0 > col)
-      /*<<bigarray.ml:110:20>>*/ return  /*<<bigarray.ml:110:20>>*/ caml_ba_set_generic
-             (arr, idx,  /*<<bigarray.ml:110:32>>*/ caml_call1(f, idx));
+     /*<<bigarray.ml:110:4>>*/ if(0 > col){
+      /*<<bigarray.ml:110:20>>*/  /*<<bigarray.ml:110:20>>*/ caml_ba_set_generic
+      (arr, idx,  /*<<bigarray.ml:110:32>>*/ caml_call1(f, idx));
+      /*<<bigarray.ml:110:20>>*/ return _a_;
+    }
      /*<<bigarray.ml:111:22>>*/ var
-      /*<<bigarray.ml:111:22>>*/ _aj_ = caml_check_bound(max, col)[1 + col],
-      /*<<bigarray.ml:111:9>>*/ _ai_ = 1;
-    if(_aj_ >= 1){
-     var j = _ai_;
+      /*<<bigarray.ml:111:22>>*/ _ak_ = caml_check_bound(max, col)[1 + col],
+      /*<<bigarray.ml:111:9>>*/ _aj_ = 1;
+    if(_ak_ >= 1){
+     var j = _aj_;
      for(;;){
        /*<<bigarray.ml:112:11>>*/ caml_check_bound(idx, col)[1 + col] = j;
        /*<<bigarray.ml:113:11>>*/ floop(arr, idx, f, col - 1 | 0, max);
        /*<<bigarray.ml:113:11>>*/  /*<<bigarray.ml:113:11>>*/ var
-       _ak_ = j + 1 | 0;
-      if(_aj_ !== j){var j = _ak_; continue;}
+       _al_ = j + 1 | 0;
+      if(_ak_ !== j){var j = _al_; continue;}
       break;
      }
     }
-    return 0;
+    return _a_;
     /*<<bigarray.ml:114:13>>*/ }
    function init(kind, layout, dims, f){
      /*<<bigarray.ml:116:4>>*/ var
@@ -22179,17 +22212,17 @@
         /*<<bigarray.ml:125:12>>*/ caml_ba_num_dims(a),
       /*<<bigarray.ml:126:12>>*/ d =
         /*<<bigarray.ml:126:12>>*/ caml_make_vect(n, 0),
-      /*<<bigarray.ml:127:4>>*/ _af_ = n - 1 | 0,
-      /*<<bigarray.ml:126:12>>*/ _ae_ = 0;
-    if(_af_ >= 0){
-     var i = _ae_;
+      /*<<bigarray.ml:127:4>>*/ _ag_ = n - 1 | 0,
+      /*<<bigarray.ml:126:12>>*/ _af_ = 0;
+    if(_ag_ >= 0){
+     var i = _af_;
      for(;;){
        /*<<bigarray.ml:127:33>>*/  /*<<bigarray.ml:127:33>>*/ var
-       _ag_ =  /*<<bigarray.ml:127:33>>*/ runtime.caml_ba_dim(a, i);
-       /*<<bigarray.ml:127:24>>*/ caml_check_bound(d, i)[1 + i] = _ag_;
+       _ah_ =  /*<<bigarray.ml:127:33>>*/ runtime.caml_ba_dim(a, i);
+       /*<<bigarray.ml:127:24>>*/ caml_check_bound(d, i)[1 + i] = _ah_;
        /*<<bigarray.ml:127:24>>*/  /*<<bigarray.ml:127:24>>*/ var
-       _ah_ = i + 1 | 0;
-      if(_af_ !== i){var i = _ah_; continue;}
+       _ai_ = i + 1 | 0;
+      if(_ag_ !== i){var i = _ai_; continue;}
       break;
      }
     }
@@ -22197,13 +22230,13 @@
     /*<<bigarray.ml:128:5>>*/ }
    function size_in_bytes(arr){
      /*<<bigarray.ml:136:4>>*/ var
-      /*<<bigarray.ml:136:63>>*/ _ac_ = dims(arr),
-      /*<<bigarray.ml:136:38>>*/ _ad_ =
+      /*<<bigarray.ml:136:63>>*/ _ad_ = dims(arr),
+      /*<<bigarray.ml:136:38>>*/ _ae_ =
         /*<<bigarray.ml:136:38>>*/ caml_call3
-        (Stdlib_Array[15], caml_mul, 1, _ac_);
+        (Stdlib_Array[15], caml_mul, 1, _ad_);
      /*<<bigarray.ml:136:4>>*/ return  /*<<bigarray.ml:136:4>>*/ caml_mul
             (kind_size_in_bytes( /*<<bigarray.ml:136:24>>*/ caml_ba_kind(arr)),
-             _ad_);
+             _ae_);
     /*<<bigarray.ml:136:74>>*/ }
    function create(kind, layout){
      /*<<bigarray.ml:157:4>>*/ return  /*<<bigarray.ml:157:4>>*/ caml_ba_create
@@ -22214,9 +22247,9 @@
             (arr, [0]);
     /*<<bigarray.ml:158:37>>*/ }
    function set(arr){
-     /*<<bigarray.ml:159:16>>*/  /*<<bigarray.ml:159:16>>*/ var _aa_ = [0];
-     /*<<bigarray.ml:159:33>>*/ return function(_ab_){
-      /*<<?>>*/ return caml_ba_set_generic(arr, _aa_, _ab_);};
+     /*<<bigarray.ml:159:16>>*/  /*<<bigarray.ml:159:16>>*/ var _ab_ = [0];
+     /*<<bigarray.ml:159:33>>*/ return function(_ac_){
+      /*<<?>>*/ return caml_ba_set_generic(arr, _ab_, _ac_);};
     /*<<bigarray.ml:159:37>>*/ }
    function size_in_bytes$0(arr){
      /*<<bigarray.ml:166:26>>*/ return kind_size_in_bytes
@@ -22234,10 +22267,10 @@
     /*<<bigarray.ml:181:39>>*/ }
    function size_in_bytes$1(arr){
      /*<<bigarray.ml:195:4>>*/  /*<<bigarray.ml:195:38>>*/ var
-     _$_ =  /*<<bigarray.ml:195:38>>*/ caml_ba_dim_1(arr);
+     _aa_ =  /*<<bigarray.ml:195:38>>*/ caml_ba_dim_1(arr);
      /*<<bigarray.ml:195:4>>*/ return  /*<<bigarray.ml:195:4>>*/ caml_mul
             (kind_size_in_bytes( /*<<bigarray.ml:195:24>>*/ caml_ba_kind(arr)),
-             _$_);
+             _aa_);
     /*<<bigarray.ml:195:47>>*/ }
    function slice(a, n){
      /*<<bigarray.ml:199:4>>*/ return  /*<<bigarray.ml:199:10>>*/ runtime.caml_ba_layout
@@ -22249,31 +22282,31 @@
      /*<<bigarray.ml:209:4>>*/  /*<<bigarray.ml:209:14>>*/ var
      arr = create$0(kind, layout, dim);
      /*<<bigarray.ml:210:4>>*/ if(layout){
-      /*<<bigarray.ml:207:4>>*/  /*<<bigarray.ml:207:4>>*/ var _Z_ = 1;
+      /*<<bigarray.ml:207:4>>*/  /*<<bigarray.ml:207:4>>*/ var ___ = 1;
      if(dim >= 1){
-      var i$0 = _Z_;
+      var i$0 = ___;
       for(;;){
         /*<<bigarray.ml:207:24>>*/  /*<<bigarray.ml:207:24>>*/ caml_ba_set_1
         (arr, i$0,  /*<<bigarray.ml:207:41>>*/ caml_call1(f, i$0));
         /*<<bigarray.ml:207:24>>*/  /*<<bigarray.ml:207:24>>*/ var
-        ___ = i$0 + 1 | 0;
-       if(dim !== i$0){var i$0 = ___; continue;}
+        _$_ = i$0 + 1 | 0;
+       if(dim !== i$0){var i$0 = _$_; continue;}
        break;
       }
      }
       /*<<bigarray.ml:212:24>>*/ return arr;
     }
      /*<<bigarray.ml:205:4>>*/ var
-     _X_ = dim - 1 | 0,
-      /*<<bigarray.ml:205:4>>*/ _W_ = 0;
-    if(_X_ >= 0){
-     var i = _W_;
+     _Y_ = dim - 1 | 0,
+      /*<<bigarray.ml:205:4>>*/ _X_ = 0;
+    if(_Y_ >= 0){
+     var i = _X_;
      for(;;){
        /*<<bigarray.ml:205:29>>*/  /*<<bigarray.ml:205:29>>*/ caml_ba_set_1
        (arr, i,  /*<<bigarray.ml:205:46>>*/ caml_call1(f, i));
        /*<<bigarray.ml:205:29>>*/  /*<<bigarray.ml:205:29>>*/ var
-       _Y_ = i + 1 | 0;
-      if(_X_ !== i){var i = _Y_; continue;}
+       _Z_ = i + 1 | 0;
+      if(_Y_ !== i){var i = _Z_; continue;}
       break;
      }
     }
@@ -22283,16 +22316,16 @@
      /*<<bigarray.ml:214:4>>*/ var
       /*<<bigarray.ml:214:13>>*/ ba = create$0(kind, layout, data.length - 1),
       /*<<bigarray.ml:215:4>>*/ ofs = layout ? 1 : 0,
-     _U_ = data.length - 1 - 1 | 0,
-     _T_ = 0;
-    if(_U_ >= 0){
-     var i = _T_;
+     _V_ = data.length - 1 - 1 | 0,
+     _U_ = 0;
+    if(_V_ >= 0){
+     var i = _U_;
      for(;;){
        /*<<bigarray.ml:220:42>>*/  /*<<bigarray.ml:220:42>>*/ caml_ba_set_1
        (ba, i + ofs | 0, caml_check_bound(data, i)[1 + i]);
        /*<<bigarray.ml:220:42>>*/  /*<<bigarray.ml:220:42>>*/ var
-       _V_ = i + 1 | 0;
-      if(_U_ !== i){var i = _V_; continue;}
+       _W_ = i + 1 | 0;
+      if(_V_ !== i){var i = _W_; continue;}
       break;
      }
     }
@@ -22304,16 +22337,16 @@
     /*<<bigarray.ml:227:46>>*/ }
    function size_in_bytes$2(arr){
      /*<<bigarray.ml:243:4>>*/ var
-      /*<<bigarray.ml:243:51>>*/ _R_ =
+      /*<<bigarray.ml:243:51>>*/ _S_ =
         /*<<bigarray.ml:243:51>>*/ caml_ba_dim_2(arr),
-      /*<<bigarray.ml:243:38>>*/ _S_ =
+      /*<<bigarray.ml:243:38>>*/ _T_ =
         /*<<bigarray.ml:243:38>>*/ caml_ba_dim_1(arr);
     return caml_mul
             ( /*<<bigarray.ml:243:4>>*/ caml_mul
               (kind_size_in_bytes
                 ( /*<<bigarray.ml:243:24>>*/ caml_ba_kind(arr)),
-               _S_),
-             _R_);
+               _T_),
+             _S_);
     /*<<bigarray.ml:243:61>>*/ }
    function slice_left(a, n){
      /*<<bigarray.ml:250:23>>*/ return  /*<<bigarray.ml:250:23>>*/ caml_ba_slice
@@ -22327,53 +22360,53 @@
      /*<<bigarray.ml:267:4>>*/  /*<<bigarray.ml:267:14>>*/ var
      arr = create$1(kind, layout, dim1, dim2);
      /*<<bigarray.ml:268:4>>*/ if(layout){
-      /*<<bigarray.ml:261:4>>*/  /*<<bigarray.ml:261:4>>*/ var _N_ = 1;
+      /*<<bigarray.ml:261:4>>*/  /*<<bigarray.ml:261:4>>*/ var _O_ = 1;
      if(dim2 >= 1){
-      var j$0 = _N_;
+      var j$0 = _O_;
       for(;;){
-        /*<<bigarray.ml:262:6>>*/  /*<<bigarray.ml:262:6>>*/ var _O_ = 1;
+        /*<<bigarray.ml:262:6>>*/  /*<<bigarray.ml:262:6>>*/ var _P_ = 1;
        if(dim1 >= 1){
-        var i$0 = _O_;
+        var i$0 = _P_;
         for(;;){
           /*<<bigarray.ml:263:8>>*/  /*<<bigarray.ml:263:8>>*/ caml_ba_set_2
           (arr, i$0, j$0,  /*<<bigarray.ml:263:27>>*/ caml_call2(f, i$0, j$0));
           /*<<bigarray.ml:263:8>>*/  /*<<bigarray.ml:263:8>>*/ var
-          _Q_ = i$0 + 1 | 0;
-         if(dim1 !== i$0){var i$0 = _Q_; continue;}
+          _R_ = i$0 + 1 | 0;
+         if(dim1 !== i$0){var i$0 = _R_; continue;}
          break;
         }
        }
         /*<<bigarray.ml:261:4>>*/  /*<<bigarray.ml:261:4>>*/ var
-        _P_ = j$0 + 1 | 0;
-       if(dim2 !== j$0){var j$0 = _P_; continue;}
+        _Q_ = j$0 + 1 | 0;
+       if(dim2 !== j$0){var j$0 = _Q_; continue;}
        break;
       }
      }
       /*<<bigarray.ml:270:24>>*/ return arr;
     }
      /*<<bigarray.ml:255:4>>*/ var
-     _I_ = dim1 - 1 | 0,
-      /*<<bigarray.ml:255:4>>*/ _H_ = 0;
-    if(_I_ >= 0){
-     var i = _H_;
+     _J_ = dim1 - 1 | 0,
+      /*<<bigarray.ml:255:4>>*/ _I_ = 0;
+    if(_J_ >= 0){
+     var i = _I_;
      for(;;){
        /*<<bigarray.ml:256:6>>*/ var
-       _K_ = dim2 - 1 | 0,
-        /*<<bigarray.ml:256:6>>*/ _J_ = 0;
-      if(_K_ >= 0){
-       var j = _J_;
+       _L_ = dim2 - 1 | 0,
+        /*<<bigarray.ml:256:6>>*/ _K_ = 0;
+      if(_L_ >= 0){
+       var j = _K_;
        for(;;){
          /*<<bigarray.ml:257:8>>*/  /*<<bigarray.ml:257:8>>*/ caml_ba_set_2
          (arr, i, j,  /*<<bigarray.ml:257:27>>*/ caml_call2(f, i, j));
          /*<<bigarray.ml:257:8>>*/  /*<<bigarray.ml:257:8>>*/ var
-         _M_ = j + 1 | 0;
-        if(_K_ !== j){var j = _M_; continue;}
+         _N_ = j + 1 | 0;
+        if(_L_ !== j){var j = _N_; continue;}
         break;
        }
       }
        /*<<bigarray.ml:255:4>>*/  /*<<bigarray.ml:255:4>>*/ var
-       _L_ = i + 1 | 0;
-      if(_I_ !== i){var i = _L_; continue;}
+       _M_ = i + 1 | 0;
+      if(_J_ !== i){var i = _M_; continue;}
       break;
      }
     }
@@ -22386,10 +22419,10 @@
        0 === dim1 ? 0 : caml_check_bound(data, 0)[1].length - 1,
       /*<<bigarray.ml:274:13>>*/ ba = create$1(kind, layout, dim1, dim2),
       /*<<bigarray.ml:275:4>>*/ ofs = layout ? 1 : 0,
-      /*<<bigarray.ml:280:4>>*/ _C_ = dim1 - 1 | 0,
-     _B_ = 0;
-    if(_C_ >= 0){
-     var i = _B_;
+      /*<<bigarray.ml:280:4>>*/ _D_ = dim1 - 1 | 0,
+     _C_ = 0;
+    if(_D_ >= 0){
+     var i = _C_;
      for(;;){
        /*<<bigarray.ml:281:16>>*/  /*<<bigarray.ml:281:16>>*/ var
        row = caml_check_bound(data, i)[1 + i];
@@ -22397,22 +22430,22 @@
         /*<<bigarray.ml:283:8>>*/  /*<<bigarray.ml:283:8>>*/ caml_call1
         (Stdlib[1], cst_Bigarray_Array2_of_array_n);
        /*<<bigarray.ml:273:32>>*/ var
-        /*<<bigarray.ml:273:32>>*/ _E_ = dim2 - 1 | 0,
-        /*<<bigarray.ml:283:8>>*/ _D_ = 0;
-      if(_E_ >= 0){
-       var j = _D_;
+        /*<<bigarray.ml:273:32>>*/ _F_ = dim2 - 1 | 0,
+        /*<<bigarray.ml:283:8>>*/ _E_ = 0;
+      if(_F_ >= 0){
+       var j = _E_;
        for(;;){
          /*<<bigarray.ml:285:8>>*/  /*<<bigarray.ml:285:8>>*/ caml_ba_set_2
          (ba, i + ofs | 0, j + ofs | 0, caml_check_bound(row, j)[1 + j]);
          /*<<bigarray.ml:285:8>>*/  /*<<bigarray.ml:285:8>>*/ var
-         _G_ = j + 1 | 0;
-        if(_E_ !== j){var j = _G_; continue;}
+         _H_ = j + 1 | 0;
+        if(_F_ !== j){var j = _H_; continue;}
         break;
        }
       }
        /*<<bigarray.ml:280:4>>*/  /*<<bigarray.ml:280:4>>*/ var
-       _F_ = i + 1 | 0;
-      if(_C_ !== i){var i = _F_; continue;}
+       _G_ = i + 1 | 0;
+      if(_D_ !== i){var i = _G_; continue;}
       break;
      }
     }
@@ -22424,20 +22457,20 @@
     /*<<bigarray.ml:294:52>>*/ }
    function size_in_bytes$3(arr){
      /*<<bigarray.ml:312:4>>*/ var
-      /*<<bigarray.ml:312:64>>*/ _y_ =
+      /*<<bigarray.ml:312:64>>*/ _z_ =
         /*<<bigarray.ml:312:64>>*/ runtime.caml_ba_dim_3(arr),
-      /*<<bigarray.ml:312:51>>*/ _z_ =
+      /*<<bigarray.ml:312:51>>*/ _A_ =
         /*<<bigarray.ml:312:51>>*/ caml_ba_dim_2(arr),
-      /*<<bigarray.ml:312:38>>*/ _A_ =
+      /*<<bigarray.ml:312:38>>*/ _B_ =
         /*<<bigarray.ml:312:38>>*/ caml_ba_dim_1(arr);
     return caml_mul
             (caml_mul
               ( /*<<bigarray.ml:312:4>>*/ caml_mul
                 (kind_size_in_bytes
                   ( /*<<bigarray.ml:312:24>>*/ caml_ba_kind(arr)),
-                 _A_),
-               _z_),
-             _y_);
+                 _B_),
+               _A_),
+             _z_);
     /*<<bigarray.ml:312:74>>*/ }
    function slice_left_1(a, n, m){
      /*<<bigarray.ml:319:27>>*/ return  /*<<bigarray.ml:319:27>>*/ caml_ba_slice
@@ -22459,17 +22492,17 @@
      /*<<bigarray.ml:342:4>>*/  /*<<bigarray.ml:342:14>>*/ var
      arr = create$2(kind, layout, dim1, dim2, dim3);
      /*<<bigarray.ml:343:4>>*/ if(layout){
-      /*<<bigarray.ml:334:4>>*/  /*<<bigarray.ml:334:4>>*/ var _s_ = 1;
+      /*<<bigarray.ml:334:4>>*/  /*<<bigarray.ml:334:4>>*/ var _t_ = 1;
      if(dim3 >= 1){
-      var k$0 = _s_;
+      var k$0 = _t_;
       for(;;){
-        /*<<bigarray.ml:335:6>>*/  /*<<bigarray.ml:335:6>>*/ var _t_ = 1;
+        /*<<bigarray.ml:335:6>>*/  /*<<bigarray.ml:335:6>>*/ var _u_ = 1;
        if(dim2 >= 1){
-        var j$0 = _t_;
+        var j$0 = _u_;
         for(;;){
-          /*<<bigarray.ml:336:8>>*/  /*<<bigarray.ml:336:8>>*/ var _v_ = 1;
+          /*<<bigarray.ml:336:8>>*/  /*<<bigarray.ml:336:8>>*/ var _w_ = 1;
          if(dim1 >= 1){
-          var i$0 = _v_;
+          var i$0 = _w_;
           for(;;){
             /*<<bigarray.ml:337:10>>*/  /*<<bigarray.ml:337:10>>*/ caml_ba_set_3
             (arr,
@@ -22478,60 +22511,60 @@
              k$0,
               /*<<bigarray.ml:337:31>>*/ caml_call3(f, i$0, j$0, k$0));
             /*<<bigarray.ml:337:10>>*/  /*<<bigarray.ml:337:10>>*/ var
-            _x_ = i$0 + 1 | 0;
-           if(dim1 !== i$0){var i$0 = _x_; continue;}
+            _y_ = i$0 + 1 | 0;
+           if(dim1 !== i$0){var i$0 = _y_; continue;}
            break;
           }
          }
           /*<<bigarray.ml:335:6>>*/  /*<<bigarray.ml:335:6>>*/ var
-          _w_ = j$0 + 1 | 0;
-         if(dim2 !== j$0){var j$0 = _w_; continue;}
+          _x_ = j$0 + 1 | 0;
+         if(dim2 !== j$0){var j$0 = _x_; continue;}
          break;
         }
        }
         /*<<bigarray.ml:334:4>>*/  /*<<bigarray.ml:334:4>>*/ var
-        _u_ = k$0 + 1 | 0;
-       if(dim3 !== k$0){var k$0 = _u_; continue;}
+        _v_ = k$0 + 1 | 0;
+       if(dim3 !== k$0){var k$0 = _v_; continue;}
        break;
       }
      }
       /*<<bigarray.ml:345:24>>*/ return arr;
     }
      /*<<bigarray.ml:326:4>>*/ var
-     _k_ = dim1 - 1 | 0,
-      /*<<bigarray.ml:326:4>>*/ _j_ = 0;
-    if(_k_ >= 0){
-     var i = _j_;
+     _l_ = dim1 - 1 | 0,
+      /*<<bigarray.ml:326:4>>*/ _k_ = 0;
+    if(_l_ >= 0){
+     var i = _k_;
      for(;;){
        /*<<bigarray.ml:327:6>>*/ var
-       _m_ = dim2 - 1 | 0,
-        /*<<bigarray.ml:327:6>>*/ _l_ = 0;
-      if(_m_ >= 0){
-       var j = _l_;
+       _n_ = dim2 - 1 | 0,
+        /*<<bigarray.ml:327:6>>*/ _m_ = 0;
+      if(_n_ >= 0){
+       var j = _m_;
        for(;;){
          /*<<bigarray.ml:328:8>>*/ var
-         _p_ = dim3 - 1 | 0,
-          /*<<bigarray.ml:328:8>>*/ _o_ = 0;
-        if(_p_ >= 0){
-         var k = _o_;
+         _q_ = dim3 - 1 | 0,
+          /*<<bigarray.ml:328:8>>*/ _p_ = 0;
+        if(_q_ >= 0){
+         var k = _p_;
          for(;;){
            /*<<bigarray.ml:329:10>>*/  /*<<bigarray.ml:329:10>>*/ caml_ba_set_3
            (arr, i, j, k,  /*<<bigarray.ml:329:31>>*/ caml_call3(f, i, j, k));
            /*<<bigarray.ml:329:10>>*/  /*<<bigarray.ml:329:10>>*/ var
-           _r_ = k + 1 | 0;
-          if(_p_ !== k){var k = _r_; continue;}
+           _s_ = k + 1 | 0;
+          if(_q_ !== k){var k = _s_; continue;}
           break;
          }
         }
          /*<<bigarray.ml:327:6>>*/  /*<<bigarray.ml:327:6>>*/ var
-         _q_ = j + 1 | 0;
-        if(_m_ !== j){var j = _q_; continue;}
+         _r_ = j + 1 | 0;
+        if(_n_ !== j){var j = _r_; continue;}
         break;
        }
       }
        /*<<bigarray.ml:326:4>>*/  /*<<bigarray.ml:326:4>>*/ var
-       _n_ = i + 1 | 0;
-      if(_k_ !== i){var i = _n_; continue;}
+       _o_ = i + 1 | 0;
+      if(_l_ !== i){var i = _o_; continue;}
       break;
      }
     }
@@ -22548,10 +22581,10 @@
         : caml_check_bound(caml_check_bound(data, 0)[1], 0)[1].length - 1,
       /*<<bigarray.ml:350:13>>*/ ba = create$2(kind, layout, dim1, dim2, dim3),
       /*<<bigarray.ml:351:4>>*/ ofs = layout ? 1 : 0,
-      /*<<bigarray.ml:356:4>>*/ _b_ = dim1 - 1 | 0,
-     _a_ = 0;
-    if(_b_ >= 0){
-     var i = _a_;
+      /*<<bigarray.ml:356:4>>*/ _c_ = dim1 - 1 | 0,
+     _b_ = 0;
+    if(_c_ >= 0){
+     var i = _b_;
      for(;;){
        /*<<bigarray.ml:357:16>>*/  /*<<bigarray.ml:357:16>>*/ var
        row = caml_check_bound(data, i)[1 + i];
@@ -22559,10 +22592,10 @@
         /*<<bigarray.ml:359:8>>*/  /*<<bigarray.ml:359:8>>*/ caml_call1
         (Stdlib[1], cst_Bigarray_Array3_of_array_n);
        /*<<bigarray.ml:348:32>>*/ var
-        /*<<bigarray.ml:348:32>>*/ _d_ = dim2 - 1 | 0,
-        /*<<bigarray.ml:359:8>>*/ _c_ = 0;
-      if(_d_ >= 0){
-       var j = _c_;
+        /*<<bigarray.ml:348:32>>*/ _e_ = dim2 - 1 | 0,
+        /*<<bigarray.ml:359:8>>*/ _d_ = 0;
+      if(_e_ >= 0){
+       var j = _d_;
        for(;;){
          /*<<bigarray.ml:361:18>>*/  /*<<bigarray.ml:361:18>>*/ var
          col = caml_check_bound(row, j)[1 + j];
@@ -22570,10 +22603,10 @@
           /*<<bigarray.ml:363:10>>*/  /*<<bigarray.ml:363:10>>*/ caml_call1
           (Stdlib[1], cst_Bigarray_Array3_of_array_n$0);
          /*<<bigarray.ml:349:32>>*/ var
-          /*<<bigarray.ml:349:32>>*/ _g_ = dim3 - 1 | 0,
-          /*<<bigarray.ml:363:10>>*/ _f_ = 0;
-        if(_g_ >= 0){
-         var k = _f_;
+          /*<<bigarray.ml:349:32>>*/ _h_ = dim3 - 1 | 0,
+          /*<<bigarray.ml:363:10>>*/ _g_ = 0;
+        if(_h_ >= 0){
+         var k = _g_;
          for(;;){
            /*<<bigarray.ml:365:10>>*/  /*<<bigarray.ml:365:10>>*/ caml_ba_set_3
            (ba,
@@ -22582,20 +22615,20 @@
             k + ofs | 0,
             caml_check_bound(col, k)[1 + k]);
            /*<<bigarray.ml:365:10>>*/  /*<<bigarray.ml:365:10>>*/ var
-           _i_ = k + 1 | 0;
-          if(_g_ !== k){var k = _i_; continue;}
+           _j_ = k + 1 | 0;
+          if(_h_ !== k){var k = _j_; continue;}
           break;
          }
         }
          /*<<bigarray.ml:359:8>>*/  /*<<bigarray.ml:359:8>>*/ var
-         _h_ = j + 1 | 0;
-        if(_d_ !== j){var j = _h_; continue;}
+         _i_ = j + 1 | 0;
+        if(_e_ !== j){var j = _i_; continue;}
         break;
        }
       }
        /*<<bigarray.ml:356:4>>*/  /*<<bigarray.ml:356:4>>*/ var
-       _e_ = i + 1 | 0;
-      if(_b_ !== i){var i = _e_; continue;}
+       _f_ = i + 1 | 0;
+      if(_c_ !== i){var i = _f_; continue;}
       break;
      }
     }
@@ -24183,6 +24216,7 @@
     Stdlib_Int = global_data.Stdlib__Int,
     Stdlib_Array = global_data.Stdlib__Array,
     Stdlib_Obj = global_data.Stdlib__Obj,
+    _a_ = undefined,
     cst_Weak_Make_hash_bucket_cann = "Weak.Make: hash bucket cannot grow more",
     cst_Weak_fill = "Weak.fill",
     cst_Weak_blit = "Weak.blit",
@@ -24193,9 +24227,9 @@
     cst_Weak_create = "Weak.create";
    function create(l){
      /*<<weak.ml:28:2>>*/ var
-     _W_ = 0 <= l ? 1 : 0,
-     _X_ = _W_ ? l <= Stdlib_Obj[24][15] ? 1 : 0 : _W_;
-    if(1 - _X_)
+     _X_ = 0 <= l ? 1 : 0,
+     _Y_ = _X_ ? l <= Stdlib_Obj[24][15] ? 1 : 0 : _X_;
+    if(1 - _Y_)
       /*<<weak.ml:29:4>>*/  /*<<weak.ml:29:4>>*/ caml_call1
       (Stdlib[1], cst_Weak_create);
      /*<<weak.ml:30:2>>*/ return  /*<<weak.ml:30:2>>*/ runtime.caml_weak_create
@@ -24206,10 +24240,10 @@
     /*<<weak.ml:33:55>>*/ }
    function raise_if_invalid_offset(e, o, msg){
      /*<<weak.ml:36:2>>*/ var
-     _T_ = 0 <= o ? 1 : 0,
-     _U_ = _T_ ? o < length(e) ? 1 : 0 : _T_,
-     _V_ = 1 - _U_;
-    return _V_ ?  /*<<weak.ml:37:4>>*/ caml_call1(Stdlib[1], msg) : _V_;
+     _U_ = 0 <= o ? 1 : 0,
+     _V_ = _U_ ? o < length(e) ? 1 : 0 : _U_,
+     _W_ = 1 - _V_;
+    return _W_ ? ( /*<<weak.ml:37:4>>*/ caml_call1(Stdlib[1], msg), _a_) : _W_;
     /*<<weak.ml:37:20>>*/ }
    function set(e, o, x){
      /*<<weak.ml:42:2>>*/ raise_if_invalid_offset(e, o, cst_Weak_set);
@@ -24242,13 +24276,13 @@
        0 <= o1
        && (length(e1) - l | 0) >= o1 && 0 <= o2 && (length(e2) - l | 0) >= o2){
      var
-      _R_ = 0 !== l ? 1 : 0,
-      _S_ =
-        _R_
+      _S_ = 0 !== l ? 1 : 0,
+      _T_ =
+        _S_
          ?  /*<<weak.ml:69:22>>*/ runtime.caml_ephe_blit_key
            (e1, o1, e2, o2, l)
-         : _R_;
-      /*<<weak.ml:69:22>>*/ return _S_;
+         : _S_;
+      /*<<weak.ml:69:22>>*/ return _T_;
     }
      /*<<weak.ml:68:7>>*/ return  /*<<weak.ml:68:7>>*/ caml_call1
             (Stdlib[1], cst_Weak_blit);
@@ -24256,13 +24290,13 @@
    function fill(ar, ofs, len, x){
      /*<<weak.ml:72:2>>*/ if
      (0 <= ofs && 0 <= len && (length(ar) - len | 0) >= ofs){
-     var _P_ = (ofs + len | 0) - 1 | 0;
-     if(_P_ >= ofs){
+     var _Q_ = (ofs + len | 0) - 1 | 0;
+     if(_Q_ >= ofs){
       var i = ofs;
       for(;;){
         /*<<weak.ml:76:6>>*/ set(ar, i, x);
-        /*<<weak.ml:76:6>>*/  /*<<weak.ml:76:6>>*/ var _Q_ = i + 1 | 0;
-       if(_P_ !== i){var i = _Q_; continue;}
+        /*<<weak.ml:76:6>>*/  /*<<weak.ml:76:6>>*/ var _R_ = i + 1 | 0;
+       if(_Q_ !== i){var i = _R_; continue;}
        break;
       }
      }
@@ -24291,15 +24325,15 @@
      /*<<weak.ml:131:5>>*/ }
     function clear(t){
       /*<<weak.ml:134:4>>*/ var
-      _N_ = t[1].length - 1 - 1 | 0,
-       /*<<weak.ml:134:4>>*/ _M_ = 0;
-     if(_N_ >= 0){
-      var i = _M_;
+      _O_ = t[1].length - 1 - 1 | 0,
+       /*<<weak.ml:134:4>>*/ _N_ = 0;
+     if(_O_ >= 0){
+      var i = _N_;
       for(;;){
         /*<<weak.ml:135:6>>*/ caml_check_bound(t[1], i)[1 + i] = emptybucket;
         /*<<weak.ml:136:6>>*/ caml_check_bound(t[2], i)[1 + i] = [0];
-        /*<<weak.ml:136:6>>*/  /*<<weak.ml:136:6>>*/ var _O_ = i + 1 | 0;
-       if(_N_ !== i){var i = _O_; continue;}
+        /*<<weak.ml:136:6>>*/  /*<<weak.ml:136:6>>*/ var _P_ = i + 1 | 0;
+       if(_O_ !== i){var i = _P_; continue;}
        break;
       }
      }
@@ -24308,8 +24342,8 @@
      return 0;
      /*<<weak.ml:139:19>>*/ }
     function fold(f, t, init){
-      /*<<weak.ml:143:4>>*/ var _K_ = t[1], i = 0;
-      /*<<weak.ml:149:21>>*/ function _L_(b, accu$1){
+      /*<<weak.ml:143:4>>*/ var _L_ = t[1], i = 0;
+      /*<<weak.ml:149:21>>*/ function _M_(b, accu$1){
       var i$0 = i, accu = accu$1;
        /*<<weak.ml:144:6>>*/ for(;;){
        if(length(b) <= i$0)  /*<<weak.ml:144:28>>*/ return accu;
@@ -24329,11 +24363,11 @@
       }
      }
       /*<<weak.ml:149:4>>*/ return  /*<<weak.ml:149:4>>*/ caml_call3
-             (Stdlib_Array[17], _L_, _K_, init);
+             (Stdlib_Array[17], _M_, _L_, init);
      /*<<weak.ml:149:49>>*/ }
     function iter(f, t){
-      /*<<weak.ml:153:4>>*/ var _I_ = t[1], i = 0;
-      /*<<weak.ml:159:15>>*/ function _J_(b){
+      /*<<weak.ml:153:4>>*/ var _J_ = t[1], i = 0;
+      /*<<weak.ml:159:15>>*/ function _K_(b){
       var i$0 = i;
        /*<<weak.ml:154:6>>*/ for(;;){
        if(length(b) <= i$0)  /*<<weak.ml:154:28>>*/ return 0;
@@ -24349,15 +24383,15 @@
       }
      }
       /*<<weak.ml:159:15>>*/ return  /*<<weak.ml:159:15>>*/ caml_call2
-             (Stdlib_Array[11], _J_, _I_);
+             (Stdlib_Array[11], _K_, _J_);
      /*<<weak.ml:159:38>>*/ }
     function count_bucket(i, b, accu){
       /*<<weak.ml:173:4>>*/ var i$0 = i, accu$0 = accu;
       /*<<weak.ml:173:4>>*/ for(;;){
       if(length(b) <= i$0)  /*<<weak.ml:173:26>>*/ return accu$0;
        /*<<weak.ml:174:37>>*/ var
-        /*<<weak.ml:174:37>>*/ _H_ = check(b, i$0) ? 1 : 0,
-       accu$1 = accu$0 + _H_ | 0,
+        /*<<weak.ml:174:37>>*/ _I_ = check(b, i$0) ? 1 : 0,
+       accu$1 = accu$0 + _I_ | 0,
        i$1 = i$0 + 1 | 0,
        i$0 = i$1,
        accu$0 = accu$1;
@@ -24365,14 +24399,14 @@
      /*<<weak.ml:174:62>>*/ }
     function count(t){
       /*<<weak.ml:178:4>>*/ var
-       /*<<weak.ml:178:4>>*/ _B_ = 0,
-      _C_ = t[1],
-      _D_ = 0;
-      /*<<weak.ml:178:21>>*/ function _E_(_F_, _G_){
-       /*<<?>>*/ return count_bucket(_D_, _F_, _G_);
+       /*<<weak.ml:178:4>>*/ _C_ = 0,
+      _D_ = t[1],
+      _E_ = 0;
+      /*<<weak.ml:178:21>>*/ function _F_(_G_, _H_){
+       /*<<?>>*/ return count_bucket(_E_, _G_, _H_);
      }
       /*<<weak.ml:178:4>>*/ return  /*<<weak.ml:178:4>>*/ caml_call3
-             (Stdlib_Array[17], _E_, _C_, _B_);
+             (Stdlib_Array[17], _F_, _D_, _C_);
      /*<<weak.ml:178:47>>*/ }
     function add_aux(t, setter, d, h, index){
       /*<<weak.ml:238:4>>*/ var
@@ -24416,17 +24450,17 @@
        /*<<weak.ml:252:8>>*/ caml_check_bound(newhashes, sz)[1 + sz] = h;
        /*<<weak.ml:253:8>>*/ caml_check_bound(t[1], index)[1 + index] = newbucket$0;
        /*<<weak.ml:254:8>>*/ caml_check_bound(t[2], index)[1 + index] = newhashes;
-      var _x_ = sz <= t[3] ? 1 : 0, _y_ = _x_ ? t[3] < newsz ? 1 : 0 : _x_;
-      if(_y_){
+      var _y_ = sz <= t[3] ? 1 : 0, _z_ = _y_ ? t[3] < newsz ? 1 : 0 : _y_;
+      if(_z_){
        t[4] = t[4] + 1 | 0;
        var i$4 = 0;
        for(;;){
          /*<<weak.ml:185:17>>*/ var
-         _n_ = t[5],
-          /*<<weak.ml:185:17>>*/ bucket = caml_check_bound(t[1], _n_)[1 + _n_],
-          /*<<weak.ml:186:4>>*/ _o_ = t[5],
+         _o_ = t[5],
+          /*<<weak.ml:185:17>>*/ bucket = caml_check_bound(t[1], _o_)[1 + _o_],
+          /*<<weak.ml:186:4>>*/ _p_ = t[5],
           /*<<weak.ml:186:18>>*/ hbucket =
-           caml_check_bound(t[2], _o_)[1 + _o_],
+           caml_check_bound(t[2], _p_)[1 + _p_],
           /*<<weak.ml:187:14>>*/ len = length(bucket),
          prev_len = (((len - 3 | 0) * 2 | 0) + 2 | 0) / 3 | 0,
           /*<<weak.ml:189:15>>*/ live = count_bucket(0, bucket, 0);
@@ -24444,8 +24478,8 @@
             /*<<weak.ml:194:18>>*/ if(check(bucket, j)){
              /*<<weak.ml:195:12>>*/ blit(bucket, j, bucket, i$0, 1);
              /*<<weak.ml:196:27>>*/  /*<<weak.ml:196:27>>*/ var
-             _p_ = caml_check_bound(hbucket, j)[1 + j];
-             /*<<weak.ml:196:12>>*/ caml_check_bound(hbucket, i$0)[1 + i$0] = _p_;
+             _q_ = caml_check_bound(hbucket, j)[1 + j];
+             /*<<weak.ml:196:12>>*/ caml_check_bound(hbucket, i$0)[1 + i$0] = _q_;
              /*<<weak.ml:196:12>>*/ var
               /*<<weak.ml:196:12>>*/ j$0 = j - 1 | 0,
              i$2 = i$0 + 1 | 0,
@@ -24459,39 +24493,39 @@
            continue;
           }
           if(0 === prev_len){
-           var _q_ = t[5];
-            /*<<weak.ml:203:8>>*/ caml_check_bound(t[1], _q_)[1 + _q_] = emptybucket;
            var _r_ = t[5];
-            /*<<weak.ml:204:8>>*/ caml_check_bound(t[2], _r_)[1 + _r_] = [0];
+            /*<<weak.ml:203:8>>*/ caml_check_bound(t[1], _r_)[1 + _r_] = emptybucket;
+           var _s_ = t[5];
+            /*<<weak.ml:204:8>>*/ caml_check_bound(t[2], _s_)[1 + _s_] = [0];
           }
           else{
             /*<<weak.ml:206:24>>*/  /*<<weak.ml:206:24>>*/ var
             newbucket = create(prev_len);
             /*<<weak.ml:207:8>>*/ blit(bucket, 0, newbucket, 0, prev_len);
-           var _u_ = t[5];
-            /*<<weak.ml:208:8>>*/ caml_check_bound(t[1], _u_)[1 + _u_] = newbucket;
+           var _v_ = t[5];
+            /*<<weak.ml:208:8>>*/ caml_check_bound(t[1], _v_)[1 + _v_] = newbucket;
             /*<<weak.ml:209:30>>*/ var
-             /*<<weak.ml:209:30>>*/ _v_ =
+             /*<<weak.ml:209:30>>*/ _w_ =
                /*<<weak.ml:209:30>>*/ caml_call3
                (Stdlib_Array[5], hbucket, 0, prev_len),
-            _w_ = t[5];
-            /*<<weak.ml:209:8>>*/ caml_check_bound(t[2], _w_)[1 + _w_] = _v_;
+            _x_ = t[5];
+            /*<<weak.ml:209:8>>*/ caml_check_bound(t[2], _x_)[1 + _x_] = _w_;
           }
           var
-           _s_ = t[3] < len ? 1 : 0,
-           _t_ = _s_ ? prev_len <= t[3] ? 1 : 0 : _s_;
-          if(_t_) t[4] = t[4] - 1 | 0;
+           _t_ = t[3] < len ? 1 : 0,
+           _u_ = _t_ ? prev_len <= t[3] ? 1 : 0 : _t_;
+          if(_u_) t[4] = t[4] - 1 | 0;
           break;
          }
         }
         t[5] = caml_mod(t[5] + 1 | 0, t[1].length - 1);
-         /*<<weak.ml:257:38>>*/  /*<<weak.ml:257:38>>*/ var _A_ = i$4 + 1 | 0;
-        if(2 !== i$4){var i$4 = _A_; continue;}
+         /*<<weak.ml:257:38>>*/  /*<<weak.ml:257:38>>*/ var _B_ = i$4 + 1 | 0;
+        if(2 !== i$4){var i$4 = _B_; continue;}
         break;
        }
       }
-      var _z_ = ((t[1].length - 1) / 2 | 0) < t[4] ? 1 : 0;
-      if(! _z_) return _z_;
+      var _A_ = ((t[1].length - 1) / 2 | 0) < t[4] ? 1 : 0;
+      if(! _A_) return _A_;
        /*<<weak.ml:181:18>>*/ var
        oldlen = t[1].length - 1,
         /*<<weak.ml:181:18>>*/ newlen =
@@ -24500,9 +24534,9 @@
       if(oldlen < newlen){
         /*<<weak.ml:220:17>>*/ var
          /*<<weak.ml:220:17>>*/ newt = create$0(newlen),
-        _l_ = t[1],
+        _m_ = t[1],
         i = 0,
-         /*<<weak.ml:169:16>>*/ _m_ =
+         /*<<weak.ml:169:16>>*/ _n_ =
           function(j, ob){
            var oi = i;
             /*<<weak.ml:164:6>>*/ for(;;){
@@ -24528,7 +24562,7 @@
            }
           };
         /*<<weak.ml:169:16>>*/  /*<<weak.ml:169:16>>*/ caml_call2
-        (Stdlib_Array[12], _m_, _l_);
+        (Stdlib_Array[12], _n_, _m_);
        t[1] = newt[1];
        t[2] = newt[2];
        t[3] = newt[3];
@@ -24676,24 +24710,24 @@
      }
      /*<<weak.ml:337:10>>*/ }
     function remove(t, d){
-      /*<<weak.ml:340:19>>*/  /*<<weak.ml:340:19>>*/ var _k_ = 0;
+      /*<<weak.ml:340:19>>*/  /*<<weak.ml:340:19>>*/ var _l_ = 0;
       /*<<weak.ml:340:19>>*/ return find_shadow
              (t,
               d,
               function(w, i){
                 /*<<weak.ml:340:47>>*/ return set(w, i, 0);
                /*<<weak.ml:340:59>>*/ },
-              _k_);
+              _l_);
      /*<<weak.ml:340:63>>*/ }
     function mem(t, d){
-      /*<<weak.ml:343:16>>*/  /*<<weak.ml:343:16>>*/ var _j_ = 0;
+      /*<<weak.ml:343:16>>*/  /*<<weak.ml:343:16>>*/ var _k_ = 0;
       /*<<weak.ml:343:16>>*/ return find_shadow
              (t,
               d,
               function(w, i){
                 /*<<weak.ml:343:46>>*/ return 1;
                /*<<weak.ml:343:50>>*/ },
-              _j_);
+              _k_);
      /*<<weak.ml:343:57>>*/ }
     function find_all(t, d){
       /*<<weak.ml:347:4>>*/ var
@@ -24740,17 +24774,17 @@
          /*<<weak.ml:369:15>>*/ caml_call2(Stdlib_Array[13], length, t[1]);
       /*<<weak.ml:370:4>>*/  /*<<weak.ml:370:4>>*/ caml_call2
       (Stdlib_Array[30], runtime.caml_int_compare, lens);
-     var _a_ = 0;
-     function _b_(_i_, _h_){ /*<<?>>*/ return _i_ + _h_ | 0;}
+     var _b_ = 0;
+     function _c_(_j_, _i_){ /*<<?>>*/ return _j_ + _i_ | 0;}
       /*<<weak.ml:371:17>>*/ var
        /*<<weak.ml:371:17>>*/ totlen =
-         /*<<weak.ml:371:17>>*/ caml_call3(Stdlib_Array[15], _b_, _a_, lens),
-       /*<<weak.ml:371:17>>*/ _c_ = len - 1 | 0,
-      _e_ = len / 2 | 0,
-       /*<<weak.ml:372:51>>*/ _d_ = caml_check_bound(lens, _c_)[1 + _c_],
-       /*<<weak.ml:372:37>>*/ _f_ = caml_check_bound(lens, _e_)[1 + _e_],
-       /*<<weak.ml:372:27>>*/ _g_ = caml_check_bound(lens, 0)[1];
-      /*<<weak.ml:372:4>>*/ return [0, len, count(t), totlen, _g_, _f_, _d_];
+         /*<<weak.ml:371:17>>*/ caml_call3(Stdlib_Array[15], _c_, _b_, lens),
+       /*<<weak.ml:371:17>>*/ _d_ = len - 1 | 0,
+      _f_ = len / 2 | 0,
+       /*<<weak.ml:372:51>>*/ _e_ = caml_check_bound(lens, _d_)[1 + _d_],
+       /*<<weak.ml:372:37>>*/ _g_ = caml_check_bound(lens, _f_)[1 + _f_],
+       /*<<weak.ml:372:27>>*/ _h_ = caml_check_bound(lens, 0)[1];
+      /*<<weak.ml:372:4>>*/ return [0, len, count(t), totlen, _h_, _g_, _e_];
      /*<<weak.ml:372:64>>*/ }
      /*<<weak.ml:101:66>>*/ return [0,
             create$0,
@@ -24807,6 +24841,7 @@
             : runtime.caml_call_gen(f, [a0, a1, a2, a3]);
    }
    var
+    _m_ = undefined,
     global_data = runtime.caml_get_global_data(),
     cst$14 = ".",
     cst$11 = cst$15,
@@ -24854,25 +24889,27 @@
     /*<<format.ml:220:32>>*/ }
    var pp_infinity = 1000000010;
    function pp_output_string(state, s){
-     /*<<format.ml:251:31>>*/ return caml_call3
-            (state[17], s, 0, caml_ml_string_length(s));
+     /*<<format.ml:251:31>>*/ caml_call3
+     (state[17], s, 0, caml_ml_string_length(s));
+    return _m_;
     /*<<format.ml:251:72>>*/ }
    function pp_output_newline(state){
-     /*<<format.ml:252:30>>*/ return  /*<<format.ml:252:30>>*/ caml_call1
-            (state[19], 0);
+     /*<<format.ml:252:30>>*/  /*<<format.ml:252:30>>*/ caml_call1
+     (state[19], 0);
+     /*<<format.ml:252:30>>*/ return _m_;
     /*<<format.ml:252:53>>*/ }
    function format_pp_text(state, size, text){
      /*<<format.ml:258:2>>*/ state[9] = state[9] - size | 0;
      /*<<format.ml:259:2>>*/ pp_output_string(state, text);
     state[11] = 0;
-    return 0;
+    return _m_;
     /*<<format.ml:260:31>>*/ }
    function format_string(state, s){
      /*<<format.ml:264:2>>*/  /*<<format.ml:264:5>>*/ var
-     _bQ_ =  /*<<format.ml:264:5>>*/ runtime.caml_string_notequal(s, cst$16);
-     /*<<format.ml:264:5>>*/ return _bQ_
-            ? format_pp_text(state, caml_ml_string_length(s), s)
-            : _bQ_;
+     _bO_ =  /*<<format.ml:264:5>>*/ runtime.caml_string_notequal(s, cst$16);
+     /*<<format.ml:264:5>>*/ return _bO_
+            ? (format_pp_text(state, caml_ml_string_length(s), s), _m_)
+            : _bO_;
     /*<<format.ml:264:58>>*/ }
    function break_new_line(state, param, width){
     var after = param[3], offset = param[2], before = param[1];
@@ -24888,10 +24925,12 @@
     var n = state[10];
      /*<<format.ml:254:31>>*/  /*<<format.ml:254:31>>*/ caml_call1
      (state[21], n);
-     /*<<format.ml:276:2>>*/ return format_string(state, after);
+     /*<<format.ml:276:2>>*/ format_string(state, after);
+     /*<<format.ml:276:2>>*/ return _m_;
    }
    function break_line(state, width){
-     /*<<format.ml:281:29>>*/ return break_new_line(state, _a_, width);
+     /*<<format.ml:281:29>>*/ break_new_line(state, _a_, width);
+     /*<<format.ml:281:29>>*/ return _m_;
     /*<<format.ml:281:67>>*/ }
    function break_same_line(state, param){
     var after = param[3], width = param[2], before = param[1];
@@ -24899,7 +24938,8 @@
     state[9] = state[9] - width | 0;
      /*<<format.ml:253:31>>*/  /*<<format.ml:253:31>>*/ caml_call1
      (state[20], width);
-     /*<<format.ml:287:2>>*/ return format_string(state, after);
+     /*<<format.ml:287:2>>*/ format_string(state, after);
+     /*<<format.ml:287:2>>*/ return _m_;
    }
    function format_pp_token(state, size$0, param){
      /*<<?>>*/ if(typeof param === "number")
@@ -24908,7 +24948,7 @@
          /*<<format.ml:348:16>>*/  /*<<format.ml:348:16>>*/ var
          match$3 =
             /*<<format.ml:348:16>>*/ caml_call1(Stdlib_Stack[7], state[3]);
-        if(! match$3)  /*<<format.ml:349:14>>*/ return 0;
+        if(! match$3)  /*<<format.ml:349:14>>*/ return _m_;
          /*<<format.ml:351:6>>*/ var
          tabs = match$3[1][1],
           /*<<format.ml:351:6>>*/ add_tab =
@@ -24921,49 +24961,54 @@
                     : [0, x, add_tab(n, l)];
            };
         tabs[1] = add_tab(state[6] - state[9] | 0, tabs[1]);
-        return 0;
+        return _m_;
        case 1:
          /*<<format.ml:339:4>>*/  /*<<format.ml:339:4>>*/ caml_call1
          (Stdlib_Stack[5], state[2]);
-         /*<<format.ml:339:4>>*/ return 0;
+         /*<<format.ml:339:4>>*/ return _m_;
        case 2:
          /*<<format.ml:345:4>>*/  /*<<format.ml:345:4>>*/ caml_call1
          (Stdlib_Stack[5], state[3]);
-         /*<<format.ml:345:4>>*/ return 0;
+         /*<<format.ml:345:4>>*/ return _m_;
        case 3:
          /*<<format.ml:378:16>>*/  /*<<format.ml:378:16>>*/ var
          match$4 =
             /*<<format.ml:378:16>>*/ caml_call1(Stdlib_Stack[7], state[2]);
-        if(! match$4)
-          /*<<format.ml:379:14>>*/ return pp_output_newline(state);
-        var width$0 = match$4[1][2];
-         /*<<format.ml:380:26>>*/ return break_line(state, width$0);
+        if(match$4){
+         var width$0 = match$4[1][2];
+          /*<<format.ml:380:26>>*/ break_line(state, width$0);
+          /*<<format.ml:380:26>>*/ return _m_;
+        }
+         /*<<format.ml:379:14>>*/ pp_output_newline(state);
+         /*<<format.ml:379:14>>*/ return _m_;
        case 4:
-        var _bO_ = state[10] !== (state[6] - state[9] | 0) ? 1 : 0;
-        if(! _bO_) return _bO_;
+        var _bM_ = state[10] !== (state[6] - state[9] | 0) ? 1 : 0;
+        if(! _bM_) return _bM_;
          /*<<format.ml:306:8>>*/  /*<<format.ml:306:8>>*/ var
          match$1 =
             /*<<format.ml:306:8>>*/ caml_call1(Stdlib_Queue[6], state[28]);
-        if(! match$1)  /*<<format.ml:307:12>>*/ return 0;
+        if(! match$1)  /*<<format.ml:307:12>>*/ return _m_;
         var match$2 = match$1[1], size = match$2[1], length = match$2[3];
         state[12] = state[12] - length | 0;
         state[9] = state[9] + size | 0;
-        return 0;
+        return _m_;
        default:
          /*<<format.ml:419:17>>*/  /*<<format.ml:419:17>>*/ var
          match$5 =
             /*<<format.ml:419:17>>*/ caml_call1(Stdlib_Stack[5], state[5]);
-        if(! match$5)  /*<<format.ml:420:15>>*/ return 0;
+        if(! match$5)  /*<<format.ml:420:15>>*/ return _m_;
          /*<<format.ml:422:20>>*/ var
          tag_name = match$5[1],
           /*<<format.ml:422:20>>*/ marker =
             /*<<format.ml:422:20>>*/ caml_call1(state[25], tag_name);
-         /*<<format.ml:423:7>>*/ return pp_output_string(state, marker);
+         /*<<format.ml:423:7>>*/ pp_output_string(state, marker);
+         /*<<format.ml:423:7>>*/ return _m_;
      }
     switch(param[0]){
       case 0:
        var s = param[1];
-        /*<<format.ml:323:4>>*/ return format_pp_text(state, size$0, s);
+        /*<<format.ml:323:4>>*/ format_pp_text(state, size$0, s);
+        /*<<format.ml:323:4>>*/ return _m_;
       case 1:
         /*<<format.ml:388:4>>*/ var
         breaks = param[2],
@@ -24972,31 +25017,32 @@
         before = breaks[1],
          /*<<format.ml:389:16>>*/ match$6 =
            /*<<format.ml:389:16>>*/ caml_call1(Stdlib_Stack[7], state[2]);
-       if(! match$6)  /*<<format.ml:390:14>>*/ return 0;
+       if(! match$6)  /*<<format.ml:390:14>>*/ return _m_;
        var
         match$7 = match$6[1],
         width$1 = match$7[2],
         box_type$0 = match$7[1];
         /*<<format.ml:392:6>>*/ switch(box_type$0){
          case 0:
-           /*<<format.ml:409:19>>*/ return break_same_line(state, fits);
+           /*<<format.ml:409:19>>*/ break_same_line(state, fits);
+           /*<<format.ml:409:19>>*/ return _m_;
          case 1:
-           /*<<format.ml:408:19>>*/ return break_new_line
-                  (state, breaks, width$1);
+           /*<<format.ml:408:19>>*/ break_new_line(state, breaks, width$1);
+           /*<<format.ml:408:19>>*/ return _m_;
          case 2:
-           /*<<format.ml:406:20>>*/ return break_new_line
-                  (state, breaks, width$1);
+           /*<<format.ml:406:20>>*/ break_new_line(state, breaks, width$1);
+           /*<<format.ml:406:20>>*/ return _m_;
          case 3:
           return state[9] < (size$0 + caml_ml_string_length(before) | 0)
-                  ? break_new_line(state, breaks, width$1)
-                  : break_same_line(state, fits);
+                  ? (break_new_line(state, breaks, width$1), _m_)
+                  : (break_same_line(state, fits), _m_);
          case 4:
           return state[11]
-                  ? break_same_line(state, fits)
+                  ? (break_same_line(state, fits), _m_)
                   : state
                      [9]
                     < (size$0 + caml_ml_string_length(before) | 0)
-                    ? break_new_line(state, breaks, width$1)
+                    ? (break_new_line(state, breaks, width$1), _m_)
                     : ((state
                        [6]
                       - width$1
@@ -25004,10 +25050,11 @@
                       + off
                       | 0)
                       < state[10]
-                      ? break_new_line(state, breaks, width$1)
-                      : break_same_line(state, fits);
+                      ? (break_new_line(state, breaks, width$1), _m_)
+                      : (break_same_line(state, fits), _m_);
          default:
-           /*<<format.ml:407:19>>*/ return break_same_line(state, fits);
+           /*<<format.ml:407:19>>*/ break_same_line(state, fits);
+           /*<<format.ml:407:19>>*/ return _m_;
        }
       case 2:
         /*<<format.ml:359:16>>*/ var
@@ -25016,7 +25063,7 @@
         insertion_point = state[6] - state[9] | 0,
          /*<<format.ml:359:16>>*/ match$8 =
            /*<<format.ml:359:16>>*/ caml_call1(Stdlib_Stack[7], state[3]);
-       if(! match$8)  /*<<format.ml:360:14>>*/ return 0;
+       if(! match$8)  /*<<format.ml:360:14>>*/ return _m_;
         /*<<format.ml:362:6>>*/ var
         tabs$0 = match$8[1][1],
          /*<<format.ml:362:6>>*/ match$9 = tabs$0[1];
@@ -25026,11 +25073,11 @@
          if(param$0){
           var tail = param$0[2], head = param$0[1];
           if(insertion_point > head){var param$0 = tail; continue;}
-          var _bP_ = head;
+          var _bN_ = head;
          }
          else
-          var _bP_ = first;
-         var tab = _bP_;
+          var _bN_ = first;
+         var tab = _bN_;
          break;
         }
        }
@@ -25038,9 +25085,12 @@
         var tab = insertion_point;
        var offset = tab - insertion_point | 0;
         /*<<format.ml:372:6>>*/ return 0 <= offset
-               ? break_same_line(state, [0, cst$0, offset + n | 0, cst])
-               : break_new_line
-                 (state, [0, cst$2, tab + off$0 | 0, cst$1], state[6]);
+               ? (break_same_line
+                  (state, [0, cst$0, offset + n | 0, cst]),
+                 _m_)
+               : (break_new_line
+                  (state, [0, cst$2, tab + off$0 | 0, cst$1], state[6]),
+                 _m_);
       case 3:
        var
         ty = param[2],
@@ -25062,19 +25112,22 @@
         width$2 = state[9] - off$1 | 0,
          /*<<format.ml:331:4>>*/ box_type$1 =
           1 === ty ? 1 : state[9] < size$0 ? ty : 5;
-        /*<<format.ml:336:4>>*/ return  /*<<format.ml:336:4>>*/ caml_call2
-               (Stdlib_Stack[3], [0, box_type$1, width$2], state[2]);
+        /*<<format.ml:336:4>>*/  /*<<format.ml:336:4>>*/ caml_call2
+        (Stdlib_Stack[3], [0, box_type$1, width$2], state[2]);
+        /*<<format.ml:336:4>>*/ return _m_;
       case 4:
        var tbox = param[1];
-        /*<<format.ml:342:4>>*/ return  /*<<format.ml:342:4>>*/ caml_call2
-               (Stdlib_Stack[3], tbox, state[3]);
+        /*<<format.ml:342:4>>*/  /*<<format.ml:342:4>>*/ caml_call2
+        (Stdlib_Stack[3], tbox, state[3]);
+        /*<<format.ml:342:4>>*/ return _m_;
       default:
         /*<<format.ml:414:18>>*/ var
         tag_name$0 = param[1],
          /*<<format.ml:414:18>>*/ marker$0 =
            /*<<format.ml:414:18>>*/ caml_call1(state[24], tag_name$0);
         /*<<format.ml:415:5>>*/ pp_output_string(state, marker$0);
-       return caml_call2(Stdlib_Stack[3], tag_name$0, state[5]);
+       caml_call2(Stdlib_Stack[3], tag_name$0, state[5]);
+       return _m_;
     }
    }
    function advance_left(state){
@@ -25088,10 +25141,10 @@
       length = match$0[3],
       token = match$0[2],
       pending_count = state[13] - state[12] | 0,
-       /*<<format.ml:435:7>>*/ _bM_ = 0 <= size ? 1 : 0,
-       /*<<format.ml:435:7>>*/ _bN_ =
-        _bM_ || (state[9] <= pending_count ? 1 : 0);
-     if(! _bN_)  /*<<format.ml:435:7>>*/ return _bN_;
+       /*<<format.ml:435:7>>*/ _bK_ = 0 <= size ? 1 : 0,
+       /*<<format.ml:435:7>>*/ _bL_ =
+        _bK_ || (state[9] <= pending_count ? 1 : 0);
+     if(! _bL_)  /*<<format.ml:435:7>>*/ return _bL_;
       /*<<format.ml:436:6>>*/  /*<<format.ml:436:6>>*/ caml_call1
       (Stdlib_Queue[5], state[28]);
       /*<<format.ml:437:20>>*/  /*<<format.ml:437:20>>*/ var
@@ -25113,48 +25166,40 @@
      (Stdlib_Stack[8], stack);
      /*<<format.ml:463:19>>*/  /*<<format.ml:463:19>>*/ var
      queue_elem = [0, unknown, _b_, 0];
-     /*<<format.ml:464:2>>*/ return  /*<<format.ml:464:2>>*/ caml_call2
-            (Stdlib_Stack[3], [0, -1, queue_elem], stack);
+     /*<<format.ml:464:2>>*/  /*<<format.ml:464:2>>*/ caml_call2
+     (Stdlib_Stack[3], [0, -1, queue_elem], stack);
+     /*<<format.ml:464:2>>*/ return _m_;
     /*<<format.ml:464:50>>*/ }
    function set_size(state, ty){
      /*<<format.ml:476:2>>*/  /*<<format.ml:476:8>>*/ var
      match =  /*<<format.ml:476:8>>*/ caml_call1(Stdlib_Stack[7], state[1]);
-    if(! match)  /*<<format.ml:477:12>>*/ return 0;
+    if(! match)  /*<<format.ml:477:12>>*/ return _m_;
      /*<<format.ml:479:4>>*/ var
      match$0 = match[1],
      queue_elem = match$0[2],
      left_total = match$0[1],
       /*<<format.ml:479:4>>*/ size = queue_elem[1];
-    if(left_total < state[12]) return initialize_scan_stack(state[1]);
-    var _bI_ = queue_elem[2];
-    if(typeof _bI_ !== "number")
-     switch(_bI_[0]){
+    if(left_total < state[12]){initialize_scan_stack(state[1]); return _m_;}
+    var _bJ_ = queue_elem[2];
+    if(typeof _bJ_ !== "number")
+     switch(_bJ_[0]){
        case 3:
-        var
-         _bK_ = 1 - ty,
-         _bL_ =
-           _bK_
-            ? (queue_elem
-               [1]
-              = state[13] + size | 0,
-               /*<<format.ml:493:10>>*/ caml_call1(Stdlib_Stack[5], state[1]),
-              0)
-            : _bK_;
-         /*<<format.ml:493:10>>*/ return _bL_;
+        if(1 - ty){
+         queue_elem[1] = state[13] + size | 0;
+          /*<<format.ml:493:10>>*/  /*<<format.ml:493:10>>*/ caml_call1
+          (Stdlib_Stack[5], state[1]);
+        }
+         /*<<format.ml:493:10>>*/ return _m_;
        case 1:
        case 2:
-        var
-         _bJ_ =
-           ty
-            ? (queue_elem
-               [1]
-              = state[13] + size | 0,
-               /*<<format.ml:488:10>>*/ caml_call1(Stdlib_Stack[5], state[1]),
-              0)
-            : ty;
-         /*<<format.ml:488:10>>*/ return _bJ_;
+        if(ty){
+         queue_elem[1] = state[13] + size | 0;
+          /*<<format.ml:488:10>>*/  /*<<format.ml:488:10>>*/ caml_call1
+          (Stdlib_Stack[5], state[1]);
+        }
+         /*<<format.ml:488:10>>*/ return _m_;
      }
-     /*<<format.ml:497:8>>*/ return 0;
+     /*<<format.ml:497:8>>*/ return _m_;
     /*<<format.ml:497:10>>*/ }
    function scan_push(state, b, token){
      /*<<format.ml:503:2>>*/ pp_enqueue(state, token);
@@ -25172,26 +25217,26 @@
        /*<<format.ml:516:15>>*/ elem = [0, size, [3, indent, br_ty], 0];
       /*<<format.ml:517:4>>*/ return scan_push(state, 0, elem);
     }
-    var _bH_ = state[14] === state[15] ? 1 : 0;
-    if(! _bH_) return _bH_;
+    var _bI_ = state[14] === state[15] ? 1 : 0;
+    if(! _bI_) return _bI_;
     var s = state[16];
      /*<<format.ml:454:2>>*/ return enqueue_string_as
             (state, caml_ml_string_length(s), s);
     /*<<format.ml:519:45>>*/ }
    function pp_close_box(state, param){
-     /*<<format.ml:527:2>>*/ var _bF_ = 1 < state[14] ? 1 : 0;
-    if(_bF_){
+     /*<<format.ml:527:2>>*/ var _bG_ = 1 < state[14] ? 1 : 0;
+    if(_bG_){
      if(state[14] < state[15]){
        /*<<format.ml:531:6>>*/ pp_enqueue(state, [0, zero, 1, 0]);
        /*<<format.ml:532:6>>*/ set_size(state, 1);
        /*<<format.ml:532:27>>*/ set_size(state, 0);
      }
      state[14] = state[14] - 1 | 0;
-     var _bG_ = 0;
+     var _bH_ = 0;
     }
     else
-     var _bG_ = _bF_;
-    return _bG_;
+     var _bH_ = _bG_;
+    return _bH_;
     /*<<format.ml:535:5>>*/ }
    function pp_open_stag(state, tag_name){
      /*<<format.ml:540:2>>*/ if(state[22]){
@@ -25200,8 +25245,8 @@
       /*<<format.ml:543:4>>*/  /*<<format.ml:543:4>>*/ caml_call1
       (state[26], tag_name);
     }
-    var _bE_ = state[23];
-    if(! _bE_) return _bE_;
+    var _bF_ = state[23];
+    if(! _bF_) return _bF_;
      /*<<format.ml:546:16>>*/  /*<<format.ml:546:16>>*/ var
      token = [5, tag_name];
      /*<<format.ml:547:21>>*/ return pp_enqueue(state, [0, zero, token, 0]);
@@ -25209,8 +25254,8 @@
    function pp_close_stag(state, param){
      /*<<format.ml:552:2>>*/ if(state[23])
       /*<<format.ml:553:4>>*/ pp_enqueue(state, [0, zero, 5, 0]);
-    var _bC_ = state[22];
-    if(_bC_){
+    var _bD_ = state[22];
+    if(_bD_){
       /*<<format.ml:555:10>>*/  /*<<format.ml:555:10>>*/ var
       match =  /*<<format.ml:555:10>>*/ caml_call1(Stdlib_Stack[5], state[4]);
      if(match){
@@ -25218,11 +25263,11 @@
        /*<<format.ml:558:6>>*/ return  /*<<format.ml:558:6>>*/ caml_call1
               (state[27], tag_name);
      }
-     var _bD_ = 0;
+     var _bE_ = 0;
     }
     else
-     var _bD_ = _bC_;
-     /*<<format.ml:556:14>>*/ return _bD_;
+     var _bE_ = _bD_;
+     /*<<format.ml:556:14>>*/ return _bE_;
     /*<<format.ml:558:39>>*/ }
    function pp_set_print_tags(state, b){
      /*<<format.ml:560:32>>*/ state[22] = b;
@@ -25276,12 +25321,12 @@
      /*<<format.ml:523:28>>*/ return pp_open_box_gen(state, 0, 3);
     /*<<format.ml:600:23>>*/ }
    function pp_flush_queue(state, b){
-     /*<<format.ml:608:2>>*/ var _bA_ = state[4];
-    function _bB_(param){
+     /*<<format.ml:608:2>>*/ var _bB_ = state[4];
+    function _bC_(param){
       /*<<format.ml:603:23>>*/ return pp_close_stag(state, 0);
      /*<<format.ml:603:45>>*/ }
      /*<<format.ml:603:13>>*/  /*<<format.ml:603:13>>*/ caml_call2
-     (Stdlib_Stack[12], _bB_, _bA_);
+     (Stdlib_Stack[12], _bC_, _bB_);
      /*<<format.ml:610:4>>*/ for(;;){
      if(1 < state[14]){
        /*<<format.ml:610:4>>*/ pp_close_box(state, 0);
@@ -25290,12 +25335,13 @@
      state[13] = pp_infinity;
       /*<<format.ml:613:2>>*/ advance_left(state);
      if(b)  /*<<format.ml:614:12>>*/ pp_output_newline(state);
-      /*<<format.ml:614:12>>*/ return pp_rinit(state);
+      /*<<format.ml:614:12>>*/ pp_rinit(state);
+      /*<<format.ml:614:12>>*/ return _m_;
     }
     /*<<format.ml:615:16>>*/ }
    function pp_print_as_size(state, size, s){
-     /*<<format.ml:625:2>>*/ var _bz_ = state[14] < state[15] ? 1 : 0;
-    return _bz_ ? enqueue_string_as(state, size, s) : _bz_;
+     /*<<format.ml:625:2>>*/ var _bA_ = state[14] < state[15] ? 1 : 0;
+    return _bA_ ? enqueue_string_as(state, size, s) : _bA_;
     /*<<format.ml:626:37>>*/ }
    function pp_print_as(state, isize, s){
      /*<<format.ml:630:2>>*/ return pp_print_as_size(state, isize, s);
@@ -25354,20 +25400,20 @@
             (state[18], 0);
     /*<<format.ml:673:51>>*/ }
    function pp_force_newline(state, param){
-     /*<<format.ml:678:2>>*/ var _by_ = state[14] < state[15] ? 1 : 0;
-    return _by_ ? enqueue_advance(state, [0, zero, 3, 0]) : _by_;
+     /*<<format.ml:678:2>>*/ var _bz_ = state[14] < state[15] ? 1 : 0;
+    return _bz_ ? enqueue_advance(state, [0, zero, 3, 0]) : _bz_;
     /*<<format.ml:679:78>>*/ }
    function pp_print_if_newline(state, param){
-     /*<<format.ml:684:2>>*/ var _bx_ = state[14] < state[15] ? 1 : 0;
-    return _bx_ ? enqueue_advance(state, [0, zero, 4, 0]) : _bx_;
+     /*<<format.ml:684:2>>*/ var _by_ = state[14] < state[15] ? 1 : 0;
+    return _by_ ? enqueue_advance(state, [0, zero, 4, 0]) : _by_;
     /*<<format.ml:686:61>>*/ }
    function pp_print_custom_break(state, fits, breaks){
      /*<<format.ml:692:2>>*/ var
      after = fits[3],
      width = fits[2],
      before = fits[1],
-     _bw_ = state[14] < state[15] ? 1 : 0;
-    if(! _bw_) return _bw_;
+     _bx_ = state[14] < state[15] ? 1 : 0;
+    if(! _bx_) return _bx_;
      /*<<format.ml:695:25>>*/ var
      size = - state[13] | 0,
       /*<<format.ml:695:25>>*/ token = [1, fits, breaks],
@@ -25390,33 +25436,33 @@
     /*<<format.ml:715:52>>*/ }
    function pp_open_tbox(state, param){
      /*<<format.ml:720:2>>*/ state[14] = state[14] + 1 | 0;
-    var _bv_ = state[14] < state[15] ? 1 : 0;
-    if(! _bv_) return _bv_;
+    var _bw_ = state[14] < state[15] ? 1 : 0;
+    if(! _bw_) return _bw_;
      /*<<format.ml:723:15>>*/  /*<<format.ml:723:15>>*/ var
      elem = [0, zero, [4, [0, [0, 0]]], 0];
      /*<<format.ml:724:4>>*/ return enqueue_advance(state, elem);
     /*<<format.ml:724:30>>*/ }
    function pp_close_tbox(state, param){
-     /*<<format.ml:729:2>>*/ var _bs_ = 1 < state[14] ? 1 : 0;
-    if(_bs_){
-     var _bt_ = state[14] < state[15] ? 1 : 0;
-     if(_bt_){
+     /*<<format.ml:729:2>>*/ var _bt_ = 1 < state[14] ? 1 : 0;
+    if(_bt_){
+     var _bu_ = state[14] < state[15] ? 1 : 0;
+     if(_bu_){
        /*<<format.ml:732:16>>*/  /*<<format.ml:732:16>>*/ var
        elem = [0, zero, 2, 0];
        /*<<format.ml:733:5>>*/ enqueue_advance(state, elem);
       state[14] = state[14] - 1 | 0;
-      var _bu_ = 0;
+      var _bv_ = 0;
      }
      else
-      var _bu_ = _bt_;
+      var _bv_ = _bu_;
     }
     else
-     var _bu_ = _bs_;
-    return _bu_;
+     var _bv_ = _bt_;
+    return _bv_;
     /*<<format.ml:735:5>>*/ }
    function pp_print_tbreak(state, width, offset){
-     /*<<format.ml:740:2>>*/ var _br_ = state[14] < state[15] ? 1 : 0;
-    if(! _br_) return _br_;
+     /*<<format.ml:740:2>>*/ var _bs_ = state[14] < state[15] ? 1 : 0;
+    if(! _bs_) return _bs_;
      /*<<format.ml:742:15>>*/ var
      size = - state[13] | 0,
       /*<<format.ml:742:15>>*/ elem = [0, size, [2, width, offset], width];
@@ -25426,17 +25472,17 @@
      /*<<format.ml:746:28>>*/ return pp_print_tbreak(state, 0, 0);
     /*<<format.ml:746:53>>*/ }
    function pp_set_tab(state, param){
-     /*<<format.ml:749:2>>*/ var _bq_ = state[14] < state[15] ? 1 : 0;
-    if(! _bq_) return _bq_;
+     /*<<format.ml:749:2>>*/ var _br_ = state[14] < state[15] ? 1 : 0;
+    if(! _br_) return _br_;
      /*<<format.ml:750:15>>*/  /*<<format.ml:750:15>>*/ var
      elem = [0, zero, 0, 0];
      /*<<format.ml:751:4>>*/ return enqueue_advance(state, elem);
     /*<<format.ml:751:30>>*/ }
    function pp_set_max_boxes(state, n){
      /*<<format.ml:761:31>>*/ var
-     _bo_ = 1 < n ? 1 : 0,
-     _bp_ = _bo_ ? (state[15] = n, 0) : _bo_;
-    return _bp_;
+     _bp_ = 1 < n ? 1 : 0,
+     _bq_ = _bp_ ? (state[15] = n, 0) : _bp_;
+    return _bq_;
     /*<<format.ml:761:68>>*/ }
    function pp_get_max_boxes(state, param){
      /*<<format.ml:764:32>>*/ return state[15];
@@ -25455,10 +25501,10 @@
      /*<<format.ml:775:2>>*/ return n < 1000000010 ? n : 1000000009;
     /*<<format.ml:775:49>>*/ }
    function pp_set_max_indent(state, n$0){
-     /*<<format.ml:791:2>>*/ var _bn_ = 1 < n$0 ? 1 : 0;
+     /*<<format.ml:791:2>>*/ var _bo_ = 1 < n$0 ? 1 : 0;
+    if(! _bo_) return _bo_;
+    var n$1 = state[6] - n$0 | 0, _bn_ = 1 <= n$1 ? 1 : 0;
     if(! _bn_) return _bn_;
-    var n$1 = state[6] - n$0 | 0, _bm_ = 1 <= n$1 ? 1 : 0;
-    if(! _bm_) return _bm_;
      /*<<format.ml:781:12>>*/  /*<<format.ml:781:12>>*/ var n = pp_limit(n$1);
     state[7] = n;
     state[8] = state[6] - state[7] | 0;
@@ -25468,19 +25514,19 @@
      /*<<format.ml:795:33>>*/ return state[8];
     /*<<format.ml:795:52>>*/ }
    function pp_set_margin(state, n){
-     /*<<format.ml:798:2>>*/ var _bk_ = 1 <= n ? 1 : 0;
-    if(! _bk_) return _bk_;
+     /*<<format.ml:798:2>>*/ var _bl_ = 1 <= n ? 1 : 0;
+    if(! _bl_) return _bl_;
      /*<<format.ml:799:12>>*/  /*<<format.ml:799:12>>*/ var n$0 = pp_limit(n);
     state[6] = n$0;
     if(state[8] <= state[6])
      var new_max_indent = state[8];
     else
       /*<<format.ml:808:15>>*/ var
-       /*<<format.ml:808:15>>*/ _bl_ =
+       /*<<format.ml:808:15>>*/ _bm_ =
          /*<<format.ml:808:15>>*/ caml_call2
          (Stdlib_Int[11], state[6] - state[7] | 0, state[6] / 2 | 0),
       new_max_indent =
-         /*<<format.ml:808:7>>*/ caml_call2(Stdlib_Int[11], _bl_, 1);
+         /*<<format.ml:808:7>>*/ caml_call2(Stdlib_Int[11], _bm_, 1);
      /*<<format.ml:811:4>>*/ return pp_set_max_indent(state, new_max_indent);
     /*<<format.ml:811:42>>*/ }
    function validate_geometry(param){
@@ -25511,11 +25557,11 @@
       /*<<format.ml:842:4>>*/ return pp_set_full_geometry(state, geometry);
      /*<<format.ml:840:28>>*/ var
      msg = match[1],
-      /*<<format.ml:840:28>>*/ _bj_ =
+      /*<<format.ml:840:28>>*/ _bk_ =
         /*<<format.ml:840:28>>*/ caml_call2
         (Stdlib[28], cst_Format_pp_set_geometry, msg);
      /*<<format.ml:840:4>>*/ throw  /*<<format.ml:840:4>>*/ caml_maybe_attach_backtrace
-           ([0, Stdlib[6], _bj_], 1);
+           ([0, Stdlib[6], _bk_], 1);
     /*<<format.ml:842:39>>*/ }
    function pp_safe_set_geometry(state, max_indent, margin){
      /*<<format.ml:845:2>>*/  /*<<format.ml:845:17>>*/ var
@@ -25568,8 +25614,8 @@
    function display_blanks(state, n){
      /*<<format.ml:896:2>>*/ var n$0 = n;
      /*<<format.ml:896:2>>*/ for(;;){
-     var _bi_ = 0 < n$0 ? 1 : 0;
-     if(! _bi_) return _bi_;
+     var _bj_ = 0 < n$0 ? 1 : 0;
+     if(! _bj_) return _bj_;
      if(80 >= n$0)
        /*<<format.ml:897:18>>*/ return  /*<<format.ml:897:18>>*/ caml_call3
               (state[17], blank_line, 0, n$0);
@@ -25589,9 +25635,9 @@
               (Stdlib[63], oc);
       /*<<format.ml:911:43>>*/ };
     state[19] =
-     function(_bh_){ /*<<?>>*/ return display_newline(state, _bh_);};
-    state[20] = function(_bg_){ /*<<?>>*/ return display_blanks(state, _bg_);};
-    state[21] = function(_bf_){ /*<<?>>*/ return display_blanks(state, _bf_);};
+     function(_bi_){ /*<<?>>*/ return display_newline(state, _bi_);};
+    state[20] = function(_bh_){ /*<<?>>*/ return display_blanks(state, _bh_);};
+    state[21] = function(_bg_){ /*<<?>>*/ return display_blanks(state, _bg_);};
     return 0;
     /*<<format.ml:914:45>>*/ }
    function default_pp_mark_open_tag(param){
@@ -25599,23 +25645,23 @@
       /*<<format.ml:924:9>>*/ return cst$10;
      /*<<format.ml:923:26>>*/ var
      s = param[2],
-      /*<<format.ml:923:26>>*/ _be_ =
+      /*<<format.ml:923:26>>*/ _bf_ =
         /*<<format.ml:923:26>>*/ caml_call2(Stdlib[28], s, cst$8);
      /*<<format.ml:923:26>>*/ return  /*<<format.ml:923:26>>*/ caml_call2
-            (Stdlib[28], cst$9, _be_);
+            (Stdlib[28], cst$9, _bf_);
     /*<<format.ml:924:11>>*/ }
    function default_pp_mark_close_tag(param){
      /*<<format.ml:925:32>>*/ if(param[1] !== String_tag)
       /*<<format.ml:927:9>>*/ return cst$13;
      /*<<format.ml:926:27>>*/ var
      s = param[2],
-      /*<<format.ml:926:27>>*/ _bd_ =
+      /*<<format.ml:926:27>>*/ _be_ =
         /*<<format.ml:926:27>>*/ caml_call2(Stdlib[28], s, cst$11);
      /*<<format.ml:926:27>>*/ return  /*<<format.ml:926:27>>*/ caml_call2
-            (Stdlib[28], cst$12, _bd_);
+            (Stdlib[28], cst$12, _be_);
     /*<<format.ml:927:11>>*/ }
-   function default_pp_print_open_tag(_bc_){ /*<<?>>*/ return 0;}
-   function default_pp_print_close_tag(_bb_){ /*<<?>>*/ return 0;}
+   function default_pp_print_open_tag(_bd_){ /*<<?>>*/ return 0;}
+   function default_pp_print_close_tag(_bc_){ /*<<?>>*/ return 0;}
    function pp_make_formatter(f, g, h, i, j){
      /*<<format.ml:936:17>>*/ var
       /*<<format.ml:936:17>>*/ pp_queue =
@@ -25629,19 +25675,19 @@
      /*<<format.ml:942:2>>*/  /*<<format.ml:942:2>>*/ caml_call2
      (Stdlib_Stack[3], [0, 1, sys_tok], scan_stack);
      /*<<format.ml:950:20>>*/ var
-     _a9_ = Stdlib[19],
-      /*<<format.ml:950:20>>*/ _a__ =
+     _a__ = Stdlib[19],
+      /*<<format.ml:950:20>>*/ _a$_ =
         /*<<format.ml:950:20>>*/ caml_call1(Stdlib_Stack[2], 0),
-      /*<<format.ml:949:19>>*/ _a$_ =
+      /*<<format.ml:949:19>>*/ _ba_ =
         /*<<format.ml:949:19>>*/ caml_call1(Stdlib_Stack[2], 0),
-      /*<<format.ml:948:20>>*/ _ba_ =
+      /*<<format.ml:948:20>>*/ _bb_ =
         /*<<format.ml:948:20>>*/ caml_call1(Stdlib_Stack[2], 0);
      /*<<format.ml:945:2>>*/ return [0,
             scan_stack,
              /*<<format.ml:947:22>>*/ caml_call1(Stdlib_Stack[2], 0),
+            _bb_,
             _ba_,
             _a$_,
-            _a__,
             78,
             10,
             68,
@@ -25651,7 +25697,7 @@
             1,
             1,
             1,
-            _a9_,
+            _a__,
             cst$14,
             f,
             g,
@@ -25671,30 +25717,30 @@
             (out_funs[1], out_funs[2], out_funs[3], out_funs[4], out_funs[5]);
     /*<<format.ml:984:23>>*/ }
    function make_formatter(output, flush){
-    function _a1_(_a8_){ /*<<?>>*/ return 0;}
-    function _a2_(_a7_){ /*<<?>>*/ return 0;}
+    function _a2_(_a9_){ /*<<?>>*/ return 0;}
+    function _a3_(_a8_){ /*<<?>>*/ return 0;}
      /*<<format.ml:990:12>>*/  /*<<format.ml:990:12>>*/ var
      ppf =
        pp_make_formatter
-        (output, flush, function(_a6_){ /*<<?>>*/ return 0;}, _a2_, _a1_);
-    ppf[19] = function(_a5_){ /*<<?>>*/ return display_newline(ppf, _a5_);};
-    ppf[20] = function(_a4_){ /*<<?>>*/ return display_blanks(ppf, _a4_);};
-    ppf[21] = function(_a3_){ /*<<?>>*/ return display_blanks(ppf, _a3_);};
+        (output, flush, function(_a7_){ /*<<?>>*/ return 0;}, _a3_, _a2_);
+    ppf[19] = function(_a6_){ /*<<?>>*/ return display_newline(ppf, _a6_);};
+    ppf[20] = function(_a5_){ /*<<?>>*/ return display_blanks(ppf, _a5_);};
+    ppf[21] = function(_a4_){ /*<<?>>*/ return display_blanks(ppf, _a4_);};
      /*<<format.ml:994:2>>*/ return ppf;
     /*<<format.ml:994:5>>*/ }
    function formatter_of_out_channel(oc){
-    function _a0_(param){
+    function _a1_(param){
       /*<<format.ml:999:50>>*/ return  /*<<format.ml:999:2>>*/ caml_call1
              (Stdlib[63], oc);
      /*<<format.ml:999:58>>*/ }
      /*<<format.ml:999:39>>*/ return make_formatter
-            ( /*<<format.ml:999:17>>*/ caml_call1(Stdlib[69], oc), _a0_);
+            ( /*<<format.ml:999:17>>*/ caml_call1(Stdlib[69], oc), _a1_);
     /*<<format.ml:999:59>>*/ }
    function formatter_of_buffer(b){
-     /*<<format.ml:1004:2>>*/ function _aY_(_aZ_){ /*<<?>>*/ return 0;}
+     /*<<format.ml:1004:2>>*/ function _aZ_(_a0_){ /*<<?>>*/ return 0;}
      /*<<format.ml:1004:42>>*/ return make_formatter
             ( /*<<format.ml:1004:17>>*/ caml_call1(Stdlib_Buffer[18], b),
-             _aY_);
+             _aZ_);
     /*<<format.ml:1004:48>>*/ }
    var pp_buffer_size = 512;
    function pp_make_buffer(param){
@@ -25725,9 +25771,9 @@
     (Stdlib_Domain[10][3], str_formatter_key, str_formatter);
     /*<<format.ml:1030:8>>*/ function buffered_out_string(key, str, ofs, len){
      /*<<format.ml:1033:2>>*/  /*<<format.ml:1033:23>>*/ var
-     _aX_ =  /*<<format.ml:1033:23>>*/ caml_call1(Stdlib_Domain[10][2], key);
+     _aY_ =  /*<<format.ml:1033:23>>*/ caml_call1(Stdlib_Domain[10][2], key);
      /*<<format.ml:1033:2>>*/ return  /*<<format.ml:1033:2>>*/ caml_call4
-            (Stdlib_Buffer[18], _aX_, str, ofs, len);
+            (Stdlib_Buffer[18], _aY_, str, ofs, len);
     /*<<format.ml:1033:55>>*/ }
    function buffered_out_flush(oc, key, param){
      /*<<format.ml:1036:2>>*/ var
@@ -25759,31 +25805,31 @@
     err_buf_key =
        /*<<format.ml:1044:18>>*/ caml_call2(Stdlib_Domain[10][1], 0, _i_);
    function _j_(param){
-    function _aG_(_aW_){ /*<<?>>*/ return 0;}
-    function _aH_(_aV_){ /*<<?>>*/ return 0;}
-    function _aI_(_aU_){ /*<<?>>*/ return 0;}
-    var _aJ_ = Stdlib[39];
-     /*<<format.ml:1049:6>>*/ function _aK_(_aT_){
-      /*<<?>>*/ return buffered_out_flush(_aJ_, std_buf_key, _aT_);
+    function _aH_(_aX_){ /*<<?>>*/ return 0;}
+    function _aI_(_aW_){ /*<<?>>*/ return 0;}
+    function _aJ_(_aV_){ /*<<?>>*/ return 0;}
+    var _aK_ = Stdlib[39];
+     /*<<format.ml:1049:6>>*/ function _aL_(_aU_){
+      /*<<?>>*/ return buffered_out_flush(_aK_, std_buf_key, _aU_);
     }
      /*<<format.ml:1048:4>>*/  /*<<format.ml:1048:4>>*/ var
      ppf =
        pp_make_formatter
-        (function(_aQ_, _aR_, _aS_){
-           /*<<?>>*/ return buffered_out_string(std_buf_key, _aQ_, _aR_, _aS_);
+        (function(_aR_, _aS_, _aT_){
+           /*<<?>>*/ return buffered_out_string(std_buf_key, _aR_, _aS_, _aT_);
          },
-         _aK_,
+         _aL_,
+         _aJ_,
          _aI_,
-         _aH_,
-         _aG_);
-    ppf[19] = function(_aP_){ /*<<?>>*/ return display_newline(ppf, _aP_);};
-    ppf[20] = function(_aO_){ /*<<?>>*/ return display_blanks(ppf, _aO_);};
-    ppf[21] = function(_aN_){ /*<<?>>*/ return display_blanks(ppf, _aN_);};
-     /*<<format.ml:1054:17>>*/ function _aL_(_aM_){
-      /*<<?>>*/ return pp_print_flush(ppf, _aM_);
+         _aH_);
+    ppf[19] = function(_aQ_){ /*<<?>>*/ return display_newline(ppf, _aQ_);};
+    ppf[20] = function(_aP_){ /*<<?>>*/ return display_blanks(ppf, _aP_);};
+    ppf[21] = function(_aO_){ /*<<?>>*/ return display_blanks(ppf, _aO_);};
+     /*<<format.ml:1054:17>>*/ function _aM_(_aN_){
+      /*<<?>>*/ return pp_print_flush(ppf, _aN_);
     }
      /*<<format.ml:1054:2>>*/  /*<<format.ml:1054:2>>*/ caml_call1
-     (Stdlib_Domain[6], _aL_);
+     (Stdlib_Domain[6], _aM_);
      /*<<format.ml:1054:2>>*/ return ppf;
     /*<<format.ml:1055:5>>*/ }
     /*<<format.ml:1046:24>>*/  /*<<format.ml:1046:24>>*/ var
@@ -25792,31 +25838,31 @@
     /*<<format.ml:1056:8>>*/  /*<<format.ml:1056:8>>*/ caml_call2
     (Stdlib_Domain[10][3], std_formatter_key, std_formatter);
    function _k_(param){
-    function _ap_(_aF_){ /*<<?>>*/ return 0;}
-    function _aq_(_aE_){ /*<<?>>*/ return 0;}
-    function _ar_(_aD_){ /*<<?>>*/ return 0;}
-    var _as_ = Stdlib[40];
-     /*<<format.ml:1061:6>>*/ function _at_(_aC_){
-      /*<<?>>*/ return buffered_out_flush(_as_, err_buf_key, _aC_);
+    function _aq_(_aG_){ /*<<?>>*/ return 0;}
+    function _ar_(_aF_){ /*<<?>>*/ return 0;}
+    function _as_(_aE_){ /*<<?>>*/ return 0;}
+    var _at_ = Stdlib[40];
+     /*<<format.ml:1061:6>>*/ function _au_(_aD_){
+      /*<<?>>*/ return buffered_out_flush(_at_, err_buf_key, _aD_);
     }
      /*<<format.ml:1060:4>>*/  /*<<format.ml:1060:4>>*/ var
      ppf =
        pp_make_formatter
-        (function(_az_, _aA_, _aB_){
-           /*<<?>>*/ return buffered_out_string(err_buf_key, _az_, _aA_, _aB_);
+        (function(_aA_, _aB_, _aC_){
+           /*<<?>>*/ return buffered_out_string(err_buf_key, _aA_, _aB_, _aC_);
          },
-         _at_,
+         _au_,
+         _as_,
          _ar_,
-         _aq_,
-         _ap_);
-    ppf[19] = function(_ay_){ /*<<?>>*/ return display_newline(ppf, _ay_);};
-    ppf[20] = function(_ax_){ /*<<?>>*/ return display_blanks(ppf, _ax_);};
-    ppf[21] = function(_aw_){ /*<<?>>*/ return display_blanks(ppf, _aw_);};
-     /*<<format.ml:1066:17>>*/ function _au_(_av_){
-      /*<<?>>*/ return pp_print_flush(ppf, _av_);
+         _aq_);
+    ppf[19] = function(_az_){ /*<<?>>*/ return display_newline(ppf, _az_);};
+    ppf[20] = function(_ay_){ /*<<?>>*/ return display_blanks(ppf, _ay_);};
+    ppf[21] = function(_ax_){ /*<<?>>*/ return display_blanks(ppf, _ax_);};
+     /*<<format.ml:1066:17>>*/ function _av_(_aw_){
+      /*<<?>>*/ return pp_print_flush(ppf, _aw_);
     }
      /*<<format.ml:1066:2>>*/  /*<<format.ml:1066:2>>*/ caml_call1
-     (Stdlib_Domain[6], _au_);
+     (Stdlib_Domain[6], _av_);
      /*<<format.ml:1066:2>>*/ return ppf;
     /*<<format.ml:1067:5>>*/ }
     /*<<format.ml:1058:24>>*/  /*<<format.ml:1058:24>>*/ var
@@ -25859,7 +25905,7 @@
             (stdbuf, str_formatter);
     /*<<format.ml:1089:45>>*/ }
    function make_synchronized_formatter(output, flush){
-    function _an_(param){
+    function _ao_(param){
       /*<<format.ml:1093:4>>*/ var
        /*<<format.ml:1093:14>>*/ buf =
          /*<<format.ml:1093:14>>*/ caml_call1
@@ -25868,12 +25914,12 @@
          /*<<format.ml:1094:18>>*/ caml_call1(Stdlib_Buffer[18], buf);
      function flush$0(param){
        /*<<format.ml:1096:6>>*/  /*<<format.ml:1096:37>>*/ var
-       _ao_ =  /*<<format.ml:1096:37>>*/ caml_call1(Stdlib_Buffer[7], buf);
+       _ap_ =  /*<<format.ml:1096:37>>*/ caml_call1(Stdlib_Buffer[7], buf);
        /*<<format.ml:1096:6>>*/  /*<<format.ml:1096:6>>*/ caml_call3
        (output,
          /*<<format.ml:1096:13>>*/ caml_call1(Stdlib_Buffer[2], buf),
         0,
-        _ao_);
+        _ap_);
        /*<<format.ml:1097:6>>*/  /*<<format.ml:1097:6>>*/ caml_call1
        (Stdlib_Buffer[8], buf);
        /*<<format.ml:1097:6>>*/ return  /*<<format.ml:1097:6>>*/ caml_call1
@@ -25882,15 +25928,15 @@
       /*<<format.ml:1100:4>>*/ return make_formatter(output$0, flush$0);
      /*<<format.ml:1100:33>>*/ }
      /*<<format.ml:1092:14>>*/ return  /*<<format.ml:1092:14>>*/ caml_call2
-            (Stdlib_Domain[10][1], 0, _an_);
+            (Stdlib_Domain[10][1], 0, _ao_);
     /*<<format.ml:1100:34>>*/ }
    function synchronized_formatter_of_out_(oc){
-    function _am_(param){
+    function _an_(param){
       /*<<format.ml:1103:63>>*/ return  /*<<format.ml:1103:2>>*/ caml_call1
              (Stdlib[63], oc);
      /*<<format.ml:1103:71>>*/ }
      /*<<format.ml:1103:52>>*/ return make_synchronized_formatter
-            ( /*<<format.ml:1103:30>>*/ caml_call1(Stdlib[69], oc), _am_);
+            ( /*<<format.ml:1103:30>>*/ caml_call1(Stdlib[69], oc), _an_);
     /*<<format.ml:1103:72>>*/ }
    function make_symbolic_output_buffer(param){ /*<<format.ml:1130:2>>*/ return [0, 0];
     /*<<format.ml:1130:35>>*/ }
@@ -25919,10 +25965,10 @@
                 /*<<format.ml:1152:48>>*/ caml_call3
                 (Stdlib_String[15], s, i, n)]);
     }
-     /*<<format.ml:1159:10>>*/ function g(_al_){
+     /*<<format.ml:1159:10>>*/ function g(_am_){
       /*<<format.ml:1148:4>>*/ return add_symbolic_output_item(sob, 0);
     }
-     /*<<format.ml:1160:10>>*/ function h(_ak_){
+     /*<<format.ml:1160:10>>*/ function h(_al_){
       /*<<format.ml:1150:4>>*/ return add_symbolic_output_item(sob, 1);
     }
      /*<<format.ml:1161:10>>*/ function i(n){
@@ -26309,8 +26355,8 @@
      /*<<format.ml:1285:31>>*/ }
     for(;;){
      if(right[1] === len){
-      var _aj_ = left[1] !== len ? 1 : 0;
-      return _aj_ ? flush(0) : _aj_;
+      var _ak_ = left[1] !== len ? 1 : 0;
+      return _ak_ ? flush(0) : _ak_;
      }
       /*<<format.ml:1288:10>>*/  /*<<format.ml:1288:10>>*/ var
       match =  /*<<format.ml:1288:10>>*/ runtime.caml_string_get(s, right[1]);
@@ -26332,7 +26378,7 @@
     else
      var
       none =
-        function(param, _ai_){
+        function(param, _aj_){
           /*<<format.ml:1300:41>>*/ return 0;
          /*<<format.ml:1300:43>>*/ };
      /*<<format.ml:1300:56>>*/ if(! param)
@@ -26425,65 +26471,65 @@
        var acc$1 = match[1];
         /*<<format.ml:1366:4>>*/ output_acc(ppf, p$0);
         /*<<format.ml:1367:43>>*/ var
-         /*<<format.ml:1367:43>>*/ _$_ = compute_tag(output_acc, acc$1),
+         /*<<format.ml:1367:43>>*/ _aa_ = compute_tag(output_acc, acc$1),
          /*<<format.ml:1367:24>>*/ match$0 =
-           /*<<format.ml:1367:24>>*/ caml_call1(CamlinternalFormat[20], _$_),
+           /*<<format.ml:1367:24>>*/ caml_call1(CamlinternalFormat[20], _aa_),
         bty = match$0[2],
         indent = match$0[1];
         /*<<format.ml:1368:4>>*/ return pp_open_box_gen(ppf, indent, bty);
       case 2:
-       var _aa_ = acc[1], switch$1 = 0;
-       if(typeof _aa_ === "number" || ! (0 === _aa_[0]))
+       var _ab_ = acc[1], switch$1 = 0;
+       if(typeof _ab_ === "number" || ! (0 === _ab_[0]))
         switch$1 = 1;
        else{
-        var _ab_ = _aa_[2], switch$2 = 0;
-        if(typeof _ab_ === "number" || ! (1 === _ab_[0]))
+        var _ac_ = _ab_[2], switch$2 = 0;
+        if(typeof _ac_ === "number" || ! (1 === _ac_[0]))
          switch$2 = 1;
         else
-         var s$0 = acc[2], size = _ab_[2], p$2 = _aa_[1];
+         var s$0 = acc[2], size = _ac_[2], p$2 = _ab_[1];
         if(switch$2) switch$1 = 1;
        }
-       if(switch$1){var s = acc[2], p$1 = _aa_; switch$0 = 2;}
+       if(switch$1){var s = acc[2], p$1 = _ab_; switch$0 = 2;}
        break;
       case 3:
-       var _ac_ = acc[1], switch$3 = 0;
-       if(typeof _ac_ === "number" || ! (0 === _ac_[0]))
+       var _ad_ = acc[1], switch$3 = 0;
+       if(typeof _ad_ === "number" || ! (0 === _ad_[0]))
         switch$3 = 1;
        else{
-        var _ad_ = _ac_[2], switch$4 = 0;
-        if(typeof _ad_ === "number" || ! (1 === _ad_[0]))
+        var _ae_ = _ad_[2], switch$4 = 0;
+        if(typeof _ae_ === "number" || ! (1 === _ae_[0]))
          switch$4 = 1;
-        else{var c$0 = acc[2], size$0 = _ad_[2], p$4 = _ac_[1]; switch$0 = 1;}
+        else{var c$0 = acc[2], size$0 = _ae_[2], p$4 = _ad_[1]; switch$0 = 1;}
         if(switch$4) switch$3 = 1;
        }
-       if(switch$3){var c = acc[2], p$3 = _ac_; switch$0 = 3;}
+       if(switch$3){var c = acc[2], p$3 = _ad_; switch$0 = 3;}
        break;
       case 4:
-       var _ae_ = acc[1], switch$5 = 0;
-       if(typeof _ae_ === "number" || ! (0 === _ae_[0]))
+       var _af_ = acc[1], switch$5 = 0;
+       if(typeof _af_ === "number" || ! (0 === _af_[0]))
         switch$5 = 1;
        else{
-        var _af_ = _ae_[2], switch$6 = 0;
-        if(typeof _af_ === "number" || ! (1 === _af_[0]))
+        var _ag_ = _af_[2], switch$6 = 0;
+        if(typeof _ag_ === "number" || ! (1 === _ag_[0]))
          switch$6 = 1;
         else
-         var s$0 = acc[2], size = _af_[2], p$2 = _ae_[1];
+         var s$0 = acc[2], size = _ag_[2], p$2 = _af_[1];
         if(switch$6) switch$5 = 1;
        }
-       if(switch$5){var s = acc[2], p$1 = _ae_; switch$0 = 2;}
+       if(switch$5){var s = acc[2], p$1 = _af_; switch$0 = 2;}
        break;
       case 5:
-       var _ag_ = acc[1], switch$7 = 0;
-       if(typeof _ag_ === "number" || ! (0 === _ag_[0]))
+       var _ah_ = acc[1], switch$7 = 0;
+       if(typeof _ah_ === "number" || ! (0 === _ah_[0]))
         switch$7 = 1;
        else{
-        var _ah_ = _ag_[2], switch$8 = 0;
-        if(typeof _ah_ === "number" || ! (1 === _ah_[0]))
+        var _ai_ = _ah_[2], switch$8 = 0;
+        if(typeof _ai_ === "number" || ! (1 === _ai_[0]))
          switch$8 = 1;
-        else{var c$0 = acc[2], size$0 = _ah_[2], p$4 = _ag_[1]; switch$0 = 1;}
+        else{var c$0 = acc[2], size$0 = _ai_[2], p$4 = _ah_[1]; switch$0 = 1;}
         if(switch$8) switch$7 = 1;
        }
-       if(switch$7){var c = acc[2], p$3 = _ag_; switch$0 = 3;}
+       if(switch$7){var c = acc[2], p$3 = _ah_; switch$0 = 3;}
        break;
       case 6:
        var f$0 = acc[2], p$5 = acc[1];
@@ -26538,65 +26584,65 @@
        var acc$1 = match[1];
         /*<<format.ml:1401:4>>*/ strput_acc(ppf, p$0);
         /*<<format.ml:1402:43>>*/ var
-         /*<<format.ml:1402:43>>*/ _S_ = compute_tag(strput_acc, acc$1),
+         /*<<format.ml:1402:43>>*/ _T_ = compute_tag(strput_acc, acc$1),
          /*<<format.ml:1402:24>>*/ match$0 =
-           /*<<format.ml:1402:24>>*/ caml_call1(CamlinternalFormat[20], _S_),
+           /*<<format.ml:1402:24>>*/ caml_call1(CamlinternalFormat[20], _T_),
         bty = match$0[2],
         indent = match$0[1];
         /*<<format.ml:1403:4>>*/ return pp_open_box_gen(ppf, indent, bty);
       case 2:
-       var _T_ = acc[1], switch$1 = 0;
-       if(typeof _T_ === "number" || ! (0 === _T_[0]))
+       var _U_ = acc[1], switch$1 = 0;
+       if(typeof _U_ === "number" || ! (0 === _U_[0]))
         switch$1 = 1;
        else{
-        var _U_ = _T_[2], switch$2 = 0;
-        if(typeof _U_ === "number" || ! (1 === _U_[0]))
+        var _V_ = _U_[2], switch$2 = 0;
+        if(typeof _V_ === "number" || ! (1 === _V_[0]))
          switch$2 = 1;
         else
-         var s$0 = acc[2], size = _U_[2], p$2 = _T_[1];
+         var s$0 = acc[2], size = _V_[2], p$2 = _U_[1];
         if(switch$2) switch$1 = 1;
        }
-       if(switch$1){var s = acc[2], p$1 = _T_; switch$0 = 2;}
+       if(switch$1){var s = acc[2], p$1 = _U_; switch$0 = 2;}
        break;
       case 3:
-       var _V_ = acc[1], switch$3 = 0;
-       if(typeof _V_ === "number" || ! (0 === _V_[0]))
+       var _W_ = acc[1], switch$3 = 0;
+       if(typeof _W_ === "number" || ! (0 === _W_[0]))
         switch$3 = 1;
        else{
-        var _W_ = _V_[2], switch$4 = 0;
-        if(typeof _W_ === "number" || ! (1 === _W_[0]))
+        var _X_ = _W_[2], switch$4 = 0;
+        if(typeof _X_ === "number" || ! (1 === _X_[0]))
          switch$4 = 1;
-        else{var c$0 = acc[2], size$0 = _W_[2], p$4 = _V_[1]; switch$0 = 1;}
+        else{var c$0 = acc[2], size$0 = _X_[2], p$4 = _W_[1]; switch$0 = 1;}
         if(switch$4) switch$3 = 1;
        }
-       if(switch$3){var c = acc[2], p$3 = _V_; switch$0 = 3;}
+       if(switch$3){var c = acc[2], p$3 = _W_; switch$0 = 3;}
        break;
       case 4:
-       var _X_ = acc[1], switch$5 = 0;
-       if(typeof _X_ === "number" || ! (0 === _X_[0]))
+       var _Y_ = acc[1], switch$5 = 0;
+       if(typeof _Y_ === "number" || ! (0 === _Y_[0]))
         switch$5 = 1;
        else{
-        var _Y_ = _X_[2], switch$6 = 0;
-        if(typeof _Y_ === "number" || ! (1 === _Y_[0]))
+        var _Z_ = _Y_[2], switch$6 = 0;
+        if(typeof _Z_ === "number" || ! (1 === _Z_[0]))
          switch$6 = 1;
         else
-         var s$0 = acc[2], size = _Y_[2], p$2 = _X_[1];
+         var s$0 = acc[2], size = _Z_[2], p$2 = _Y_[1];
         if(switch$6) switch$5 = 1;
        }
-       if(switch$5){var s = acc[2], p$1 = _X_; switch$0 = 2;}
+       if(switch$5){var s = acc[2], p$1 = _Y_; switch$0 = 2;}
        break;
       case 5:
-       var _Z_ = acc[1], switch$7 = 0;
-       if(typeof _Z_ === "number" || ! (0 === _Z_[0]))
+       var ___ = acc[1], switch$7 = 0;
+       if(typeof ___ === "number" || ! (0 === ___[0]))
         switch$7 = 1;
        else{
-        var ___ = _Z_[2], switch$8 = 0;
-        if(typeof ___ === "number" || ! (1 === ___[0]))
+        var _$_ = ___[2], switch$8 = 0;
+        if(typeof _$_ === "number" || ! (1 === _$_[0]))
          switch$8 = 1;
-        else{var c$0 = acc[2], size$0 = ___[2], p$4 = _Z_[1]; switch$0 = 1;}
+        else{var c$0 = acc[2], size$0 = _$_[2], p$4 = ___[1]; switch$0 = 1;}
         if(switch$8) switch$7 = 1;
        }
-       if(switch$7){var c = acc[2], p$3 = _Z_; switch$0 = 3;}
+       if(switch$7){var c = acc[2], p$3 = ___; switch$0 = 3;}
        break;
       case 6:
        var p$5 = acc[1];
@@ -26645,13 +26691,13 @@
    function kfprintf(k, ppf, param){
      /*<<format.ml:1420:2>>*/ var
      fmt = param[1],
-      /*<<format.ml:1420:2>>*/ _Q_ = 0;
-    function _R_(acc){
+      /*<<format.ml:1420:2>>*/ _R_ = 0;
+    function _S_(acc){
       /*<<format.ml:1421:16>>*/ output_acc(ppf, acc);
      return caml_call1(k, ppf);
      /*<<format.ml:1421:41>>*/ }
      /*<<format.ml:1420:2>>*/ return  /*<<format.ml:1420:2>>*/ caml_call3
-            (CamlinternalFormat[7], _R_, _Q_, fmt);
+            (CamlinternalFormat[7], _S_, _R_, fmt);
    }
    function ikfprintf(k, ppf, param){
     var fmt = param[1];
@@ -26661,47 +26707,47 @@
    function ifprintf(ppf, param){
      /*<<format.ml:1428:2>>*/ var
      fmt = param[1],
-      /*<<format.ml:1428:2>>*/ _N_ = 0;
-    function _O_(_P_){ /*<<?>>*/ return 0;}
+      /*<<format.ml:1428:2>>*/ _O_ = 0;
+    function _P_(_Q_){ /*<<?>>*/ return 0;}
      /*<<format.ml:1428:2>>*/ return  /*<<format.ml:1428:2>>*/ caml_call3
-            (CamlinternalFormat[8], _O_, _N_, fmt);
+            (CamlinternalFormat[8], _P_, _O_, fmt);
    }
    function fprintf(ppf){
-    function _K_(_M_){ /*<<?>>*/ return 0;}
-     /*<<format.ml:1430:18>>*/ return function(_L_){
-      /*<<?>>*/ return kfprintf(_K_, ppf, _L_);};
+    function _L_(_N_){ /*<<?>>*/ return 0;}
+     /*<<format.ml:1430:18>>*/ return function(_M_){
+      /*<<?>>*/ return kfprintf(_L_, ppf, _M_);};
     /*<<format.ml:1430:37>>*/ }
    function printf(param){
      /*<<format.ml:1433:2>>*/ var
      fmt = param[1],
-      /*<<format.ml:1433:2>>*/ _I_ = 0;
-    function _J_(acc){
+      /*<<format.ml:1433:2>>*/ _J_ = 0;
+    function _K_(acc){
       /*<<format.ml:1434:16>>*/ return output_acc
              ( /*<<format.ml:1434:27>>*/ caml_call1
                (Stdlib_Domain[10][2], std_formatter_key),
               acc);
      /*<<format.ml:1434:58>>*/ }
      /*<<format.ml:1433:2>>*/ return  /*<<format.ml:1433:2>>*/ caml_call3
-            (CamlinternalFormat[7], _J_, _I_, fmt);
+            (CamlinternalFormat[7], _K_, _J_, fmt);
    }
    function eprintf(param){
      /*<<format.ml:1438:2>>*/ var
      fmt = param[1],
-      /*<<format.ml:1438:2>>*/ _G_ = 0;
-    function _H_(acc){
+      /*<<format.ml:1438:2>>*/ _H_ = 0;
+    function _I_(acc){
       /*<<format.ml:1439:16>>*/ return output_acc
              ( /*<<format.ml:1439:27>>*/ caml_call1
                (Stdlib_Domain[10][2], err_formatter_key),
               acc);
      /*<<format.ml:1439:58>>*/ }
      /*<<format.ml:1438:2>>*/ return  /*<<format.ml:1438:2>>*/ caml_call3
-            (CamlinternalFormat[7], _H_, _G_, fmt);
+            (CamlinternalFormat[7], _I_, _H_, fmt);
    }
    function kdprintf(k, param){
      /*<<format.ml:1443:2>>*/ var
      fmt = param[1],
-      /*<<format.ml:1443:2>>*/ _E_ = 0;
-    function _F_(acc){
+      /*<<format.ml:1443:2>>*/ _F_ = 0;
+    function _G_(acc){
       /*<<format.ml:1444:16>>*/ return  /*<<format.ml:1444:18>>*/ caml_call1
              (k,
               function(ppf){
@@ -26709,7 +26755,7 @@
                /*<<format.ml:1444:48>>*/ });
      /*<<format.ml:1444:49>>*/ }
      /*<<format.ml:1443:2>>*/ return  /*<<format.ml:1443:2>>*/ caml_call3
-            (CamlinternalFormat[7], _F_, _E_, fmt);
+            (CamlinternalFormat[7], _G_, _F_, fmt);
    }
    function dprintf(fmt){
      /*<<format.ml:1447:18>>*/ return kdprintf
@@ -26767,44 +26813,44 @@
      /*<<format.ml:1481:11>>*/ var
       /*<<format.ml:1481:11>>*/ fs =
        pp_get_formatter_out_functions(std_formatter, 0),
-     _m_ = fs[5],
-     _n_ = fs[4],
-     _o_ = fs[3],
-     _p_ = Stdlib[39];
-     /*<<format.ml:1484:25>>*/ function _q_(_D_){
-      /*<<?>>*/ return buffered_out_flush(_p_, std_buf_key, _D_);
+     _n_ = fs[5],
+     _o_ = fs[4],
+     _p_ = fs[3],
+     _q_ = Stdlib[39];
+     /*<<format.ml:1484:25>>*/ function _r_(_E_){
+      /*<<?>>*/ return buffered_out_flush(_q_, std_buf_key, _E_);
     }
      /*<<format.ml:1482:2>>*/ pp_set_formatter_out_functions
      (std_formatter,
       [0,
-       function(_A_, _B_, _C_){
-         /*<<?>>*/ return buffered_out_string(std_buf_key, _A_, _B_, _C_);
+       function(_B_, _C_, _D_){
+         /*<<?>>*/ return buffered_out_string(std_buf_key, _B_, _C_, _D_);
        },
-       _q_,
+       _r_,
+       _p_,
        _o_,
-       _n_,
-       _m_]);
+       _n_]);
      /*<<format.ml:1486:11>>*/ var
       /*<<format.ml:1486:11>>*/ fs$0 =
        pp_get_formatter_out_functions(err_formatter, 0),
-     _r_ = fs$0[5],
-     _s_ = fs$0[4],
-     _t_ = fs$0[3],
-     _u_ = Stdlib[40];
-     /*<<format.ml:1489:25>>*/ function _v_(_z_){
-      /*<<?>>*/ return buffered_out_flush(_u_, err_buf_key, _z_);
+     _s_ = fs$0[5],
+     _t_ = fs$0[4],
+     _u_ = fs$0[3],
+     _v_ = Stdlib[40];
+     /*<<format.ml:1489:25>>*/ function _w_(_A_){
+      /*<<?>>*/ return buffered_out_flush(_v_, err_buf_key, _A_);
     }
      /*<<format.ml:1488:4>>*/ return pp_set_formatter_out_functions
             (err_formatter,
              [0,
-              function(_w_, _x_, _y_){
+              function(_x_, _y_, _z_){
                 /*<<?>>*/ return buffered_out_string
-                       (err_buf_key, _w_, _x_, _y_);
+                       (err_buf_key, _x_, _y_, _z_);
               },
-              _v_,
+              _w_,
+              _u_,
               _t_,
-              _s_,
-              _r_]);
+              _s_]);
     /*<<format.ml:1489:71>>*/ }
     /*<<format.ml:1479:9>>*/  /*<<format.ml:1479:9>>*/ caml_call1
     (Stdlib_Domain[5], _l_);
@@ -27005,6 +27051,7 @@
             : runtime.caml_call_gen(f, [a0, a1, a2, a3]);
    }
    var
+    _u_ = undefined,
     global_data = runtime.caml_get_global_data(),
     cst$3 = cst$5,
     cst$4 = cst$5,
@@ -27128,9 +27175,9 @@
      if(10 === c) ib[5] = ib[5] + 1 | 0;
       /*<<scanf.ml:171:6>>*/ return c;
     }
-    catch(_bb_){
-     var _ba_ = caml_wrap_exception(_bb_);
-     if(_ba_ !== Stdlib[12]) throw caml_maybe_attach_backtrace(_ba_, 0);
+    catch(_bc_){
+     var _bb_ = caml_wrap_exception(_bc_);
+     if(_bb_ !== Stdlib[12]) throw caml_maybe_attach_backtrace(_bb_, 0);
      ib[2] = null_char;
      ib[3] = 0;
      ib[1] = 1;
@@ -27223,8 +27270,8 @@
      /*<<scanf.ml:271:4>>*/ return create(1, next);
     /*<<scanf.ml:271:27>>*/ }
    var _a_ = 0;
-    /*<<scanf.ml:274:22>>*/ function from_function(_a$_){
-     /*<<?>>*/ return create(_a_, _a$_);
+    /*<<scanf.ml:274:22>>*/ function from_function(_ba_){
+     /*<<?>>*/ return create(_a_, _ba_);
    }
     /*<<scanf.ml:274:22>>*/  /*<<scanf.ml:274:22>>*/ var len = 1024;
    function scan_close_at_end(ic){
@@ -27271,12 +27318,12 @@
     return from_ic(scan_close_at_end, [1, fname, ic], ic);
     /*<<scanf.ml:371:53>>*/ }
    var _b_ = Stdlib[79];
-    /*<<scanf.ml:374:16>>*/ function open_in(_a__){
-     /*<<?>>*/ return open_in_file(_b_, _a__);
+    /*<<scanf.ml:374:16>>*/ function open_in(_a$_){
+     /*<<?>>*/ return open_in_file(_b_, _a$_);
    }
     /*<<scanf.ml:374:16>>*/  /*<<scanf.ml:374:16>>*/ var _c_ = Stdlib[80];
-    /*<<scanf.ml:375:20>>*/ function open_in_bin(_a9_){
-     /*<<?>>*/ return open_in_file(_c_, _a9_);
+    /*<<scanf.ml:375:20>>*/ function open_in_bin(_a__){
+     /*<<?>>*/ return open_in_file(_c_, _a__);
    }
    function from_channel(ic){
      /*<<scanf.ml:381:4>>*/ return from_ic(scan_raise_at_end, [0, ic], ic);
@@ -27339,15 +27386,15 @@
      /*<<scanf.ml:444:2>>*/ for(;;){
       /*<<scanf.ml:444:10>>*/ var
        /*<<scanf.ml:444:10>>*/ c = peek_char(ib),
-       /*<<scanf.ml:445:9>>*/ _a7_ = 1 - ib[1];
-     if(! _a7_)  /*<<scanf.ml:445:9>>*/ return _a7_;
+       /*<<scanf.ml:445:9>>*/ _a8_ = 1 - ib[1];
+     if(! _a8_)  /*<<scanf.ml:445:9>>*/ return _a8_;
       /*<<scanf.ml:445:32>>*/ var
-       /*<<scanf.ml:445:32>>*/ _a8_ = c - 9 | 0,
+       /*<<scanf.ml:445:32>>*/ _a9_ = c - 9 | 0,
       switch$0 = 0;
-     if(4 < _a8_ >>> 0){
-      if(23 === _a8_) switch$0 = 1;
+     if(4 < _a9_ >>> 0){
+      if(23 === _a9_) switch$0 = 1;
      }
-     else if(1 < _a8_ - 2 >>> 0) switch$0 = 1;
+     else if(1 < _a9_ - 2 >>> 0) switch$0 = 1;
      if(! switch$0)  /*<<scanf.ml:449:11>>*/ return 0;
       /*<<scanf.ml:448:6>>*/ invalidate_current_char(ib);
     }
@@ -27392,23 +27439,23 @@
      /*<<scanf.ml:523:2>>*/ switch(conv){
       case 0:
         /*<<scanf.ml:529:29>>*/ var
-         /*<<scanf.ml:529:29>>*/ _a3_ = token_string(ib),
-        tok =  /*<<scanf.ml:529:22>>*/ caml_call2(Stdlib[28], cst_0b, _a3_);
+         /*<<scanf.ml:529:29>>*/ _a4_ = token_string(ib),
+        tok =  /*<<scanf.ml:529:22>>*/ caml_call2(Stdlib[28], cst_0b, _a4_);
        break;
       case 3:
         /*<<scanf.ml:527:29>>*/ var
-         /*<<scanf.ml:527:29>>*/ _a4_ = token_string(ib),
-        tok =  /*<<scanf.ml:527:22>>*/ caml_call2(Stdlib[28], cst_0o, _a4_);
+         /*<<scanf.ml:527:29>>*/ _a5_ = token_string(ib),
+        tok =  /*<<scanf.ml:527:22>>*/ caml_call2(Stdlib[28], cst_0o, _a5_);
        break;
       case 4:
         /*<<scanf.ml:526:29>>*/ var
-         /*<<scanf.ml:526:29>>*/ _a5_ = token_string(ib),
-        tok =  /*<<scanf.ml:526:22>>*/ caml_call2(Stdlib[28], cst_0u, _a5_);
+         /*<<scanf.ml:526:29>>*/ _a6_ = token_string(ib),
+        tok =  /*<<scanf.ml:526:22>>*/ caml_call2(Stdlib[28], cst_0u, _a6_);
        break;
       case 5:
         /*<<scanf.ml:528:29>>*/ var
-         /*<<scanf.ml:528:29>>*/ _a6_ = token_string(ib),
-        tok =  /*<<scanf.ml:528:22>>*/ caml_call2(Stdlib[28], cst_0x, _a6_);
+         /*<<scanf.ml:528:29>>*/ _a7_ = token_string(ib),
+        tok =  /*<<scanf.ml:528:22>>*/ caml_call2(Stdlib[28], cst_0x, _a7_);
        break;
       default: var tok = token_string(ib);
     }
@@ -27493,28 +27540,28 @@
    function is_binary_digit(param){
      /*<<scanf.ml:629:22>>*/ return 1 < param - 48 >>> 0 ? 0 : 1;
     /*<<scanf.ml:631:14>>*/ }
-    /*<<scanf.ml:634:22>>*/ function scan_binary_int(_a1_, _a2_){
-     /*<<?>>*/ return scan_digit_plus(cst_binary, is_binary_digit, _a1_, _a2_);
+    /*<<scanf.ml:634:22>>*/ function scan_binary_int(_a2_, _a3_){
+     /*<<?>>*/ return scan_digit_plus(cst_binary, is_binary_digit, _a2_, _a3_);
    }
    function is_octal_digit(param){
      /*<<scanf.ml:636:21>>*/ return 7 < param - 48 >>> 0 ? 0 : 1;
     /*<<scanf.ml:638:14>>*/ }
-    /*<<scanf.ml:641:21>>*/ function scan_octal_int(_aZ_, _a0_){
-     /*<<?>>*/ return scan_digit_plus(cst_octal, is_octal_digit, _aZ_, _a0_);
+    /*<<scanf.ml:641:21>>*/ function scan_octal_int(_a0_, _a1_){
+     /*<<?>>*/ return scan_digit_plus(cst_octal, is_octal_digit, _a0_, _a1_);
    }
    function is_hexa_digit(param){
      /*<<scanf.ml:643:20>>*/ var
-      /*<<scanf.ml:643:20>>*/ _aY_ = param - 48 | 0,
+      /*<<scanf.ml:643:20>>*/ _aZ_ = param - 48 | 0,
      switch$0 = 0;
-    if(22 < _aY_ >>> 0){
-     if(5 >= _aY_ - 49 >>> 0) switch$0 = 1;
+    if(22 < _aZ_ >>> 0){
+     if(5 >= _aZ_ - 49 >>> 0) switch$0 = 1;
     }
-    else if(6 < _aY_ - 10 >>> 0) switch$0 = 1;
+    else if(6 < _aZ_ - 10 >>> 0) switch$0 = 1;
     return switch$0 ? 1 : 0;
     /*<<scanf.ml:645:14>>*/ }
-    /*<<scanf.ml:648:27>>*/ function scan_hexadecimal_int(_aW_, _aX_){
+    /*<<scanf.ml:648:27>>*/ function scan_hexadecimal_int(_aX_, _aY_){
      /*<<?>>*/ return scan_digit_plus
-            (cst_hexadecimal, is_hexa_digit, _aW_, _aX_);
+            (cst_hexadecimal, is_hexa_digit, _aX_, _aY_);
    }
    function scan_sign(width, ib){
      /*<<scanf.ml:654:2>>*/ var
@@ -27631,22 +27678,22 @@
       /*<<scanf.ml:785:2>>*/ len =
         /*<<scanf.ml:785:2>>*/ caml_ml_string_length(str),
       /*<<scanf.ml:786:14>>*/ width$0 = [0, width],
-      /*<<scanf.ml:787:2>>*/ _aT_ = len - 1 | 0,
-      /*<<scanf.ml:786:14>>*/ _aS_ = 0;
-    if(_aT_ >= 0){
-     var i = _aS_;
+      /*<<scanf.ml:787:2>>*/ _aU_ = len - 1 | 0,
+      /*<<scanf.ml:786:14>>*/ _aT_ = 0;
+    if(_aU_ >= 0){
+     var i = _aT_;
      for(;;){
        /*<<scanf.ml:788:12>>*/ var
         /*<<scanf.ml:788:12>>*/ c = peek_char(ib),
-        /*<<scanf.ml:789:22>>*/ _aU_ =
+        /*<<scanf.ml:789:22>>*/ _aV_ =
          lowercase( /*<<scanf.ml:789:32>>*/ caml_string_get(str, i));
-      if(lowercase(c) !== _aU_)
+      if(lowercase(c) !== _aV_)
         /*<<scanf.ml:789:45>>*/  /*<<scanf.ml:789:45>>*/ caml_call1(error, 0);
       if(0 === width$0[1])
         /*<<scanf.ml:790:23>>*/  /*<<scanf.ml:790:23>>*/ caml_call1(error, 0);
       width$0[1] = store_char(width$0[1], ib, c);
-       /*<<scanf.ml:787:2>>*/  /*<<scanf.ml:787:2>>*/ var _aV_ = i + 1 | 0;
-      if(_aT_ !== i){var i = _aV_; continue;}
+       /*<<scanf.ml:787:2>>*/  /*<<scanf.ml:787:2>>*/ var _aW_ = i + 1 | 0;
+      if(_aU_ !== i){var i = _aW_; continue;}
       break;
      }
     }
@@ -27654,15 +27701,15 @@
     /*<<scanf.ml:793:8>>*/ }
    function scan_hex_float(width, precision, ib){
      /*<<scanf.ml:797:2>>*/ var
-     _aF_ = 0 === width ? 1 : 0,
-     _aG_ = _aF_ || end_of_input(ib);
-     /*<<scanf.ml:797:18>>*/ if(_aG_)
+     _aG_ = 0 === width ? 1 : 0,
+     _aH_ = _aG_ || end_of_input(ib);
+     /*<<scanf.ml:797:18>>*/ if(_aH_)
       /*<<scanf.ml:797:48>>*/ bad_hex_float(0);
      /*<<scanf.ml:798:14>>*/ var
       /*<<scanf.ml:798:14>>*/ width$0 = scan_sign(width, ib),
-     _aH_ = 0 === width$0 ? 1 : 0,
-     _aI_ = _aH_ || end_of_input(ib);
-     /*<<scanf.ml:799:18>>*/ if(_aI_)
+     _aI_ = 0 === width$0 ? 1 : 0,
+     _aJ_ = _aI_ || end_of_input(ib);
+     /*<<scanf.ml:799:18>>*/ if(_aJ_)
       /*<<scanf.ml:799:48>>*/ bad_hex_float(0);
      /*<<scanf.ml:800:8>>*/ var
       /*<<scanf.ml:800:8>>*/ c = peek_char(ib),
@@ -27674,9 +27721,9 @@
       if(32 > switcher){
         /*<<scanf.ml:830:16>>*/ var
          /*<<scanf.ml:830:16>>*/ width$1 = store_char(width$0, ib, c),
-        _aJ_ = 0 === width$1 ? 1 : 0,
-        _aK_ = _aJ_ || end_of_input(ib);
-        /*<<scanf.ml:831:20>>*/ if(_aK_)
+        _aK_ = 0 === width$1 ? 1 : 0,
+        _aL_ = _aK_ || end_of_input(ib);
+        /*<<scanf.ml:831:20>>*/ if(_aL_)
          /*<<scanf.ml:831:50>>*/ bad_hex_float(0);
         /*<<scanf.ml:831:50>>*/ return check_case_insensitive_string
                (width$1, ib, bad_hex_float, cst_an);
@@ -27688,21 +27735,21 @@
      if(48 === c){
        /*<<scanf.ml:802:16>>*/ var
         /*<<scanf.ml:802:16>>*/ width$3 = store_char(width$0, ib, c),
-       _aN_ = 0 === width$3 ? 1 : 0,
-       _aO_ = _aN_ || end_of_input(ib);
-       /*<<scanf.ml:803:20>>*/ if(_aO_)
+       _aO_ = 0 === width$3 ? 1 : 0,
+       _aP_ = _aO_ || end_of_input(ib);
+       /*<<scanf.ml:803:20>>*/ if(_aP_)
         /*<<scanf.ml:803:50>>*/ bad_hex_float(0);
        /*<<scanf.ml:804:16>>*/  /*<<scanf.ml:804:16>>*/ var
        width$4 =
          check_case_insensitive_string(width$3, ib, bad_hex_float, cst_x);
        /*<<scanf.ml:805:20>>*/ if(0 !== width$4 && ! end_of_input(ib)){
         /*<<scanf.ml:806:24>>*/ var
-         /*<<scanf.ml:806:24>>*/ _aP_ = peek_char(ib) - 46 | 0,
+         /*<<scanf.ml:806:24>>*/ _aQ_ = peek_char(ib) - 46 | 0,
         switch$1 = 0;
-       if(34 < _aP_ >>> 0){
-        if(66 === _aP_) switch$1 = 1;
+       if(34 < _aQ_ >>> 0){
+        if(66 === _aQ_) switch$1 = 1;
        }
-       else if(32 < _aP_ - 1 >>> 0) switch$1 = 1;
+       else if(32 < _aQ_ - 1 >>> 0) switch$1 = 1;
        var width$5 = switch$1 ? width$4 : scan_hexadecimal_int(width$4, ib);
         /*<<scanf.ml:809:22>>*/ if(0 !== width$5 && ! end_of_input(ib)){
          /*<<scanf.ml:810:26>>*/  /*<<scanf.ml:810:26>>*/ var
@@ -27742,9 +27789,9 @@
            /*<<scanf.ml:827:17>>*/ return width$8;
           /*<<scanf.ml:824:24>>*/ var
            /*<<scanf.ml:824:24>>*/ width$9 = store_char(width$8, ib, c$1),
-          _aQ_ = 0 === width$9 ? 1 : 0,
-          _aR_ = _aQ_ || end_of_input(ib);
-          /*<<scanf.ml:825:28>>*/ if(_aR_)
+          _aR_ = 0 === width$9 ? 1 : 0,
+          _aS_ = _aR_ || end_of_input(ib);
+          /*<<scanf.ml:825:28>>*/ if(_aS_)
            /*<<scanf.ml:825:58>>*/ bad_hex_float(0);
           /*<<scanf.ml:825:58>>*/ return scan_optionally_signed_decimal
                  (width$9, ib);
@@ -27760,23 +27807,23 @@
     if(! switch$0)  /*<<scanf.ml:837:9>>*/ return bad_hex_float(0);
      /*<<scanf.ml:834:16>>*/ var
       /*<<scanf.ml:834:16>>*/ width$2 = store_char(width$0, ib, c),
-     _aL_ = 0 === width$2 ? 1 : 0,
-     _aM_ = _aL_ || end_of_input(ib);
-     /*<<scanf.ml:835:20>>*/ if(_aM_)
+     _aM_ = 0 === width$2 ? 1 : 0,
+     _aN_ = _aM_ || end_of_input(ib);
+     /*<<scanf.ml:835:20>>*/ if(_aN_)
       /*<<scanf.ml:835:50>>*/ bad_hex_float(0);
      /*<<scanf.ml:835:50>>*/ return check_case_insensitive_string
             (width$2, ib, bad_hex_float, cst_nfinity);
     /*<<scanf.ml:837:25>>*/ }
    function scan_caml_float_rest(width, precision, ib){
      /*<<scanf.ml:841:2>>*/ var
-     _aB_ = 0 === width ? 1 : 0,
-     _aC_ = _aB_ || end_of_input(ib);
-     /*<<scanf.ml:841:18>>*/ if(_aC_)  /*<<scanf.ml:841:48>>*/ bad_float(0);
+     _aC_ = 0 === width ? 1 : 0,
+     _aD_ = _aC_ || end_of_input(ib);
+     /*<<scanf.ml:841:18>>*/ if(_aD_)  /*<<scanf.ml:841:48>>*/ bad_float(0);
      /*<<scanf.ml:842:14>>*/ var
       /*<<scanf.ml:842:14>>*/ width$0 = scan_decimal_digit_star(width, ib),
-     _aD_ = 0 === width$0 ? 1 : 0,
-     _aE_ = _aD_ || end_of_input(ib);
-     /*<<scanf.ml:843:18>>*/ if(_aE_)  /*<<scanf.ml:843:48>>*/ bad_float(0);
+     _aE_ = 0 === width$0 ? 1 : 0,
+     _aF_ = _aE_ || end_of_input(ib);
+     /*<<scanf.ml:843:18>>*/ if(_aF_)  /*<<scanf.ml:843:48>>*/ bad_float(0);
      /*<<scanf.ml:844:10>>*/ var
       /*<<scanf.ml:844:10>>*/ c = peek_char(ib),
       /*<<scanf.ml:844:10>>*/ switcher = c - 69 | 0;
@@ -27800,22 +27847,22 @@
     /*<<scanf.ml:862:21>>*/ }
    function scan_caml_float(width, precision, ib){
      /*<<scanf.ml:866:2>>*/ var
-     _an_ = 0 === width ? 1 : 0,
-     _ao_ = _an_ || end_of_input(ib);
-     /*<<scanf.ml:866:18>>*/ if(_ao_)  /*<<scanf.ml:866:48>>*/ bad_float(0);
+     _ao_ = 0 === width ? 1 : 0,
+     _ap_ = _ao_ || end_of_input(ib);
+     /*<<scanf.ml:866:18>>*/ if(_ap_)  /*<<scanf.ml:866:48>>*/ bad_float(0);
      /*<<scanf.ml:867:14>>*/ var
       /*<<scanf.ml:867:14>>*/ width$0 = scan_sign(width, ib),
-     _ap_ = 0 === width$0 ? 1 : 0,
-     _aq_ = _ap_ || end_of_input(ib);
-     /*<<scanf.ml:868:18>>*/ if(_aq_)  /*<<scanf.ml:868:48>>*/ bad_float(0);
+     _aq_ = 0 === width$0 ? 1 : 0,
+     _ar_ = _aq_ || end_of_input(ib);
+     /*<<scanf.ml:868:18>>*/ if(_ar_)  /*<<scanf.ml:868:48>>*/ bad_float(0);
      /*<<scanf.ml:869:8>>*/  /*<<scanf.ml:869:8>>*/ var c = peek_char(ib);
     if(49 <= c){
      if(58 > c){
        /*<<scanf.ml:903:16>>*/ var
         /*<<scanf.ml:903:16>>*/ width$1 = store_char(width$0, ib, c),
-       _ar_ = 0 === width$1 ? 1 : 0,
-       _as_ = _ar_ || end_of_input(ib);
-       /*<<scanf.ml:904:20>>*/ if(_as_)  /*<<scanf.ml:904:50>>*/ bad_float(0);
+       _as_ = 0 === width$1 ? 1 : 0,
+       _at_ = _as_ || end_of_input(ib);
+       /*<<scanf.ml:904:20>>*/ if(_at_)  /*<<scanf.ml:904:50>>*/ bad_float(0);
        /*<<scanf.ml:904:50>>*/ return scan_caml_float_rest
               (width$1, precision, ib);
      }
@@ -27823,9 +27870,9 @@
     else if(48 <= c){
       /*<<scanf.ml:871:16>>*/ var
        /*<<scanf.ml:871:16>>*/ width$2 = store_char(width$0, ib, c),
-      _at_ = 0 === width$2 ? 1 : 0,
-      _au_ = _at_ || end_of_input(ib);
-      /*<<scanf.ml:872:20>>*/ if(_au_)  /*<<scanf.ml:872:50>>*/ bad_float(0);
+      _au_ = 0 === width$2 ? 1 : 0,
+      _av_ = _au_ || end_of_input(ib);
+      /*<<scanf.ml:872:20>>*/ if(_av_)  /*<<scanf.ml:872:50>>*/ bad_float(0);
       /*<<scanf.ml:873:10>>*/  /*<<scanf.ml:873:10>>*/ var
       c$0 = peek_char(ib);
      if(88 !== c$0 && 120 !== c$0)
@@ -27833,14 +27880,14 @@
               (width$2, precision, ib);
       /*<<scanf.ml:875:18>>*/ var
        /*<<scanf.ml:875:18>>*/ width$3 = store_char(width$2, ib, c$0),
-      _av_ = 0 === width$3 ? 1 : 0,
-      _aw_ = _av_ || end_of_input(ib);
-      /*<<scanf.ml:876:22>>*/ if(_aw_)  /*<<scanf.ml:876:52>>*/ bad_float(0);
+      _aw_ = 0 === width$3 ? 1 : 0,
+      _ax_ = _aw_ || end_of_input(ib);
+      /*<<scanf.ml:876:22>>*/ if(_ax_)  /*<<scanf.ml:876:52>>*/ bad_float(0);
       /*<<scanf.ml:877:18>>*/ var
        /*<<scanf.ml:877:18>>*/ width$4 = scan_hexadecimal_int(width$3, ib),
-      _ax_ = 0 === width$4 ? 1 : 0,
-      _ay_ = _ax_ || end_of_input(ib);
-      /*<<scanf.ml:878:22>>*/ if(_ay_)  /*<<scanf.ml:878:52>>*/ bad_float(0);
+      _ay_ = 0 === width$4 ? 1 : 0,
+      _az_ = _ay_ || end_of_input(ib);
+      /*<<scanf.ml:878:22>>*/ if(_az_)  /*<<scanf.ml:878:52>>*/ bad_float(0);
       /*<<scanf.ml:879:24>>*/ var
        /*<<scanf.ml:879:24>>*/ c$1 = peek_char(ib),
        /*<<scanf.ml:879:24>>*/ switcher = c$1 - 80 | 0,
@@ -27885,9 +27932,9 @@
       if(80 !== c$2 && 112 !== c$2)  /*<<scanf.ml:897:15>>*/ return width$8;
        /*<<scanf.ml:894:22>>*/ var
         /*<<scanf.ml:894:22>>*/ width$9 = store_char(width$8, ib, c$2),
-       _az_ = 0 === width$9 ? 1 : 0,
-       _aA_ = _az_ || end_of_input(ib);
-       /*<<scanf.ml:895:26>>*/ if(_aA_)
+       _aA_ = 0 === width$9 ? 1 : 0,
+       _aB_ = _aA_ || end_of_input(ib);
+       /*<<scanf.ml:895:26>>*/ if(_aB_)
         /*<<scanf.ml:895:56>>*/ bad_hex_float(0);
        /*<<scanf.ml:895:56>>*/ return scan_optionally_signed_decimal
               (width$9, ib);
@@ -27912,12 +27959,12 @@
       continue;
      }
       /*<<scanf.ml:928:8>>*/ var
-       /*<<scanf.ml:928:8>>*/ _am_ = c - 9 | 0,
+       /*<<scanf.ml:928:8>>*/ _an_ = c - 9 | 0,
       switch$0 = 0;
-     if(4 < _am_ >>> 0){
-      if(23 === _am_) switch$0 = 1;
+     if(4 < _an_ >>> 0){
+      if(23 === _an_) switch$0 = 1;
      }
-     else if(1 < _am_ - 2 >>> 0) switch$0 = 1;
+     else if(1 < _an_ - 2 >>> 0) switch$0 = 1;
      if(switch$0)  /*<<scanf.ml:929:38>>*/ return width$0;
       /*<<scanf.ml:930:20>>*/ var
        /*<<scanf.ml:930:20>>*/ width$2 = store_char(width$0, ib, c),
@@ -27939,11 +27986,11 @@
                 (Stdlib_Printf[4], _f_, message))
             : c;
     /*<<scanf.ml:998:3>>*/ }
-    /*<<scanf.ml:1001:31>>*/ function check_next_char_for_char(_ak_, _al_){
-     /*<<?>>*/ return check_next_char(cst_a_Char, _ak_, _al_);
+    /*<<scanf.ml:1001:31>>*/ function check_next_char_for_char(_al_, _am_){
+     /*<<?>>*/ return check_next_char(cst_a_Char, _al_, _am_);
    }
-    /*<<scanf.ml:1002:33>>*/ function check_next_char_for_string(_ai_, _aj_){
-     /*<<?>>*/ return check_next_char(cst_a_String, _ai_, _aj_);
+    /*<<scanf.ml:1002:33>>*/ function check_next_char_for_string(_aj_, _ak_){
+     /*<<?>>*/ return check_next_char(cst_a_String, _aj_, _ak_);
    }
    function scan_backslash_char(width, ib){
      /*<<scanf.ml:1005:2>>*/ var
@@ -27961,30 +28008,30 @@
              function(param){
                /*<<scanf.ml:1020:6>>*/ var
                 /*<<scanf.ml:1020:14>>*/ c = next_char(ib),
-                /*<<scanf.ml:1020:14>>*/ _ah_ = c - 48 | 0,
+                /*<<scanf.ml:1020:14>>*/ _ai_ = c - 48 | 0,
                switch$0 = 0;
-              if(22 < _ah_ >>> 0){
-               if(5 >= _ah_ - 49 >>> 0) switch$0 = 1;
+              if(22 < _ai_ >>> 0){
+               if(5 >= _ai_ - 49 >>> 0) switch$0 = 1;
               }
-              else if(6 < _ah_ - 10 >>> 0) switch$0 = 1;
+              else if(6 < _ai_ - 10 >>> 0) switch$0 = 1;
               return switch$0 ? c : bad_input_escape(c);
               /*<<scanf.ml:1023:31>>*/ },
             /*<<scanf.ml:1024:13>>*/ c1 = get_digit(0),
             /*<<scanf.ml:1025:13>>*/ c2 = get_digit(0),
-            /*<<scanf.ml:985:9>>*/ _ad_ = hexadecimal_value_of_char(c2),
-           c$0 = (16 * hexadecimal_value_of_char(c1) | 0) + _ad_ | 0,
+            /*<<scanf.ml:985:9>>*/ _ae_ = hexadecimal_value_of_char(c2),
+           c$0 = (16 * hexadecimal_value_of_char(c1) | 0) + _ae_ | 0,
            switch$1 = 0;
           if(0 <= c$0 && 255 >= c$0){
-           var _af_ =  /*<<scanf.ml:989:2>>*/ caml_call1(Stdlib[29], c$0);
+           var _ag_ =  /*<<scanf.ml:989:2>>*/ caml_call1(Stdlib[29], c$0);
            switch$1 = 1;
           }
           if(! switch$1)
            var
-            _af_ =
+            _ag_ =
               bad_input
                ( /*<<scanf.ml:988:6>>*/ caml_call3
                  (Stdlib_Printf[4], _m_, c1, c2));
-           /*<<scanf.ml:1026:39>>*/ return store_char(width - 2 | 0, ib, _af_);
+           /*<<scanf.ml:1026:39>>*/ return store_char(width - 2 | 0, ib, _ag_);
          case 0:
          case 6:
          case 18:
@@ -28009,16 +28056,16 @@
          | 0,
        switch$2 = 0;
       if(0 <= c && 255 >= c){
-       var _ag_ =  /*<<scanf.ml:963:2>>*/ caml_call1(Stdlib[29], c);
+       var _ah_ =  /*<<scanf.ml:963:2>>*/ caml_call1(Stdlib[29], c);
        switch$2 = 1;
       }
       if(! switch$2)
        var
-        _ag_ =
+        _ah_ =
           bad_input
            ( /*<<scanf.ml:961:6>>*/ caml_call4
              (Stdlib_Printf[4], _l_, c0, c1$0, c2$0));
-       /*<<scanf.ml:1017:39>>*/ return store_char(width - 2 | 0, ib, _ag_);
+       /*<<scanf.ml:1017:39>>*/ return store_char(width - 2 | 0, ib, _ah_);
      }
     }
     else if(34 === c0 || 39 <= c0) switch$0 = 1;
@@ -28030,16 +28077,16 @@
      else
       switch(c0 - 110 | 0){
         case 0:
-         var _ae_ = 10; break;
+         var _af_ = 10; break;
         case 4:
-         var _ae_ = 13; break;
+         var _af_ = 13; break;
         case 6:
-         var _ae_ = 9; break;
+         var _af_ = 9; break;
         default: switch$3 = 1;
       }
-    else if(98 === c0) var _ae_ = 8; else switch$3 = 1;
-    if(switch$3) var _ae_ = c0;
-     /*<<scanf.ml:1007:33>>*/ return store_char(width, ib, _ae_);
+    else if(98 === c0) var _af_ = 8; else switch$3 = 1;
+    if(switch$3) var _af_ = c0;
+     /*<<scanf.ml:1007:33>>*/ return store_char(width, ib, _af_);
     /*<<scanf.ml:1028:22>>*/ }
    function scan_caml_string(width, ib){
     function find_stop$0(counter, width){
@@ -28060,12 +28107,12 @@
          check_next_char_for_string(width$1, ib);
       if(10 === match){
         /*<<scanf.ml:1071:26>>*/  /*<<scanf.ml:1071:26>>*/ var
-        _ab_ = ignore_char(width$1, ib);
+        _ac_ = ignore_char(width$1, ib);
         /*<<scanf.ml:1071:26>>*/ if(counter >= 50)
          /*<<scanf.ml:1071:26>>*/ return  /*<<scanf.ml:1071:26>>*/ caml_trampoline_return
-                (skip_spaces, [0, _ab_]);
+                (skip_spaces, [0, _ac_]);
        var counter$0 = counter + 1 | 0;
-        /*<<scanf.ml:1071:26>>*/ return skip_spaces(counter$0, _ab_);
+        /*<<scanf.ml:1071:26>>*/ return skip_spaces(counter$0, _ac_);
       }
       if(13 !== match){
         /*<<scanf.ml:1072:21>>*/ var
@@ -28082,12 +28129,12 @@
        continue;
       }
        /*<<scanf.ml:1076:26>>*/  /*<<scanf.ml:1076:26>>*/ var
-       _ac_ = ignore_char(width$3, ib);
+       _ad_ = ignore_char(width$3, ib);
        /*<<scanf.ml:1076:26>>*/ if(counter >= 50)
         /*<<scanf.ml:1076:26>>*/ return  /*<<scanf.ml:1076:26>>*/ caml_trampoline_return
-               (skip_spaces, [0, _ac_]);
+               (skip_spaces, [0, _ad_]);
       var counter$1 = counter + 1 | 0;
-       /*<<scanf.ml:1076:26>>*/ return skip_spaces(counter$1, _ac_);
+       /*<<scanf.ml:1076:26>>*/ return skip_spaces(counter$1, _ad_);
      }
      /*<<scanf.ml:1066:53>>*/ }
     function skip_spaces(counter, width){
@@ -28121,34 +28168,39 @@
       /*<<scanf.ml:1104:4>>*/ for(;;){
        /*<<scanf.ml:1104:12>>*/ var
         /*<<scanf.ml:1104:12>>*/ c = peek_char(ib),
-       _Z_ = 0 < i$0 ? 1 : 0;
-      if(_Z_){
+       ___ = 0 < i$0 ? 1 : 0;
+      if(___){
         /*<<scanf.ml:1105:20>>*/  /*<<scanf.ml:1105:20>>*/ var
-        ___ = 1 - ib[1];
-       if(___)
+        _$_ = 1 - ib[1];
+       if(_$_)
          /*<<scanf.ml:1106:7>>*/ var
-          /*<<scanf.ml:1106:7>>*/ _$_ =
+          /*<<scanf.ml:1106:7>>*/ _aa_ =
             /*<<scanf.ml:1106:7>>*/ caml_call2
             (CamlinternalFormat[1], char_set, c),
-          /*<<scanf.ml:1106:7>>*/ _aa_ = _$_ ? c !== stp ? 1 : 0 : _$_;
+          /*<<scanf.ml:1106:7>>*/ _ab_ = _aa_ ? c !== stp ? 1 : 0 : _aa_;
        else
-        var _aa_ = ___;
+        var _ab_ = _$_;
       }
       else
-       var _aa_ = _Z_;
-      if(! _aa_) return _aa_;
+       var _ab_ = ___;
+      if(! _ab_) return _ab_;
        /*<<scanf.ml:1108:14>>*/ store_char(Stdlib[19], ib, c);
       var i$1 = i$0 - 1 | 0, i$0 = i$1;
      }
      /*<<scanf.ml:1109:28>>*/ }
-    if(! scan_indic)  /*<<scanf.ml:1111:12>>*/ return scan_chars(width, -1);
+    if(! scan_indic){
+      /*<<scanf.ml:1111:12>>*/ scan_chars(width, -1);
+      /*<<scanf.ml:1111:12>>*/ return _u_;
+    }
     var c = scan_indic[1];
      /*<<scanf.ml:1113:4>>*/ scan_chars(width, c);
-     /*<<scanf.ml:1114:11>>*/  /*<<scanf.ml:1114:11>>*/ var _Y_ = 1 - ib[1];
-    if(! _Y_)  /*<<scanf.ml:1114:11>>*/ return _Y_;
+     /*<<scanf.ml:1114:11>>*/  /*<<scanf.ml:1114:11>>*/ var _Z_ = 1 - ib[1];
+    if(! _Z_)  /*<<scanf.ml:1114:11>>*/ return _Z_;
      /*<<scanf.ml:1115:15>>*/  /*<<scanf.ml:1115:15>>*/ var
      ci = peek_char(ib);
-    return c === ci ? invalidate_current_char(ib) : character_mismatch(c, ci);
+    return c === ci
+            ? (invalidate_current_char(ib), _u_)
+            : (character_mismatch(c, ci), _u_);
     /*<<scanf.ml:1118:34>>*/ }
    function scanf_bad_input(ib, x){
      /*<<?>>*/ if(x[1] === Scan_failure)
@@ -28225,17 +28277,17 @@
          /*<<scanf.ml:1195:44>>*/ var
          rest$13 = fmt$0[3],
          fmtty = fmt$0[2],
-          /*<<scanf.ml:1195:44>>*/ _V_ =
+          /*<<scanf.ml:1195:44>>*/ _W_ =
             /*<<scanf.ml:1195:44>>*/ caml_call1(CamlinternalFormat[21], fmtty),
-          /*<<scanf.ml:1195:33>>*/ _W_ =
+          /*<<scanf.ml:1195:33>>*/ _X_ =
             /*<<scanf.ml:1195:33>>*/ caml_call1
-            (CamlinternalFormatBasics[2], _V_);
+            (CamlinternalFormatBasics[2], _W_);
          /*<<scanf.ml:1195:5>>*/ if(counter >= 50)
           /*<<scanf.ml:1195:5>>*/ return  /*<<scanf.ml:1195:5>>*/ caml_trampoline_return
-                 (take_fmtty_format_readers$0, [0, k, _W_, rest$13]);
+                 (take_fmtty_format_readers$0, [0, k, _X_, rest$13]);
         var counter$0 = counter + 1 | 0;
          /*<<scanf.ml:1195:5>>*/ return take_fmtty_format_readers$0
-                (counter$0, k, _W_, rest$13);
+                (counter$0, k, _X_, rest$13);
        case 15:
         var rest$14 = fmt$0[1], fmt$0 = rest$14; continue;
        case 16:
@@ -28243,11 +28295,11 @@
        case 17:
         var rest$16 = fmt$0[2], fmt$0 = rest$16; continue;
        case 18:
-        var _X_ = fmt$0[1];
-        if(0 === _X_[0]){
+        var _Y_ = fmt$0[1];
+        if(0 === _Y_[0]){
           /*<<scanf.ml:1189:28>>*/ var
           rest$17 = fmt$0[2],
-          fmt$1 = _X_[1][1],
+          fmt$1 = _Y_[1][1],
            /*<<scanf.ml:1189:28>>*/ fmt$2 =
              /*<<scanf.ml:1189:28>>*/ caml_call2
              (CamlinternalFormatBasics[3], fmt$1, rest$17),
@@ -28256,7 +28308,7 @@
         }
          /*<<scanf.ml:1191:28>>*/ var
          rest$18 = fmt$0[2],
-         fmt$3 = _X_[1][1],
+         fmt$3 = _Y_[1][1],
           /*<<scanf.ml:1191:28>>*/ fmt$4 =
             /*<<scanf.ml:1191:28>>*/ caml_call2
             (CamlinternalFormatBasics[3], fmt$3, rest$18),
@@ -28357,11 +28409,11 @@
           rest = fmtty$0[3],
           ty2 = fmtty$0[2],
           ty1 = fmtty$0[1],
-           /*<<scanf.ml:1227:19>>*/ _U_ =
+           /*<<scanf.ml:1227:19>>*/ _V_ =
              /*<<scanf.ml:1227:19>>*/ caml_call1(CamlinternalFormat[21], ty1),
            /*<<scanf.ml:1227:13>>*/ ty =
              /*<<scanf.ml:1227:13>>*/ caml_call2
-             (CamlinternalFormat[22], _U_, ty2),
+             (CamlinternalFormat[22], _V_, ty2),
            /*<<scanf.ml:1228:32>>*/ fmtty$10 =
              /*<<scanf.ml:1228:32>>*/ caml_call2
              (CamlinternalFormatBasics[1], ty, rest),
@@ -28471,8 +28523,8 @@
              /*<<scanf.ml:1047:4>>*/  /*<<scanf.ml:1047:10>>*/ var
              c = check_next_char_for_char(width, ib);
             return 39 === c
-                    ? ignore_char(width, ib)
-                    : character_mismatch(39, c);
+                    ? (ignore_char(width, ib), _u_)
+                    : (character_mismatch(39, c), _u_);
             /*<<scanf.ml:1049:36>>*/ },
           /*<<scanf.ml:1035:10>>*/ c = checked_peek_char(ib);
         if(39 === c){
@@ -28513,11 +28565,11 @@
              /*<<scanf.ml:1280:4>>*/ return pad_prec_scanf
                     (ib, str_rest, readers, pad, 0, scan$0, token_string);
            case 18:
-            var _G_ = match[1];
-            if(0 === _G_[0]){
+            var _H_ = match[1];
+            if(0 === _H_[0]){
               /*<<scanf.ml:1282:4>>*/ var
               rest$3 = match[2],
-              fmt$1 = _G_[1][1],
+              fmt$1 = _H_[1][1],
                /*<<scanf.ml:1282:4>>*/ scan$1 =
                 function(width, param, ib){
                   /*<<scanf.ml:1282:26>>*/ return scan_string(_q_, width, ib);
@@ -28534,7 +28586,7 @@
             }
              /*<<scanf.ml:1286:4>>*/ var
              rest$4 = match[2],
-             fmt$2 = _G_[1][1],
+             fmt$2 = _H_[1][1],
               /*<<scanf.ml:1286:4>>*/ scan$2 =
                function(width, param, ib){
                  /*<<scanf.ml:1286:26>>*/ return scan_string(_r_, width, ib);
@@ -28711,7 +28763,7 @@
          rest$13 = fmt$0[2],
          pad$8 = fmt$0[1],
           /*<<scanf.ml:1320:4>>*/ scan$8 =
-           function(param, _T_, ib){
+           function(param, _U_, ib){
              /*<<scanf.ml:1320:22>>*/ var
               /*<<scanf.ml:1089:10>>*/ c = checked_peek_char(ib),
               /*<<scanf.ml:1090:2>>*/ m =
@@ -28737,10 +28789,10 @@
          /*<<scanf.ml:1341:16>>*/ var
          rest$15 = fmt$0[2],
          str$0 = fmt$0[1],
-          /*<<scanf.ml:1341:16>>*/ _H_ =
-           function(_S_){ /*<<?>>*/ return check_char(ib, _S_);};
+          /*<<scanf.ml:1341:16>>*/ _I_ =
+           function(_T_){ /*<<?>>*/ return check_char(ib, _T_);};
          /*<<scanf.ml:1341:4>>*/  /*<<scanf.ml:1341:4>>*/ caml_call2
-         (Stdlib_String[29], _H_, str$0);
+         (Stdlib_String[29], _I_, str$0);
         var fmt$0 = rest$15;
         continue;
        case 12:
@@ -28756,10 +28808,10 @@
          s = token_string(ib);
          /*<<scanf.ml:1350:4>>*/ try{
           /*<<scanf.ml:1351:10>>*/ var
-           /*<<scanf.ml:1351:10>>*/ _I_ =
+           /*<<scanf.ml:1351:10>>*/ _J_ =
              /*<<scanf.ml:1351:10>>*/ caml_call2
              (CamlinternalFormat[14], s, fmtty),
-          fmt$3 = _I_;
+          fmt$3 = _J_;
         }
         catch(exn$0){
          var exn = caml_wrap_exception(exn$0);
@@ -28785,23 +28837,23 @@
              /*<<scanf.ml:1361:27>>*/ caml_call2
               (CamlinternalFormat[13], 0, s$0)
              [1],
-           /*<<scanf.ml:1375:36>>*/ _K_ =
+           /*<<scanf.ml:1375:36>>*/ _L_ =
              /*<<scanf.ml:1375:36>>*/ caml_call1
              (CamlinternalFormat[21], fmtty$0),
-           /*<<scanf.ml:1375:25>>*/ _L_ =
+           /*<<scanf.ml:1375:25>>*/ _M_ =
              /*<<scanf.ml:1375:25>>*/ caml_call1
-             (CamlinternalFormatBasics[2], _K_),
+             (CamlinternalFormatBasics[2], _L_),
            /*<<scanf.ml:1375:8>>*/ fmt$8 =
              /*<<scanf.ml:1375:8>>*/ caml_call2
-             (CamlinternalFormat[12], fmt$7, _L_),
-           /*<<scanf.ml:1374:24>>*/ _M_ =
+             (CamlinternalFormat[12], fmt$7, _M_),
+           /*<<scanf.ml:1374:24>>*/ _N_ =
              /*<<scanf.ml:1374:24>>*/ caml_call1
              (CamlinternalFormatBasics[2], fmtty$0),
-           /*<<scanf.ml:1374:8>>*/ _N_ =
+           /*<<scanf.ml:1374:8>>*/ _O_ =
              /*<<scanf.ml:1374:8>>*/ caml_call2
-             (CamlinternalFormat[12], fmt$6, _M_),
+             (CamlinternalFormat[12], fmt$6, _N_),
           fmt$5 = fmt$8,
-          fmt$4 = _N_;
+          fmt$4 = _O_;
         }
         catch(exn){
          var exn$0 = caml_wrap_exception(exn);
@@ -28809,9 +28861,9 @@
           throw caml_maybe_attach_backtrace(exn$0, 0);
          var
           msg$0 = exn$0[2],
-          _J_ = bad_input(msg$0),
-          fmt$5 = _J_[2],
-          fmt$4 = _J_[1];
+          _K_ = bad_input(msg$0),
+          fmt$5 = _K_[2],
+          fmt$4 = _K_[1];
         }
          /*<<scanf.ml:1378:4>>*/ return [0,
                 [0, fmt$4, s$0],
@@ -28830,19 +28882,19 @@
          /*<<scanf.ml:1401:32>>*/ var
          rest$19 = fmt$0[2],
          formatting_lit = fmt$0[1],
-          /*<<scanf.ml:1401:32>>*/ _O_ =
+          /*<<scanf.ml:1401:32>>*/ _P_ =
             /*<<scanf.ml:1401:32>>*/ caml_call1
             (CamlinternalFormat[17], formatting_lit),
-          /*<<scanf.ml:1401:16>>*/ _P_ =
-           function(_R_){ /*<<?>>*/ return check_char(ib, _R_);};
+          /*<<scanf.ml:1401:16>>*/ _Q_ =
+           function(_S_){ /*<<?>>*/ return check_char(ib, _S_);};
          /*<<scanf.ml:1401:4>>*/  /*<<scanf.ml:1401:4>>*/ caml_call2
-         (Stdlib_String[29], _P_, _O_);
+         (Stdlib_String[29], _Q_, _P_);
         var fmt$0 = rest$19;
         continue;
        case 18:
-        var _Q_ = fmt$0[1];
-        if(0 === _Q_[0]){
-         var rest$20 = fmt$0[2], fmt$9 = _Q_[1][1];
+        var _R_ = fmt$0[1];
+        if(0 === _R_[0]){
+         var rest$20 = fmt$0[2], fmt$9 = _R_[1][1];
           /*<<scanf.ml:1404:4>>*/ check_char(ib, 64);
           /*<<scanf.ml:1404:23>>*/ check_char(ib, 123);
           /*<<scanf.ml:1405:18>>*/ var
@@ -28852,7 +28904,7 @@
           fmt$0 = fmt$10;
          continue;
         }
-        var rest$21 = fmt$0[2], fmt$11 = _Q_[1][1];
+        var rest$21 = fmt$0[2], fmt$11 = _R_[1][1];
          /*<<scanf.ml:1407:4>>*/ check_char(ib, 64);
          /*<<scanf.ml:1407:23>>*/ check_char(ib, 91);
          /*<<scanf.ml:1408:18>>*/ var
@@ -28960,16 +29012,16 @@
        if(exc[1] !== Stdlib[6]) throw caml_maybe_attach_backtrace(exc, 0);
         /*<<scanf.ml:1470:45>>*/ var
         msg = exc[2],
-         /*<<scanf.ml:1470:45>>*/ _C_ =
-           /*<<scanf.ml:1470:45>>*/ caml_call1(Stdlib_String[24], str),
          /*<<scanf.ml:1470:45>>*/ _D_ =
-           /*<<scanf.ml:1470:45>>*/ caml_call2(Stdlib[28], _C_, cst$0),
-         /*<<scanf.ml:1470:27>>*/ _E_ =
-           /*<<scanf.ml:1470:27>>*/ caml_call2(Stdlib[28], cst_in_format, _D_),
-         /*<<scanf.ml:1470:20>>*/ _F_ =
-           /*<<scanf.ml:1470:20>>*/ caml_call2(Stdlib[28], msg, _E_);
+           /*<<scanf.ml:1470:45>>*/ caml_call1(Stdlib_String[24], str),
+         /*<<scanf.ml:1470:45>>*/ _E_ =
+           /*<<scanf.ml:1470:45>>*/ caml_call2(Stdlib[28], _D_, cst$0),
+         /*<<scanf.ml:1470:27>>*/ _F_ =
+           /*<<scanf.ml:1470:27>>*/ caml_call2(Stdlib[28], cst_in_format, _E_),
+         /*<<scanf.ml:1470:20>>*/ _G_ =
+           /*<<scanf.ml:1470:20>>*/ caml_call2(Stdlib[28], msg, _F_);
         /*<<scanf.ml:1470:20>>*/ return  /*<<scanf.ml:1470:20>>*/ caml_call1
-               (Stdlib[1], _F_);
+               (Stdlib[1], _G_);
       }
        /*<<scanf.ml:1468:8>>*/ return  /*<<scanf.ml:1468:8>>*/ caml_call2
               (ef, ib, exc);
@@ -29000,15 +29052,15 @@
              fmt);
     /*<<scanf.ml:1477:35>>*/ }
    function kscanf_opt(ib, fmt){
-    function _A_(x){
+    function _B_(x){
       /*<<scanf.ml:1480:44>>*/ return [0, x];
      /*<<scanf.ml:1480:50>>*/ }
      /*<<scanf.ml:1480:2>>*/ return kscanf_gen
             (ib,
-             function(param, _B_){
+             function(param, _C_){
                /*<<scanf.ml:1480:28>>*/ return 0;
               /*<<scanf.ml:1480:32>>*/ },
-             _A_,
+             _B_,
              fmt);
     /*<<scanf.ml:1480:55>>*/ }
    function bscanf(ib, fmt){
@@ -29039,10 +29091,10 @@
      str = token_string(ib);
      /*<<scanf.ml:1504:4>>*/ try{
       /*<<scanf.ml:1505:10>>*/ var
-       /*<<scanf.ml:1505:10>>*/ _z_ =
+       /*<<scanf.ml:1505:10>>*/ _A_ =
          /*<<scanf.ml:1505:10>>*/ caml_call2
          (CamlinternalFormat[15], str, format),
-      fmt = _z_;
+      fmt = _A_;
     }
     catch(exn$0){
      var exn = caml_wrap_exception(exn$0);
@@ -29056,30 +29108,30 @@
      /*<<scanf.ml:1513:20>>*/ return bscanf_format(from_string(s), format, f);
     /*<<scanf.ml:1513:67>>*/ }
    function format_from_string(s, fmt){
-     /*<<scanf.ml:1517:2>>*/ function _w_(x){
+     /*<<scanf.ml:1517:2>>*/ function _x_(x){
       /*<<scanf.ml:1517:63>>*/ return x;
      /*<<scanf.ml:1517:64>>*/ }
      /*<<scanf.ml:1517:24>>*/ var
-      /*<<scanf.ml:1517:24>>*/ _x_ =
-        /*<<scanf.ml:1517:24>>*/ caml_call1(Stdlib_String[24], s),
       /*<<scanf.ml:1517:24>>*/ _y_ =
-        /*<<scanf.ml:1517:24>>*/ caml_call2(Stdlib[28], _x_, cst$1);
+        /*<<scanf.ml:1517:24>>*/ caml_call1(Stdlib_String[24], s),
+      /*<<scanf.ml:1517:24>>*/ _z_ =
+        /*<<scanf.ml:1517:24>>*/ caml_call2(Stdlib[28], _y_, cst$1);
      /*<<scanf.ml:1517:53>>*/ return sscanf_format
-            ( /*<<scanf.ml:1517:16>>*/ caml_call2(Stdlib[28], cst$2, _y_),
+            ( /*<<scanf.ml:1517:16>>*/ caml_call2(Stdlib[28], cst$2, _z_),
              fmt,
-             _w_);
+             _x_);
     /*<<scanf.ml:1517:65>>*/ }
    function unescaped(s){
-     /*<<scanf.ml:1521:2>>*/ function _u_(x){
+     /*<<scanf.ml:1521:2>>*/ function _v_(x){
       /*<<scanf.ml:1521:44>>*/ return x;
      /*<<scanf.ml:1521:45>>*/ }
      /*<<scanf.ml:1521:17>>*/  /*<<scanf.ml:1521:17>>*/ var
-     _v_ =  /*<<scanf.ml:1521:17>>*/ caml_call2(Stdlib[28], s, cst$3);
+     _w_ =  /*<<scanf.ml:1521:17>>*/ caml_call2(Stdlib[28], s, cst$3);
      /*<<scanf.ml:1521:34>>*/ return  /*<<scanf.ml:1521:34>>*/ caml_call1
             (sscanf
-              ( /*<<scanf.ml:1521:9>>*/ caml_call2(Stdlib[28], cst$4, _v_),
+              ( /*<<scanf.ml:1521:9>>*/ caml_call2(Stdlib[28], cst$4, _w_),
                _t_),
-             _u_);
+             _v_);
     /*<<scanf.ml:1521:46>>*/ }
    var
     Stdlib_Scanf =
@@ -30440,6 +30492,7 @@
             : runtime.caml_call_gen(f, [a0, a1, a2]);
    }
    var
+    _d_ = undefined,
     global_data = runtime.caml_get_global_data(),
     Stdlib_List = global_data.Stdlib__List,
     Stdlib = global_data.Stdlib,
@@ -30458,7 +30511,7 @@
      /*<<ephemeron.ml:105:20>>*/  /*<<ephemeron.ml:105:20>>*/ var
      prng =
        [246,
-        function(_aM_){ /*<<?>>*/ return caml_call1(Stdlib_Random[15][2], 0);}];
+        function(_aN_){ /*<<?>>*/ return caml_call1(Stdlib_Random[15][2], 0);}];
     function create(opt, initial_size){
       /*<<ephemeron.ml:108:6>>*/ if(opt)
       var sth = opt[1], random = sth;
@@ -30469,17 +30522,17 @@
       /*<<ephemeron.ml:101:6>>*/ for(;;){
       if(initial_size > x && Stdlib_Sys[13] >= (x * 2 | 0)){var x$0 = x * 2 | 0, x = x$0; continue;}
        /*<<ephemeron.ml:109:6>>*/ if(random){
-       var _aK_ = runtime.caml_obj_tag(prng);
-       if(250 === _aK_)
-        var _aL_ = prng[1];
+       var _aL_ = runtime.caml_obj_tag(prng);
+       if(250 === _aL_)
+        var _aM_ = prng[1];
        else{
         var switch$0 = 0;
-        if(246 !== _aK_ && 244 !== _aK_){var _aL_ = prng; switch$0 = 1;}
-        if(! switch$0) var _aL_ = caml_call1(CamlinternalLazy[2], prng);
+        if(246 !== _aL_ && 244 !== _aL_){var _aM_ = prng; switch$0 = 1;}
+        if(! switch$0) var _aM_ = caml_call1(CamlinternalLazy[2], prng);
        }
        var
         seed =
-           /*<<ephemeron.ml:109:32>>*/ caml_call1(Stdlib_Random[15][4], _aL_);
+           /*<<ephemeron.ml:109:32>>*/ caml_call1(Stdlib_Random[15][4], _aM_);
       }
       else
        var seed = 0;
@@ -30494,15 +30547,15 @@
       /*<<ephemeron.ml:113:6>>*/ h[1] = 0;
       /*<<ephemeron.ml:115:6>>*/ var
       len = h[2].length - 1,
-       /*<<ephemeron.ml:115:6>>*/ _aI_ = len - 1 | 0,
-      _aH_ = 0;
-     if(_aI_ >= 0){
-      var i = _aH_;
+       /*<<ephemeron.ml:115:6>>*/ _aJ_ = len - 1 | 0,
+      _aI_ = 0;
+     if(_aJ_ >= 0){
+      var i = _aI_;
       for(;;){
         /*<<ephemeron.ml:116:8>>*/ caml_check_bound(h[2], i)[1 + i] = 0;
         /*<<ephemeron.ml:116:8>>*/  /*<<ephemeron.ml:116:8>>*/ var
-        _aJ_ = i + 1 | 0;
-       if(_aI_ !== i){var i = _aJ_; continue;}
+        _aK_ = i + 1 | 0;
+       if(_aJ_ !== i){var i = _aK_; continue;}
        break;
       }
      }
@@ -30520,11 +30573,11 @@
      /*<<ephemeron.ml:126:9>>*/ }
     function copy(h){
       /*<<ephemeron.ml:128:17>>*/ var
-      _aE_ = h[4],
-      _aF_ = h[3],
-       /*<<ephemeron.ml:128:33>>*/ _aG_ =
+      _aF_ = h[4],
+      _aG_ = h[3],
+       /*<<ephemeron.ml:128:33>>*/ _aH_ =
          /*<<ephemeron.ml:128:33>>*/ caml_call1(Stdlib_Array[6], h[2]);
-      /*<<ephemeron.ml:128:17>>*/ return [0, h[1], _aG_, _aF_, _aE_];
+      /*<<ephemeron.ml:128:17>>*/ return [0, h[1], _aH_, _aG_, _aF_];
      /*<<ephemeron.ml:128:52>>*/ }
     function key_index(h, hkey){
       /*<<ephemeron.ml:131:6>>*/ return hkey & (h[2].length - 1 - 1 | 0);
@@ -30544,15 +30597,15 @@
        var param$0 = rest;
       }
       /*<<ephemeron.ml:141:41>>*/ }
-     var d = h[2], _aC_ = d.length - 1 - 1 | 0, _aB_ = 0;
-     if(_aC_ >= 0){
-      var i = _aB_;
+     var d = h[2], _aD_ = d.length - 1 - 1 | 0, _aC_ = 0;
+     if(_aD_ >= 0){
+      var i = _aC_;
       for(;;){
         /*<<ephemeron.ml:145:8>>*/ d[1 + i] =
         do_bucket(caml_check_bound(d, i)[1 + i]);
         /*<<ephemeron.ml:145:8>>*/  /*<<ephemeron.ml:145:8>>*/ var
-        _aD_ = i + 1 | 0;
-       if(_aC_ !== i){var i = _aD_; continue;}
+        _aE_ = i + 1 | 0;
+       if(_aD_ !== i){var i = _aE_; continue;}
        break;
       }
      }
@@ -30565,9 +30618,9 @@
       nsize = osize * 2 | 0;
       /*<<ephemeron.ml:172:6>>*/ clean(h);
      var
-      _av_ = nsize < Stdlib_Sys[13] ? 1 : 0,
-      _aw_ = _av_ ? (osize >>> 1 | 0) <= h[1] ? 1 : 0 : _av_;
-     if(_aw_){
+      _aw_ = nsize < Stdlib_Sys[13] ? 1 : 0,
+      _ax_ = _aw_ ? (osize >>> 1 | 0) <= h[1] ? 1 : 0 : _aw_;
+     if(_ax_){
        /*<<ephemeron.ml:174:20>>*/  /*<<ephemeron.ml:174:20>>*/ var
        ndata =  /*<<ephemeron.ml:174:20>>*/ caml_make_vect(nsize, 0);
       h[2] = ndata;
@@ -30575,33 +30628,33 @@
        insert_bucket =
          function(param){
            /*<<ephemeron.ml:176:32>>*/ if(! param)
-            /*<<ephemeron.ml:177:21>>*/ return 0;
+            /*<<ephemeron.ml:177:21>>*/ return _d_;
           var rest = param[3], data = param[2], hkey = param[1];
            /*<<ephemeron.ml:179:14>>*/ insert_bucket(rest);
            /*<<ephemeron.ml:180:25>>*/  /*<<ephemeron.ml:180:25>>*/ var
            nidx = key_index(h, hkey);
            /*<<ephemeron.ml:181:14>>*/ ndata[1 + nidx] =
            [0, hkey, data, caml_check_bound(ndata, nidx)[1 + nidx]];
-           /*<<ephemeron.ml:181:14>>*/ return 0;
+           /*<<ephemeron.ml:181:14>>*/ return _d_;
           /*<<ephemeron.ml:181:60>>*/ },
-        /*<<ephemeron.ml:170:6>>*/ _ay_ = osize - 1 | 0,
-        /*<<ephemeron.ml:182:8>>*/ _ax_ = 0;
-      if(_ay_ >= 0){
-       var i = _ax_;
+        /*<<ephemeron.ml:170:6>>*/ _az_ = osize - 1 | 0,
+        /*<<ephemeron.ml:182:8>>*/ _ay_ = 0;
+      if(_az_ >= 0){
+       var i = _ay_;
        for(;;){
          /*<<ephemeron.ml:183:10>>*/ insert_bucket
          (caml_check_bound(odata, i)[1 + i]);
          /*<<ephemeron.ml:183:10>>*/  /*<<ephemeron.ml:183:10>>*/ var
-         _aA_ = i + 1 | 0;
-        if(_ay_ !== i){var i = _aA_; continue;}
+         _aB_ = i + 1 | 0;
+        if(_az_ !== i){var i = _aB_; continue;}
         break;
        }
       }
-      var _az_ = 0;
+      var _aA_ = 0;
      }
      else
-      var _az_ = _aw_;
-     return _az_;
+      var _aA_ = _ax_;
+     return _aA_;
      /*<<ephemeron.ml:185:9>>*/ }
     function add(h, key, info){
       /*<<ephemeron.ml:188:6>>*/ var
@@ -30614,8 +30667,8 @@
         [0, hkey, container, caml_check_bound(h[2], i)[1 + i]];
       /*<<ephemeron.ml:192:6>>*/ caml_check_bound(h[2], i)[1 + i] = bucket;
      h[1] = h[1] + 1 | 0;
-     var _au_ = h[2].length - 1 << 1 < h[1] ? 1 : 0;
-     return _au_ ? resize(h) : _au_;
+     var _av_ = h[2].length - 1 << 1 < h[1] ? 1 : 0;
+     return _av_ ? resize(h) : _av_;
      /*<<ephemeron.ml:194:57>>*/ }
     function remove(h, key){
       /*<<ephemeron.ml:197:6>>*/  /*<<ephemeron.ml:197:17>>*/ var
@@ -30639,17 +30692,17 @@
       /*<<ephemeron.ml:210:60>>*/ }
       /*<<ephemeron.ml:211:14>>*/ var
        /*<<ephemeron.ml:211:14>>*/ i = key_index(h, hkey),
-       /*<<ephemeron.ml:212:20>>*/ _at_ =
+       /*<<ephemeron.ml:212:20>>*/ _au_ =
         remove_bucket(caml_check_bound(h[2], i)[1 + i]);
-      /*<<ephemeron.ml:212:6>>*/ caml_check_bound(h[2], i)[1 + i] = _at_;
+      /*<<ephemeron.ml:212:6>>*/ caml_check_bound(h[2], i)[1 + i] = _au_;
       /*<<ephemeron.ml:212:6>>*/ return 0;
      /*<<ephemeron.ml:212:44>>*/ }
     function find(h, key){
       /*<<ephemeron.ml:239:6>>*/ var
        /*<<ephemeron.ml:239:17>>*/ hkey =
          /*<<ephemeron.ml:239:17>>*/ caml_call2(H[2], h[3], key),
-       /*<<ephemeron.ml:241:33>>*/ _as_ = key_index(h, hkey),
-      param = caml_check_bound(h[2], _as_)[1 + _as_];
+       /*<<ephemeron.ml:241:33>>*/ _at_ = key_index(h, hkey),
+      param = caml_check_bound(h[2], _at_)[1 + _at_];
      for(;;){
       if(! param)
         /*<<ephemeron.ml:220:10>>*/ throw  /*<<ephemeron.ml:220:10>>*/ caml_maybe_attach_backtrace
@@ -30673,8 +30726,8 @@
       /*<<ephemeron.ml:264:6>>*/ var
        /*<<ephemeron.ml:264:17>>*/ hkey =
          /*<<ephemeron.ml:264:17>>*/ caml_call2(H[2], h[3], key),
-       /*<<ephemeron.ml:266:37>>*/ _ar_ = key_index(h, hkey),
-      param = caml_check_bound(h[2], _ar_)[1 + _ar_];
+       /*<<ephemeron.ml:266:37>>*/ _as_ = key_index(h, hkey),
+      param = caml_check_bound(h[2], _as_)[1 + _as_];
      for(;;){
       if(! param)  /*<<ephemeron.ml:245:10>>*/ return 0;
       var hk = param[1], rest = param[3], c = param[2];
@@ -30719,9 +30772,9 @@
       }
       /*<<ephemeron.ml:284:29>>*/ }
       /*<<ephemeron.ml:285:29>>*/  /*<<ephemeron.ml:285:29>>*/ var
-      _aq_ = key_index(h, hkey);
+      _ar_ = key_index(h, hkey);
       /*<<ephemeron.ml:285:21>>*/ return find_in_bucket
-             (caml_check_bound(h[2], _aq_)[1 + _aq_]);
+             (caml_check_bound(h[2], _ar_)[1 + _ar_]);
      /*<<ephemeron.ml:285:46>>*/ }
     function replace(h, key, info){
       /*<<ephemeron.ml:289:6>>*/ var
@@ -30739,27 +30792,27 @@
        if(hkey !== hk){var next$0 = param[3], param = next$0; continue;}
        if( /*<<ephemeron.ml:293:24>>*/ caml_call2(H[3], c, key)){var param = next; continue;}
         /*<<ephemeron.ml:290:6>>*/  /*<<ephemeron.ml:290:6>>*/ var
-        _am_ =  /*<<ephemeron.ml:290:6>>*/ caml_call3(H[5], c, key, info);
-        /*<<ephemeron.ml:302:8>>*/ return _am_;
+        _an_ =  /*<<ephemeron.ml:290:6>>*/ caml_call3(H[5], c, key, info);
+        /*<<ephemeron.ml:302:8>>*/ return _an_;
       }
      }
-     catch(_ap_){
-      var _an_ = caml_wrap_exception(_ap_);
-      if(_an_ !== Stdlib[8]) throw caml_maybe_attach_backtrace(_an_, 0);
+     catch(_aq_){
+      var _ao_ = caml_wrap_exception(_aq_);
+      if(_ao_ !== Stdlib[8]) throw caml_maybe_attach_backtrace(_ao_, 0);
        /*<<ephemeron.ml:304:24>>*/  /*<<ephemeron.ml:304:24>>*/ var
        container =  /*<<ephemeron.ml:304:24>>*/ caml_call2(H[1], key, info);
        /*<<ephemeron.ml:305:8>>*/ caml_check_bound(h[2], i)[1 + i] = [0, hkey, container, l];
       h[1] = h[1] + 1 | 0;
-      var _ao_ = h[2].length - 1 << 1 < h[1] ? 1 : 0;
-      return _ao_ ? resize(h) : _ao_;
+      var _ap_ = h[2].length - 1 << 1 < h[1] ? 1 : 0;
+      return _ap_ ? resize(h) : _ap_;
      }
      /*<<ephemeron.ml:307:59>>*/ }
     function mem(h, key){
       /*<<ephemeron.ml:310:6>>*/ var
        /*<<ephemeron.ml:310:17>>*/ hkey =
          /*<<ephemeron.ml:310:17>>*/ caml_call2(H[2], h[3], key),
-       /*<<ephemeron.ml:320:28>>*/ _al_ = key_index(h, hkey),
-      param = caml_check_bound(h[2], _al_)[1 + _al_];
+       /*<<ephemeron.ml:320:28>>*/ _am_ = key_index(h, hkey),
+      param = caml_check_bound(h[2], _am_)[1 + _am_];
       /*<<ephemeron.ml:311:30>>*/ for(;;){
       if(! param)  /*<<ephemeron.ml:313:10>>*/ return 0;
       var hk = param[1], rest = param[3], c = param[2];
@@ -30784,21 +30837,21 @@
      }
     }
     function stats(h){
-      /*<<ephemeron.ml:329:6>>*/ var _af_ = h[2], _ag_ = 0;
-     function _ah_(m, b){
+      /*<<ephemeron.ml:329:6>>*/ var _ag_ = h[2], _ah_ = 0;
+     function _ai_(m, b){
        /*<<ephemeron.ml:330:36>>*/  /*<<ephemeron.ml:330:46>>*/ var
-       _ak_ = bucket_length(0, b);
+       _al_ = bucket_length(0, b);
        /*<<ephemeron.ml:330:46>>*/ return  /*<<ephemeron.ml:330:46>>*/ caml_call2
-              (Stdlib_Int[11], m, _ak_);
+              (Stdlib_Int[11], m, _al_);
       /*<<ephemeron.ml:330:65>>*/ }
       /*<<ephemeron.ml:330:8>>*/ var
        /*<<ephemeron.ml:330:8>>*/ mbl =
          /*<<ephemeron.ml:330:8>>*/ caml_call3
-         (Stdlib_Array[15], _ah_, _ag_, _af_),
+         (Stdlib_Array[15], _ai_, _ah_, _ag_),
        /*<<ephemeron.ml:331:18>>*/ histo =
          /*<<ephemeron.ml:331:18>>*/ caml_make_vect(mbl + 1 | 0, 0),
-       /*<<ephemeron.ml:332:6>>*/ _ai_ = h[2];
-     function _aj_(b){
+       /*<<ephemeron.ml:332:6>>*/ _aj_ = h[2];
+     function _ak_(b){
        /*<<ephemeron.ml:334:11>>*/  /*<<ephemeron.ml:334:19>>*/ var
        l = bucket_length(0, b);
        /*<<ephemeron.ml:335:11>>*/ histo[1 + l] =
@@ -30806,7 +30859,7 @@
        /*<<ephemeron.ml:335:11>>*/ return 0;
       /*<<ephemeron.ml:335:37>>*/ }
       /*<<ephemeron.ml:332:6>>*/  /*<<ephemeron.ml:332:6>>*/ caml_call2
-      (Stdlib_Array[11], _aj_, _ai_);
+      (Stdlib_Array[11], _ak_, _aj_);
       /*<<ephemeron.ml:337:6>>*/ return [0, h[1], h[2].length - 1, mbl, histo];
      /*<<ephemeron.ml:340:34>>*/ }
     function bucket_length_alive(accu, param){
@@ -30825,22 +30878,22 @@
     function stats_alive(h){
       /*<<ephemeron.ml:349:6>>*/ var
        /*<<ephemeron.ml:349:17>>*/ size = [0, 0],
-       /*<<ephemeron.ml:350:6>>*/ _$_ = h[2],
-      _aa_ = 0;
-     function _ab_(m, b){
+       /*<<ephemeron.ml:350:6>>*/ _aa_ = h[2],
+      _ab_ = 0;
+     function _ac_(m, b){
        /*<<ephemeron.ml:352:22>>*/  /*<<ephemeron.ml:352:32>>*/ var
-       _ae_ = bucket_length_alive(0, b);
+       _af_ = bucket_length_alive(0, b);
        /*<<ephemeron.ml:352:32>>*/ return  /*<<ephemeron.ml:352:32>>*/ caml_call2
-              (Stdlib_Int[11], m, _ae_);
+              (Stdlib_Int[11], m, _af_);
       /*<<ephemeron.ml:352:57>>*/ }
       /*<<ephemeron.ml:351:8>>*/ var
        /*<<ephemeron.ml:351:8>>*/ mbl =
          /*<<ephemeron.ml:351:8>>*/ caml_call3
-         (Stdlib_Array[15], _ab_, _aa_, _$_),
+         (Stdlib_Array[15], _ac_, _ab_, _aa_),
        /*<<ephemeron.ml:354:18>>*/ histo =
          /*<<ephemeron.ml:354:18>>*/ caml_make_vect(mbl + 1 | 0, 0),
-       /*<<ephemeron.ml:355:6>>*/ _ac_ = h[2];
-     function _ad_(b){
+       /*<<ephemeron.ml:355:6>>*/ _ad_ = h[2];
+     function _ae_(b){
        /*<<ephemeron.ml:357:11>>*/  /*<<ephemeron.ml:357:19>>*/ var
        l = bucket_length_alive(0, b);
       size[1] = size[1] + l | 0;
@@ -30849,7 +30902,7 @@
        /*<<ephemeron.ml:359:11>>*/ return 0;
       /*<<ephemeron.ml:359:37>>*/ }
       /*<<ephemeron.ml:355:6>>*/  /*<<ephemeron.ml:355:6>>*/ caml_call2
-      (Stdlib_Array[11], _ad_, _ac_);
+      (Stdlib_Array[11], _ae_, _ad_);
       /*<<ephemeron.ml:361:6>>*/ return [0,
              size[1],
              h[2].length - 1,
@@ -30857,20 +30910,20 @@
              histo];
      /*<<ephemeron.ml:364:34>>*/ }
     function add_seq(tbl, i){
-     function ___(param){
+     function _$_(param){
        /*<<ephemeron.ml:367:15>>*/ var v = param[2], k = param[1];
        /*<<ephemeron.ml:367:29>>*/ return add(tbl, k, v);
       /*<<ephemeron.ml:367:41>>*/ }
       /*<<ephemeron.ml:367:6>>*/ return  /*<<ephemeron.ml:367:6>>*/ caml_call2
-             (Stdlib_Seq[4], ___, i);
+             (Stdlib_Seq[4], _$_, i);
      /*<<ephemeron.ml:367:43>>*/ }
     function replace_seq(tbl, i){
-     function _Z_(param){
+     function ___(param){
        /*<<ephemeron.ml:370:15>>*/ var v = param[2], k = param[1];
        /*<<ephemeron.ml:370:29>>*/ return replace(tbl, k, v);
       /*<<ephemeron.ml:370:45>>*/ }
       /*<<ephemeron.ml:370:6>>*/ return  /*<<ephemeron.ml:370:6>>*/ caml_call2
-             (Stdlib_Seq[4], _Z_, i);
+             (Stdlib_Seq[4], ___, i);
      /*<<ephemeron.ml:370:47>>*/ }
     function of_seq(i){
       /*<<ephemeron.ml:373:6>>*/  /*<<ephemeron.ml:373:16>>*/ var
@@ -30907,8 +30960,9 @@
             (Stdlib_Obj[24][3], t, 0);
     /*<<ephemeron.ml:396:70>>*/ }
    function set_key(t, k){
-     /*<<ephemeron.ml:397:44>>*/ return  /*<<ephemeron.ml:397:44>>*/ caml_call3
-            (Stdlib_Obj[24][5], t, 0, k);
+     /*<<ephemeron.ml:397:44>>*/  /*<<ephemeron.ml:397:44>>*/ caml_call3
+     (Stdlib_Obj[24][5], t, 0, k);
+     /*<<ephemeron.ml:397:44>>*/ return _d_;
     /*<<ephemeron.ml:397:75>>*/ }
    function check_key(t){
      /*<<ephemeron.ml:398:39>>*/ return  /*<<ephemeron.ml:398:39>>*/ caml_call2
@@ -30994,10 +31048,10 @@
      replace_seq = include[15],
      clean = include[17],
      stats_alive = include[18],
-     _Y_ = include[1];
+     _Z_ = include[1];
     function create(sz){
       /*<<ephemeron.ml:448:20>>*/ return  /*<<ephemeron.ml:448:20>>*/ caml_call2
-             (_Y_, _a_, sz);
+             (_Z_, _a_, sz);
      /*<<ephemeron.ml:448:43>>*/ }
     function of_seq(i){
       /*<<ephemeron.ml:450:6>>*/  /*<<ephemeron.ml:450:16>>*/ var
@@ -31030,8 +31084,8 @@
      /*<<ephemeron.ml:459:18>>*/ return [0, 0];
     /*<<ephemeron.ml:459:24>>*/ }
    function add(b, k, d){
-     /*<<ephemeron.ml:460:20>>*/ var _X_ = b[1];
-    b[1] = [0, make(k, d), _X_];
+     /*<<ephemeron.ml:460:20>>*/ var _Y_ = b[1];
+    b[1] = [0, make(k, d), _Y_];
     return 0;
     /*<<ephemeron.ml:460:42>>*/ }
    function test_key(k, e){
@@ -31060,13 +31114,13 @@
     }
     /*<<ephemeron.ml:474:16>>*/ }
    function find(b, k){
-     /*<<ephemeron.ml:477:6>>*/ var _U_ = b[1];
-     /*<<ephemeron.ml:477:26>>*/ function _V_(_W_){
-      /*<<?>>*/ return test_key(k, _W_);
+     /*<<ephemeron.ml:477:6>>*/ var _V_ = b[1];
+     /*<<ephemeron.ml:477:26>>*/ function _W_(_X_){
+      /*<<?>>*/ return test_key(k, _X_);
     }
      /*<<ephemeron.ml:477:12>>*/  /*<<ephemeron.ml:477:12>>*/ var
      match =
-        /*<<ephemeron.ml:477:12>>*/ caml_call2(Stdlib_List[39], _V_, _U_);
+        /*<<ephemeron.ml:477:12>>*/ caml_call2(Stdlib_List[39], _W_, _V_);
     if(! match)  /*<<ephemeron.ml:479:16>>*/ return 0;
     var e = match[1];
      /*<<ephemeron.ml:478:18>>*/ return get_data(e);
@@ -31087,16 +31141,18 @@
             (Stdlib_Obj[24][3], t, 0);
     /*<<ephemeron.ml:493:77>>*/ }
    function set_key1(t, k){
-     /*<<ephemeron.ml:495:4>>*/ return  /*<<ephemeron.ml:495:4>>*/ caml_call3
-            (Stdlib_Obj[24][5], t, 0, k);
+     /*<<ephemeron.ml:495:4>>*/  /*<<ephemeron.ml:495:4>>*/ caml_call3
+     (Stdlib_Obj[24][5], t, 0, k);
+     /*<<ephemeron.ml:495:4>>*/ return _d_;
     /*<<ephemeron.ml:495:35>>*/ }
    function get_key2(t){
      /*<<ephemeron.ml:498:49>>*/ return  /*<<ephemeron.ml:498:57>>*/ caml_call2
             (Stdlib_Obj[24][3], t, 1);
     /*<<ephemeron.ml:498:77>>*/ }
    function set_key2(t, k){
-     /*<<ephemeron.ml:500:4>>*/ return  /*<<ephemeron.ml:500:4>>*/ caml_call3
-            (Stdlib_Obj[24][5], t, 1, k);
+     /*<<ephemeron.ml:500:4>>*/  /*<<ephemeron.ml:500:4>>*/ caml_call3
+     (Stdlib_Obj[24][5], t, 1, k);
+     /*<<ephemeron.ml:500:4>>*/ return _d_;
     /*<<ephemeron.ml:500:35>>*/ }
    function get_data$0(t){
      /*<<ephemeron.ml:503:48>>*/ return  /*<<ephemeron.ml:503:56>>*/ caml_call1
@@ -31141,11 +31197,11 @@
       /*<<ephemeron.ml:539:33>>*/ var
       k2 = param[2],
       k1 = param[1],
-       /*<<ephemeron.ml:539:33>>*/ _T_ =
+       /*<<ephemeron.ml:539:33>>*/ _U_ =
          /*<<ephemeron.ml:539:33>>*/ caml_call2(H2[2], seed, k2) * 65599 | 0;
       /*<<ephemeron.ml:539:8>>*/ return  /*<<ephemeron.ml:539:8>>*/ caml_call2
              (H1[2], seed, k1)
-            + _T_
+            + _U_
             | 0;
     }
     function equal(c, param){
@@ -31174,11 +31230,11 @@
     }
     function check_key(c){
       /*<<ephemeron.ml:551:24>>*/  /*<<ephemeron.ml:496:45>>*/ var
-      _S_ =  /*<<ephemeron.ml:496:45>>*/ caml_call2(Stdlib_Obj[24][7], c, 0);
-      /*<<ephemeron.ml:551:24>>*/ return _S_
+      _T_ =  /*<<ephemeron.ml:496:45>>*/ caml_call2(Stdlib_Obj[24][7], c, 0);
+      /*<<ephemeron.ml:551:24>>*/ return _T_
              ?  /*<<ephemeron.ml:501:45>>*/ caml_call2
                (Stdlib_Obj[24][7], c, 1)
-             : _S_;
+             : _T_;
      /*<<ephemeron.ml:551:52>>*/ }
      /*<<ephemeron.ml:530:28>>*/ return MakeSeeded
             ([0,
@@ -31197,13 +31253,13 @@
      /*<<ephemeron.ml:566:52>>*/ }
      /*<<ephemeron.ml:563:9>>*/ var
      equal$0 = H1[1],
-      /*<<ephemeron.ml:563:9>>*/ _Q_ = [0, equal, seeded_hash];
+      /*<<ephemeron.ml:563:9>>*/ _R_ = [0, equal, seeded_hash];
     function seeded_hash$0(seed, x){
       /*<<ephemeron.ml:561:43>>*/ return  /*<<ephemeron.ml:561:43>>*/ caml_call1
              (H1[2], x);
      /*<<ephemeron.ml:561:52>>*/ }
     var
-     include = MakeSeeded$1([0, equal$0, seeded_hash$0], _Q_),
+     include = MakeSeeded$1([0, equal$0, seeded_hash$0], _R_),
      clear = include[2],
      reset = include[3],
      copy = include[4],
@@ -31220,10 +31276,10 @@
      replace_seq = include[15],
      clean = include[17],
      stats_alive = include[18],
-     _R_ = include[1];
+     _S_ = include[1];
     function create(sz){
       /*<<ephemeron.ml:568:20>>*/ return  /*<<ephemeron.ml:568:20>>*/ caml_call2
-             (_R_, _b_, sz);
+             (_S_, _b_, sz);
      /*<<ephemeron.ml:568:43>>*/ }
     function of_seq(i){
       /*<<ephemeron.ml:570:6>>*/  /*<<ephemeron.ml:570:16>>*/ var
@@ -31256,8 +31312,8 @@
      /*<<ephemeron.ml:579:18>>*/ return [0, 0];
     /*<<ephemeron.ml:579:24>>*/ }
    function add$0(b, k1, k2, d){
-     /*<<ephemeron.ml:580:24>>*/ var _P_ = b[1];
-    b[1] = [0, make$1(k1, k2, d), _P_];
+     /*<<ephemeron.ml:580:24>>*/ var _Q_ = b[1];
+    b[1] = [0, make$1(k1, k2, d), _Q_];
     return 0;
     /*<<ephemeron.ml:580:50>>*/ }
    function test_keys(k1, k2, e){
@@ -31287,13 +31343,13 @@
     }
     /*<<ephemeron.ml:594:16>>*/ }
    function find$0(b, k1, k2){
-     /*<<ephemeron.ml:597:6>>*/ var _M_ = b[1];
-     /*<<ephemeron.ml:597:26>>*/ function _N_(_O_){
-      /*<<?>>*/ return test_keys(k1, k2, _O_);
+     /*<<ephemeron.ml:597:6>>*/ var _N_ = b[1];
+     /*<<ephemeron.ml:597:26>>*/ function _O_(_P_){
+      /*<<?>>*/ return test_keys(k1, k2, _P_);
     }
      /*<<ephemeron.ml:597:12>>*/  /*<<ephemeron.ml:597:12>>*/ var
      match =
-        /*<<ephemeron.ml:597:12>>*/ caml_call2(Stdlib_List[39], _N_, _M_);
+        /*<<ephemeron.ml:597:12>>*/ caml_call2(Stdlib_List[39], _O_, _N_);
     if(! match)  /*<<ephemeron.ml:599:16>>*/ return 0;
     var e = match[1];
      /*<<ephemeron.ml:598:18>>*/ return get_data$0(e);
@@ -31318,8 +31374,9 @@
             (Stdlib_Obj[24][3], t, n);
     /*<<ephemeron.ml:614:78>>*/ }
    function set_key$0(t, n, k){
-     /*<<ephemeron.ml:616:4>>*/ return  /*<<ephemeron.ml:616:4>>*/ caml_call3
-            (Stdlib_Obj[24][5], t, n, k);
+     /*<<ephemeron.ml:616:4>>*/  /*<<ephemeron.ml:616:4>>*/ caml_call3
+     (Stdlib_Obj[24][5], t, n, k);
+     /*<<ephemeron.ml:616:4>>*/ return _d_;
     /*<<ephemeron.ml:616:35>>*/ }
    function get_data$1(t){
      /*<<ephemeron.ml:619:43>>*/ return  /*<<ephemeron.ml:619:51>>*/ caml_call1
@@ -31335,16 +31392,16 @@
       /*<<ephemeron.ml:625:14>>*/ eph = create$1(l);
      /*<<ephemeron.ml:626:4>>*/ set_data$1(eph, data);
      /*<<ephemeron.ml:626:4>>*/ var
-     _K_ = l - 1 | 0,
-      /*<<ephemeron.ml:626:4>>*/ _J_ = 0;
-    if(_K_ >= 0){
-     var i = _J_;
+     _L_ = l - 1 | 0,
+      /*<<ephemeron.ml:626:4>>*/ _K_ = 0;
+    if(_L_ >= 0){
+     var i = _K_;
      for(;;){
        /*<<ephemeron.ml:627:26>>*/ set_key$0
        (eph, i, caml_check_bound(keys, i)[1 + i]);
        /*<<ephemeron.ml:627:26>>*/  /*<<ephemeron.ml:627:26>>*/ var
-       _L_ = i + 1 | 0;
-      if(_K_ !== i){var i = _L_; continue;}
+       _M_ = i + 1 | 0;
+      if(_L_ !== i){var i = _M_; continue;}
       break;
      }
     }
@@ -31358,10 +31415,10 @@
        /*<<ephemeron.ml:633:37>>*/ throw  /*<<ephemeron.ml:633:37>>*/ caml_maybe_attach_backtrace
              (Stdlib[3], 1);
       /*<<ephemeron.ml:631:12>>*/ var
-       /*<<ephemeron.ml:631:12>>*/ _F_ = l - 1 | 0,
-       /*<<ephemeron.ml:634:6>>*/ _E_ = 0;
-     if(_F_ >= 0){
-      var i = _E_;
+       /*<<ephemeron.ml:631:12>>*/ _G_ = l - 1 | 0,
+       /*<<ephemeron.ml:634:6>>*/ _F_ = 0;
+     if(_G_ >= 0){
+      var i = _F_;
       for(;;){
         /*<<ephemeron.ml:635:14>>*/  /*<<ephemeron.ml:635:14>>*/ var
         match = get_key$0(eph, i);
@@ -31373,19 +31430,19 @@
          /*<<ephemeron.ml:638:20>>*/ throw  /*<<ephemeron.ml:638:20>>*/ caml_maybe_attach_backtrace
                (Stdlib[3], 1);
         /*<<ephemeron.ml:634:6>>*/  /*<<ephemeron.ml:634:6>>*/ var
-        _H_ = i + 1 | 0;
-       if(_F_ !== i){var i = _H_; continue;}
+        _I_ = i + 1 | 0;
+       if(_G_ !== i){var i = _I_; continue;}
        break;
       }
      }
       /*<<ephemeron.ml:640:6>>*/  /*<<ephemeron.ml:640:6>>*/ var
-      _G_ = get_data$1(eph);
-      /*<<ephemeron.ml:640:6>>*/ return _G_;
+      _H_ = get_data$1(eph);
+      /*<<ephemeron.ml:640:6>>*/ return _H_;
     }
-    catch(_I_){
-     var _D_ = caml_wrap_exception(_I_);
-     if(_D_ === Stdlib[3])  /*<<ephemeron.ml:641:17>>*/ return 0;
-     throw caml_maybe_attach_backtrace(_D_, 0);
+    catch(_J_){
+     var _E_ = caml_wrap_exception(_J_);
+     if(_E_ === Stdlib[3])  /*<<ephemeron.ml:641:17>>*/ return 0;
+     throw caml_maybe_attach_backtrace(_E_, 0);
     }
     /*<<ephemeron.ml:641:21>>*/ }
    function MakeSeeded$2(H){
@@ -31394,16 +31451,16 @@
       c = create$1(k.length - 1);
       /*<<ephemeron.ml:649:8>>*/ set_data$1(c, d);
       /*<<ephemeron.ml:649:8>>*/ var
-      _B_ = k.length - 1 - 1 | 0,
-       /*<<ephemeron.ml:649:8>>*/ _A_ = 0;
-     if(_B_ >= 0){
-      var i = _A_;
+      _C_ = k.length - 1 - 1 | 0,
+       /*<<ephemeron.ml:649:8>>*/ _B_ = 0;
+     if(_C_ >= 0){
+      var i = _B_;
       for(;;){
         /*<<ephemeron.ml:651:10>>*/ set_key$0
         (c, i, caml_check_bound(k, i)[1 + i]);
         /*<<ephemeron.ml:651:10>>*/  /*<<ephemeron.ml:651:10>>*/ var
-        _C_ = i + 1 | 0;
-       if(_B_ !== i){var i = _C_; continue;}
+        _D_ = i + 1 | 0;
+       if(_C_ !== i){var i = _D_; continue;}
        break;
       }
      }
@@ -31412,21 +31469,21 @@
     function seeded_hash(seed, k){
       /*<<ephemeron.ml:655:8>>*/ var
        /*<<ephemeron.ml:655:16>>*/ h = [0, 0],
-      _w_ = k.length - 1 - 1 | 0,
-       /*<<ephemeron.ml:655:16>>*/ _v_ = 0;
-     if(_w_ >= 0){
-      var i = _v_;
+      _x_ = k.length - 1 - 1 | 0,
+       /*<<ephemeron.ml:655:16>>*/ _w_ = 0;
+     if(_x_ >= 0){
+      var i = _w_;
       for(;;){
         /*<<ephemeron.ml:657:34>>*/ var
-        _x_ = h[1],
-         /*<<ephemeron.ml:657:34>>*/ _y_ = caml_check_bound(k, i)[1 + i];
+        _y_ = h[1],
+         /*<<ephemeron.ml:657:34>>*/ _z_ = caml_check_bound(k, i)[1 + i];
        h[1] =
-        ( /*<<ephemeron.ml:657:15>>*/ caml_call2(H[2], seed, _y_) * 65599 | 0)
-        + _x_
+        ( /*<<ephemeron.ml:657:15>>*/ caml_call2(H[2], seed, _z_) * 65599 | 0)
+        + _y_
         | 0;
         /*<<ephemeron.ml:656:8>>*/  /*<<ephemeron.ml:656:8>>*/ var
-        _z_ = i + 1 | 0;
-       if(_w_ !== i){var i = _z_; continue;}
+        _A_ = i + 1 | 0;
+       if(_x_ !== i){var i = _A_; continue;}
        break;
       }
      }
@@ -31447,9 +31504,9 @@
       if(! match)  /*<<ephemeron.ml:669:24>>*/ return 2;
        /*<<ephemeron.ml:671:29>>*/ var
        ki = match[1],
-        /*<<ephemeron.ml:671:29>>*/ _u_ = caml_check_bound(k, i)[1 + i];
+        /*<<ephemeron.ml:671:29>>*/ _v_ = caml_check_bound(k, i)[1 + i];
        /*<<ephemeron.ml:671:21>>*/ if
-       (!  /*<<ephemeron.ml:671:21>>*/ caml_call2(H[1], _u_, ki))
+       (!  /*<<ephemeron.ml:671:21>>*/ caml_call2(H[1], _v_, ki))
         /*<<ephemeron.ml:673:23>>*/ return 1;
        /*<<ephemeron.ml:672:23>>*/ var
         /*<<ephemeron.ml:672:23>>*/ i$0 = i - 1 | 0,
@@ -31460,16 +31517,16 @@
       /*<<ephemeron.ml:678:8>>*/  /*<<ephemeron.ml:621:40>>*/ caml_call1
       (Stdlib_Obj[24][12], c);
       /*<<ephemeron.ml:678:8>>*/ var
-      _s_ = k.length - 1 - 1 | 0,
-       /*<<ephemeron.ml:678:8>>*/ _r_ = 0;
-     if(_s_ >= 0){
-      var i = _r_;
+      _t_ = k.length - 1 - 1 | 0,
+       /*<<ephemeron.ml:678:8>>*/ _s_ = 0;
+     if(_t_ >= 0){
+      var i = _s_;
       for(;;){
         /*<<ephemeron.ml:680:10>>*/ set_key$0
         (c, i, caml_check_bound(k, i)[1 + i]);
         /*<<ephemeron.ml:680:10>>*/  /*<<ephemeron.ml:680:10>>*/ var
-        _t_ = i + 1 | 0;
-       if(_s_ !== i){var i = _t_; continue;}
+        _u_ = i + 1 | 0;
+       if(_t_ !== i){var i = _u_; continue;}
        break;
       }
      }
@@ -31480,19 +31537,19 @@
        /*<<ephemeron.ml:686:17>>*/ i$1 = length$1(c) - 1 | 0,
       i = i$1;
       /*<<ephemeron.ml:685:10>>*/ for(;;){
-      var _p_ = i < 0 ? 1 : 0;
-      if(_p_)
-       var _q_ = _p_;
+      var _q_ = i < 0 ? 1 : 0;
+      if(_q_)
+       var _r_ = _q_;
       else{
         /*<<ephemeron.ml:617:47>>*/  /*<<ephemeron.ml:617:47>>*/ var
-        _o_ =  /*<<ephemeron.ml:617:47>>*/ caml_call2(Stdlib_Obj[24][7], c, i);
-        /*<<ephemeron.ml:685:20>>*/ if(_o_){
+        _p_ =  /*<<ephemeron.ml:617:47>>*/ caml_call2(Stdlib_Obj[24][7], c, i);
+        /*<<ephemeron.ml:685:20>>*/ if(_p_){
         var i$0 = i - 1 | 0, i = i$0;
         continue;
        }
-       var _q_ = _o_;
+       var _r_ = _p_;
       }
-      return _q_;
+      return _r_;
      }
      /*<<ephemeron.ml:686:30>>*/ }
      /*<<ephemeron.ml:644:28>>*/ return MakeSeeded
@@ -31528,10 +31585,10 @@
      replace_seq = include[15],
      clean = include[17],
      stats_alive = include[18],
-     _n_ = include[1];
+     _o_ = include[1];
     function create(sz){
       /*<<ephemeron.ml:696:20>>*/ return  /*<<ephemeron.ml:696:20>>*/ caml_call2
-             (_n_, _c_, sz);
+             (_o_, _c_, sz);
      /*<<ephemeron.ml:696:43>>*/ }
     function of_seq(i){
       /*<<ephemeron.ml:698:6>>*/  /*<<ephemeron.ml:698:16>>*/ var
@@ -31564,8 +31621,8 @@
      /*<<ephemeron.ml:707:18>>*/ return [0, 0];
     /*<<ephemeron.ml:707:24>>*/ }
    function add$1(b, k, d){
-     /*<<ephemeron.ml:708:20>>*/ var _m_ = b[1];
-    b[1] = [0, make$3(k, d), _m_];
+     /*<<ephemeron.ml:708:20>>*/ var _n_ = b[1];
+    b[1] = [0, make$3(k, d), _n_];
     return 0;
     /*<<ephemeron.ml:708:42>>*/ }
    function test_keys$0(k, e){
@@ -31574,10 +31631,10 @@
        /*<<ephemeron.ml:712:43>>*/ throw  /*<<ephemeron.ml:712:43>>*/ caml_maybe_attach_backtrace
              (Stdlib[3], 1);
       /*<<ephemeron.ml:713:8>>*/ var
-      _i_ = k.length - 1 - 1 | 0,
-       /*<<ephemeron.ml:713:8>>*/ _h_ = 0;
-     if(_i_ >= 0){
-      var i = _h_;
+      _j_ = k.length - 1 - 1 | 0,
+       /*<<ephemeron.ml:713:8>>*/ _i_ = 0;
+     if(_j_ >= 0){
+      var i = _i_;
       for(;;){
         /*<<ephemeron.ml:714:16>>*/ var
          /*<<ephemeron.ml:714:16>>*/ match = get_key$0(e, i),
@@ -31586,8 +31643,8 @@
         var x = match[1];
         if(x === caml_check_bound(k, i)[1 + i]){
           /*<<ephemeron.ml:713:8>>*/  /*<<ephemeron.ml:713:8>>*/ var
-          _k_ = i + 1 | 0;
-         if(_i_ !== i){var i = _k_; continue;}
+          _l_ = i + 1 | 0;
+         if(_j_ !== i){var i = _l_; continue;}
          switch$0 = 1;
         }
        }
@@ -31597,13 +31654,13 @@
        break;
       }
      }
-      /*<<ephemeron.ml:718:8>>*/  /*<<ephemeron.ml:718:8>>*/ var _j_ = 1;
-      /*<<ephemeron.ml:718:8>>*/ return _j_;
+      /*<<ephemeron.ml:718:8>>*/  /*<<ephemeron.ml:718:8>>*/ var _k_ = 1;
+      /*<<ephemeron.ml:718:8>>*/ return _k_;
     }
-    catch(_l_){
-     var _g_ = caml_wrap_exception(_l_);
-     if(_g_ === Stdlib[3])  /*<<ephemeron.ml:719:19>>*/ return 0;
-     throw caml_maybe_attach_backtrace(_g_, 0);
+    catch(_m_){
+     var _h_ = caml_wrap_exception(_m_);
+     if(_h_ === Stdlib[3])  /*<<ephemeron.ml:719:19>>*/ return 0;
+     throw caml_maybe_attach_backtrace(_h_, 0);
     }
     /*<<ephemeron.ml:719:24>>*/ }
    function remove$1(b, k){
@@ -31623,13 +31680,13 @@
     }
     /*<<ephemeron.ml:728:16>>*/ }
    function find$1(b, k){
-     /*<<ephemeron.ml:731:6>>*/ var _d_ = b[1];
-     /*<<ephemeron.ml:731:26>>*/ function _e_(_f_){
-      /*<<?>>*/ return test_keys$0(k, _f_);
+     /*<<ephemeron.ml:731:6>>*/ var _e_ = b[1];
+     /*<<ephemeron.ml:731:26>>*/ function _f_(_g_){
+      /*<<?>>*/ return test_keys$0(k, _g_);
     }
      /*<<ephemeron.ml:731:12>>*/  /*<<ephemeron.ml:731:12>>*/ var
      match =
-        /*<<ephemeron.ml:731:12>>*/ caml_call2(Stdlib_List[39], _e_, _d_);
+        /*<<ephemeron.ml:731:12>>*/ caml_call2(Stdlib_List[39], _f_, _e_);
     if(! match)  /*<<ephemeron.ml:733:16>>*/ return 0;
     var e = match[1];
      /*<<ephemeron.ml:732:18>>*/ return get_data$1(e);
@@ -31694,8 +31751,6 @@
     caml_string_get = runtime.caml_string_get,
     caml_string_notequal = runtime.caml_string_notequal,
     caml_sys_getenv = runtime.caml_sys_getenv,
-    caml_trampoline = runtime.caml_trampoline,
-    caml_trampoline_return = runtime.caml_trampoline_return,
     caml_wrap_exception = runtime.caml_wrap_exception;
     /*<<?>>*/ function caml_call1(f, a0){
     return (f.l >= 0 ? f.l : f.l = f.length) == 1
@@ -31718,6 +31773,7 @@
             : runtime.caml_call_gen(f, [a0, a1, a2, a3]);
    }
    var
+    _l_ = undefined,
     global_data = runtime.caml_get_global_data(),
     cst$18 = cst$19,
     cst$17 = cst$19,
@@ -31853,39 +31909,39 @@
     /*<<filename.ml:96:34>>*/ }
    function is_relative(n){
      /*<<filename.ml:97:22>>*/ var
-     _aK_ = caml_ml_string_length(n) < 1 ? 1 : 0,
-     _aL_ =
-       _aK_
+     _aI_ = caml_ml_string_length(n) < 1 ? 1 : 0,
+     _aJ_ =
+       _aI_
        || (47 !==  /*<<filename.ml:97:45>>*/ caml_string_get(n, 0) ? 1 : 0);
-    return _aL_;
+    return _aJ_;
     /*<<filename.ml:97:57>>*/ }
    function is_implicit(n){
      /*<<filename.ml:99:4>>*/  /*<<filename.ml:99:4>>*/ var
-     _aF_ = is_relative(n);
-     /*<<filename.ml:99:4>>*/ if(_aF_){
+     _aD_ = is_relative(n);
+     /*<<filename.ml:99:4>>*/ if(_aD_){
      var
-      _aG_ = caml_ml_string_length(n) < 2 ? 1 : 0,
-      _aH_ =
-        _aG_
+      _aE_ = caml_ml_string_length(n) < 2 ? 1 : 0,
+      _aF_ =
+        _aE_
         ||
           /*<<filename.ml:100:31>>*/ caml_string_notequal
           ( /*<<filename.ml:100:31>>*/ caml_call3(Stdlib_String[15], n, 0, 2),
            cst$27);
-      /*<<filename.ml:100:31>>*/ if(_aH_)
+      /*<<filename.ml:100:31>>*/ if(_aF_)
       var
-       _aI_ = caml_ml_string_length(n) < 3 ? 1 : 0,
-       _aJ_ =
-         _aI_
+       _aG_ = caml_ml_string_length(n) < 3 ? 1 : 0,
+       _aH_ =
+         _aG_
          ||
            /*<<filename.ml:101:31>>*/ caml_string_notequal
            ( /*<<filename.ml:101:31>>*/ caml_call3(Stdlib_String[15], n, 0, 3),
             cst$28);
      else
-      var _aJ_ = _aH_;
+      var _aH_ = _aF_;
     }
     else
-     var _aJ_ = _aF_;
-     /*<<filename.ml:101:31>>*/ return _aJ_;
+     var _aH_ = _aD_;
+     /*<<filename.ml:101:31>>*/ return _aH_;
     /*<<filename.ml:101:57>>*/ }
    function check_suffix(name, suff){
      /*<<filename.ml:103:4>>*/ return  /*<<filename.ml:103:4>>*/ caml_call2
@@ -31913,8 +31969,8 @@
         /*<<filename.ml:117:8>>*/ caml_sys_getenv("TMPDIR"),
      temp_dir_name = _k_;
    }
-   catch(_aE_){
-    var _a_ = caml_wrap_exception(_aE_);
+   catch(_aC_){
+    var _a_ = caml_wrap_exception(_aC_);
     if(_a_ !== Stdlib[8]) throw caml_maybe_attach_backtrace(_a_, 0);
     var temp_dir_name = cst_tmp;
    }
@@ -31926,10 +31982,10 @@
      /*<<filename.ml:19:2>>*/  /*<<filename.ml:19:2>>*/ caml_call2
      (Stdlib_Buffer[12], b, 39);
      /*<<filename.ml:19:2>>*/ var
-     _aB_ = l - 1 | 0,
-      /*<<filename.ml:19:2>>*/ _aA_ = 0;
-    if(_aB_ >= 0){
-     var i = _aA_;
+     _az_ = l - 1 | 0,
+      /*<<filename.ml:19:2>>*/ _ay_ = 0;
+    if(_az_ >= 0){
+     var i = _ay_;
      for(;;){
        /*<<filename.ml:21:7>>*/ if
        (39 ===  /*<<filename.ml:21:7>>*/ caml_string_get(s, i))
@@ -31937,13 +31993,13 @@
         (Stdlib_Buffer[16], b, quotequote);
       else{
         /*<<filename.ml:23:28>>*/  /*<<filename.ml:23:28>>*/ var
-        _aD_ =  /*<<filename.ml:23:28>>*/ caml_string_get(s, i);
+        _aB_ =  /*<<filename.ml:23:28>>*/ caml_string_get(s, i);
         /*<<filename.ml:23:9>>*/  /*<<filename.ml:23:9>>*/ caml_call2
-        (Stdlib_Buffer[12], b, _aD_);
+        (Stdlib_Buffer[12], b, _aB_);
       }
        /*<<filename.ml:23:9>>*/  /*<<filename.ml:23:9>>*/ var
-       _aC_ = i + 1 | 0;
-      if(_aB_ !== i){var i = _aC_; continue;}
+       _aA_ = i + 1 | 0;
+      if(_az_ !== i){var i = _aA_; continue;}
       break;
      }
     }
@@ -31957,47 +32013,47 @@
      var f = stderr[1];
       /*<<filename.ml:123:51>>*/ if
       ( /*<<filename.ml:123:51>>*/ caml_equal(stderr, stdout))
-      var _ap_ = cst_2_1;
+      var _an_ = cst_2_1;
      else
        /*<<filename.ml:125:61>>*/ var
-        /*<<filename.ml:125:61>>*/ _az_ = quote(f),
-       _ap_ =  /*<<filename.ml:125:53>>*/ caml_call2(Stdlib[28], cst_2, _az_);
-     var _aq_ = _ap_;
+        /*<<filename.ml:125:61>>*/ _ax_ = quote(f),
+       _an_ =  /*<<filename.ml:125:53>>*/ caml_call2(Stdlib[28], cst_2, _ax_);
+     var _ao_ = _an_;
     }
     else
-     var _aq_ = cst$4;
+     var _ao_ = cst$4;
     if(stdout)
       /*<<filename.ml:122:55>>*/ var
       f$0 = stdout[1],
-       /*<<filename.ml:122:55>>*/ _ar_ = quote(f$0),
-      _as_ =  /*<<filename.ml:122:48>>*/ caml_call2(Stdlib[28], cst, _ar_);
+       /*<<filename.ml:122:55>>*/ _ap_ = quote(f$0),
+      _aq_ =  /*<<filename.ml:122:48>>*/ caml_call2(Stdlib[28], cst, _ap_);
     else
-     var _as_ = cst$3;
+     var _aq_ = cst$3;
      /*<<filename.ml:122:6>>*/  /*<<filename.ml:122:6>>*/ var
-     _at_ =  /*<<filename.ml:122:6>>*/ caml_call2(Stdlib[28], _as_, _aq_);
+     _ar_ =  /*<<filename.ml:122:6>>*/ caml_call2(Stdlib[28], _aq_, _ao_);
     if(stdin)
       /*<<filename.ml:121:55>>*/ var
       f$1 = stdin[1],
-       /*<<filename.ml:121:55>>*/ _au_ = quote(f$1),
-      _av_ =  /*<<filename.ml:121:48>>*/ caml_call2(Stdlib[28], cst$0, _au_);
+       /*<<filename.ml:121:55>>*/ _as_ = quote(f$1),
+      _at_ =  /*<<filename.ml:121:48>>*/ caml_call2(Stdlib[28], cst$0, _as_);
     else
-     var _av_ = cst$2;
+     var _at_ = cst$2;
      /*<<filename.ml:121:6>>*/ var
-      /*<<filename.ml:121:6>>*/ _aw_ =
-        /*<<filename.ml:121:6>>*/ caml_call2(Stdlib[28], _av_, _at_),
-      /*<<filename.ml:120:22>>*/ _ax_ =
+      /*<<filename.ml:121:6>>*/ _au_ =
+        /*<<filename.ml:121:6>>*/ caml_call2(Stdlib[28], _at_, _ar_),
+      /*<<filename.ml:120:22>>*/ _av_ =
         /*<<filename.ml:120:22>>*/ caml_call2
         (Stdlib_List[19], quote, [0, cmd, args]),
-      /*<<filename.ml:120:4>>*/ _ay_ =
-        /*<<filename.ml:120:4>>*/ caml_call2(Stdlib_String[6], cst$1, _ax_);
+      /*<<filename.ml:120:4>>*/ _aw_ =
+        /*<<filename.ml:120:4>>*/ caml_call2(Stdlib_String[6], cst$1, _av_);
      /*<<filename.ml:121:6>>*/ return  /*<<filename.ml:121:6>>*/ caml_call2
-            (Stdlib[28], _ay_, _aw_);
+            (Stdlib[28], _aw_, _au_);
     /*<<filename.ml:125:69>>*/ }
-    /*<<filename.ml:126:17>>*/ function basename(_ao_){
-     /*<<?>>*/ return generic_basename(is_dir_sep, current_dir_name, _ao_);
+    /*<<filename.ml:126:17>>*/ function basename(_am_){
+     /*<<?>>*/ return generic_basename(is_dir_sep, current_dir_name, _am_);
    }
-    /*<<filename.ml:127:16>>*/ function dirname(_an_){
-     /*<<?>>*/ return generic_dirname(is_dir_sep, current_dir_name, _an_);
+    /*<<filename.ml:127:16>>*/ function dirname(_al_){
+     /*<<?>>*/ return generic_dirname(is_dir_sep, current_dir_name, _al_);
    }
     /*<<filename.ml:91:24>>*/  /*<<filename.ml:91:24>>*/ var
     Unix =
@@ -32020,96 +32076,96 @@
      /*<<filename.ml:135:23>>*/ var
       /*<<filename.ml:135:31>>*/ c =
         /*<<filename.ml:135:31>>*/ caml_string_get(s, i),
-     _ak_ = 47 === c ? 1 : 0;
-    if(_ak_)
-     var _al_ = _ak_;
+     _ai_ = 47 === c ? 1 : 0;
+    if(_ai_)
+     var _aj_ = _ai_;
     else
-     var _am_ = 92 === c ? 1 : 0, _al_ = _am_ || (58 === c ? 1 : 0);
-    return _al_;
+     var _ak_ = 92 === c ? 1 : 0, _aj_ = _ak_ || (58 === c ? 1 : 0);
+    return _aj_;
     /*<<filename.ml:135:70>>*/ }
    function is_relative$0(n){
      /*<<filename.ml:137:4>>*/ var
-     _ae_ = caml_ml_string_length(n) < 1 ? 1 : 0,
-     _af_ =
-       _ae_
+     _ac_ = caml_ml_string_length(n) < 1 ? 1 : 0,
+     _ad_ =
+       _ac_
        || (47 !==  /*<<filename.ml:137:28>>*/ caml_string_get(n, 0) ? 1 : 0);
-    if(_af_){
+    if(_ad_){
      var
-      _ag_ = caml_ml_string_length(n) < 1 ? 1 : 0,
-      _ah_ =
-        _ag_
+      _ae_ = caml_ml_string_length(n) < 1 ? 1 : 0,
+      _af_ =
+        _ae_
         || (92 !==  /*<<filename.ml:138:31>>*/ caml_string_get(n, 0) ? 1 : 0);
-     if(_ah_)
+     if(_af_)
       var
-       _ai_ = caml_ml_string_length(n) < 2 ? 1 : 0,
-       _aj_ =
-         _ai_
+       _ag_ = caml_ml_string_length(n) < 2 ? 1 : 0,
+       _ah_ =
+         _ag_
          || (58 !==  /*<<filename.ml:139:31>>*/ caml_string_get(n, 1) ? 1 : 0);
      else
-      var _aj_ = _ah_;
+      var _ah_ = _af_;
     }
     else
-     var _aj_ = _af_;
-    return _aj_;
+     var _ah_ = _ad_;
+    return _ah_;
     /*<<filename.ml:139:44>>*/ }
    function is_implicit$0(n){
      /*<<filename.ml:141:4>>*/  /*<<filename.ml:141:4>>*/ var
-     _X_ = is_relative$0(n);
-     /*<<filename.ml:141:4>>*/ if(_X_){
+     _V_ = is_relative$0(n);
+     /*<<filename.ml:141:4>>*/ if(_V_){
      var
-      _Y_ = caml_ml_string_length(n) < 2 ? 1 : 0,
-      _Z_ =
-        _Y_
+      _W_ = caml_ml_string_length(n) < 2 ? 1 : 0,
+      _X_ =
+        _W_
         ||
           /*<<filename.ml:142:31>>*/ caml_string_notequal
           ( /*<<filename.ml:142:31>>*/ caml_call3(Stdlib_String[15], n, 0, 2),
            cst$27);
-      /*<<filename.ml:142:31>>*/ if(_Z_){
+      /*<<filename.ml:142:31>>*/ if(_X_){
       var
-       ___ = caml_ml_string_length(n) < 2 ? 1 : 0,
-       _$_ =
-         ___
+       _Y_ = caml_ml_string_length(n) < 2 ? 1 : 0,
+       _Z_ =
+         _Y_
          ||
            /*<<filename.ml:143:31>>*/ caml_string_notequal
            ( /*<<filename.ml:143:31>>*/ caml_call3(Stdlib_String[15], n, 0, 2),
             ".\\");
-       /*<<filename.ml:143:31>>*/ if(_$_){
+       /*<<filename.ml:143:31>>*/ if(_Z_){
        var
-        _aa_ = caml_ml_string_length(n) < 3 ? 1 : 0,
-        _ab_ =
-          _aa_
+        ___ = caml_ml_string_length(n) < 3 ? 1 : 0,
+        _$_ =
+          ___
           ||
             /*<<filename.ml:144:31>>*/ caml_string_notequal
             ( /*<<filename.ml:144:31>>*/ caml_call3
               (Stdlib_String[15], n, 0, 3),
              cst$28);
-        /*<<filename.ml:144:31>>*/ if(_ab_)
+        /*<<filename.ml:144:31>>*/ if(_$_)
         var
-         _ac_ = caml_ml_string_length(n) < 3 ? 1 : 0,
-         _ad_ =
-           _ac_
+         _aa_ = caml_ml_string_length(n) < 3 ? 1 : 0,
+         _ab_ =
+           _aa_
            ||
              /*<<filename.ml:145:31>>*/ caml_string_notequal
              ( /*<<filename.ml:145:31>>*/ caml_call3
                (Stdlib_String[15], n, 0, 3),
               "..\\");
        else
-        var _ad_ = _ab_;
+        var _ab_ = _$_;
       }
       else
-       var _ad_ = _$_;
+       var _ab_ = _Z_;
      }
      else
-      var _ad_ = _Z_;
+      var _ab_ = _X_;
     }
     else
-     var _ad_ = _X_;
-     /*<<filename.ml:145:31>>*/ return _ad_;
+     var _ab_ = _V_;
+     /*<<filename.ml:145:31>>*/ return _ab_;
     /*<<filename.ml:145:58>>*/ }
    function check_suffix$0(name, suff){
      /*<<filename.ml:147:3>>*/ var
-     _U_ = caml_ml_string_length(suff) <= caml_ml_string_length(name) ? 1 : 0;
-    if(_U_)
+     _S_ = caml_ml_string_length(suff) <= caml_ml_string_length(name) ? 1 : 0;
+    if(_S_)
       /*<<filename.ml:148:12>>*/ var
        /*<<filename.ml:148:12>>*/ s =
          /*<<filename.ml:148:12>>*/ caml_call3
@@ -32117,14 +32173,14 @@
           name,
           caml_ml_string_length(name) - caml_ml_string_length(suff) | 0,
           caml_ml_string_length(suff)),
-       /*<<filename.ml:150:31>>*/ _V_ =
+       /*<<filename.ml:150:31>>*/ _T_ =
          /*<<filename.ml:150:31>>*/ caml_call1(Stdlib_String[26], suff),
-      _W_ =
+      _U_ =
          /*<<filename.ml:150:4>>*/ caml_string_equal
-         ( /*<<filename.ml:150:4>>*/ caml_call1(Stdlib_String[26], s), _V_);
+         ( /*<<filename.ml:150:4>>*/ caml_call1(Stdlib_String[26], s), _T_);
     else
-     var _W_ = _U_;
-     /*<<filename.ml:150:4>>*/ return _W_;
+     var _U_ = _S_;
+     /*<<filename.ml:150:4>>*/ return _U_;
     /*<<filename.ml:150:59>>*/ }
    function chop_suffix_opt$0(suffix, filename){
      /*<<filename.ml:153:4>>*/ var
@@ -32135,11 +32191,11 @@
       /*<<filename.ml:155:14>>*/ r =
         /*<<filename.ml:155:14>>*/ caml_call3
         (Stdlib_String[15], filename, len_f - len_s | 0, len_s),
-      /*<<filename.ml:156:36>>*/ _T_ =
+      /*<<filename.ml:156:36>>*/ _R_ =
         /*<<filename.ml:156:36>>*/ caml_call1(Stdlib_String[26], suffix);
      /*<<filename.ml:156:9>>*/ return  /*<<filename.ml:156:9>>*/ caml_string_equal
              ( /*<<filename.ml:156:9>>*/ caml_call1(Stdlib_String[26], r),
-              _T_)
+              _R_)
             ? [0,
                /*<<filename.ml:157:13>>*/ caml_call3
                (Stdlib_String[15], filename, 0, len_f - len_s | 0)]
@@ -32151,8 +32207,8 @@
         /*<<filename.ml:165:8>>*/ caml_sys_getenv("TEMP"),
      temp_dir_name$0 = _j_;
    }
-   catch(_S_){
-    var _b_ = caml_wrap_exception(_S_);
+   catch(_Q_){
+    var _b_ = caml_wrap_exception(_Q_);
     if(_b_ !== Stdlib[8]) throw caml_maybe_attach_backtrace(_b_, 0);
     var temp_dir_name$0 = cst$5;
    }
@@ -32163,60 +32219,39 @@
         /*<<filename.ml:168:12>>*/ caml_call1(Stdlib_Buffer[1], l + 20 | 0);
      /*<<filename.ml:169:4>>*/  /*<<filename.ml:169:4>>*/ caml_call2
      (Stdlib_Buffer[12], b, 34);
-    function add_bs(n){
-      /*<<filename.ml:186:19>>*/  /*<<filename.ml:186:19>>*/ var _Q_ = 1;
-     if(n >= 1){
-      var j = _Q_;
-      for(;;){
-        /*<<filename.ml:186:38>>*/  /*<<filename.ml:186:38>>*/ caml_call2
-        (Stdlib_Buffer[12], b, 92);
-        /*<<filename.ml:186:38>>*/  /*<<filename.ml:186:38>>*/ var
-        _R_ = j + 1 | 0;
-       if(n !== j){var j = _R_; continue;}
-       break;
-      }
-     }
-     return 0;
-     /*<<filename.ml:186:66>>*/ }
-    function loop$0(counter, i){
+    function loop(i){
       /*<<filename.ml:171:6>>*/ var i$0 = i;
       /*<<filename.ml:171:6>>*/ for(;;){
-      if(i$0 === l)
-        /*<<filename.ml:171:20>>*/ return  /*<<filename.ml:171:20>>*/ caml_call2
-               (Stdlib_Buffer[12], b, 34);
+      if(i$0 === l){
+        /*<<filename.ml:171:20>>*/  /*<<filename.ml:171:20>>*/ caml_call2
+        (Stdlib_Buffer[12], b, 34);
+        /*<<filename.ml:171:20>>*/ return _l_;
+      }
        /*<<filename.ml:172:12>>*/  /*<<filename.ml:172:12>>*/ var
        c =  /*<<filename.ml:172:12>>*/ caml_string_get(s, i$0);
       if(34 === c){
-       var _O_ = 0;
-        /*<<filename.ml:173:16>>*/ if(counter >= 50)
-         /*<<filename.ml:173:16>>*/ return  /*<<filename.ml:173:16>>*/ caml_trampoline_return
-                (loop_bs, [0, _O_, i$0]);
-       var counter$1 = counter + 1 | 0;
-        /*<<filename.ml:173:16>>*/ return loop_bs(counter$1, _O_, i$0);
+        /*<<filename.ml:173:16>>*/ loop_bs(0, i$0);
+        /*<<filename.ml:173:16>>*/ return _l_;
       }
-      if(92 !== c){
-        /*<<filename.ml:175:16>>*/  /*<<filename.ml:175:16>>*/ caml_call2
-        (Stdlib_Buffer[12], b, c);
-        /*<<filename.ml:175:16>>*/ var
-         /*<<filename.ml:175:16>>*/ i$1 = i$0 + 1 | 0,
-        i$0 = i$1;
-       continue;
+      if(92 === c){
+        /*<<filename.ml:174:16>>*/ loop_bs(0, i$0);
+        /*<<filename.ml:174:16>>*/ return _l_;
       }
-      var _P_ = 0;
-       /*<<filename.ml:174:16>>*/ if(counter >= 50)
-        /*<<filename.ml:174:16>>*/ return  /*<<filename.ml:174:16>>*/ caml_trampoline_return
-               (loop_bs, [0, _P_, i$0]);
-      var counter$0 = counter + 1 | 0;
-       /*<<filename.ml:174:16>>*/ return loop_bs(counter$0, _P_, i$0);
+       /*<<filename.ml:175:16>>*/  /*<<filename.ml:175:16>>*/ caml_call2
+       (Stdlib_Buffer[12], b, c);
+       /*<<filename.ml:175:16>>*/ var
+        /*<<filename.ml:175:16>>*/ i$1 = i$0 + 1 | 0,
+       i$0 = i$1;
      }
      /*<<filename.ml:175:48>>*/ }
-    function loop_bs(counter, n, i){
+    function loop_bs(n, i){
       /*<<filename.ml:177:6>>*/ var n$0 = n, i$0 = i;
       /*<<filename.ml:177:6>>*/ for(;;){
       if(i$0 === l){
         /*<<filename.ml:178:8>>*/  /*<<filename.ml:178:8>>*/ caml_call2
         (Stdlib_Buffer[12], b, 34);
-        /*<<filename.ml:178:8>>*/ return add_bs(n$0);
+        /*<<filename.ml:178:8>>*/ add_bs(n$0);
+        /*<<filename.ml:178:8>>*/ return _l_;
       }
        /*<<filename.ml:181:14>>*/  /*<<filename.ml:181:14>>*/ var
        match =  /*<<filename.ml:181:14>>*/ caml_string_get(s, i$0);
@@ -32224,13 +32259,8 @@
         /*<<filename.ml:182:18>>*/ add_bs((2 * n$0 | 0) + 1 | 0);
         /*<<filename.ml:182:34>>*/  /*<<filename.ml:182:34>>*/ caml_call2
         (Stdlib_Buffer[12], b, 34);
-        /*<<filename.ml:182:34>>*/  /*<<filename.ml:182:34>>*/ var
-        _N_ = i$0 + 1 | 0;
-        /*<<filename.ml:182:34>>*/ if(counter >= 50)
-         /*<<filename.ml:182:34>>*/ return  /*<<filename.ml:182:34>>*/ caml_trampoline_return
-                (loop$0, [0, _N_]);
-       var counter$1 = counter + 1 | 0;
-        /*<<filename.ml:182:34>>*/ return loop$0(counter$1, _N_);
+        /*<<filename.ml:182:34>>*/ loop(i$0 + 1 | 0);
+        /*<<filename.ml:182:34>>*/ return _l_;
       }
       if(92 === match){
         /*<<filename.ml:183:18>>*/ var
@@ -32241,14 +32271,25 @@
        continue;
       }
        /*<<filename.ml:184:18>>*/ add_bs(n$0);
-       /*<<filename.ml:184:18>>*/ if(counter >= 50)
-        /*<<filename.ml:184:18>>*/ return  /*<<filename.ml:184:18>>*/ caml_trampoline_return
-               (loop$0, [0, i$0]);
-      var counter$0 = counter + 1 | 0;
-       /*<<filename.ml:184:18>>*/ return loop$0(counter$0, i$0);
+       /*<<filename.ml:184:18>>*/ loop(i$0);
+       /*<<filename.ml:184:18>>*/ return _l_;
      }
      /*<<filename.ml:185:9>>*/ }
-    function loop(i){ /*<<?>>*/ return caml_trampoline(loop$0(0, i));}
+    function add_bs(n){
+      /*<<filename.ml:186:19>>*/  /*<<filename.ml:186:19>>*/ var _O_ = 1;
+     if(n >= 1){
+      var j = _O_;
+      for(;;){
+        /*<<filename.ml:186:38>>*/  /*<<filename.ml:186:38>>*/ caml_call2
+        (Stdlib_Buffer[12], b, 92);
+        /*<<filename.ml:186:38>>*/  /*<<filename.ml:186:38>>*/ var
+        _P_ = j + 1 | 0;
+       if(n !== j){var j = _P_; continue;}
+       break;
+      }
+     }
+     return _l_;
+     /*<<filename.ml:186:66>>*/ }
      /*<<filename.ml:188:4>>*/ loop(0);
      /*<<filename.ml:188:4>>*/ return  /*<<filename.ml:188:4>>*/ caml_call1
             (Stdlib_Buffer[2], b);
@@ -32262,64 +32303,64 @@
       (!  /*<<filename.ml:224:12>>*/ caml_call2(Stdlib_String[14], f, 32))
        /*<<filename.ml:227:6>>*/ return f;
       /*<<filename.ml:225:13>>*/  /*<<filename.ml:225:13>>*/ var
-      _M_ =  /*<<filename.ml:225:13>>*/ caml_call2(Stdlib[28], f, cst$6);
+      _N_ =  /*<<filename.ml:225:13>>*/ caml_call2(Stdlib[28], f, cst$6);
       /*<<filename.ml:225:13>>*/ return  /*<<filename.ml:225:13>>*/ caml_call2
-             (Stdlib[28], cst$7, _M_);
+             (Stdlib[28], cst$7, _N_);
     }
      /*<<filename.ml:223:15>>*/  /*<<filename.ml:223:15>>*/ var
-     _L_ =
+     _M_ =
         /*<<filename.ml:223:15>>*/ caml_call2
         (Stdlib[28], cst_Filename_quote_command_bad, f);
      /*<<filename.ml:223:15>>*/ return  /*<<filename.ml:223:15>>*/ caml_call1
-            (Stdlib[2], _L_);
+            (Stdlib[2], _M_);
     /*<<filename.ml:227:7>>*/ }
    function quote_command$0(cmd, stdin, stdout, stderr, args){
      /*<<filename.ml:232:4>>*/ if(stderr){
      var f = stderr[1];
       /*<<filename.ml:240:43>>*/ if
       ( /*<<filename.ml:240:43>>*/ caml_equal(stderr, stdout))
-      var _x_ = cst_2_1$0;
+      var _y_ = cst_2_1$0;
      else
        /*<<filename.ml:242:53>>*/ var
-        /*<<filename.ml:242:53>>*/ _J_ = quote_cmd_filename(f),
-       _x_ =  /*<<filename.ml:242:45>>*/ caml_call2(Stdlib[28], cst_2$0, _J_);
-     var _y_ = _x_;
+        /*<<filename.ml:242:53>>*/ _K_ = quote_cmd_filename(f),
+       _y_ =  /*<<filename.ml:242:45>>*/ caml_call2(Stdlib[28], cst_2$0, _K_);
+     var _z_ = _y_;
     }
     else
-     var _y_ = cst$16;
-    var _z_ = [0, _y_, _c_];
+     var _z_ = cst$16;
+    var _A_ = [0, _z_, _c_];
     if(stdout)
       /*<<filename.ml:238:55>>*/ var
       f$0 = stdout[1],
-       /*<<filename.ml:238:55>>*/ _A_ = quote_cmd_filename(f$0),
-      _B_ =  /*<<filename.ml:238:48>>*/ caml_call2(Stdlib[28], cst$8, _A_);
+       /*<<filename.ml:238:55>>*/ _B_ = quote_cmd_filename(f$0),
+      _C_ =  /*<<filename.ml:238:48>>*/ caml_call2(Stdlib[28], cst$8, _B_);
     else
-     var _B_ = cst$15;
-    var _C_ = [0, _B_, _z_];
+     var _C_ = cst$15;
+    var _D_ = [0, _C_, _A_];
     if(stdin)
       /*<<filename.ml:237:55>>*/ var
       f$1 = stdin[1],
-       /*<<filename.ml:237:55>>*/ _D_ = quote_cmd_filename(f$1),
-      _E_ =  /*<<filename.ml:237:48>>*/ caml_call2(Stdlib[28], cst$9, _D_);
+       /*<<filename.ml:237:55>>*/ _E_ = quote_cmd_filename(f$1),
+      _F_ =  /*<<filename.ml:237:48>>*/ caml_call2(Stdlib[28], cst$9, _E_);
     else
-     var _E_ = cst$14;
+     var _F_ = cst$14;
      /*<<filename.ml:236:35>>*/ var
-      /*<<filename.ml:236:35>>*/ _G_ =
+      /*<<filename.ml:236:35>>*/ _H_ =
         /*<<filename.ml:236:35>>*/ caml_call2(Stdlib_List[19], quote$0, args),
       /*<<filename.ml:236:16>>*/ s =
-        /*<<filename.ml:236:16>>*/ caml_call2(Stdlib_String[6], cst$10, _G_),
+        /*<<filename.ml:236:16>>*/ caml_call2(Stdlib_String[6], cst$10, _H_),
       /*<<filename.ml:211:12>>*/ b =
         /*<<filename.ml:211:12>>*/ caml_call1
         (Stdlib_Buffer[1], caml_ml_string_length(s) + 20 | 0),
-     _F_ = [0, _E_, _C_];
-    function _w_(c){
+     _G_ = [0, _F_, _D_];
+    function _x_(c){
       /*<<filename.ml:214:8>>*/ var switch$0 = 0;
      if(62 <= c){
-      var _K_ = c - 63 | 0;
-      if(60 < _K_ >>> 0){
-       if(62 > _K_) switch$0 = 1;
+      var _L_ = c - 63 | 0;
+      if(60 < _L_ >>> 0){
+       if(62 > _L_) switch$0 = 1;
       }
-      else if(31 === _K_) switch$0 = 1;
+      else if(31 === _L_) switch$0 = 1;
      }
      else
       if(42 <= c){
@@ -32334,21 +32375,21 @@
              :  /*<<filename.ml:218:12>>*/ caml_call2(Stdlib_Buffer[12], b, c);
      /*<<filename.ml:218:31>>*/ }
      /*<<filename.ml:212:4>>*/  /*<<filename.ml:212:4>>*/ caml_call2
-     (Stdlib_String[29], _w_, s);
+     (Stdlib_String[29], _x_, s);
      /*<<filename.ml:232:21>>*/ var
-     _H_ =
+     _I_ =
        [0,
         cst$11,
-        [0,  /*<<filename.ml:212:4>>*/ caml_call1(Stdlib_Buffer[2], b), _F_]],
-      /*<<filename.ml:232:21>>*/ _I_ =
-       [0, cst$12, [0, quote_cmd_filename(cmd), _H_]];
+        [0,  /*<<filename.ml:212:4>>*/ caml_call1(Stdlib_Buffer[2], b), _G_]],
+      /*<<filename.ml:232:21>>*/ _J_ =
+       [0, cst$12, [0, quote_cmd_filename(cmd), _I_]];
      /*<<filename.ml:232:21>>*/ return  /*<<filename.ml:232:21>>*/ caml_call2
-            (Stdlib_String[6], cst$13, _I_);
+            (Stdlib_String[6], cst$13, _J_);
     /*<<filename.ml:244:5>>*/ }
    function drive_and_path(s){
      /*<<filename.ml:252:4>>*/ var
-     _s_ = 2 <=  /*<<filename.ml:250:4>>*/ caml_ml_string_length(s) ? 1 : 0;
-    if(_s_){
+     _t_ = 2 <=  /*<<filename.ml:250:4>>*/ caml_ml_string_length(s) ? 1 : 0;
+    if(_t_){
       /*<<filename.ml:250:38>>*/ var
        /*<<filename.ml:250:38>>*/ param =
          /*<<filename.ml:250:38>>*/ caml_string_get(s, 0),
@@ -32358,23 +32399,23 @@
      }
      else if(65 <= param) switch$0 = 1;
       /*<<filename.ml:250:28>>*/ var
-      _t_ = switch$0 ? 1 : 0,
-       /*<<filename.ml:250:28>>*/ _u_ =
-        _t_
+      _u_ = switch$0 ? 1 : 0,
+       /*<<filename.ml:250:28>>*/ _v_ =
+        _u_
          ? 58 ===  /*<<filename.ml:250:47>>*/ caml_string_get(s, 1) ? 1 : 0
-         : _t_;
+         : _u_;
     }
     else
-     var _u_ = _s_;
-     /*<<filename.ml:252:7>>*/ if(! _u_)
+     var _v_ = _t_;
+     /*<<filename.ml:252:7>>*/ if(! _v_)
       /*<<filename.ml:254:9>>*/ return [0, cst$17, s];
      /*<<filename.ml:253:28>>*/  /*<<filename.ml:253:28>>*/ var
-     _v_ =
+     _w_ =
         /*<<filename.ml:253:28>>*/ caml_call3
         (Stdlib_String[15], s, 2, caml_ml_string_length(s) - 2 | 0);
      /*<<filename.ml:253:9>>*/ return [0,
              /*<<filename.ml:253:10>>*/ caml_call3(Stdlib_String[15], s, 0, 2),
-            _v_];
+            _w_];
     /*<<filename.ml:254:16>>*/ }
    function dirname$0(s){
      /*<<filename.ml:256:4>>*/ var
@@ -32408,11 +32449,11 @@
        quote_command$0,
        basename$0,
        dirname$0];
-    /*<<filename.ml:277:17>>*/ function basename$1(_r_){
-     /*<<?>>*/ return generic_basename(is_dir_sep$0, current_dir_name$1, _r_);
+    /*<<filename.ml:277:17>>*/ function basename$1(_s_){
+     /*<<?>>*/ return generic_basename(is_dir_sep$0, current_dir_name$1, _s_);
    }
-    /*<<filename.ml:278:16>>*/ function dirname$1(_q_){
-     /*<<?>>*/ return generic_dirname(is_dir_sep$0, current_dir_name$1, _q_);
+    /*<<filename.ml:278:16>>*/ function dirname$1(_r_){
+     /*<<?>>*/ return generic_dirname(is_dir_sep$0, current_dir_name$1, _r_);
    }
     /*<<filename.ml:264:26>>*/ var
      /*<<filename.ml:264:26>>*/ Cygwin =
@@ -32455,11 +32496,11 @@
      /*<<filename.ml:291:14>>*/ if
      (0 !== l && ! is_dir_sep$1(dirname, l - 1 | 0)){
       /*<<filename.ml:293:17>>*/  /*<<filename.ml:293:17>>*/ var
-      _p_ =
+      _q_ =
          /*<<filename.ml:293:17>>*/ caml_call2
          (Stdlib[28], dir_sep$2, filename);
       /*<<filename.ml:293:17>>*/ return  /*<<filename.ml:293:17>>*/ caml_call2
-             (Stdlib[28], dirname, _p_);
+             (Stdlib[28], dirname, _q_);
     }
      /*<<filename.ml:292:7>>*/ return  /*<<filename.ml:292:7>>*/ caml_call2
             (Stdlib[28], dirname, filename);
@@ -32562,7 +32603,7 @@
     /*<<filename.ml:338:71>>*/ }
     /*<<filename.ml:338:40>>*/ var
      /*<<filename.ml:338:40>>*/ _g_ =
-      [0, function(_o_){ /*<<?>>*/ return _o_;}],
+      [0, function(_p_){ /*<<?>>*/ return _p_;}],
      /*<<filename.ml:338:2>>*/ current_temp_dir_name =
        /*<<filename.ml:338:2>>*/ caml_call2(Stdlib_Domain[10][1], _g_, _f_);
    function set_temp_dir_name(s){
@@ -32603,17 +32644,17 @@
      }
     }
     /*<<filename.ml:351:15>>*/ }
-   function open_temp_file(opt, _m_, _l_, prefix, suffix){
+   function open_temp_file(opt, _n_, _m_, prefix, suffix){
      /*<<filename.ml:356:2>>*/ if(opt)
      var sth = opt[1], mode = sth;
     else
      var mode = _i_;
-     /*<<filename.ml:356:2>>*/ if(_m_)
-     var sth$0 = _m_[1], perms = sth$0;
+     /*<<filename.ml:356:2>>*/ if(_n_)
+     var sth$0 = _n_[1], perms = sth$0;
     else
      var perms = 384;
-     /*<<filename.ml:356:2>>*/ if(_l_)
-     var sth$1 = _l_[1], temp_dir = sth$1;
+     /*<<filename.ml:356:2>>*/ if(_m_)
+     var sth$1 = _m_[1], temp_dir = sth$1;
     else
      var
       temp_dir =
@@ -32625,12 +32666,12 @@
       name = temp_file_name(temp_dir, prefix, suffix);
       /*<<filename.ml:358:4>>*/ try{
        /*<<filename.ml:359:6>>*/  /*<<filename.ml:359:6>>*/ var
-       _n_ =
+       _o_ =
          [0,
           name,
            /*<<filename.ml:360:7>>*/ caml_call3
            (Stdlib[62], [0, 1, [0, 3, [0, 5, mode]]], perms, name)];
-       /*<<filename.ml:359:6>>*/ return _n_;
+       /*<<filename.ml:359:6>>*/ return _o_;
      }
      catch(e$0){
       var e = caml_wrap_exception(e$0);

From 89df59fb4e6d20cb99f49b152095c0b723967d38 Mon Sep 17 00:00:00 2001
From: Micah Cantor <micahcantor01@gmail.com>
Date: Tue, 8 Aug 2023 13:15:32 +0200
Subject: [PATCH 053/112] sentinal name, start recursive liveness

---
 compiler/lib/deadcode_dgraph.ml            |  47 ++++---
 compiler/tests-compiler/direct_calls.ml    |  20 +--
 compiler/tests-compiler/gh1007.ml          |  46 +++----
 compiler/tests-compiler/gh1494.ml          |   2 +-
 compiler/tests-compiler/global_deadcode.ml | 137 ++++++++++++++-------
 5 files changed, 152 insertions(+), 100 deletions(-)

diff --git a/compiler/lib/deadcode_dgraph.ml b/compiler/lib/deadcode_dgraph.ml
index c0ba1698cb..6f8ade7821 100644
--- a/compiler/lib/deadcode_dgraph.ml
+++ b/compiler/lib/deadcode_dgraph.ml
@@ -41,7 +41,7 @@ type def =
 (** Liveness of a variable [x], forming a lattice structure. *)
 type live =
   | Top (** [x] is live and not a block. *)
-  | Live of IntSet.t (** [x] is a live block with a (non-empty) set of live fields. *)
+  | Live of live IntMap.t (** [x] is a live block with a (non-empty) set of live fields. *)
   | Dead (** [x] is dead. *)
 
 module G = Dgraph.Make_Imperative (Var) (Var.ISet) (Var.Tbl)
@@ -49,19 +49,21 @@ module G = Dgraph.Make_Imperative (Var) (Var.ISet) (Var.Tbl)
 module Domain = struct
   type t = live
 
-  let equal l1 l2 =
+  let rec equal l1 l2 =
     match l1, l2 with
     | Top, Top | Dead, Dead -> true
-    | Live f1, Live f2 -> IntSet.equal f1 f2
+    | Live f1, Live f2 -> IntMap.equal equal f1 f2
     | _ -> false
 
   let bot = Dead
 
   (** Join the liveness according to lattice structure. *)
-  let join l1 l2 =
+  let rec join l1 l2 =
     match l1, l2 with
     | _, Top | Top, _ -> Top
-    | Live f1, Live f2 -> Live (IntSet.union f1 f2)
+    | Live f1, Live f2 -> 
+        let fields = IntMap.union (fun _ l1 l2 -> Some (join l1 l2)) f1 f2 in 
+        Live fields
     | Dead, Live f | Live f, Dead -> Live f
     | Dead, Dead -> Dead
 end
@@ -211,19 +213,22 @@ let liveness nv prog pure_funs (global_info : Global_flow.info) =
     let idx = Var.idx v in
     live_vars.(idx) <- Top
   in
-  let add_live v i =
+  let add_live v i l =
     let idx = Var.idx v in
     match live_vars.(idx) with
-    | Live fields -> live_vars.(idx) <- Live (IntSet.add i fields)
-    | _ -> live_vars.(idx) <- Live (IntSet.singleton i)
+    | Live fields -> live_vars.(idx) <- Live (IntMap.add i l fields)
+    | _ -> live_vars.(idx) <- Live (IntMap.singleton i l)
   in
   let live_instruction i =
     match i with
-    | Let (_x, e) ->
+    | Let (_, e) ->
+        (* We add all variables in impure expressions as top to ensure they aren't removed. *)
         if not (pure_expr pure_funs e)
         then (
           let vars = expr_vars e in
           Var.ISet.iter add_top vars;)
+        (* We might be able to do better in pure fn applications. The function itself must be kept but
+           arguments might be dead if they don't escape. *)
         else (match e with
           | Apply { f; args; _} ->
               add_top f;
@@ -231,13 +236,13 @@ let liveness nv prog pure_funs (global_info : Global_flow.info) =
           | _ -> ()) 
     | Assign (_, _) -> ()
     | Set_field (x, i, y) ->
-        add_live x i;
+        add_live x i Top;
         add_top y
     | Array_set (x, y, z) ->
         add_top x;
         add_top y;
         add_top z
-    | Offset_ref (x, i) -> add_live x i
+    | Offset_ref (x, i) -> add_live x i Top
   in
   let live_block block =
     List.iter ~f:(fun (i, _) -> live_instruction i) block.body;
@@ -277,17 +282,19 @@ let propagate uses defs live_vars live_table x =
         | Live fields -> (
             match defs.(Var.idx y) with
             | Expr (Block (_, vars, _)) ->
-                let found = ref false in
-                Array.iteri
-                  ~f:(fun i v ->
-                    if Var.equal v x && IntSet.mem i fields then found := true)
+                let live = ref Dead in
+                Array.iteri ~f:(fun i v -> 
+                  if Var.equal v x
+                    then match IntMap.find_opt i fields with
+                    | Some l -> live := l
+                    | None -> ())
                   vars;
-                if !found then Top else Dead
+                !live
             | _ -> Top)
         (* If y is top and y is a field access, x depends only on that field *)
         | Top -> (
             match defs.(Var.idx y) with
-            | Expr (Field (_, i)) -> Live (IntSet.singleton i)
+            | Expr (Field (_, i)) -> Live (IntMap.singleton i Top)
             | _ -> Top))
     (* If x is used as an argument for parameter y, then contribution is liveness of y *)
     | Propagate -> Var.Tbl.get live_table y
@@ -352,7 +359,7 @@ let zero prog sentinal live_table =
             | Live fields ->
                 let vars =
                   Array.mapi
-                    ~f:(fun i v -> if IntSet.mem i fields then v else sentinal)
+                    ~f:(fun i v -> if IntMap.mem i fields then v else sentinal)
                     vars
                   |> compact_vars
                 in
@@ -393,7 +400,7 @@ let zero prog sentinal live_table =
 module Print = struct
   let live_to_string = function
     | Live fields ->
-        "live { " ^ IntSet.fold (fun i s -> s ^ Format.sprintf "%d " i) fields "" ^ "}"
+        "live { " ^ IntMap.fold (fun i _ s -> s ^ Format.sprintf "%d " i) fields "" ^ "}"
     | Top -> "top"
     | Dead -> "dead"
 
@@ -428,7 +435,7 @@ end
 
 (** Add a sentinal variable declaration to the IR. The fresh variable is assigned to `undefined`. *)
 let add_sentinal p =
-  let sentinal = Var.fresh () in
+  let sentinal = Var.fresh_n "sentinal" in
   let undefined = Prim (Extern "%undefined", []) in
   let instr, loc = Let (sentinal, undefined), Before 0 in
   Code.prepend p [ instr, loc ], sentinal
diff --git a/compiler/tests-compiler/direct_calls.ml b/compiler/tests-compiler/direct_calls.ml
index 98b7a4249c..e7c66cb85a 100644
--- a/compiler/tests-compiler/direct_calls.ml
+++ b/compiler/tests-compiler/direct_calls.ml
@@ -57,26 +57,26 @@ let%expect_test "direct calls without --enable effects" =
   [%expect
     {|
     function test1(param){
-     function f(g, x){caml_call1(g, x); return _b_;}
-     var _e_ = 7;
-     f(function(x){return x + 1 | 0;}, _e_);
-     var _f_ = 4.;
-     f(function(x){return x * 2.;}, _f_);
+     function f(g, x){caml_call1(g, x); return sentinal;}
+     var _d_ = 7;
+     f(function(x){return x + 1 | 0;}, _d_);
+     var _e_ = 4.;
+     f(function(x){return x * 2.;}, _e_);
      return 0;
     }
     //end
     function test2(param){
-     function f(g, x){caml_call1(g, x); return _b_;}
-     var _d_ = 7;
-     f(function(x){return x + 1 | 0;}, _d_);
+     function f(g, x){caml_call1(g, x); return sentinal;}
+     var _c_ = 7;
+     f(function(x){return x + 1 | 0;}, _c_);
      f(function(x){return caml_call2(Stdlib[28], x, cst_a$0);}, cst_a);
      return 0;
     }
     //end
     function test3(x){
      function F(symbol){function f(x){return x + 1 | 0;} return [0, f];}
-     var M1 = F([0]), M2 = F([0]), _c_ = M2[1].call(null, 2);
-     return [0, M1[1].call(null, 1), _c_];
+     var M1 = F([0]), M2 = F([0]), _b_ = M2[1].call(null, 2);
+     return [0, M1[1].call(null, 1), _b_];
     }
     //end
     function test4(x){
diff --git a/compiler/tests-compiler/gh1007.ml b/compiler/tests-compiler/gh1007.ml
index 6aed85957d..6379531de1 100644
--- a/compiler/tests-compiler/gh1007.ml
+++ b/compiler/tests-compiler/gh1007.ml
@@ -369,31 +369,31 @@ let ()  = M.run ()
           if(2 >= n >>> 0)
            switch(n){
              case 0:
-              return _a_;
+              return sentinal;
              case 1:
-              odd(0); return _a_;
-             default: odd(1); return _a_;
+              odd(0); return sentinal;
+             default: odd(1); return sentinal;
            }
           odd(n - 1 | 0);
-          return _a_;
+          return sentinal;
          },
        odd =
          function(n){
           if(2 >= n >>> 0)
            switch(n){
              case 0:
-              return _a_;
+              return sentinal;
              case 1:
-              even(0); return _a_;
-             default: even(1); return _a_;
+              even(0); return sentinal;
+             default: even(1); return sentinal;
            }
           even(n - 1 | 0);
-          return _a_;
+          return sentinal;
          };
       even(i);
-      var _b_ = i + 1 | 0;
+      var _a_ = i + 1 | 0;
       if(4 === i) return 0;
-      var i = _b_;
+      var i = _a_;
      }
     }
     //end |}]
@@ -467,13 +467,13 @@ let ()  = M.run ()
                 f = function(param){return caml_call2(Stdlib_Printf[2], _b_, i);};
                delayed[1] = [0, f, delayed[1]];
                f(0);
-               return _c_;
+               return sentinal;
               case 1:
-               odd(0); return _c_;
-              default: odd(1); return _c_;
+               odd(0); return sentinal;
+              default: odd(1); return sentinal;
             }
            odd(n - 1 | 0);
-           return _c_;
+           return sentinal;
           }
           function odd(n){
            if(2 >= n >>> 0)
@@ -483,13 +483,13 @@ let ()  = M.run ()
                 f = function(param){return caml_call2(Stdlib_Printf[2], _a_, i);};
                delayed[1] = [0, f, delayed[1]];
                f(0);
-               return _c_;
+               return sentinal;
               case 1:
-               even(0); return _c_;
-              default: even(1); return _c_;
+               even(0); return sentinal;
+              default: even(1); return sentinal;
             }
            even(n - 1 | 0);
-           return _c_;
+           return sentinal;
           }
           var block = [0, even, odd];
           return block;
@@ -497,14 +497,14 @@ let ()  = M.run ()
        closures$0 = closures(i),
        even = closures$0[1];
       even(i);
-      var _f_ = i + 1 | 0;
+      var _e_ = i + 1 | 0;
       if(4 === i){
        var
-        _d_ = caml_call1(Stdlib_List[9], delayed[1]),
-        _e_ = function(f){return caml_call1(f, 0);};
-       return caml_call2(Stdlib_List[17], _e_, _d_);
+        _c_ = caml_call1(Stdlib_List[9], delayed[1]),
+        _d_ = function(f){return caml_call1(f, 0);};
+       return caml_call2(Stdlib_List[17], _d_, _c_);
       }
-      var i = _f_;
+      var i = _e_;
      }
     }
     //end |}]
diff --git a/compiler/tests-compiler/gh1494.ml b/compiler/tests-compiler/gh1494.ml
index 17cab23faf..fd646b38f2 100644
--- a/compiler/tests-compiler/gh1494.ml
+++ b/compiler/tests-compiler/gh1494.ml
@@ -39,7 +39,7 @@ let () =
   [%expect
     {|
     function bug(param){
-     var g = [0, function(x){return function(_d_){return _d_;};}];
+     var g = [0, function(x){return function(_c_){return _c_;};}];
      return [0, function(param){return caml_call1(g[1], 1);}, g];
     }
     //end |}]
diff --git a/compiler/tests-compiler/global_deadcode.ml b/compiler/tests-compiler/global_deadcode.ml
index c82dd943ea..eb48cf9a89 100644
--- a/compiler/tests-compiler/global_deadcode.ml
+++ b/compiler/tests-compiler/global_deadcode.ml
@@ -15,41 +15,97 @@ let%expect_test "Eliminates unused functions from functor" =
       |}
   in
   (* Expect: compiles functor members used in the program *)
-  print_fun_decl program (Some "find");
-  [%expect
-    {|
-    function find(x, param){
-     var param$0 = param;
-     for(;;){
-      if(! param$0) throw caml_maybe_attach_backtrace(Not_found, 1);
-      var
-       r = param$0[3],
-       v = param$0[2],
-       l = param$0[1],
-       c = caml_call2(Ord[1], x, v);
-      if(0 === c) return v;
-      var r$0 = 0 <= c ? r : l, param$0 = r$0;
-     }
-    }
-    //end |}];
-  print_fun_decl program (Some "add");
+  print_fun_decl program (Some "_e_");
   [%expect {|
-    function add(x, t){
-     if(! t) return [0, 0, x, 0, 1];
-     var r = t[3], v = t[2], l = t[1], c = caml_call2(Ord[1], x, v);
-     if(0 === c) return t;
-     if(0 <= c){var rr = add(x, r); return r === rr ? t : bal(l, v, rr);}
-     var ll = add(x, l);
-     return l === ll ? t : bal(ll, v, r);
+    function _e_(Ord){
+     function height(param){if(! param) return 0; var h = param[4]; return h;}
+     function create(l, v, r){
+      if(l) var h = l[4], hl = h; else var hl = 0;
+      if(r) var h$0 = r[4], hr = h$0; else var hr = 0;
+      var _m_ = hr <= hl ? hl + 1 | 0 : hr + 1 | 0;
+      return [0, l, v, r, _m_];
+     }
+     function bal(l, v, r){
+      if(l) var h = l[4], hl = h; else var hl = 0;
+      if(r) var h$0 = r[4], hr = h$0; else var hr = 0;
+      if((hr + 2 | 0) < hl){
+       if(! l) return invalid_arg(_b_);
+       var lr = l[3], lv = l[2], ll = l[1], _h_ = height(lr);
+       if(_h_ <= height(ll)) return create(ll, lv, create(lr, v, r));
+       if(! lr) return invalid_arg(_a_);
+       var lrr = lr[3], lrv = lr[2], lrl = lr[1], _i_ = create(lrr, v, r);
+       return create(create(ll, lv, lrl), lrv, _i_);
+      }
+      if((hl + 2 | 0) >= hr){
+       var _l_ = hr <= hl ? hl + 1 | 0 : hr + 1 | 0;
+       return [0, l, v, r, _l_];
+      }
+      if(! r) return invalid_arg(_d_);
+      var rr = r[3], rv = r[2], rl = r[1], _j_ = height(rl);
+      if(_j_ <= height(rr)) return create(create(l, v, rl), rv, rr);
+      if(! rl) return invalid_arg(_c_);
+      var rlr = rl[3], rlv = rl[2], rll = rl[1], _k_ = create(rlr, rv, rr);
+      return create(create(l, v, rll), rlv, _k_);
+     }
+     function add(x, t){
+      if(! t) return [0, 0, x, 0, 1];
+      var r = t[3], v = t[2], l = t[1], c = caml_call2(Ord[1], x, v);
+      if(0 === c) return t;
+      if(0 <= c){var rr = add(x, r); return r === rr ? t : bal(l, v, rr);}
+      var ll = add(x, l);
+      return l === ll ? t : bal(ll, v, r);
+     }
+     function singleton(x){return [0, 0, x, 0, 1];}
+     var empty = 0;
+     function find(x, param){
+      var param$0 = param;
+      for(;;){
+       if(! param$0) throw caml_maybe_attach_backtrace(Not_found, 1);
+       var
+        r = param$0[3],
+        v = param$0[2],
+        l = param$0[1],
+        c = caml_call2(Ord[1], x, v);
+       if(0 === c) return v;
+       var r$0 = 0 <= c ? r : l, param$0 = r$0;
+      }
+     }
+     return [0,
+             empty,
+             sentinal,
+             sentinal,
+             add,
+             singleton,
+             sentinal,
+             sentinal,
+             sentinal,
+             sentinal,
+             sentinal,
+             sentinal,
+             sentinal,
+             sentinal,
+             sentinal,
+             sentinal,
+             sentinal,
+             sentinal,
+             sentinal,
+             sentinal,
+             sentinal,
+             sentinal,
+             sentinal,
+             sentinal,
+             sentinal,
+             sentinal,
+             sentinal,
+             sentinal,
+             sentinal,
+             sentinal,
+             sentinal,
+             find];
     }
-    //end |}];
-  (* Expect: does not compile unused functor member *)
-  print_fun_decl program (Some "union");
-  [%expect {| not found |}];
-  print_fun_decl program (Some "inter");
-  [%expect {| not found |}]
+    //end |}]
 
-let%expect_test "Substitutes unused fields with undefined" =
+let%expect_test "Substitutes unused fields with sentinal" =
   let program =
     compile_and_parse
       {|
@@ -64,23 +120,12 @@ let%expect_test "Substitutes unused fields with undefined" =
   print_fun_decl program (Some "f");
   [%expect {|
     function f(b, x){
-     var t = b ? [0, 1, _c_, x] : [0, 3, _c_, 4], v = t[3], u = t[1];
+     var t = b ? [0, 1, sentinal, x] : [0, 3, sentinal, 4], v = t[3], u = t[1];
      return [0, u, v];
     }
     //end |}];
   (* And that variable is defined as `undefined` *)
-  print_var_decl program "_c_";
+  print_var_decl program "sentinal";
   [%expect {|
-    var _c_ = undefined;
+    var sentinal = undefined;
     //end |}]
-
-let%expect_test "Sets unused return value to undefined" =
-  let program =
-    compile_and_parse
-      {|
-
-      |}
-  in print_fun_decl program (Some "f");
-  [%expect {| not found |}];
-  print_var_decl program "__";
-  [%expect {| var __ = not found |}]
\ No newline at end of file

From 2e62a34a2110b7b2b72505c6eea455711772797c Mon Sep 17 00:00:00 2001
From: Micah Cantor <micahcantor01@gmail.com>
Date: Tue, 8 Aug 2023 19:30:36 +0200
Subject: [PATCH 054/112] fix printing vars

---
 compiler/lib/deadcode_dgraph.ml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/compiler/lib/deadcode_dgraph.ml b/compiler/lib/deadcode_dgraph.ml
index 6f8ade7821..440dd6e0c4 100644
--- a/compiler/lib/deadcode_dgraph.ml
+++ b/compiler/lib/deadcode_dgraph.ml
@@ -408,7 +408,7 @@ module Print = struct
     Format.eprintf "Usages:\n";
     Array.iteri
       ~f:(fun i ds ->
-        Format.eprintf "v%d: { " i;
+        Format.eprintf "%a: { " Var.print (Var.of_idx i);
         Var.Map.iter
           (fun d k ->
             Format.eprintf
@@ -424,7 +424,7 @@ module Print = struct
 
   let print_liveness live_vars =
     Format.eprintf "Liveness:\n";
-    Array.iteri ~f:(fun i l -> Format.eprintf "v%d: %s\n" i (live_to_string l)) live_vars
+    Array.iteri ~f:(fun i l -> Format.eprintf "%a: %s\n" Var.print (Var.of_idx i) (live_to_string l)) live_vars
 
   let print_live_tbl live_table =
     Format.eprintf "Liveness with dependencies:\n";

From d930a080523c7a4b1101033b185d6722fb905a3b Mon Sep 17 00:00:00 2001
From: Micah Cantor <micahcantor01@gmail.com>
Date: Fri, 11 Aug 2023 14:55:14 +0200
Subject: [PATCH 055/112] continue recursive blocks

---
 compiler/lib/deadcode_dgraph.ml | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/compiler/lib/deadcode_dgraph.ml b/compiler/lib/deadcode_dgraph.ml
index 440dd6e0c4..d5c29c7068 100644
--- a/compiler/lib/deadcode_dgraph.ml
+++ b/compiler/lib/deadcode_dgraph.ml
@@ -286,10 +286,14 @@ let propagate uses defs live_vars live_table x =
                 Array.iteri ~f:(fun i v -> 
                   if Var.equal v x
                     then match IntMap.find_opt i fields with
-                    | Some l -> live := l
+                    | Some l -> live := Domain.join !live l
                     | None -> ())
                   vars;
                 !live
+            | Expr (Field (_, i)) ->(
+                match IntMap.find_opt i fields with
+                  | Some l -> l
+                  | None -> Dead)
             | _ -> Top)
         (* If y is top and y is a field access, x depends only on that field *)
         | Top -> (
@@ -334,7 +338,7 @@ let zero prog sentinal live_table =
     | Dead -> false
     | _ -> true
   in
-  let zero_var x = if not (is_live x) then sentinal else x in
+  let zero_var x = if is_live x then x else sentinal in
   let zero_cont ((pc, args) : cont) =
     match Addr.Map.find_opt pc prog.blocks with
     | Some block ->

From 2f60c4ec9dbcb822f52ff28a235792fc0bd99705 Mon Sep 17 00:00:00 2001
From: Micah Cantor <micahcantor01@gmail.com>
Date: Fri, 11 Aug 2023 14:58:24 +0200
Subject: [PATCH 056/112] promote stdlib changes

---
 compiler/tests-full/stdlib.cma.expected.js | 4557 ++++++++++----------
 1 file changed, 2285 insertions(+), 2272 deletions(-)

diff --git a/compiler/tests-full/stdlib.cma.expected.js b/compiler/tests-full/stdlib.cma.expected.js
index 7e201668fd..8249793bfe 100644
--- a/compiler/tests-full/stdlib.cma.expected.js
+++ b/compiler/tests-full/stdlib.cma.expected.js
@@ -1248,11 +1248,11 @@
             : runtime.caml_call_gen(f, [a0]);
    }
    var
+    sentinal = undefined,
     global_data = runtime.caml_get_global_data(),
     Stdlib = global_data.Stdlib,
     Assert_failure = global_data.Assert_failure,
     Stdlib_Sys = global_data.Stdlib__Sys,
-    _b_ = undefined,
     cst_Obj_Ephemeron_blit_key = "Obj.Ephemeron.blit_key",
     cst_Obj_Ephemeron_check_key = "Obj.Ephemeron.check_key",
     cst_Obj_Ephemeron_unset_key = "Obj.Ephemeron.unset_key",
@@ -1330,9 +1330,9 @@
     max_ephe_length = Stdlib_Sys[13] - 2 | 0;
    function create(l){
      /*<<obj.ml:135:4>>*/ var
-     _h_ = 0 <= l ? 1 : 0,
-     _i_ = _h_ ? l <= max_ephe_length ? 1 : 0 : _h_;
-    if(1 - _i_)
+     _g_ = 0 <= l ? 1 : 0,
+     _h_ = _g_ ? l <= max_ephe_length ? 1 : 0 : _g_;
+    if(1 - _h_)
       /*<<obj.ml:136:6>>*/  /*<<obj.ml:136:6>>*/ caml_call1
       (Stdlib[1], cst_Obj_Ephemeron_create);
      /*<<obj.ml:137:4>>*/ return  /*<<obj.ml:137:4>>*/ runtime.caml_ephe_create
@@ -1343,10 +1343,12 @@
     /*<<obj.ml:139:49>>*/ }
    function raise_if_invalid_offset(e, o, msg){
      /*<<obj.ml:142:4>>*/ var
-     _e_ = 0 <= o ? 1 : 0,
-     _f_ = _e_ ? o < length(e) ? 1 : 0 : _e_,
-     _g_ = 1 - _f_;
-    return _g_ ? ( /*<<obj.ml:143:6>>*/ caml_call1(Stdlib[1], msg), _b_) : _g_;
+     _d_ = 0 <= o ? 1 : 0,
+     _e_ = _d_ ? o < length(e) ? 1 : 0 : _d_,
+     _f_ = 1 - _e_;
+    return _f_
+            ? ( /*<<obj.ml:143:6>>*/ caml_call1(Stdlib[1], msg), sentinal)
+            : _f_;
     /*<<obj.ml:143:21>>*/ }
    function get_key(e, o){
      /*<<obj.ml:147:4>>*/ raise_if_invalid_offset
@@ -1385,13 +1387,13 @@
        0 <= o1
        && (length(e1) - l | 0) >= o1 && 0 <= o2 && (length(e2) - l | 0) >= o2){
      var
-      _c_ = 0 !== l ? 1 : 0,
-      _d_ =
-        _c_
+      _b_ = 0 !== l ? 1 : 0,
+      _c_ =
+        _b_
          ?  /*<<obj.ml:177:24>>*/ runtime.caml_ephe_blit_key
            (e1, o1, e2, o2, l)
-         : _c_;
-      /*<<obj.ml:177:24>>*/ return _d_;
+         : _b_;
+      /*<<obj.ml:177:24>>*/ return _c_;
     }
      /*<<obj.ml:176:9>>*/ return  /*<<obj.ml:176:9>>*/ caml_call1
             (Stdlib[1], cst_Obj_Ephemeron_blit_key);
@@ -4549,7 +4551,7 @@
             : runtime.caml_call_gen(f, [a0, a1]);
    }
    var
-    _g_ = undefined,
+    sentinal = undefined,
     global_data = runtime.caml_get_global_data(),
     Stdlib = global_data.Stdlib,
     Stdlib_Uchar = global_data.Stdlib__Uchar,
@@ -4594,15 +4596,15 @@
    function init(n, f){
      /*<<bytes.ml:47:2>>*/ var
       /*<<bytes.ml:47:10>>*/ s =  /*<<bytes.ml:47:10>>*/ caml_create_bytes(n),
-      /*<<bytes.ml:48:2>>*/ _ar_ = n - 1 | 0,
-      /*<<bytes.ml:47:10>>*/ _aq_ = 0;
-    if(_ar_ >= 0){
-     var i = _aq_;
+      /*<<bytes.ml:48:2>>*/ _aq_ = n - 1 | 0,
+      /*<<bytes.ml:47:10>>*/ _ap_ = 0;
+    if(_aq_ >= 0){
+     var i = _ap_;
      for(;;){
       caml_bytes_unsafe_set(s, i,  /*<<bytes.ml:49:19>>*/ caml_call1(f, i));
-       /*<<bytes.ml:48:2>>*/  /*<<bytes.ml:48:2>>*/ var _as_ = i + 1 | 0;
-      if(_ar_ === i) break;
-      var i = _as_;
+       /*<<bytes.ml:48:2>>*/  /*<<bytes.ml:48:2>>*/ var _ar_ = i + 1 | 0;
+      if(_aq_ === i) break;
+      var i = _ar_;
      }
     }
      /*<<bytes.ml:51:2>>*/ return s;
@@ -4644,11 +4646,11 @@
    function symbol(a, b){
      /*<<bytes.ml:77:2>>*/ var
      c = a + b | 0,
-     _ap_ = b < 0 ? 1 : 0,
+     _ao_ = b < 0 ? 1 : 0,
      match = c < 0 ? 1 : 0;
     a:
     {
-     if(a < 0){if(_ap_ && ! match) break a;} else if(! _ap_ && match) break a;
+     if(a < 0){if(_ao_ && ! match) break a;} else if(! _ao_ && match) break a;
       /*<<bytes.ml:81:9>>*/ return c;
     }
      /*<<bytes.ml:80:27>>*/ return  /*<<bytes.ml:80:27>>*/ caml_call1
@@ -4711,32 +4713,32 @@
     /*<<bytes.ml:106:45>>*/ }
    function iter(f, a){
      /*<<bytes.ml:110:2>>*/ var
-     _an_ = caml_ml_bytes_length(a) - 1 | 0,
-      /*<<bytes.ml:110:2>>*/ _am_ = 0;
-    if(_an_ >= 0){
-     var i = _am_;
+     _am_ = caml_ml_bytes_length(a) - 1 | 0,
+      /*<<bytes.ml:110:2>>*/ _al_ = 0;
+    if(_am_ >= 0){
+     var i = _al_;
      for(;;){
        /*<<bytes.ml:110:31>>*/  /*<<bytes.ml:110:31>>*/ caml_call1
        (f, caml_bytes_unsafe_get(a, i));
-       /*<<bytes.ml:110:31>>*/  /*<<bytes.ml:110:31>>*/ var _ao_ = i + 1 | 0;
-      if(_an_ === i) break;
-      var i = _ao_;
+       /*<<bytes.ml:110:31>>*/  /*<<bytes.ml:110:31>>*/ var _an_ = i + 1 | 0;
+      if(_am_ === i) break;
+      var i = _an_;
      }
     }
     return 0;
     /*<<bytes.ml:110:53>>*/ }
    function iteri(f, a){
      /*<<bytes.ml:114:2>>*/ var
-     _ak_ = caml_ml_bytes_length(a) - 1 | 0,
-      /*<<bytes.ml:114:2>>*/ _aj_ = 0;
-    if(_ak_ >= 0){
-     var i = _aj_;
+     _aj_ = caml_ml_bytes_length(a) - 1 | 0,
+      /*<<bytes.ml:114:2>>*/ _ai_ = 0;
+    if(_aj_ >= 0){
+     var i = _ai_;
      for(;;){
        /*<<bytes.ml:114:31>>*/  /*<<bytes.ml:114:31>>*/ caml_call2
        (f, i, caml_bytes_unsafe_get(a, i));
-       /*<<bytes.ml:114:31>>*/  /*<<bytes.ml:114:31>>*/ var _al_ = i + 1 | 0;
-      if(_ak_ === i) break;
-      var i = _al_;
+       /*<<bytes.ml:114:31>>*/  /*<<bytes.ml:114:31>>*/ var _ak_ = i + 1 | 0;
+      if(_aj_ === i) break;
+      var i = _ak_;
      }
     }
     return 0;
@@ -4759,13 +4761,13 @@
         param = tl;
        continue;
       }
-      var _ai_ = caml_ml_bytes_length(hd) + acc | 0;
+      var _ah_ = caml_ml_bytes_length(hd) + acc | 0;
      }
      else
-      var _ai_ = acc;
+      var _ah_ = acc;
       /*<<bytes.ml:136:12>>*/ var
        /*<<bytes.ml:136:12>>*/ dst =
-         /*<<bytes.ml:136:12>>*/ caml_create_bytes(_ai_),
+         /*<<bytes.ml:136:12>>*/ caml_create_bytes(_ah_),
       pos = pos$1,
       param$0 = l;
      for(;;){
@@ -4803,10 +4805,10 @@
     /*<<bytes.ml:145:3>>*/ }
    function is_space(param){
      /*<<bytes.ml:151:15>>*/  /*<<bytes.ml:151:15>>*/ var
-     _ah_ = param - 9 | 0;
+     _ag_ = param - 9 | 0;
     a:
     {
-     if(4 < _ah_ >>> 0){if(23 !== _ah_) break a;} else if(2 === _ah_) break a;
+     if(4 < _ag_ >>> 0){if(23 !== _ag_) break a;} else if(2 === _ag_) break a;
       /*<<bytes.ml:152:41>>*/ return 1;
     }
      /*<<bytes.ml:153:9>>*/ return 0;
@@ -4830,10 +4832,10 @@
    function unsafe_escape(s){
      /*<<bytes.ml:184:2>>*/ var
       /*<<bytes.ml:184:10>>*/ n = [0, 0],
-     _aa_ = caml_ml_bytes_length(s) - 1 | 0,
-      /*<<bytes.ml:184:10>>*/ _$_ = 0;
-    if(_aa_ >= 0){
-     var i$0 = _$_;
+     _$_ = caml_ml_bytes_length(s) - 1 | 0,
+      /*<<bytes.ml:184:10>>*/ ___ = 0;
+    if(_$_ >= 0){
+     var i$0 = ___;
      for(;;){
       var match = caml_bytes_unsafe_get(s, i$0);
       a:
@@ -4843,12 +4845,12 @@
         c:
         {
          if(32 <= match){
-          var _ae_ = match - 34 | 0;
-          if(58 < _ae_ >>> 0){
-           if(93 <= _ae_) break c;
+          var _ad_ = match - 34 | 0;
+          if(58 < _ad_ >>> 0){
+           if(93 <= _ad_) break c;
           }
-          else if(56 < _ae_ - 1 >>> 0) break b;
-          var _af_ = 1;
+          else if(56 < _ad_ - 1 >>> 0) break b;
+          var _ae_ = 1;
           break a;
          }
          if(11 <= match){
@@ -4856,15 +4858,15 @@
          }
          else if(8 <= match) break b;
         }
-        var _af_ = 4;
+        var _ae_ = 4;
         break a;
        }
-       var _af_ = 2;
+       var _ae_ = 2;
       }
-      n[1] = n[1] + _af_ | 0;
-       /*<<bytes.ml:185:2>>*/  /*<<bytes.ml:185:2>>*/ var _ag_ = i$0 + 1 | 0;
-      if(_aa_ === i$0) break;
-      var i$0 = _ag_;
+      n[1] = n[1] + _ae_ | 0;
+       /*<<bytes.ml:185:2>>*/  /*<<bytes.ml:185:2>>*/ var _af_ = i$0 + 1 | 0;
+      if(_$_ === i$0) break;
+      var i$0 = _af_;
      }
     }
     if(n[1] === caml_ml_bytes_length(s))  /*<<bytes.ml:192:24>>*/ return s;
@@ -4872,10 +4874,10 @@
      s$0 =  /*<<bytes.ml:194:13>>*/ caml_create_bytes(n[1]);
     n[1] = 0;
      /*<<bytes.ml:196:4>>*/ var
-     _ac_ = caml_ml_bytes_length(s) - 1 | 0,
-      /*<<bytes.ml:196:4>>*/ _ab_ = 0;
-    if(_ac_ >= 0){
-     var i = _ab_;
+     _ab_ = caml_ml_bytes_length(s) - 1 | 0,
+      /*<<bytes.ml:196:4>>*/ _aa_ = 0;
+    if(_ab_ >= 0){
+     var i = _aa_;
      for(;;){
       var c = caml_bytes_unsafe_get(s, i);
       a:
@@ -4933,9 +4935,9 @@
        caml_bytes_unsafe_set(s$0, n[1], c);
       }
       n[1]++;
-       /*<<bytes.ml:196:4>>*/  /*<<bytes.ml:196:4>>*/ var _ad_ = i + 1 | 0;
-      if(_ac_ === i) break;
-      var i = _ad_;
+       /*<<bytes.ml:196:4>>*/  /*<<bytes.ml:196:4>>*/ var _ac_ = i + 1 | 0;
+      if(_ab_ === i) break;
+      var i = _ac_;
      }
     }
      /*<<bytes.ml:221:4>>*/ return s$0;
@@ -4950,18 +4952,18 @@
      /*<<bytes.ml:233:12>>*/ var
       /*<<bytes.ml:233:12>>*/ r =
         /*<<bytes.ml:233:12>>*/ caml_create_bytes(l),
-      /*<<bytes.ml:234:4>>*/ _Z_ = l - 1 | 0,
-      /*<<bytes.ml:233:12>>*/ _Y_ = 0;
-    if(_Z_ >= 0){
-     var i = _Y_;
+      /*<<bytes.ml:234:4>>*/ _Y_ = l - 1 | 0,
+      /*<<bytes.ml:233:12>>*/ _X_ = 0;
+    if(_Y_ >= 0){
+     var i = _X_;
      for(;;){
       caml_bytes_unsafe_set
        (r,
         i,
          /*<<bytes.ml:234:41>>*/ caml_call1(f, caml_bytes_unsafe_get(s, i)));
-       /*<<bytes.ml:234:4>>*/  /*<<bytes.ml:234:4>>*/ var ___ = i + 1 | 0;
-      if(_Z_ === i) break;
-      var i = ___;
+       /*<<bytes.ml:234:4>>*/  /*<<bytes.ml:234:4>>*/ var _Z_ = i + 1 | 0;
+      if(_Y_ === i) break;
+      var i = _Z_;
      }
     }
      /*<<bytes.ml:235:4>>*/ return r;
@@ -4972,18 +4974,18 @@
      /*<<bytes.ml:241:12>>*/ var
       /*<<bytes.ml:241:12>>*/ r =
         /*<<bytes.ml:241:12>>*/ caml_create_bytes(l),
-      /*<<bytes.ml:242:4>>*/ _W_ = l - 1 | 0,
-      /*<<bytes.ml:241:12>>*/ _V_ = 0;
-    if(_W_ >= 0){
-     var i = _V_;
+      /*<<bytes.ml:242:4>>*/ _V_ = l - 1 | 0,
+      /*<<bytes.ml:241:12>>*/ _U_ = 0;
+    if(_V_ >= 0){
+     var i = _U_;
      for(;;){
       caml_bytes_unsafe_set
        (r,
         i,
          /*<<bytes.ml:242:41>>*/ caml_call2(f, i, caml_bytes_unsafe_get(s, i)));
-       /*<<bytes.ml:242:4>>*/  /*<<bytes.ml:242:4>>*/ var _X_ = i + 1 | 0;
-      if(_W_ === i) break;
-      var i = _X_;
+       /*<<bytes.ml:242:4>>*/  /*<<bytes.ml:242:4>>*/ var _W_ = i + 1 | 0;
+      if(_V_ === i) break;
+      var i = _W_;
      }
     }
      /*<<bytes.ml:243:4>>*/ return r;
@@ -4991,17 +4993,17 @@
    function fold_left(f, x, a){
      /*<<bytes.ml:247:2>>*/ var
       /*<<bytes.ml:247:10>>*/ r = [0, x],
-     _T_ = caml_ml_bytes_length(a) - 1 | 0,
-      /*<<bytes.ml:247:10>>*/ _S_ = 0;
-    if(_T_ >= 0){
-     var i = _S_;
+     _S_ = caml_ml_bytes_length(a) - 1 | 0,
+      /*<<bytes.ml:247:10>>*/ _R_ = 0;
+    if(_S_ >= 0){
+     var i = _R_;
      for(;;){
       r[1] =
         /*<<bytes.ml:249:9>>*/ caml_call2
         (f, r[1], caml_bytes_unsafe_get(a, i));
-       /*<<bytes.ml:248:2>>*/  /*<<bytes.ml:248:2>>*/ var _U_ = i + 1 | 0;
-      if(_T_ === i) break;
-      var i = _U_;
+       /*<<bytes.ml:248:2>>*/  /*<<bytes.ml:248:2>>*/ var _T_ = i + 1 | 0;
+      if(_S_ === i) break;
+      var i = _T_;
      }
     }
     return r[1];
@@ -5009,17 +5011,17 @@
    function fold_right(f, a, x){
      /*<<bytes.ml:254:2>>*/ var
       /*<<bytes.ml:254:10>>*/ r = [0, x],
-      /*<<bytes.ml:255:2>>*/ _Q_ =
+      /*<<bytes.ml:255:2>>*/ _P_ =
         /*<<bytes.ml:255:2>>*/ caml_ml_bytes_length(a) - 1 | 0;
-    if(_Q_ >= 0){
-     var i = _Q_;
+    if(_P_ >= 0){
+     var i = _P_;
      for(;;){
       r[1] =
         /*<<bytes.ml:256:9>>*/ caml_call2
         (f, caml_bytes_unsafe_get(a, i), r[1]);
-       /*<<bytes.ml:255:2>>*/  /*<<bytes.ml:255:2>>*/ var _R_ = i - 1 | 0;
+       /*<<bytes.ml:255:2>>*/  /*<<bytes.ml:255:2>>*/ var _Q_ = i - 1 | 0;
       if(0 === i) break;
-      var i = _R_;
+      var i = _Q_;
      }
     }
     return r[1];
@@ -5074,8 +5076,8 @@
      /*<<bytes.ml:291:2>>*/ var
      len_s = caml_ml_bytes_length(s),
      len_pre = caml_ml_bytes_length(prefix),
-     _P_ = len_pre <= len_s ? 1 : 0;
-    if(! _P_) return _P_;
+     _O_ = len_pre <= len_s ? 1 : 0;
+    if(! _O_) return _O_;
     var i = 0;
      /*<<bytes.ml:294:4>>*/ for(;;){
      if(i === len_pre)  /*<<bytes.ml:294:24>>*/ return 1;
@@ -5091,8 +5093,8 @@
      len_s = caml_ml_bytes_length(s),
      len_suf = caml_ml_bytes_length(suffix),
      diff = len_s - len_suf | 0,
-     _O_ = 0 <= diff ? 1 : 0;
-    if(! _O_) return _O_;
+     _N_ = 0 <= diff ? 1 : 0;
+    if(! _N_) return _N_;
     var i = 0;
      /*<<bytes.ml:305:4>>*/ for(;;){
      if(i === len_suf)  /*<<bytes.ml:305:24>>*/ return 1;
@@ -5191,13 +5193,13 @@
     if(0 <= i && l >= i)
       /*<<bytes.ml:377:4>>*/ try{
        /*<<bytes.ml:377:15>>*/ index_rec(s, l, i, c);
-       /*<<bytes.ml:377:36>>*/  /*<<bytes.ml:377:36>>*/ var _M_ = 1;
-       /*<<bytes.ml:377:36>>*/ return _M_;
+       /*<<bytes.ml:377:36>>*/  /*<<bytes.ml:377:36>>*/ var _L_ = 1;
+       /*<<bytes.ml:377:36>>*/ return _L_;
      }
-     catch(_N_){
-      var _L_ = caml_wrap_exception(_N_);
-      if(_L_ === Stdlib[8])  /*<<bytes.ml:377:59>>*/ return 0;
-      throw caml_maybe_attach_backtrace(_L_, 0);
+     catch(_M_){
+      var _K_ = caml_wrap_exception(_M_);
+      if(_K_ === Stdlib[8])  /*<<bytes.ml:377:59>>*/ return 0;
+      throw caml_maybe_attach_backtrace(_K_, 0);
      }
      /*<<bytes.ml:375:4>>*/ return  /*<<bytes.ml:375:4>>*/ caml_call1
             (Stdlib[1], cst_String_contains_from_Bytes);
@@ -5209,13 +5211,13 @@
      /*<<bytes.ml:385:2>>*/ if(0 <= i && caml_ml_bytes_length(s) > i)
       /*<<bytes.ml:388:4>>*/ try{
        /*<<bytes.ml:388:15>>*/ rindex_rec(s, i, c);
-       /*<<bytes.ml:388:35>>*/  /*<<bytes.ml:388:35>>*/ var _J_ = 1;
-       /*<<bytes.ml:388:35>>*/ return _J_;
+       /*<<bytes.ml:388:35>>*/  /*<<bytes.ml:388:35>>*/ var _I_ = 1;
+       /*<<bytes.ml:388:35>>*/ return _I_;
      }
-     catch(_K_){
-      var _I_ = caml_wrap_exception(_K_);
-      if(_I_ === Stdlib[8])  /*<<bytes.ml:388:58>>*/ return 0;
-      throw caml_maybe_attach_backtrace(_I_, 0);
+     catch(_J_){
+      var _H_ = caml_wrap_exception(_J_);
+      if(_H_ === Stdlib[8])  /*<<bytes.ml:388:58>>*/ return 0;
+      throw caml_maybe_attach_backtrace(_H_, 0);
      }
      /*<<bytes.ml:386:4>>*/ return  /*<<bytes.ml:386:4>>*/ caml_call1
             (Stdlib[1], cst_String_rcontains_from_Byte);
@@ -5226,23 +5228,23 @@
       /*<<bytes.ml:398:10>>*/ r = [0, 0],
       /*<<bytes.ml:399:10>>*/ j =
        [0,  /*<<bytes.ml:399:2>>*/ caml_ml_bytes_length(s)],
-      /*<<bytes.ml:400:2>>*/ _E_ =
+      /*<<bytes.ml:400:2>>*/ _D_ =
         /*<<bytes.ml:400:2>>*/ caml_ml_bytes_length(s) - 1 | 0;
-    if(_E_ >= 0){
-     var i = _E_;
+    if(_D_ >= 0){
+     var i = _D_;
      for(;;){
       if(caml_bytes_unsafe_get(s, i) === sep){
-       var _G_ = r[1];
-       r[1] = [0, sub(s, i + 1 | 0, (j[1] - i | 0) - 1 | 0), _G_];
+       var _F_ = r[1];
+       r[1] = [0, sub(s, i + 1 | 0, (j[1] - i | 0) - 1 | 0), _F_];
        j[1] = i;
       }
-       /*<<bytes.ml:400:2>>*/  /*<<bytes.ml:400:2>>*/ var _H_ = i - 1 | 0;
+       /*<<bytes.ml:400:2>>*/  /*<<bytes.ml:400:2>>*/ var _G_ = i - 1 | 0;
       if(0 === i) break;
-      var i = _H_;
+      var i = _G_;
      }
     }
-    var _F_ = r[1];
-     /*<<bytes.ml:406:2>>*/ return [0, sub(s, 0, j[1]), _F_];
+    var _E_ = r[1];
+     /*<<bytes.ml:406:2>>*/ return [0, sub(s, 0, j[1]), _E_];
     /*<<bytes.ml:406:18>>*/ }
    function to_seq(s){
     function aux(i, param){
@@ -5251,14 +5253,14 @@
       /*<<bytes.ml:414:14>>*/ var
        /*<<bytes.ml:414:14>>*/ x =
          /*<<bytes.ml:414:14>>*/ caml_bytes_get(s, i),
-       /*<<bytes.ml:414:14>>*/ _C_ = i + 1 | 0;
+       /*<<bytes.ml:414:14>>*/ _B_ = i + 1 | 0;
       /*<<bytes.ml:415:6>>*/ return [0,
              x,
-             function(_D_){ /*<<?>>*/ return aux(_C_, _D_);}];
+             function(_C_){ /*<<?>>*/ return aux(_B_, _C_);}];
      /*<<bytes.ml:415:29>>*/ }
-     /*<<bytes.ml:417:2>>*/  /*<<bytes.ml:417:2>>*/ var _A_ = 0;
-     /*<<bytes.ml:417:2>>*/ return function(_B_){
-      /*<<?>>*/ return aux(_A_, _B_);};
+     /*<<bytes.ml:417:2>>*/  /*<<bytes.ml:417:2>>*/ var _z_ = 0;
+     /*<<bytes.ml:417:2>>*/ return function(_A_){
+      /*<<?>>*/ return aux(_z_, _A_);};
     /*<<bytes.ml:417:7>>*/ }
    function to_seqi(s){
     function aux(i, param){
@@ -5267,20 +5269,20 @@
       /*<<bytes.ml:423:14>>*/ var
        /*<<bytes.ml:423:14>>*/ x =
          /*<<bytes.ml:423:14>>*/ caml_bytes_get(s, i),
-       /*<<bytes.ml:423:14>>*/ _y_ = i + 1 | 0;
+       /*<<bytes.ml:423:14>>*/ _x_ = i + 1 | 0;
       /*<<bytes.ml:424:6>>*/ return [0,
              [0, i, x],
-             function(_z_){ /*<<?>>*/ return aux(_y_, _z_);}];
+             function(_y_){ /*<<?>>*/ return aux(_x_, _y_);}];
      /*<<bytes.ml:424:33>>*/ }
-     /*<<bytes.ml:426:2>>*/  /*<<bytes.ml:426:2>>*/ var _w_ = 0;
-     /*<<bytes.ml:426:2>>*/ return function(_x_){
-      /*<<?>>*/ return aux(_w_, _x_);};
+     /*<<bytes.ml:426:2>>*/  /*<<bytes.ml:426:2>>*/ var _v_ = 0;
+     /*<<bytes.ml:426:2>>*/ return function(_w_){
+      /*<<?>>*/ return aux(_v_, _w_);};
     /*<<bytes.ml:426:7>>*/ }
    function of_seq(i){
      /*<<bytes.ml:429:2>>*/ var
       /*<<bytes.ml:429:10>>*/ n = [0, 0],
       /*<<bytes.ml:430:12>>*/ buf = [0, make(256, 0)];
-    function _v_(c){
+    function _u_(c){
       /*<<bytes.ml:441:7>>*/ if(n[1] === caml_ml_bytes_length(buf[1])){
        /*<<bytes.ml:433:18>>*/  /*<<bytes.ml:433:18>>*/ var
        new_len =
@@ -5302,7 +5304,7 @@
      return 0;
      /*<<bytes.ml:443:13>>*/ }
      /*<<bytes.ml:439:2>>*/  /*<<bytes.ml:439:2>>*/ caml_call2
-     (Stdlib_Seq[4], _v_, i);
+     (Stdlib_Seq[4], _u_, i);
     return sub(buf[1], 0, n[1]);
     /*<<bytes.ml:445:15>>*/ }
    function unsafe_get_uint16_le(b, i){
@@ -5319,9 +5321,9 @@
     /*<<bytes.ml:477:40>>*/ }
    function get_int8(b, i){
      /*<<bytes.ml:480:2>>*/ var
-      /*<<bytes.ml:480:2>>*/ _t_ = Stdlib_Sys[10] - 8 | 0,
-     _u_ = Stdlib_Sys[10] - 8 | 0;
-    return  /*<<bytes.ml:480:3>>*/ caml_bytes_get(b, i) << _u_ >> _t_;
+      /*<<bytes.ml:480:2>>*/ _s_ = Stdlib_Sys[10] - 8 | 0,
+     _t_ = Stdlib_Sys[10] - 8 | 0;
+    return  /*<<bytes.ml:480:3>>*/ caml_bytes_get(b, i) << _t_ >> _s_;
     /*<<bytes.ml:480:65>>*/ }
    function get_uint16_le(b, i){
      /*<<bytes.ml:483:2>>*/ return Stdlib_Sys[11]
@@ -5337,21 +5339,21 @@
     /*<<bytes.ml:488:24>>*/ }
    function get_int16_ne(b, i){
      /*<<bytes.ml:491:2>>*/ var
-      /*<<bytes.ml:491:2>>*/ _r_ = Stdlib_Sys[10] - 16 | 0,
-     _s_ = Stdlib_Sys[10] - 16 | 0;
-    return  /*<<bytes.ml:491:3>>*/ caml_bytes_get16(b, i) << _s_ >> _r_;
+      /*<<bytes.ml:491:2>>*/ _q_ = Stdlib_Sys[10] - 16 | 0,
+     _r_ = Stdlib_Sys[10] - 16 | 0;
+    return  /*<<bytes.ml:491:3>>*/ caml_bytes_get16(b, i) << _r_ >> _q_;
     /*<<bytes.ml:491:71>>*/ }
    function get_int16_le(b, i){
      /*<<bytes.ml:494:2>>*/ var
-      /*<<bytes.ml:494:2>>*/ _p_ = Stdlib_Sys[10] - 16 | 0,
-     _q_ = Stdlib_Sys[10] - 16 | 0;
-    return get_uint16_le(b, i) << _q_ >> _p_;
+      /*<<bytes.ml:494:2>>*/ _o_ = Stdlib_Sys[10] - 16 | 0,
+     _p_ = Stdlib_Sys[10] - 16 | 0;
+    return get_uint16_le(b, i) << _p_ >> _o_;
     /*<<bytes.ml:494:71>>*/ }
    function get_int16_be(b, i){
      /*<<bytes.ml:497:2>>*/ var
-      /*<<bytes.ml:497:2>>*/ _n_ = Stdlib_Sys[10] - 16 | 0,
-     _o_ = Stdlib_Sys[10] - 16 | 0;
-    return get_uint16_be(b, i) << _o_ >> _n_;
+      /*<<bytes.ml:497:2>>*/ _m_ = Stdlib_Sys[10] - 16 | 0,
+     _n_ = Stdlib_Sys[10] - 16 | 0;
+    return get_uint16_be(b, i) << _n_ >> _m_;
     /*<<bytes.ml:497:71>>*/ }
    function get_int32_le(b, i){
      /*<<bytes.ml:500:2>>*/ return Stdlib_Sys[11]
@@ -5381,15 +5383,15 @@
      /*<<bytes.ml:516:2>>*/ return Stdlib_Sys[11]
             ? ( /*<<bytes.ml:517:7>>*/ caml_bytes_set16
                (b, i, caml_bswap16(x)),
-              _g_)
-            : ( /*<<bytes.ml:518:7>>*/ caml_bytes_set16(b, i, x), _g_);
+              sentinal)
+            : ( /*<<bytes.ml:518:7>>*/ caml_bytes_set16(b, i, x), sentinal);
     /*<<bytes.ml:518:33>>*/ }
    function unsafe_set_uint16_be(b, i, x){
      /*<<bytes.ml:521:2>>*/ return Stdlib_Sys[11]
-            ? ( /*<<bytes.ml:522:7>>*/ caml_bytes_set16(b, i, x), _g_)
+            ? ( /*<<bytes.ml:522:7>>*/ caml_bytes_set16(b, i, x), sentinal)
             : ( /*<<bytes.ml:523:2>>*/ caml_bytes_set16
                (b, i, caml_bswap16(x)),
-              _g_);
+              sentinal);
     /*<<bytes.ml:523:37>>*/ }
    function set_int16_le(b, i, x){
      /*<<bytes.ml:526:2>>*/ return Stdlib_Sys[11]
@@ -5431,9 +5433,9 @@
     dec_invalid = Stdlib_Uchar[22];
    function dec_ret(n, u){
      /*<<bytes.ml:557:27>>*/  /*<<bytes.ml:557:46>>*/ var
-     _m_ =  /*<<bytes.ml:557:46>>*/ caml_call1(Stdlib_Uchar[9], u);
+     _l_ =  /*<<bytes.ml:557:46>>*/ caml_call1(Stdlib_Uchar[9], u);
      /*<<bytes.ml:557:46>>*/ return  /*<<bytes.ml:557:46>>*/ caml_call2
-            (Stdlib_Uchar[21], n, _m_);
+            (Stdlib_Uchar[21], n, _l_);
     /*<<bytes.ml:557:69>>*/ }
    function not_in_x80_to_xBF(b){
      /*<<bytes.ml:575:35>>*/ return 2 !== (b >>> 6 | 0) ? 1 : 0;
@@ -5446,9 +5448,9 @@
     /*<<bytes.ml:577:51>>*/ }
    function not_in_x90_to_xBF(b){
      /*<<bytes.ml:578:35>>*/ var
-     _k_ = b < 144 ? 1 : 0,
-     _l_ = _k_ || (191 < b ? 1 : 0);
-    return _l_;
+     _j_ = b < 144 ? 1 : 0,
+     _k_ = _j_ || (191 < b ? 1 : 0);
+    return _k_;
     /*<<bytes.ml:578:55>>*/ }
    function not_in_x80_to_x8F(b){
      /*<<bytes.ml:579:35>>*/ return 8 !== (b >>> 4 | 0) ? 1 : 0;
@@ -5645,9 +5647,9 @@
             (dec_invalid, 1);
     /*<<bytes.ml:648:22>>*/ }
    function set_utf_8_uchar(b, i, u){
-     /*<<bytes.ml:651:2>>*/ function set(_j_, _i_, _h_){
-      /*<<?>>*/ caml_bytes_unsafe_set(_j_, _i_, _h_);
-     return _g_;
+     /*<<bytes.ml:651:2>>*/ function set(_i_, _h_, _g_){
+      /*<<?>>*/ caml_bytes_unsafe_set(_i_, _h_, _g_);
+     return sentinal;
     }
      /*<<bytes.ml:652:2>>*/ var
       /*<<bytes.ml:652:2>>*/ max =
@@ -6861,7 +6863,7 @@
             : runtime.caml_call_gen(f, [a0, a1, a2]);
    }
     /*<<array.ml:37:20>>*/ var
-    _b_ = undefined,
+    sentinal = undefined,
     global_data = runtime.caml_get_global_data(),
     Stdlib_Seq = global_data.Stdlib__Seq,
     Assert_failure = global_data.Assert_failure,
@@ -6889,16 +6891,16 @@
       /*<<array.ml:53:13>>*/ res =
         /*<<array.ml:53:13>>*/ caml_make_vect
         (l,  /*<<array.ml:53:22>>*/ caml_call1(f, 0)),
-      /*<<array.ml:54:3>>*/ _at_ = l - 1 | 0,
-      /*<<array.ml:53:13>>*/ _as_ = 1;
-    if(_at_ >= 1){
-     var i = _as_;
+      /*<<array.ml:54:3>>*/ _as_ = l - 1 | 0,
+      /*<<array.ml:53:13>>*/ _ar_ = 1;
+    if(_as_ >= 1){
+     var i = _ar_;
      for(;;){
        /*<<array.ml:55:5>>*/ res[1 + i] =
         /*<<array.ml:55:22>>*/ caml_call1(f, i);
-       /*<<array.ml:55:5>>*/  /*<<array.ml:55:5>>*/ var _au_ = i + 1 | 0;
-      if(_at_ === i) break;
-      var i = _au_;
+       /*<<array.ml:55:5>>*/  /*<<array.ml:55:5>>*/ var _at_ = i + 1 | 0;
+      if(_as_ === i) break;
+      var i = _at_;
      }
     }
      /*<<array.ml:57:3>>*/ return res;
@@ -6907,15 +6909,15 @@
      /*<<array.ml:60:2>>*/ var
       /*<<array.ml:60:12>>*/ res =
         /*<<array.ml:60:12>>*/ caml_make_vect(sx, [0]),
-      /*<<array.ml:61:2>>*/ _aq_ = sx - 1 | 0,
-      /*<<array.ml:60:12>>*/ _ap_ = 0;
-    if(_aq_ >= 0){
-     var x = _ap_;
+      /*<<array.ml:61:2>>*/ _ap_ = sx - 1 | 0,
+      /*<<array.ml:60:12>>*/ _ao_ = 0;
+    if(_ap_ >= 0){
+     var x = _ao_;
      for(;;){
       res[1 + x] =  /*<<array.ml:62:21>>*/ caml_make_vect(sy, init);
-       /*<<array.ml:61:2>>*/  /*<<array.ml:61:2>>*/ var _ar_ = x + 1 | 0;
-      if(_aq_ === x) break;
-      var x = _ar_;
+       /*<<array.ml:61:2>>*/  /*<<array.ml:61:2>>*/ var _aq_ = x + 1 | 0;
+      if(_ap_ === x) break;
+      var x = _aq_;
      }
     }
      /*<<array.ml:64:2>>*/ return res;
@@ -6966,15 +6968,15 @@
     /*<<array.ml:89:38>>*/ }
    function iter(f, a){
      /*<<array.ml:92:2>>*/ var
-     _an_ = a.length - 1 - 1 | 0,
-      /*<<array.ml:92:2>>*/ _am_ = 0;
-    if(_an_ >= 0){
-     var i = _am_;
+     _am_ = a.length - 1 - 1 | 0,
+      /*<<array.ml:92:2>>*/ _al_ = 0;
+    if(_am_ >= 0){
+     var i = _al_;
      for(;;){
        /*<<array.ml:92:31>>*/  /*<<array.ml:92:31>>*/ caml_call1(f, a[1 + i]);
-       /*<<array.ml:92:31>>*/  /*<<array.ml:92:31>>*/ var _ao_ = i + 1 | 0;
-      if(_an_ === i) break;
-      var i = _ao_;
+       /*<<array.ml:92:31>>*/  /*<<array.ml:92:31>>*/ var _an_ = i + 1 | 0;
+      if(_am_ === i) break;
+      var i = _an_;
      }
     }
     return 0;
@@ -6984,16 +6986,16 @@
       /*<<array.ml:96:4>>*/ return  /*<<array.ml:96:4>>*/ caml_call1
              (Stdlib[1], cst_Array_iter2_arrays_must_ha);
      /*<<array.ml:98:4>>*/ var
-     _ak_ = a.length - 1 - 1 | 0,
-      /*<<array.ml:98:4>>*/ _aj_ = 0;
-    if(_ak_ >= 0){
-     var i = _aj_;
+     _aj_ = a.length - 1 - 1 | 0,
+      /*<<array.ml:98:4>>*/ _ai_ = 0;
+    if(_aj_ >= 0){
+     var i = _ai_;
      for(;;){
        /*<<array.ml:98:33>>*/  /*<<array.ml:98:33>>*/ caml_call2
        (f, a[1 + i], b[1 + i]);
-       /*<<array.ml:98:33>>*/  /*<<array.ml:98:33>>*/ var _al_ = i + 1 | 0;
-      if(_ak_ === i) break;
-      var i = _al_;
+       /*<<array.ml:98:33>>*/  /*<<array.ml:98:33>>*/ var _ak_ = i + 1 | 0;
+      if(_aj_ === i) break;
+      var i = _ak_;
      }
     }
     return 0;
@@ -7005,16 +7007,16 @@
       /*<<array.ml:103:12>>*/ r =
         /*<<array.ml:103:12>>*/ caml_make_vect
         (l,  /*<<array.ml:103:21>>*/ caml_call1(f, a[1])),
-      /*<<array.ml:104:4>>*/ _ah_ = l - 1 | 0,
-      /*<<array.ml:103:12>>*/ _ag_ = 1;
-    if(_ah_ >= 1){
-     var i = _ag_;
+      /*<<array.ml:104:4>>*/ _ag_ = l - 1 | 0,
+      /*<<array.ml:103:12>>*/ _af_ = 1;
+    if(_ag_ >= 1){
+     var i = _af_;
      for(;;){
        /*<<array.ml:105:6>>*/ r[1 + i] =
         /*<<array.ml:105:21>>*/ caml_call1(f, a[1 + i]);
-       /*<<array.ml:105:6>>*/  /*<<array.ml:105:6>>*/ var _ai_ = i + 1 | 0;
-      if(_ah_ === i) break;
-      var i = _ai_;
+       /*<<array.ml:105:6>>*/  /*<<array.ml:105:6>>*/ var _ah_ = i + 1 | 0;
+      if(_ag_ === i) break;
+      var i = _ah_;
      }
     }
      /*<<array.ml:107:4>>*/ return r;
@@ -7031,32 +7033,32 @@
       /*<<array.ml:117:14>>*/ r =
         /*<<array.ml:117:14>>*/ caml_make_vect
         (la,  /*<<array.ml:117:24>>*/ caml_call2(f, a[1], b[1])),
-      /*<<array.ml:118:6>>*/ _ae_ = la - 1 | 0,
-      /*<<array.ml:117:14>>*/ _ad_ = 1;
-    if(_ae_ >= 1){
-     var i = _ad_;
+      /*<<array.ml:118:6>>*/ _ad_ = la - 1 | 0,
+      /*<<array.ml:117:14>>*/ _ac_ = 1;
+    if(_ad_ >= 1){
+     var i = _ac_;
      for(;;){
        /*<<array.ml:119:8>>*/ r[1 + i] =
         /*<<array.ml:119:23>>*/ caml_call2(f, a[1 + i], b[1 + i]);
-       /*<<array.ml:119:8>>*/  /*<<array.ml:119:8>>*/ var _af_ = i + 1 | 0;
-      if(_ae_ === i) break;
-      var i = _af_;
+       /*<<array.ml:119:8>>*/  /*<<array.ml:119:8>>*/ var _ae_ = i + 1 | 0;
+      if(_ad_ === i) break;
+      var i = _ae_;
      }
     }
      /*<<array.ml:121:6>>*/ return r;
     /*<<array.ml:123:5>>*/ }
    function iteri(f, a){
      /*<<array.ml:126:2>>*/ var
-     _ab_ = a.length - 1 - 1 | 0,
-      /*<<array.ml:126:2>>*/ _aa_ = 0;
-    if(_ab_ >= 0){
-     var i = _aa_;
+     _aa_ = a.length - 1 - 1 | 0,
+      /*<<array.ml:126:2>>*/ _$_ = 0;
+    if(_aa_ >= 0){
+     var i = _$_;
      for(;;){
        /*<<array.ml:126:31>>*/  /*<<array.ml:126:31>>*/ caml_call2
        (f, i, a[1 + i]);
-       /*<<array.ml:126:31>>*/  /*<<array.ml:126:31>>*/ var _ac_ = i + 1 | 0;
-      if(_ab_ === i) break;
-      var i = _ac_;
+       /*<<array.ml:126:31>>*/  /*<<array.ml:126:31>>*/ var _ab_ = i + 1 | 0;
+      if(_aa_ === i) break;
+      var i = _ab_;
      }
     }
     return 0;
@@ -7068,16 +7070,16 @@
       /*<<array.ml:131:12>>*/ r =
         /*<<array.ml:131:12>>*/ caml_make_vect
         (l,  /*<<array.ml:131:21>>*/ caml_call2(f, 0, a[1])),
-      /*<<array.ml:132:4>>*/ ___ = l - 1 | 0,
-      /*<<array.ml:131:12>>*/ _Z_ = 1;
-    if(___ >= 1){
-     var i = _Z_;
+      /*<<array.ml:132:4>>*/ _Z_ = l - 1 | 0,
+      /*<<array.ml:131:12>>*/ _Y_ = 1;
+    if(_Z_ >= 1){
+     var i = _Y_;
      for(;;){
        /*<<array.ml:133:6>>*/ r[1 + i] =
         /*<<array.ml:133:21>>*/ caml_call2(f, i, a[1 + i]);
-       /*<<array.ml:133:6>>*/  /*<<array.ml:133:6>>*/ var _$_ = i + 1 | 0;
-      if(___ === i) break;
-      var i = _$_;
+       /*<<array.ml:133:6>>*/  /*<<array.ml:133:6>>*/ var ___ = i + 1 | 0;
+      if(_Z_ === i) break;
+      var i = ___;
      }
     }
      /*<<array.ml:135:4>>*/ return r;
@@ -7126,15 +7128,15 @@
    function fold_left(f, x, a){
      /*<<array.ml:158:2>>*/ var
       /*<<array.ml:158:10>>*/ r = [0, x],
-     _X_ = a.length - 1 - 1 | 0,
-      /*<<array.ml:158:10>>*/ _W_ = 0;
-    if(_X_ >= 0){
-     var i = _W_;
+     _W_ = a.length - 1 - 1 | 0,
+      /*<<array.ml:158:10>>*/ _V_ = 0;
+    if(_W_ >= 0){
+     var i = _V_;
      for(;;){
       r[1] =  /*<<array.ml:160:9>>*/ caml_call2(f, r[1], a[1 + i]);
-       /*<<array.ml:159:2>>*/  /*<<array.ml:159:2>>*/ var _Y_ = i + 1 | 0;
-      if(_X_ === i) break;
-      var i = _Y_;
+       /*<<array.ml:159:2>>*/  /*<<array.ml:159:2>>*/ var _X_ = i + 1 | 0;
+      if(_W_ === i) break;
+      var i = _X_;
      }
     }
     return r[1];
@@ -7151,10 +7153,10 @@
       /*<<array.ml:168:23>>*/ output_array =
         /*<<array.ml:168:23>>*/ caml_make_vect(len, elt),
       /*<<array.ml:169:14>>*/ acc$1 = [0, acc$0],
-      /*<<array.ml:170:4>>*/ _U_ = len - 1 | 0,
-      /*<<array.ml:169:14>>*/ _T_ = 1;
-    if(_U_ >= 1){
-     var i = _T_;
+      /*<<array.ml:170:4>>*/ _T_ = len - 1 | 0,
+      /*<<array.ml:169:14>>*/ _S_ = 1;
+    if(_T_ >= 1){
+     var i = _S_;
      for(;;){
        /*<<array.ml:171:22>>*/ var
         /*<<array.ml:171:22>>*/ match$0 =
@@ -7163,9 +7165,9 @@
        acc$2 = match$0[1];
       acc$1[1] = acc$2;
        /*<<array.ml:173:6>>*/ output_array[1 + i] = elt$0;
-       /*<<array.ml:170:4>>*/  /*<<array.ml:170:4>>*/ var _V_ = i + 1 | 0;
-      if(_U_ === i) break;
-      var i = _V_;
+       /*<<array.ml:170:4>>*/  /*<<array.ml:170:4>>*/ var _U_ = i + 1 | 0;
+      if(_T_ === i) break;
+      var i = _U_;
      }
     }
      /*<<array.ml:175:4>>*/ return [0, acc$1[1], output_array];
@@ -7173,14 +7175,14 @@
    function fold_right(f, a, x){
      /*<<array.ml:179:2>>*/ var
       /*<<array.ml:179:10>>*/ r = [0, x],
-      /*<<array.ml:180:2>>*/ _R_ = a.length - 1 - 1 | 0;
-    if(_R_ >= 0){
-     var i = _R_;
+      /*<<array.ml:180:2>>*/ _Q_ = a.length - 1 - 1 | 0;
+    if(_Q_ >= 0){
+     var i = _Q_;
      for(;;){
       r[1] =  /*<<array.ml:181:9>>*/ caml_call2(f, a[1 + i], r[1]);
-       /*<<array.ml:180:2>>*/  /*<<array.ml:180:2>>*/ var _S_ = i - 1 | 0;
+       /*<<array.ml:180:2>>*/  /*<<array.ml:180:2>>*/ var _R_ = i - 1 | 0;
       if(0 === i) break;
-      var i = _S_;
+      var i = _R_;
      }
     }
     return r[1];
@@ -7300,17 +7302,17 @@
         /*<<array.ml:264:12>>*/ caml_make_vect(n, a0),
       /*<<array.ml:265:12>>*/ b =
         /*<<array.ml:265:12>>*/ caml_make_vect(n, b0),
-      /*<<array.ml:266:4>>*/ _P_ = n - 1 | 0,
-      /*<<array.ml:265:12>>*/ _O_ = 1;
-    if(_P_ >= 1){
-     var i = _O_;
+      /*<<array.ml:266:4>>*/ _O_ = n - 1 | 0,
+      /*<<array.ml:265:12>>*/ _N_ = 1;
+    if(_O_ >= 1){
+     var i = _N_;
      for(;;){
       var match$0 = x[1 + i], bi = match$0[2], ai = match$0[1];
        /*<<array.ml:268:6>>*/ a[1 + i] = ai;
        /*<<array.ml:269:6>>*/ b[1 + i] = bi;
-       /*<<array.ml:266:4>>*/  /*<<array.ml:266:4>>*/ var _Q_ = i + 1 | 0;
-      if(_P_ === i) break;
-      var i = _Q_;
+       /*<<array.ml:266:4>>*/  /*<<array.ml:266:4>>*/ var _P_ = i + 1 | 0;
+      if(_O_ === i) break;
+      var i = _P_;
      }
     }
      /*<<array.ml:271:4>>*/ return [0, a, b];
@@ -7326,15 +7328,15 @@
      /*<<array.ml:280:12>>*/ var
       /*<<array.ml:280:12>>*/ x =
         /*<<array.ml:280:12>>*/ caml_make_vect(na, [0, a[1], b[1]]),
-      /*<<array.ml:281:4>>*/ _M_ = na - 1 | 0,
-      /*<<array.ml:280:12>>*/ _L_ = 1;
-    if(_M_ >= 1){
-     var i = _L_;
+      /*<<array.ml:281:4>>*/ _L_ = na - 1 | 0,
+      /*<<array.ml:280:12>>*/ _K_ = 1;
+    if(_L_ >= 1){
+     var i = _K_;
      for(;;){
       x[1 + i] = [0, a[1 + i], b[1 + i]];
-       /*<<array.ml:281:4>>*/  /*<<array.ml:281:4>>*/ var _N_ = i + 1 | 0;
-      if(_M_ === i) break;
-      var i = _N_;
+       /*<<array.ml:281:4>>*/  /*<<array.ml:281:4>>*/ var _M_ = i + 1 | 0;
+      if(_L_ === i) break;
+      var i = _M_;
      }
     }
      /*<<array.ml:284:4>>*/ return x;
@@ -7348,42 +7350,42 @@
        /*<<array.ml:291:12>>*/ x = [0, i31];
      if((i31 + 2 | 0) < l){
        /*<<array.ml:292:22>>*/ var
-        /*<<array.ml:292:22>>*/ _E_ = i31 + 1 | 0,
-        /*<<array.ml:293:25>>*/ _F_ = caml_check_bound(a, _E_)[1 + _E_];
+        /*<<array.ml:292:22>>*/ _D_ = i31 + 1 | 0,
+        /*<<array.ml:293:25>>*/ _E_ = caml_check_bound(a, _D_)[1 + _D_];
       if
        ( /*<<array.ml:293:9>>*/ caml_call2
-         (cmp, caml_check_bound(a, i31)[1 + i31], _F_)
+         (cmp, caml_check_bound(a, i31)[1 + i31], _E_)
         < 0)
        x[1] = i31 + 1 | 0;
        /*<<array.ml:294:6>>*/ var
-        /*<<array.ml:294:6>>*/ _G_ = i31 + 2 | 0,
-        /*<<array.ml:294:24>>*/ _H_ = caml_check_bound(a, _G_)[1 + _G_],
-       _I_ = x[1];
+        /*<<array.ml:294:6>>*/ _F_ = i31 + 2 | 0,
+        /*<<array.ml:294:24>>*/ _G_ = caml_check_bound(a, _F_)[1 + _F_],
+       _H_ = x[1];
       if
        ( /*<<array.ml:294:9>>*/ caml_call2
-         (cmp, caml_check_bound(a, _I_)[1 + _I_], _H_)
+         (cmp, caml_check_bound(a, _H_)[1 + _H_], _G_)
         < 0)
        x[1] = i31 + 2 | 0;
       return x[1];
      }
      if((i31 + 1 | 0) < l){
        /*<<array.ml:297:38>>*/ var
-       _J_ = i31 + 1 | 0,
-        /*<<array.ml:297:38>>*/ _K_ = caml_check_bound(a, _J_)[1 + _J_];
+       _I_ = i31 + 1 | 0,
+        /*<<array.ml:297:38>>*/ _J_ = caml_check_bound(a, _I_)[1 + _I_];
        /*<<array.ml:297:22>>*/ if
        (0
         >
           /*<<array.ml:297:22>>*/ caml_call2
-          (cmp, caml_check_bound(a, i31)[1 + i31], _K_))
+          (cmp, caml_check_bound(a, i31)[1 + i31], _J_))
         /*<<array.ml:298:11>>*/ return i31 + 1 | 0;
      }
      if(i31 < l)  /*<<array.ml:299:27>>*/ return i31;
       /*<<array.ml:299:36>>*/ throw  /*<<array.ml:299:36>>*/ caml_maybe_attach_backtrace
             ([0, Bottom, i], 1);
      /*<<array.ml:299:52>>*/ }
-    var l = a.length - 1, _y_ = ((l + 1 | 0) / 3 | 0) - 1 | 0;
-    if(_y_ >= 0){
-     var i$6 = _y_;
+    var l = a.length - 1, _x_ = ((l + 1 | 0) / 3 | 0) - 1 | 0;
+    if(_x_ >= 0){
+     var i$6 = _x_;
      for(;;){
        /*<<array.ml:328:50>>*/  /*<<array.ml:328:50>>*/ var
        e$1 = caml_check_bound(a, i$6)[1 + i$6];
@@ -7401,8 +7403,8 @@
          break;
         }
          /*<<array.ml:304:14>>*/  /*<<array.ml:304:14>>*/ var
-         _v_ = caml_check_bound(a, j)[1 + j];
-         /*<<array.ml:304:6>>*/ caml_check_bound(a, i)[1 + i] = _v_;
+         _u_ = caml_check_bound(a, j)[1 + j];
+         /*<<array.ml:304:6>>*/ caml_check_bound(a, i)[1 + i] = _u_;
         var i = j;
        }
       }
@@ -7412,14 +7414,14 @@
        var i$0 = exn[2];
         /*<<array.ml:310:61>>*/ caml_check_bound(a, i$0)[1 + i$0] = e$1;
       }
-       /*<<array.ml:328:38>>*/  /*<<array.ml:328:38>>*/ var _D_ = i$6 - 1 | 0;
+       /*<<array.ml:328:38>>*/  /*<<array.ml:328:38>>*/ var _C_ = i$6 - 1 | 0;
       if(0 === i$6) break;
-      var i$6 = _D_;
+      var i$6 = _C_;
      }
     }
-     /*<<array.ml:329:2>>*/  /*<<array.ml:329:2>>*/ var _z_ = l - 1 | 0;
-    if(_z_ >= 2){
-     var i$4 = _z_;
+     /*<<array.ml:329:2>>*/  /*<<array.ml:329:2>>*/ var _y_ = l - 1 | 0;
+    if(_y_ >= 2){
+     var i$4 = _y_;
      a:
      for(;;){
        /*<<array.ml:330:12>>*/  /*<<array.ml:330:12>>*/ var
@@ -7431,8 +7433,8 @@
         /*<<array.ml:312:4>>*/ for(;;){
          /*<<array.ml:312:12>>*/ var
           /*<<array.ml:312:12>>*/ j$0 = maxson(i$4, i$1),
-          /*<<array.ml:313:12>>*/ _w_ = caml_check_bound(a, j$0)[1 + j$0];
-         /*<<array.ml:313:4>>*/ caml_check_bound(a, i$1)[1 + i$1] = _w_;
+          /*<<array.ml:313:12>>*/ _v_ = caml_check_bound(a, j$0)[1 + j$0];
+         /*<<array.ml:313:4>>*/ caml_check_bound(a, i$1)[1 + i$1] = _v_;
         var i$1 = j$0;
        }
       }
@@ -7453,30 +7455,30 @@
           /*<<array.ml:323:13>>*/ caml_check_bound(a, i$3)[1 + i$3] = e$0;
         else{
           /*<<array.ml:321:14>>*/  /*<<array.ml:321:14>>*/ var
-          _x_ = caml_check_bound(a, father)[1 + father];
-          /*<<array.ml:321:6>>*/ caml_check_bound(a, i$3)[1 + i$3] = _x_;
+          _w_ = caml_check_bound(a, father)[1 + father];
+          /*<<array.ml:321:6>>*/ caml_check_bound(a, i$3)[1 + i$3] = _w_;
          if(0 < father){var i$3 = father; continue;}
           /*<<array.ml:322:49>>*/ caml_check_bound(a, 0)[1] = e$0;
         }
-         /*<<array.ml:329:2>>*/  /*<<array.ml:329:2>>*/ var _C_ = i$4 - 1 | 0;
+         /*<<array.ml:329:2>>*/  /*<<array.ml:329:2>>*/ var _B_ = i$4 - 1 | 0;
         if(2 === i$4) break a;
-        var i$4 = _C_;
+        var i$4 = _B_;
         break;
        }
       }
      }
     }
-    var _A_ = 1 < l ? 1 : 0;
-    if(_A_){
+    var _z_ = 1 < l ? 1 : 0;
+    if(_z_){
       /*<<array.ml:334:25>>*/  /*<<array.ml:334:25>>*/ var
       e = caml_check_bound(a, 1)[2];
       /*<<array.ml:334:38>>*/ a[2] = caml_check_bound(a, 0)[1];
       /*<<array.ml:334:57>>*/ a[1] = e;
-     var _B_ = 0;
+     var _A_ = 0;
     }
     else
-     var _B_ = _A_;
-     /*<<array.ml:334:57>>*/ return _B_;
+     var _A_ = _z_;
+     /*<<array.ml:334:57>>*/ return _A_;
     /*<<array.ml:334:67>>*/ }
    function stable_sort(cmp, a){
     function merge(src1ofs, src1len, src2, src2ofs, src2len, dst, dstofs){
@@ -7520,38 +7522,38 @@
      /*<<array.ml:357:70>>*/ }
     function isortto(srcofs, dst, dstofs, len){
       /*<<array.ml:360:4>>*/ var
-      _n_ = len - 1 | 0,
-       /*<<array.ml:360:4>>*/ _m_ = 0;
-     if(_n_ >= 0){
-      var i = _m_;
+      _m_ = len - 1 | 0,
+       /*<<array.ml:360:4>>*/ _l_ = 0;
+     if(_m_ >= 0){
+      var i = _l_;
       a:
       for(;;){
         /*<<array.ml:361:14>>*/ var
-        _o_ = srcofs + i | 0,
-         /*<<array.ml:361:14>>*/ e = caml_check_bound(a, _o_)[1 + _o_],
+        _n_ = srcofs + i | 0,
+         /*<<array.ml:361:14>>*/ e = caml_check_bound(a, _n_)[1 + _n_],
          /*<<array.ml:362:14>>*/ j = [0, (dstofs + i | 0) - 1 | 0];
        for(;;){
         if(dstofs <= j[1]){
-         var _p_ = j[1];
+         var _o_ = j[1];
           /*<<array.ml:363:29>>*/ if
           (0
            <
              /*<<array.ml:363:29>>*/ caml_call2
-             (cmp, caml_check_bound(dst, _p_)[1 + _p_], e)){
+             (cmp, caml_check_bound(dst, _o_)[1 + _o_], e)){
            /*<<array.ml:364:25>>*/ var
-           _q_ = j[1],
-            /*<<array.ml:364:25>>*/ _r_ = caml_check_bound(dst, _q_)[1 + _q_],
-           _s_ = j[1] + 1 | 0;
-           /*<<array.ml:364:8>>*/ caml_check_bound(dst, _s_)[1 + _s_] = _r_;
+           _p_ = j[1],
+            /*<<array.ml:364:25>>*/ _q_ = caml_check_bound(dst, _p_)[1 + _p_],
+           _r_ = j[1] + 1 | 0;
+           /*<<array.ml:364:8>>*/ caml_check_bound(dst, _r_)[1 + _r_] = _q_;
           j[1] += -1;
           continue;
          }
         }
-        var _t_ = j[1] + 1 | 0;
-         /*<<array.ml:367:6>>*/ caml_check_bound(dst, _t_)[1 + _t_] = e;
-         /*<<array.ml:360:4>>*/  /*<<array.ml:360:4>>*/ var _u_ = i + 1 | 0;
-        if(_n_ === i) break a;
-        var i = _u_;
+        var _s_ = j[1] + 1 | 0;
+         /*<<array.ml:367:6>>*/ caml_check_bound(dst, _s_)[1 + _s_] = e;
+         /*<<array.ml:360:4>>*/  /*<<array.ml:360:4>>*/ var _t_ = i + 1 | 0;
+        if(_m_ === i) break a;
+        var i = _t_;
         break;
        }
       }
@@ -7561,14 +7563,14 @@
     function sortto(srcofs, dst, dstofs, len){
       /*<<array.ml:371:4>>*/ if(len <= 5){
        /*<<array.ml:371:26>>*/ isortto(srcofs, dst, dstofs, len);
-       /*<<array.ml:371:26>>*/ return _b_;
+       /*<<array.ml:371:26>>*/ return sentinal;
      }
      var l1 = len / 2 | 0, l2 = len - l1 | 0;
       /*<<array.ml:374:6>>*/ sortto(srcofs + l1 | 0, dst, dstofs + l1 | 0, l2);
       /*<<array.ml:375:6>>*/ sortto(srcofs, a, srcofs + l2 | 0, l1);
       /*<<array.ml:375:6>>*/ merge
       (srcofs + l2 | 0, l1, dst, dstofs + l1 | 0, l2, dst, dstofs);
-      /*<<array.ml:375:6>>*/ return _b_;
+      /*<<array.ml:375:6>>*/ return sentinal;
      /*<<array.ml:377:7>>*/ }
     var l = a.length - 1;
     if(l <= 5)  /*<<array.ml:380:22>>*/ return isortto(0, a, 0, l);
@@ -7587,14 +7589,14 @@
        /*<<array.ml:400:9>>*/ return 0;
       /*<<array.ml:398:14>>*/ var
        /*<<array.ml:398:14>>*/ x = a[1 + i],
-       /*<<array.ml:398:14>>*/ _k_ = i + 1 | 0;
+       /*<<array.ml:398:14>>*/ _j_ = i + 1 | 0;
       /*<<array.ml:399:6>>*/ return [0,
              x,
-             function(_l_){ /*<<?>>*/ return aux(_k_, _l_);}];
+             function(_k_){ /*<<?>>*/ return aux(_j_, _k_);}];
      /*<<array.ml:400:16>>*/ }
-     /*<<array.ml:402:2>>*/  /*<<array.ml:402:2>>*/ var _i_ = 0;
-     /*<<array.ml:402:2>>*/ return function(_j_){
-      /*<<?>>*/ return aux(_i_, _j_);};
+     /*<<array.ml:402:2>>*/  /*<<array.ml:402:2>>*/ var _h_ = 0;
+     /*<<array.ml:402:2>>*/ return function(_i_){
+      /*<<?>>*/ return aux(_h_, _i_);};
     /*<<array.ml:402:7>>*/ }
    function to_seqi(a){
     function aux(i, param){
@@ -7602,22 +7604,22 @@
        /*<<array.ml:410:9>>*/ return 0;
       /*<<array.ml:408:14>>*/ var
        /*<<array.ml:408:14>>*/ x = a[1 + i],
-       /*<<array.ml:408:14>>*/ _g_ = i + 1 | 0;
+       /*<<array.ml:408:14>>*/ _f_ = i + 1 | 0;
       /*<<array.ml:409:6>>*/ return [0,
              [0, i, x],
-             function(_h_){ /*<<?>>*/ return aux(_g_, _h_);}];
+             function(_g_){ /*<<?>>*/ return aux(_f_, _g_);}];
      /*<<array.ml:410:16>>*/ }
-     /*<<array.ml:412:2>>*/  /*<<array.ml:412:2>>*/ var _e_ = 0;
-     /*<<array.ml:412:2>>*/ return function(_f_){
-      /*<<?>>*/ return aux(_e_, _f_);};
+     /*<<array.ml:412:2>>*/  /*<<array.ml:412:2>>*/ var _d_ = 0;
+     /*<<array.ml:412:2>>*/ return function(_e_){
+      /*<<?>>*/ return aux(_d_, _e_);};
     /*<<array.ml:412:7>>*/ }
    function of_seq(i$2){
-     /*<<array.ml:426:2>>*/ var _c_ = 0;
-    function _d_(acc, x){
+     /*<<array.ml:426:2>>*/ var _b_ = 0;
+    function _c_(acc, x){
       /*<<array.ml:426:38>>*/ return [0, x, acc];
      /*<<array.ml:426:44>>*/ }
      /*<<array.ml:426:10>>*/  /*<<array.ml:426:10>>*/ var
-     l =  /*<<array.ml:426:10>>*/ caml_call3(Stdlib_Seq[5], _d_, _c_, i$2);
+     l =  /*<<array.ml:426:10>>*/ caml_call3(Stdlib_Seq[5], _c_, _b_, i$2);
     if(! l)  /*<<array.ml:415:10>>*/ return [0];
      /*<<array.ml:417:16>>*/ var
      tl = l[2],
@@ -7716,7 +7718,7 @@
             : runtime.caml_call_gen(f, [a0, a1, a2]);
    }
    var
-    _j_ = undefined,
+    sentinal = undefined,
     global_data = runtime.caml_get_global_data(),
     Stdlib_Seq = global_data.Stdlib__Seq,
     Stdlib_List = global_data.Stdlib__List,
@@ -7759,8 +7761,8 @@
     pi = 3.141592653589793;
    function is_integer(x){
      /*<<float.ml:111:19>>*/ var
-     _ar_ = x ==  /*<<float.ml:111:23>>*/ runtime.caml_trunc_float(x) ? 1 : 0;
-    return _ar_ ? is_finite(x) : _ar_;
+     _aq_ = x ==  /*<<float.ml:111:23>>*/ runtime.caml_trunc_float(x) ? 1 : 0;
+    return _aq_ ? is_finite(x) : _aq_;
     /*<<float.ml:111:45>>*/ }
    function succ(x){
      /*<<float.ml:116:13>>*/ return  /*<<float.ml:116:13>>*/ caml_nextafter_float
@@ -7857,34 +7859,34 @@
             (10, 100, 0, x);
     /*<<float.ml:164:41>>*/ }
    function unsafe_fill(a, ofs, len, v){
-     /*<<float.ml:178:4>>*/ var _ap_ = (ofs + len | 0) - 1 | 0;
-    if(_ap_ >= ofs){
+     /*<<float.ml:178:4>>*/ var _ao_ = (ofs + len | 0) - 1 | 0;
+    if(_ao_ >= ofs){
      var i = ofs;
      for(;;){
        /*<<float.ml:178:36>>*/ a[1 + i] = v;
-       /*<<float.ml:178:36>>*/  /*<<float.ml:178:36>>*/ var _aq_ = i + 1 | 0;
-      if(_ap_ === i) break;
-      var i = _aq_;
+       /*<<float.ml:178:36>>*/  /*<<float.ml:178:36>>*/ var _ap_ = i + 1 | 0;
+      if(_ao_ === i) break;
+      var i = _ap_;
      }
     }
     return 0;
     /*<<float.ml:178:57>>*/ }
    function check(a, ofs, len, msg){
-     /*<<float.ml:184:4>>*/ var _al_ = ofs < 0 ? 1 : 0;
-    if(_al_)
-     var _am_ = _al_;
+     /*<<float.ml:184:4>>*/ var _ak_ = ofs < 0 ? 1 : 0;
+    if(_ak_)
+     var _al_ = _ak_;
     else{
-     var _an_ = len < 0 ? 1 : 0;
-     if(_an_)
-      var _am_ = _an_;
+     var _am_ = len < 0 ? 1 : 0;
+     if(_am_)
+      var _al_ = _am_;
      else
       var
-       _ao_ = (ofs + len | 0) < 0 ? 1 : 0,
-       _am_ = _ao_ || (a.length - 1 < (ofs + len | 0) ? 1 : 0);
+       _an_ = (ofs + len | 0) < 0 ? 1 : 0,
+       _al_ = _an_ || (a.length - 1 < (ofs + len | 0) ? 1 : 0);
     }
-    return _am_
-            ? ( /*<<float.ml:185:6>>*/ caml_call1(Stdlib[1], msg), _j_)
-            : _am_;
+    return _al_
+            ? ( /*<<float.ml:185:6>>*/ caml_call1(Stdlib[1], msg), sentinal)
+            : _al_;
     /*<<float.ml:185:21>>*/ }
    function make(n, v){
      /*<<float.ml:188:4>>*/  /*<<float.ml:188:17>>*/ var
@@ -7899,16 +7901,16 @@
      /*<<float.ml:195:16>>*/ var
       /*<<float.ml:195:16>>*/ res =
         /*<<float.ml:195:16>>*/ caml_floatarray_create(l),
-      /*<<float.ml:196:6>>*/ _aj_ = l - 1 | 0,
-      /*<<float.ml:195:16>>*/ _ai_ = 0;
-    if(_aj_ >= 0){
-     var i = _ai_;
+      /*<<float.ml:196:6>>*/ _ai_ = l - 1 | 0,
+      /*<<float.ml:195:16>>*/ _ah_ = 0;
+    if(_ai_ >= 0){
+     var i = _ah_;
      for(;;){
        /*<<float.ml:197:8>>*/ res[1 + i] =
         /*<<float.ml:197:25>>*/ caml_call1(f, i);
-       /*<<float.ml:197:8>>*/  /*<<float.ml:197:8>>*/ var _ak_ = i + 1 | 0;
-      if(_aj_ === i) break;
-      var i = _ak_;
+       /*<<float.ml:197:8>>*/  /*<<float.ml:197:8>>*/ var _aj_ = i + 1 | 0;
+      if(_ai_ === i) break;
+      var i = _aj_;
      }
     }
      /*<<float.ml:199:6>>*/ return res;
@@ -7990,11 +7992,11 @@
             (src, sofs, dst, dofs, len);
     /*<<float.ml:250:37>>*/ }
    function to_list(a){
-     /*<<float.ml:253:25>>*/ function _ag_(_ah_){
-      /*<<?>>*/ return a[1 + _ah_];
+     /*<<float.ml:253:25>>*/ function _af_(_ag_){
+      /*<<?>>*/ return a[1 + _ag_];
     }
      /*<<float.ml:253:25>>*/ return  /*<<float.ml:253:25>>*/ caml_call2
-            (Stdlib_List[10], a.length - 1, _ag_);
+            (Stdlib_List[10], a.length - 1, _af_);
     /*<<float.ml:253:39>>*/ }
    function of_list(l){
      /*<<float.ml:256:4>>*/ var
@@ -8015,16 +8017,16 @@
     /*<<float.ml:262:12>>*/ }
    function iter(f, a){
      /*<<float.ml:266:4>>*/ var
-     _ae_ = a.length - 1 - 1 | 0,
-      /*<<float.ml:266:4>>*/ _ad_ = 0;
-    if(_ae_ >= 0){
-     var i = _ad_;
+     _ad_ = a.length - 1 - 1 | 0,
+      /*<<float.ml:266:4>>*/ _ac_ = 0;
+    if(_ad_ >= 0){
+     var i = _ac_;
      for(;;){
        /*<<float.ml:266:33>>*/  /*<<float.ml:266:33>>*/ caml_call1
        (f, a[1 + i]);
-       /*<<float.ml:266:33>>*/  /*<<float.ml:266:33>>*/ var _af_ = i + 1 | 0;
-      if(_ae_ === i) break;
-      var i = _af_;
+       /*<<float.ml:266:33>>*/  /*<<float.ml:266:33>>*/ var _ae_ = i + 1 | 0;
+      if(_ad_ === i) break;
+      var i = _ae_;
      }
     }
     return 0;
@@ -8034,16 +8036,16 @@
       /*<<float.ml:271:6>>*/ return  /*<<float.ml:271:6>>*/ caml_call1
              (Stdlib[1], cst_Float_Array_iter2_arrays_m);
      /*<<float.ml:273:6>>*/ var
-     _ab_ = a.length - 1 - 1 | 0,
-      /*<<float.ml:273:6>>*/ _aa_ = 0;
-    if(_ab_ >= 0){
-     var i = _aa_;
+     _aa_ = a.length - 1 - 1 | 0,
+      /*<<float.ml:273:6>>*/ _$_ = 0;
+    if(_aa_ >= 0){
+     var i = _$_;
      for(;;){
        /*<<float.ml:273:35>>*/  /*<<float.ml:273:35>>*/ caml_call2
        (f, a[1 + i], b[1 + i]);
-       /*<<float.ml:273:35>>*/  /*<<float.ml:273:35>>*/ var _ac_ = i + 1 | 0;
-      if(_ab_ === i) break;
-      var i = _ac_;
+       /*<<float.ml:273:35>>*/  /*<<float.ml:273:35>>*/ var _ab_ = i + 1 | 0;
+      if(_aa_ === i) break;
+      var i = _ab_;
      }
     }
     return 0;
@@ -8053,16 +8055,16 @@
      l = a.length - 1,
       /*<<float.ml:277:12>>*/ r =
         /*<<float.ml:277:12>>*/ caml_floatarray_create(l),
-      /*<<float.ml:278:4>>*/ ___ = l - 1 | 0,
-      /*<<float.ml:277:12>>*/ _Z_ = 0;
-    if(___ >= 0){
-     var i = _Z_;
+      /*<<float.ml:278:4>>*/ _Z_ = l - 1 | 0,
+      /*<<float.ml:277:12>>*/ _Y_ = 0;
+    if(_Z_ >= 0){
+     var i = _Y_;
      for(;;){
        /*<<float.ml:279:6>>*/ r[1 + i] =
         /*<<float.ml:279:21>>*/ caml_call1(f, a[1 + i]);
-       /*<<float.ml:279:6>>*/  /*<<float.ml:279:6>>*/ var _$_ = i + 1 | 0;
-      if(___ === i) break;
-      var i = _$_;
+       /*<<float.ml:279:6>>*/  /*<<float.ml:279:6>>*/ var ___ = i + 1 | 0;
+      if(_Z_ === i) break;
+      var i = ___;
      }
     }
      /*<<float.ml:281:4>>*/ return r;
@@ -8077,32 +8079,32 @@
      /*<<float.ml:289:14>>*/ var
       /*<<float.ml:289:14>>*/ r =
         /*<<float.ml:289:14>>*/ caml_floatarray_create(la),
-      /*<<float.ml:290:6>>*/ _X_ = la - 1 | 0,
-      /*<<float.ml:289:14>>*/ _W_ = 0;
-    if(_X_ >= 0){
-     var i = _W_;
+      /*<<float.ml:290:6>>*/ _W_ = la - 1 | 0,
+      /*<<float.ml:289:14>>*/ _V_ = 0;
+    if(_W_ >= 0){
+     var i = _V_;
      for(;;){
        /*<<float.ml:291:8>>*/ r[1 + i] =
         /*<<float.ml:291:23>>*/ caml_call2(f, a[1 + i], b[1 + i]);
-       /*<<float.ml:291:8>>*/  /*<<float.ml:291:8>>*/ var _Y_ = i + 1 | 0;
-      if(_X_ === i) break;
-      var i = _Y_;
+       /*<<float.ml:291:8>>*/  /*<<float.ml:291:8>>*/ var _X_ = i + 1 | 0;
+      if(_W_ === i) break;
+      var i = _X_;
      }
     }
      /*<<float.ml:293:6>>*/ return r;
     /*<<float.ml:294:7>>*/ }
    function iteri(f, a){
      /*<<float.ml:298:4>>*/ var
-     _U_ = a.length - 1 - 1 | 0,
-      /*<<float.ml:298:4>>*/ _T_ = 0;
-    if(_U_ >= 0){
-     var i = _T_;
+     _T_ = a.length - 1 - 1 | 0,
+      /*<<float.ml:298:4>>*/ _S_ = 0;
+    if(_T_ >= 0){
+     var i = _S_;
      for(;;){
        /*<<float.ml:298:33>>*/  /*<<float.ml:298:33>>*/ caml_call2
        (f, i, a[1 + i]);
-       /*<<float.ml:298:33>>*/  /*<<float.ml:298:33>>*/ var _V_ = i + 1 | 0;
-      if(_U_ === i) break;
-      var i = _V_;
+       /*<<float.ml:298:33>>*/  /*<<float.ml:298:33>>*/ var _U_ = i + 1 | 0;
+      if(_T_ === i) break;
+      var i = _U_;
      }
     }
     return 0;
@@ -8112,16 +8114,16 @@
      l = a.length - 1,
       /*<<float.ml:302:12>>*/ r =
         /*<<float.ml:302:12>>*/ caml_floatarray_create(l),
-      /*<<float.ml:303:4>>*/ _R_ = l - 1 | 0,
-      /*<<float.ml:302:12>>*/ _Q_ = 0;
-    if(_R_ >= 0){
-     var i = _Q_;
+      /*<<float.ml:303:4>>*/ _Q_ = l - 1 | 0,
+      /*<<float.ml:302:12>>*/ _P_ = 0;
+    if(_Q_ >= 0){
+     var i = _P_;
      for(;;){
        /*<<float.ml:304:6>>*/ r[1 + i] =
         /*<<float.ml:304:21>>*/ caml_call2(f, i, a[1 + i]);
-       /*<<float.ml:304:6>>*/  /*<<float.ml:304:6>>*/ var _S_ = i + 1 | 0;
-      if(_R_ === i) break;
-      var i = _S_;
+       /*<<float.ml:304:6>>*/  /*<<float.ml:304:6>>*/ var _R_ = i + 1 | 0;
+      if(_Q_ === i) break;
+      var i = _R_;
      }
     }
      /*<<float.ml:306:4>>*/ return r;
@@ -8129,15 +8131,15 @@
    function fold_left(f, x, a){
      /*<<float.ml:310:4>>*/ var
       /*<<float.ml:310:12>>*/ r = [0, x],
-     _O_ = a.length - 1 - 1 | 0,
-      /*<<float.ml:310:12>>*/ _N_ = 0;
-    if(_O_ >= 0){
-     var i = _N_;
+     _N_ = a.length - 1 - 1 | 0,
+      /*<<float.ml:310:12>>*/ _M_ = 0;
+    if(_N_ >= 0){
+     var i = _M_;
      for(;;){
       r[1] =  /*<<float.ml:312:11>>*/ caml_call2(f, r[1], a[1 + i]);
-       /*<<float.ml:311:4>>*/  /*<<float.ml:311:4>>*/ var _P_ = i + 1 | 0;
-      if(_O_ === i) break;
-      var i = _P_;
+       /*<<float.ml:311:4>>*/  /*<<float.ml:311:4>>*/ var _O_ = i + 1 | 0;
+      if(_N_ === i) break;
+      var i = _O_;
      }
     }
     return r[1];
@@ -8145,14 +8147,14 @@
    function fold_right(f, a, x){
      /*<<float.ml:318:4>>*/ var
       /*<<float.ml:318:12>>*/ r = [0, x],
-      /*<<float.ml:319:4>>*/ _L_ = a.length - 1 - 1 | 0;
-    if(_L_ >= 0){
-     var i = _L_;
+      /*<<float.ml:319:4>>*/ _K_ = a.length - 1 - 1 | 0;
+    if(_K_ >= 0){
+     var i = _K_;
      for(;;){
       r[1] =  /*<<float.ml:320:11>>*/ caml_call2(f, a[1 + i], r[1]);
-       /*<<float.ml:319:4>>*/  /*<<float.ml:319:4>>*/ var _M_ = i - 1 | 0;
+       /*<<float.ml:319:4>>*/  /*<<float.ml:319:4>>*/ var _L_ = i - 1 | 0;
       if(0 === i) break;
-      var i = _M_;
+      var i = _L_;
      }
     }
     return r[1];
@@ -8240,9 +8242,9 @@
       /*<<float.ml:375:38>>*/ throw  /*<<float.ml:375:38>>*/ caml_maybe_attach_backtrace
             ([0, Bottom, i], 1);
      /*<<float.ml:375:54>>*/ }
-    var l = a.length - 1, _F_ = ((l + 1 | 0) / 3 | 0) - 1 | 0;
-    if(_F_ >= 0){
-     var i$6 = _F_;
+    var l = a.length - 1, _E_ = ((l + 1 | 0) / 3 | 0) - 1 | 0;
+    if(_E_ >= 0){
+     var i$6 = _E_;
      for(;;){
        /*<<float.ml:404:52>>*/  /*<<float.ml:404:52>>*/ var
        e$1 =  /*<<float.ml:404:52>>*/ caml_array_get(a, i$6);
@@ -8272,14 +8274,14 @@
         /*<<float.ml:386:63>>*/  /*<<float.ml:386:63>>*/ caml_array_set
         (a, i$0, e$1);
       }
-       /*<<float.ml:404:40>>*/  /*<<float.ml:404:40>>*/ var _K_ = i$6 - 1 | 0;
+       /*<<float.ml:404:40>>*/  /*<<float.ml:404:40>>*/ var _J_ = i$6 - 1 | 0;
       if(0 === i$6) break;
-      var i$6 = _K_;
+      var i$6 = _J_;
      }
     }
-     /*<<float.ml:405:4>>*/  /*<<float.ml:405:4>>*/ var _G_ = l - 1 | 0;
-    if(_G_ >= 2){
-     var i$4 = _G_;
+     /*<<float.ml:405:4>>*/  /*<<float.ml:405:4>>*/ var _F_ = l - 1 | 0;
+    if(_F_ >= 2){
+     var i$4 = _F_;
      a:
      for(;;){
        /*<<float.ml:406:14>>*/  /*<<float.ml:406:14>>*/ var
@@ -8320,25 +8322,25 @@
           /*<<float.ml:398:51>>*/  /*<<float.ml:398:51>>*/ caml_array_set
           (a, 0, e$0);
         }
-         /*<<float.ml:405:4>>*/  /*<<float.ml:405:4>>*/ var _J_ = i$4 - 1 | 0;
+         /*<<float.ml:405:4>>*/  /*<<float.ml:405:4>>*/ var _I_ = i$4 - 1 | 0;
         if(2 === i$4) break a;
-        var i$4 = _J_;
+        var i$4 = _I_;
         break;
        }
       }
      }
     }
-    var _H_ = 1 < l ? 1 : 0;
-    if(_H_){
+    var _G_ = 1 < l ? 1 : 0;
+    if(_G_){
       /*<<float.ml:410:27>>*/  /*<<float.ml:410:27>>*/ var
       e =  /*<<float.ml:410:27>>*/ caml_array_get(a, 1);
       /*<<float.ml:410:40>>*/  /*<<float.ml:410:40>>*/ caml_array_set
       (a, 1,  /*<<float.ml:410:48>>*/ caml_array_get(a, 0));
-     var _I_ =  /*<<float.ml:410:59>>*/ caml_array_set(a, 0, e);
+     var _H_ =  /*<<float.ml:410:59>>*/ caml_array_set(a, 0, e);
     }
     else
-     var _I_ = _H_;
-     /*<<float.ml:410:59>>*/ return _I_;
+     var _H_ = _G_;
+     /*<<float.ml:410:59>>*/ return _H_;
     /*<<float.ml:410:69>>*/ }
    function stable_sort(cmp, a){
     function merge(src1ofs, src1len, src2, src2ofs, src2len, dst, dstofs){
@@ -8388,10 +8390,10 @@
      /*<<float.ml:433:72>>*/ }
     function isortto(srcofs, dst, dstofs, len){
       /*<<float.ml:436:6>>*/ var
-      _D_ = len - 1 | 0,
-       /*<<float.ml:436:6>>*/ _C_ = 0;
-     if(_D_ >= 0){
-      var i = _C_;
+      _C_ = len - 1 | 0,
+       /*<<float.ml:436:6>>*/ _B_ = 0;
+     if(_C_ >= 0){
+      var i = _B_;
       a:
       for(;;){
         /*<<float.ml:437:16>>*/ var
@@ -8415,9 +8417,9 @@
         }
          /*<<float.ml:443:8>>*/  /*<<float.ml:443:8>>*/ caml_array_set
          (dst, j[1] + 1 | 0, e);
-         /*<<float.ml:436:6>>*/  /*<<float.ml:436:6>>*/ var _E_ = i + 1 | 0;
-        if(_D_ === i) break a;
-        var i = _E_;
+         /*<<float.ml:436:6>>*/  /*<<float.ml:436:6>>*/ var _D_ = i + 1 | 0;
+        if(_C_ === i) break a;
+        var i = _D_;
         break;
        }
       }
@@ -8427,14 +8429,14 @@
     function sortto(srcofs, dst, dstofs, len){
       /*<<float.ml:447:6>>*/ if(len <= 5){
        /*<<float.ml:447:28>>*/ isortto(srcofs, dst, dstofs, len);
-       /*<<float.ml:447:28>>*/ return _j_;
+       /*<<float.ml:447:28>>*/ return sentinal;
      }
      var l1 = len / 2 | 0, l2 = len - l1 | 0;
       /*<<float.ml:450:8>>*/ sortto(srcofs + l1 | 0, dst, dstofs + l1 | 0, l2);
       /*<<float.ml:451:8>>*/ sortto(srcofs, a, srcofs + l2 | 0, l1);
       /*<<float.ml:451:8>>*/ merge
       (srcofs + l2 | 0, l1, dst, dstofs + l1 | 0, l2, dst, dstofs);
-      /*<<float.ml:451:8>>*/ return _j_;
+      /*<<float.ml:451:8>>*/ return sentinal;
      /*<<float.ml:453:9>>*/ }
     var l = a.length - 1;
     if(l <= 5)  /*<<float.ml:456:24>>*/ return isortto(0, a, 0, l);
@@ -8453,14 +8455,14 @@
        /*<<float.ml:474:11>>*/ return 0;
       /*<<float.ml:472:16>>*/ var
        /*<<float.ml:472:16>>*/ x = a[1 + i],
-       /*<<float.ml:472:16>>*/ _A_ = i + 1 | 0;
+       /*<<float.ml:472:16>>*/ _z_ = i + 1 | 0;
       /*<<float.ml:473:8>>*/ return [0,
              x,
-             function(_B_){ /*<<?>>*/ return aux(_A_, _B_);}];
+             function(_A_){ /*<<?>>*/ return aux(_z_, _A_);}];
      /*<<float.ml:474:18>>*/ }
-     /*<<float.ml:476:4>>*/  /*<<float.ml:476:4>>*/ var _y_ = 0;
-     /*<<float.ml:476:4>>*/ return function(_z_){
-      /*<<?>>*/ return aux(_y_, _z_);};
+     /*<<float.ml:476:4>>*/  /*<<float.ml:476:4>>*/ var _x_ = 0;
+     /*<<float.ml:476:4>>*/ return function(_y_){
+      /*<<?>>*/ return aux(_x_, _y_);};
     /*<<float.ml:476:9>>*/ }
    function to_seqi(a){
     function aux(i, param){
@@ -8468,23 +8470,23 @@
        /*<<float.ml:485:11>>*/ return 0;
       /*<<float.ml:483:16>>*/ var
        /*<<float.ml:483:16>>*/ x = a[1 + i],
-       /*<<float.ml:483:16>>*/ _w_ = i + 1 | 0;
+       /*<<float.ml:483:16>>*/ _v_ = i + 1 | 0;
       /*<<float.ml:484:8>>*/ return [0,
              [0, i, x],
-             function(_x_){ /*<<?>>*/ return aux(_w_, _x_);}];
+             function(_w_){ /*<<?>>*/ return aux(_v_, _w_);}];
      /*<<float.ml:485:18>>*/ }
-     /*<<float.ml:487:4>>*/  /*<<float.ml:487:4>>*/ var _u_ = 0;
-     /*<<float.ml:487:4>>*/ return function(_v_){
-      /*<<?>>*/ return aux(_u_, _v_);};
+     /*<<float.ml:487:4>>*/  /*<<float.ml:487:4>>*/ var _t_ = 0;
+     /*<<float.ml:487:4>>*/ return function(_u_){
+      /*<<?>>*/ return aux(_t_, _u_);};
     /*<<float.ml:487:9>>*/ }
    function of_seq(i$2){
-     /*<<float.ml:501:4>>*/ var _s_ = 0;
-    function _t_(acc, x){
+     /*<<float.ml:501:4>>*/ var _r_ = 0;
+    function _s_(acc, x){
       /*<<float.ml:501:40>>*/ return [0, x, acc];
      /*<<float.ml:501:46>>*/ }
      /*<<float.ml:501:12>>*/ var
       /*<<float.ml:501:12>>*/ l =
-        /*<<float.ml:501:12>>*/ caml_call3(Stdlib_Seq[5], _t_, _s_, i$2),
+        /*<<float.ml:501:12>>*/ caml_call3(Stdlib_Seq[5], _s_, _r_, i$2),
       /*<<float.ml:491:14>>*/ len =
         /*<<float.ml:491:14>>*/ caml_call1(Stdlib_List[1], l),
       /*<<float.ml:492:12>>*/ a =
@@ -8509,16 +8511,16 @@
       /*<<float.ml:508:14>>*/ r =
         /*<<float.ml:508:14>>*/ runtime.caml_make_vect
         (l,  /*<<float.ml:508:27>>*/ caml_call1(f, a[1])),
-      /*<<float.ml:509:6>>*/ _q_ = l - 1 | 0,
-      /*<<float.ml:508:14>>*/ _p_ = 1;
-    if(_q_ >= 1){
-     var i = _p_;
+      /*<<float.ml:509:6>>*/ _p_ = l - 1 | 0,
+      /*<<float.ml:508:14>>*/ _o_ = 1;
+    if(_p_ >= 1){
+     var i = _o_;
      for(;;){
        /*<<float.ml:510:8>>*/ r[1 + i] =
         /*<<float.ml:510:29>>*/ caml_call1(f, a[1 + i]);
-       /*<<float.ml:510:8>>*/  /*<<float.ml:510:8>>*/ var _r_ = i + 1 | 0;
-      if(_q_ === i) break;
-      var i = _r_;
+       /*<<float.ml:510:8>>*/  /*<<float.ml:510:8>>*/ var _q_ = i + 1 | 0;
+      if(_p_ === i) break;
+      var i = _q_;
      }
     }
      /*<<float.ml:512:6>>*/ return r;
@@ -8528,16 +8530,16 @@
      l = a.length - 1,
       /*<<float.ml:517:12>>*/ r =
         /*<<float.ml:517:12>>*/ caml_floatarray_create(l),
-      /*<<float.ml:518:4>>*/ _n_ = l - 1 | 0,
-      /*<<float.ml:517:12>>*/ _m_ = 0;
-    if(_n_ >= 0){
-     var i = _m_;
+      /*<<float.ml:518:4>>*/ _m_ = l - 1 | 0,
+      /*<<float.ml:517:12>>*/ _l_ = 0;
+    if(_m_ >= 0){
+     var i = _l_;
      for(;;){
        /*<<float.ml:519:6>>*/ r[1 + i] =
         /*<<float.ml:519:21>>*/ caml_call1(f, a[1 + i]);
-       /*<<float.ml:519:6>>*/  /*<<float.ml:519:6>>*/ var _o_ = i + 1 | 0;
-      if(_n_ === i) break;
-      var i = _o_;
+       /*<<float.ml:519:6>>*/  /*<<float.ml:519:6>>*/ var _n_ = i + 1 | 0;
+      if(_m_ === i) break;
+      var i = _n_;
      }
     }
      /*<<float.ml:521:4>>*/ return r;
@@ -8548,7 +8550,7 @@
     _e_ = caml_array_get,
     _f_ =
       [0,
-       function(_l_){ /*<<?>>*/ return _l_.length - 1;},
+       function(_k_){ /*<<?>>*/ return _k_.length - 1;},
        _e_,
        _d_,
        make,
@@ -8615,7 +8617,7 @@
        min_max_num,
        hash,
        [0,
-        function(_k_){ /*<<?>>*/ return _k_.length - 1;},
+        function(_j_){ /*<<?>>*/ return _j_.length - 1;},
         _i_,
         _h_,
         make,
@@ -9414,6 +9416,7 @@
             : runtime.caml_call_gen(f, [a0, a1, a2, a3, a4]);
    }
     /*<<parsing.ml:59:0>>*/ var
+    sentinal = undefined,
     global_data = runtime.caml_get_global_data(),
     Stdlib_Obj = global_data.Stdlib__Obj,
     Stdlib_Array = global_data.Stdlib__Array,
@@ -9440,7 +9443,6 @@
        0,
        0,
        0],
-    _a_ = undefined,
     cst_syntax_error = "syntax error";
    function grow_stacks(param){
      /*<<parsing.ml:108:2>>*/ var
@@ -9467,7 +9469,7 @@
      (Stdlib_Array[8], env[4], 0, new_end, 0, oldsize);
     env[4] = new_end;
     env[5] = newsize;
-    return _a_;
+    return sentinal;
     /*<<parsing.ml:122:28>>*/ }
    function clear_parser(param){
      /*<<parsing.ml:125:2>>*/  /*<<parsing.ml:125:2>>*/ caml_call4
@@ -9520,17 +9522,17 @@
         case 4:
          try{
            /*<<parsing.ml:143:39>>*/ var
-           _j_ = env[13],
-            /*<<parsing.ml:143:39>>*/ _k_ =
+           _i_ = env[13],
+            /*<<parsing.ml:143:39>>*/ _j_ =
               /*<<parsing.ml:143:39>>*/ caml_call1
-              (caml_check_bound(tables[1], _j_)[1 + _j_], env),
-            /*<<parsing.ml:143:39>>*/ _l_ = 4,
-           value = _k_,
-           action = _l_;
+              (caml_check_bound(tables[1], _i_)[1 + _i_], env),
+            /*<<parsing.ml:143:39>>*/ _k_ = 4,
+           value = _j_,
+           action = _k_;
          }
-         catch(_n_){
-          var _i_ = caml_wrap_exception(_n_);
-          if(_i_ !== Parse_error) throw caml_maybe_attach_backtrace(_i_, 0);
+         catch(_m_){
+          var _h_ = caml_wrap_exception(_m_);
+          if(_h_ !== Parse_error) throw caml_maybe_attach_backtrace(_h_, 0);
           var value = 0, action = 5;
          }
          var cmd = action, arg = value;
@@ -9566,9 +9568,9 @@
                 ? 1
                 : 0;
         /*<<parsing.ml:182:38>>*/  /*<<parsing.ml:182:38>>*/ var
-        _m_ =  /*<<parsing.ml:182:38>>*/ runtime.caml_obj_tag(tok);
-        /*<<parsing.ml:182:17>>*/ return caml_check_bound(tables[3], _m_)
-                [1 + _m_]
+        _l_ =  /*<<parsing.ml:182:38>>*/ runtime.caml_obj_tag(tok);
+        /*<<parsing.ml:182:17>>*/ return caml_check_bound(tables[3], _l_)
+                [1 + _l_]
                === curr_char
                ? 1
                : 0;
@@ -9578,21 +9580,21 @@
     }
     /*<<parsing.ml:184:17>>*/ }
    function peek_val(env, n){
-     /*<<parsing.ml:187:2>>*/ var _h_ = env[11] - n | 0;
-     /*<<parsing.ml:187:12>>*/ return caml_check_bound(env[2], _h_)[1 + _h_];
+     /*<<parsing.ml:187:2>>*/ var _g_ = env[11] - n | 0;
+     /*<<parsing.ml:187:12>>*/ return caml_check_bound(env[2], _g_)[1 + _g_];
     /*<<parsing.ml:187:37>>*/ }
    function symbol_start_pos(param){
      /*<<parsing.ml:190:2>>*/ var i$1 = env[12], i = i$1;
      /*<<parsing.ml:191:4>>*/ for(;;){
      if(0 >= i){
-      var _g_ = env[11];
-       /*<<parsing.ml:191:19>>*/ return caml_check_bound(env[4], _g_)[1 + _g_];
+      var _f_ = env[11];
+       /*<<parsing.ml:191:19>>*/ return caml_check_bound(env[4], _f_)[1 + _f_];
      }
       /*<<parsing.ml:193:15>>*/ var
+      _d_ = (env[11] - i | 0) + 1 | 0,
+       /*<<parsing.ml:193:15>>*/ st = caml_check_bound(env[3], _d_)[1 + _d_],
       _e_ = (env[11] - i | 0) + 1 | 0,
-       /*<<parsing.ml:193:15>>*/ st = caml_check_bound(env[3], _e_)[1 + _e_],
-      _f_ = (env[11] - i | 0) + 1 | 0,
-       /*<<parsing.ml:194:15>>*/ en = caml_check_bound(env[4], _f_)[1 + _f_];
+       /*<<parsing.ml:194:15>>*/ en = caml_check_bound(env[4], _e_)[1 + _e_];
       /*<<parsing.ml:195:9>>*/ if
       ( /*<<parsing.ml:195:9>>*/ runtime.caml_notequal(st, en))
        /*<<parsing.ml:195:23>>*/ return st;
@@ -9602,16 +9604,16 @@
     }
     /*<<parsing.ml:198:19>>*/ }
    function symbol_end_pos(param){
-     /*<<parsing.ml:200:24>>*/ var _d_ = env[11];
-     /*<<parsing.ml:200:24>>*/ return caml_check_bound(env[4], _d_)[1 + _d_];
+     /*<<parsing.ml:200:24>>*/ var _c_ = env[11];
+     /*<<parsing.ml:200:24>>*/ return caml_check_bound(env[4], _c_)[1 + _c_];
     /*<<parsing.ml:200:52>>*/ }
    function rhs_start_pos(n){
-     /*<<parsing.ml:201:22>>*/ var _c_ = env[11] - (env[12] - n | 0) | 0;
-     /*<<parsing.ml:201:22>>*/ return caml_check_bound(env[3], _c_)[1 + _c_];
+     /*<<parsing.ml:201:22>>*/ var _b_ = env[11] - (env[12] - n | 0) | 0;
+     /*<<parsing.ml:201:22>>*/ return caml_check_bound(env[3], _b_)[1 + _b_];
     /*<<parsing.ml:201:73>>*/ }
    function rhs_end_pos(n){
-     /*<<parsing.ml:202:20>>*/ var _b_ = env[11] - (env[12] - n | 0) | 0;
-     /*<<parsing.ml:202:20>>*/ return caml_check_bound(env[4], _b_)[1 + _b_];
+     /*<<parsing.ml:202:20>>*/ var _a_ = env[11] - (env[12] - n | 0) | 0;
+     /*<<parsing.ml:202:20>>*/ return caml_check_bound(env[4], _a_)[1 + _a_];
     /*<<parsing.ml:202:69>>*/ }
    function symbol_start(param){
      /*<<parsing.ml:204:22>>*/ return symbol_start_pos(0)[4];
@@ -12006,6 +12008,7 @@
             : runtime.caml_call_gen(f, [a0, a1, a2, a3, a4]);
    }
    var
+    sentinal = undefined,
     global_data = runtime.caml_get_global_data(),
     Stdlib_Bytes = global_data.Stdlib__Bytes,
     Stdlib_Sys = global_data.Stdlib__Sys,
@@ -12013,7 +12016,6 @@
     Stdlib = global_data.Stdlib,
     Stdlib_String = global_data.Stdlib__String,
     Assert_failure = global_data.Assert_failure,
-    _b_ = undefined,
     cst_Buffer_truncate = "Buffer.truncate",
     _a_ = [0, "buffer.ml", 220, 9],
     cst_Buffer_add_channel = "Buffer.add_channel",
@@ -12102,7 +12104,7 @@
        /*<<buffer.ml:99:2>>*/  /*<<buffer.ml:99:2>>*/ caml_call5
        (Stdlib_Bytes[11], b[1][1], 0, new_buffer, 0, b[2]);
       b[1] = [0, new_buffer, new_len[1]];
-      return _b_;
+      return sentinal;
      }
      new_len[1] = 2 * new_len[1] | 0;
     }
@@ -12164,14 +12166,14 @@
     }
     /*<<buffer.ml:147:30>>*/ }
    function add_substring(b, s, offset, len){
-     /*<<buffer.ml:150:2>>*/ var _s_ = offset < 0 ? 1 : 0;
-    if(_s_)
-     var _t_ = _s_;
+     /*<<buffer.ml:150:2>>*/ var _r_ = offset < 0 ? 1 : 0;
+    if(_r_)
+     var _s_ = _r_;
     else
      var
-      _u_ = len < 0 ? 1 : 0,
-      _t_ = _u_ || ((caml_ml_string_length(s) - len | 0) < offset ? 1 : 0);
-    if(_t_)
+      _t_ = len < 0 ? 1 : 0,
+      _s_ = _t_ || ((caml_ml_string_length(s) - len | 0) < offset ? 1 : 0);
+    if(_s_)
       /*<<buffer.ml:151:7>>*/  /*<<buffer.ml:151:7>>*/ caml_call1
       (Stdlib[1], cst_Buffer_add_substring_add_s);
      /*<<buffer.ml:153:2>>*/ var
@@ -12226,9 +12228,9 @@
     /*<<buffer.ml:180:46>>*/ }
    function add_channel(b, ic, to_read$1){
      /*<<buffer.ml:206:2>>*/ var
-     _q_ = to_read$1 < 0 ? 1 : 0,
-     _r_ = _q_ || (Stdlib_Sys[12] < to_read$1 ? 1 : 0);
-    if(_r_)
+     _p_ = to_read$1 < 0 ? 1 : 0,
+     _q_ = _p_ || (Stdlib_Sys[12] < to_read$1 ? 1 : 0);
+    if(_q_)
       /*<<buffer.ml:207:4>>*/  /*<<buffer.ml:207:4>>*/ caml_call1
       (Stdlib[1], cst_Buffer_add_channel);
     if(b[1][2] < (b[2] + to_read$1 | 0))
@@ -12274,8 +12276,8 @@
      i$4 = 0;
      /*<<buffer.ml:262:4>>*/ for(;;){
      if(i$4 >= lim$1){
-      var _p_ = 92 === previous ? 1 : 0;
-      return _p_ ? add_char(b, previous) : _p_;
+      var _o_ = 92 === previous ? 1 : 0;
+      return _o_ ? add_char(b, previous) : _o_;
      }
       /*<<buffer.ml:263:12>>*/  /*<<buffer.ml:263:12>>*/ var
       previous$0 =  /*<<buffer.ml:263:12>>*/ caml_string_get(s, i$4);
@@ -12415,14 +12417,14 @@
       /*<<buffer.ml:298:14>>*/ var
        /*<<buffer.ml:298:14>>*/ x =
          /*<<buffer.ml:298:14>>*/ caml_bytes_get(b[1][1], i),
-       /*<<buffer.ml:298:14>>*/ _n_ = i + 1 | 0;
+       /*<<buffer.ml:298:14>>*/ _m_ = i + 1 | 0;
       /*<<buffer.ml:299:6>>*/ return [0,
              x,
-             function(_o_){ /*<<?>>*/ return aux(_n_, _o_);}];
+             function(_n_){ /*<<?>>*/ return aux(_m_, _n_);}];
      /*<<buffer.ml:299:29>>*/ }
-     /*<<buffer.ml:301:2>>*/  /*<<buffer.ml:301:2>>*/ var _l_ = 0;
-     /*<<buffer.ml:301:2>>*/ return function(_m_){
-      /*<<?>>*/ return aux(_l_, _m_);};
+     /*<<buffer.ml:301:2>>*/  /*<<buffer.ml:301:2>>*/ var _k_ = 0;
+     /*<<buffer.ml:301:2>>*/ return function(_l_){
+      /*<<?>>*/ return aux(_k_, _l_);};
     /*<<buffer.ml:301:7>>*/ }
    function to_seqi(b){
     function aux(i, param){
@@ -12431,21 +12433,21 @@
       /*<<buffer.ml:308:14>>*/ var
        /*<<buffer.ml:308:14>>*/ x =
          /*<<buffer.ml:308:14>>*/ caml_bytes_get(b[1][1], i),
-       /*<<buffer.ml:308:14>>*/ _j_ = i + 1 | 0;
+       /*<<buffer.ml:308:14>>*/ _i_ = i + 1 | 0;
       /*<<buffer.ml:309:6>>*/ return [0,
              [0, i, x],
-             function(_k_){ /*<<?>>*/ return aux(_j_, _k_);}];
+             function(_j_){ /*<<?>>*/ return aux(_i_, _j_);}];
      /*<<buffer.ml:309:33>>*/ }
-     /*<<buffer.ml:311:2>>*/  /*<<buffer.ml:311:2>>*/ var _h_ = 0;
-     /*<<buffer.ml:311:2>>*/ return function(_i_){
-      /*<<?>>*/ return aux(_h_, _i_);};
+     /*<<buffer.ml:311:2>>*/  /*<<buffer.ml:311:2>>*/ var _g_ = 0;
+     /*<<buffer.ml:311:2>>*/ return function(_h_){
+      /*<<?>>*/ return aux(_g_, _h_);};
     /*<<buffer.ml:311:7>>*/ }
    function add_seq(b, seq){
-     /*<<buffer.ml:313:29>>*/ function _f_(_g_){
-      /*<<?>>*/ return add_char(b, _g_);
+     /*<<buffer.ml:313:29>>*/ function _e_(_f_){
+      /*<<?>>*/ return add_char(b, _f_);
     }
      /*<<buffer.ml:313:20>>*/ return  /*<<buffer.ml:313:20>>*/ caml_call2
-            (Stdlib_Seq[4], _f_, seq);
+            (Stdlib_Seq[4], _e_, seq);
     /*<<buffer.ml:313:45>>*/ }
    function of_seq(i){
      /*<<buffer.ml:316:2>>*/  /*<<buffer.ml:316:10>>*/ var b = create(32);
@@ -12524,8 +12526,8 @@
     return 0;
     /*<<buffer.ml:378:28>>*/ }
    function add_int16_le(b, x){
-     /*<<buffer.ml:381:2>>*/ var _e_ = Stdlib_Sys[11] ? caml_bswap16(x) : x;
-    return add_int16_ne(b, _e_);
+     /*<<buffer.ml:381:2>>*/ var _d_ = Stdlib_Sys[11] ? caml_bswap16(x) : x;
+    return add_int16_ne(b, _d_);
     /*<<buffer.ml:381:57>>*/ }
    function add_int16_be(b, x){
      /*<<buffer.ml:384:2>>*/ var x$0 = Stdlib_Sys[11] ? x : caml_bswap16(x);
@@ -12533,8 +12535,8 @@
     /*<<buffer.ml:384:57>>*/ }
    function add_int32_le(b, x){
      /*<<buffer.ml:387:2>>*/ var
-     _d_ = Stdlib_Sys[11] ?  /*<<buffer.ml:387:41>>*/ caml_int32_bswap(x) : x;
-     /*<<buffer.ml:387:41>>*/ return add_int32_ne(b, _d_);
+     _c_ = Stdlib_Sys[11] ?  /*<<buffer.ml:387:41>>*/ caml_int32_bswap(x) : x;
+     /*<<buffer.ml:387:41>>*/ return add_int32_ne(b, _c_);
     /*<<buffer.ml:387:57>>*/ }
    function add_int32_be(b, x){
      /*<<buffer.ml:390:2>>*/ var
@@ -12543,8 +12545,8 @@
     /*<<buffer.ml:390:57>>*/ }
    function add_int64_le(b, x){
      /*<<buffer.ml:393:2>>*/ var
-     _c_ = Stdlib_Sys[11] ?  /*<<buffer.ml:393:41>>*/ caml_int64_bswap(x) : x;
-     /*<<buffer.ml:393:41>>*/ return add_int64_ne(b, _c_);
+     _b_ = Stdlib_Sys[11] ?  /*<<buffer.ml:393:41>>*/ caml_int64_bswap(x) : x;
+     /*<<buffer.ml:393:41>>*/ return add_int64_ne(b, _b_);
     /*<<buffer.ml:393:57>>*/ }
    function add_int64_be(b, x){
      /*<<buffer.ml:396:2>>*/ var
@@ -12785,7 +12787,7 @@
             : runtime.caml_call_gen(f, [a0, a1, a2, a3, a4]);
    }
    var
-    _a_ = undefined,
+    sentinal = undefined,
     global_data = runtime.caml_get_global_data(),
     Stdlib_Mutex = global_data.Stdlib__Mutex,
     Stdlib_Condition = global_data.Stdlib__Condition,
@@ -12805,7 +12807,7 @@
      /*<<domain.ml:59:4>>*/  /*<<domain.ml:59:13>>*/ var
      st =  /*<<domain.ml:59:13>>*/ caml_make_vect(8, unique_value);
      /*<<domain.ml:60:4>>*/  /*<<domain.ml:60:4>>*/ caml_domain_dls_set(st);
-     /*<<domain.ml:60:4>>*/ return _a_;
+     /*<<domain.ml:60:4>>*/ return sentinal;
     /*<<domain.ml:60:20>>*/ }
     /*<<domain.ml:62:10>>*/ create_dls(0);
     /*<<domain.ml:66:20>>*/ var
@@ -12894,7 +12896,7 @@
      /*<<domain.ml:147:27>>*/ first_spawn_function =
       [0,
        function(param){
-         /*<<domain.ml:147:42>>*/ return _a_;
+         /*<<domain.ml:147:42>>*/ return sentinal;
         /*<<domain.ml:147:44>>*/ }];
    function before_first_spawn(f){
      /*<<domain.ml:150:2>>*/ if
@@ -12915,7 +12917,7 @@
     at_exit_key =
       new_key
        (0,
-        function(param, _f_){
+        function(param, _e_){
           /*<<domain.ml:166:52>>*/ return 0;
          /*<<domain.ml:166:54>>*/ });
    function at_exit(f){
@@ -12950,8 +12952,8 @@
        /*<<domain.ml:163:41>>*/ };
     }
      /*<<domain.ml:124:6>>*/  /*<<domain.ml:124:6>>*/ var
-     _b_ =  /*<<domain.ml:124:6>>*/ caml_call1(Stdlib_Atomic[2], parent_keys);
-    function _c_(param){
+     _a_ =  /*<<domain.ml:124:6>>*/ caml_call1(Stdlib_Atomic[2], parent_keys);
+    function _b_(param){
       /*<<domain.ml:122:6>>*/ var split = param[2], k = param[1], idx = k[1];
       /*<<domain.ml:123:11>>*/ return [0,
              idx,
@@ -12959,7 +12961,7 @@
      /*<<domain.ml:123:43>>*/ }
      /*<<domain.ml:124:6>>*/ var
       /*<<domain.ml:124:6>>*/ pk =
-        /*<<domain.ml:124:6>>*/ caml_call2(Stdlib_List[19], _c_, _b_),
+        /*<<domain.ml:124:6>>*/ caml_call2(Stdlib_List[19], _b_, _a_),
       /*<<domain.ml:193:19>>*/ term_mutex =
         /*<<domain.ml:193:19>>*/ caml_call1(Stdlib_Mutex[1], 0),
       /*<<domain.ml:194:23>>*/ term_condition =
@@ -12971,7 +12973,7 @@
        /*<<domain.ml:198:4>>*/ try{
         /*<<domain.ml:200:8>>*/ create_dls(0);
        var
-        _d_ =
+        _c_ =
           function(param){
             /*<<domain.ml:128:6>>*/ var
             v = param[2],
@@ -12981,7 +12983,7 @@
             /*<<domain.ml:129:35>>*/ return 0;
            /*<<domain.ml:129:49>>*/ };
         /*<<domain.ml:127:4>>*/  /*<<domain.ml:127:4>>*/ caml_call2
-        (Stdlib_List[17], _d_, pk);
+        (Stdlib_List[17], _c_, pk);
         /*<<domain.ml:202:18>>*/  /*<<domain.ml:202:18>>*/ var
         res =  /*<<domain.ml:202:18>>*/ caml_call1(f, 0);
       }
@@ -12998,8 +13000,8 @@
      catch(ex){
        /*<<domain.ml:215:10>>*/ var
        ex$0 = caml_wrap_exception(ex),
-        /*<<domain.ml:215:10>>*/ _e_ = 0 === result[0] ? [1, ex$0] : result,
-       result$0 = _e_;
+        /*<<domain.ml:215:10>>*/ _d_ = 0 === result[0] ? [1, ex$0] : result,
+       result$0 = _d_;
      }
       /*<<domain.ml:230:4>>*/  /*<<domain.ml:230:4>>*/ caml_call1
       (Stdlib_Mutex[2], term_mutex);
@@ -13130,7 +13132,7 @@
             : runtime.caml_call_gen(f, [a0, a1, a2, a3, a4]);
    }
    var
-    _$_ = undefined,
+    sentinal = undefined,
     global_data = runtime.caml_get_global_data(),
     cst$9 = "%{",
     cst$10 = "%}",
@@ -13457,14 +13459,14 @@
      /*<<camlinternalFormat.ml:28:2>>*/ var
      str_ind = c >>> 3 | 0,
      mask = 1 << (c & 7),
-      /*<<camlinternalFormat.ml:31:30>>*/ _dT_ =
+      /*<<camlinternalFormat.ml:31:30>>*/ _dS_ =
         /*<<camlinternalFormat.ml:31:30>>*/ runtime.caml_bytes_get
         (char_set, str_ind)
        | mask;
      /*<<camlinternalFormat.ml:30:2>>*/ return  /*<<camlinternalFormat.ml:30:2>>*/ caml_bytes_set
             (char_set,
              str_ind,
-              /*<<camlinternalFormat.ml:31:4>>*/ caml_call1(Stdlib[29], _dT_));
+              /*<<camlinternalFormat.ml:31:4>>*/ caml_call1(Stdlib[29], _dS_));
     /*<<camlinternalFormat.ml:31:69>>*/ }
    function freeze_char_set(char_set){
      /*<<camlinternalFormat.ml:34:2>>*/ return  /*<<camlinternalFormat.ml:34:2>>*/ caml_call1
@@ -13476,19 +13478,19 @@
      i = 0;
     for(;;){
       /*<<camlinternalFormat.ml:41:32>>*/  /*<<camlinternalFormat.ml:41:32>>*/ var
-      _dR_ =
+      _dQ_ =
          /*<<camlinternalFormat.ml:41:32>>*/ caml_string_get(char_set, i)
         ^ 255;
       /*<<camlinternalFormat.ml:40:4>>*/  /*<<camlinternalFormat.ml:40:4>>*/ caml_bytes_set
       (char_set$0,
        i,
-        /*<<camlinternalFormat.ml:41:6>>*/ caml_call1(Stdlib[29], _dR_));
+        /*<<camlinternalFormat.ml:41:6>>*/ caml_call1(Stdlib[29], _dQ_));
       /*<<camlinternalFormat.ml:40:4>>*/  /*<<camlinternalFormat.ml:40:4>>*/ var
-      _dS_ = i + 1 | 0;
+      _dR_ = i + 1 | 0;
      if(31 === i)
        /*<<camlinternalFormat.ml:43:2>>*/ return  /*<<camlinternalFormat.ml:43:2>>*/ caml_call1
               (Stdlib_Bytes[44], char_set$0);
-     var i = _dS_;
+     var i = _dR_;
     }
     /*<<camlinternalFormat.ml:43:34>>*/ }
    function is_in_char_set(char_set, c){
@@ -13548,11 +13550,11 @@
       case 6:
        var prec_opt = ign[2], pad_opt$5 = ign[1];
        if(prec_opt)
-        var ndec = prec_opt[1], _dQ_ = [0, ndec];
+        var ndec = prec_opt[1], _dP_ = [0, ndec];
        else
-        var _dQ_ = 0;
+        var _dP_ = 0;
         /*<<camlinternalFormat.ml:97:4>>*/ return [0,
-               [8, _a_, pad_of_pad_opt(pad_opt$5), _dQ_, fmt]];
+               [8, _a_, pad_of_pad_opt(pad_opt$5), _dP_, fmt]];
       case 7:
        var pad_opt$6 = ign[1];
         /*<<camlinternalFormat.ml:101:4>>*/ return [0,
@@ -13597,14 +13599,14 @@
       (Stdlib_Bytes[11], buf[2], 0, new_str, 0, len);
      buf[2] = new_str;
     }
-    return _$_;
+    return sentinal;
     /*<<camlinternalFormat.ml:267:3>>*/ }
    function buffer_add_char(buf, c){
      /*<<camlinternalFormat.ml:271:2>>*/ buffer_check_size(buf, 1);
      /*<<camlinternalFormat.ml:272:2>>*/  /*<<camlinternalFormat.ml:272:2>>*/ caml_bytes_set
      (buf[2], buf[1], c);
     buf[1] = buf[1] + 1 | 0;
-    return _$_;
+    return sentinal;
     /*<<camlinternalFormat.ml:273:24>>*/ }
    function buffer_add_string(buf, s){
      /*<<camlinternalFormat.ml:277:2>>*/ var
@@ -13613,7 +13615,7 @@
      /*<<camlinternalFormat.ml:279:2>>*/  /*<<camlinternalFormat.ml:279:2>>*/ caml_call5
      (Stdlib_String[48], s, 0, buf[2], buf[1], str_len);
     buf[1] = buf[1] + str_len | 0;
-    return _$_;
+    return sentinal;
     /*<<camlinternalFormat.ml:280:30>>*/ }
    function buffer_contents(buf){
      /*<<camlinternalFormat.ml:284:2>>*/ return caml_call3
@@ -13670,64 +13672,64 @@
      /*<<camlinternalFormat.ml:374:29>>*/ switch(padty){
       case 0:
         /*<<camlinternalFormat.ml:375:13>>*/ buffer_add_char(buf, 45);
-        /*<<camlinternalFormat.ml:375:13>>*/ return _$_;
+        /*<<camlinternalFormat.ml:375:13>>*/ return sentinal;
       case 1:
-        /*<<camlinternalFormat.ml:376:13>>*/ return _$_;
+        /*<<camlinternalFormat.ml:376:13>>*/ return sentinal;
       default:
         /*<<camlinternalFormat.ml:377:13>>*/ buffer_add_char(buf, 48);
-        /*<<camlinternalFormat.ml:377:13>>*/ return _$_;
+        /*<<camlinternalFormat.ml:377:13>>*/ return sentinal;
     }
     /*<<camlinternalFormat.ml:377:36>>*/ }
    function bprint_ignored_flag(buf, ign_flag){
      /*<<camlinternalFormat.ml:381:2>>*/ return ign_flag
-            ? (buffer_add_char(buf, 95), _$_)
+            ? (buffer_add_char(buf, 95), sentinal)
             : ign_flag;
     /*<<camlinternalFormat.ml:381:42>>*/ }
    function bprint_pad_opt(buf, pad_opt){
      /*<<camlinternalFormat.ml:385:33>>*/ if(! pad_opt)
-      /*<<camlinternalFormat.ml:386:12>>*/ return _$_;
+      /*<<camlinternalFormat.ml:386:12>>*/ return sentinal;
     var width = pad_opt[1];
      /*<<camlinternalFormat.ml:387:40>>*/ buffer_add_string
      (buf,
        /*<<camlinternalFormat.ml:387:40>>*/ caml_call1(Stdlib_Int[12], width));
-     /*<<camlinternalFormat.ml:387:40>>*/ return _$_;
+     /*<<camlinternalFormat.ml:387:40>>*/ return sentinal;
     /*<<camlinternalFormat.ml:387:61>>*/ }
    function bprint_padding(buf, pad){
      /*<<camlinternalFormat.ml:393:15>>*/ if(typeof pad === "number")
-      /*<<camlinternalFormat.ml:394:18>>*/ return _$_;
+      /*<<camlinternalFormat.ml:394:18>>*/ return sentinal;
     if(0 === pad[0]){
      var n = pad[2], padty = pad[1];
       /*<<camlinternalFormat.ml:396:4>>*/ bprint_padty(buf, padty);
       /*<<camlinternalFormat.ml:397:26>>*/ buffer_add_string
       (buf,
         /*<<camlinternalFormat.ml:397:26>>*/ caml_call1(Stdlib_Int[12], n));
-      /*<<camlinternalFormat.ml:397:26>>*/ return _$_;
+      /*<<camlinternalFormat.ml:397:26>>*/ return sentinal;
     }
     var padty$0 = pad[1];
      /*<<camlinternalFormat.ml:399:4>>*/ bprint_padty(buf, padty$0);
      /*<<camlinternalFormat.ml:399:4>>*/ buffer_add_char(buf, 42);
-     /*<<camlinternalFormat.ml:399:4>>*/ return _$_;
+     /*<<camlinternalFormat.ml:399:4>>*/ return sentinal;
     /*<<camlinternalFormat.ml:400:27>>*/ }
    function bprint_precision(buf, prec){
      /*<<camlinternalFormat.ml:404:18>>*/ if(typeof prec === "number")
-     return prec ? (buffer_add_string(buf, cst), _$_) : _$_;
+     return prec ? (buffer_add_string(buf, cst), sentinal) : sentinal;
     var n = prec[1];
      /*<<camlinternalFormat.ml:407:4>>*/ buffer_add_char(buf, 46);
      /*<<camlinternalFormat.ml:408:26>>*/ buffer_add_string
      (buf,
        /*<<camlinternalFormat.ml:408:26>>*/ caml_call1(Stdlib_Int[12], n));
-     /*<<camlinternalFormat.ml:408:26>>*/ return _$_;
+     /*<<camlinternalFormat.ml:408:26>>*/ return sentinal;
     /*<<camlinternalFormat.ml:410:30>>*/ }
    function bprint_iconv_flag(buf, iconv){
      /*<<camlinternalFormat.ml:415:34>>*/ switch(iconv){
       case 1:
       case 4:
         /*<<camlinternalFormat.ml:416:23>>*/ buffer_add_char(buf, 43);
-        /*<<camlinternalFormat.ml:416:23>>*/ return _$_;
+        /*<<camlinternalFormat.ml:416:23>>*/ return sentinal;
       case 2:
       case 5:
         /*<<camlinternalFormat.ml:417:23>>*/ buffer_add_char(buf, 32);
-        /*<<camlinternalFormat.ml:417:23>>*/ return _$_;
+        /*<<camlinternalFormat.ml:417:23>>*/ return sentinal;
       case 7:
       case 9:
       case 11:
@@ -13735,8 +13737,8 @@
       case 14:
       case 15:
         /*<<camlinternalFormat.ml:419:6>>*/ buffer_add_char(buf, 35);
-        /*<<camlinternalFormat.ml:419:6>>*/ return _$_;
-      default:  /*<<camlinternalFormat.ml:420:53>>*/ return _$_;
+        /*<<camlinternalFormat.ml:419:6>>*/ return sentinal;
+      default:  /*<<camlinternalFormat.ml:420:53>>*/ return sentinal;
     }
     /*<<camlinternalFormat.ml:420:55>>*/ }
    function bprint_altint_fmt(buf, ign_flag, iconv, pad, prec, c){
@@ -13748,7 +13750,7 @@
      /*<<camlinternalFormat.ml:438:2>>*/ buffer_add_char(buf, c);
      /*<<camlinternalFormat.ml:439:22>>*/ buffer_add_char
      (buf, char_of_iconv(iconv));
-     /*<<camlinternalFormat.ml:439:22>>*/ return _$_;
+     /*<<camlinternalFormat.ml:439:22>>*/ return sentinal;
     /*<<camlinternalFormat.ml:439:43>>*/ }
    function bprint_fconv_flag(buf, fconv){
      /*<<camlinternalFormat.ml:445:2>>*/ switch(fconv[1]){
@@ -13757,7 +13759,7 @@
         /*<<camlinternalFormat.ml:446:20>>*/ buffer_add_char(buf, 43); break;
       default:  /*<<camlinternalFormat.ml:447:20>>*/ buffer_add_char(buf, 32);
     }
-    return 8 <= fconv[2] ? (buffer_add_char(buf, 35), _$_) : _$_;
+    return 8 <= fconv[2] ? (buffer_add_char(buf, 35), sentinal) : sentinal;
     /*<<camlinternalFormat.ml:452:37>>*/ }
    function string_of_formatting_lit(formatting_lit){
      /*<<camlinternalFormat.ml:465:46>>*/ if
@@ -13787,40 +13789,40 @@
       default:
         /*<<camlinternalFormat.ml:475:26>>*/ var
         c = formatting_lit[1],
-         /*<<camlinternalFormat.ml:475:26>>*/ _dP_ =
+         /*<<camlinternalFormat.ml:475:26>>*/ _dO_ =
            /*<<camlinternalFormat.ml:475:26>>*/ caml_call2
            (Stdlib_String[1], 1, c);
         /*<<camlinternalFormat.ml:475:26>>*/ return  /*<<camlinternalFormat.ml:475:26>>*/ caml_call2
-               (Stdlib[28], cst$7, _dP_);
+               (Stdlib[28], cst$7, _dO_);
     }
     /*<<camlinternalFormat.ml:475:43>>*/ }
    function bprint_char_literal(buf, chr){
      /*<<camlinternalFormat.ml:480:34>>*/ return 37 === chr
-            ? (buffer_add_string(buf, cst$8), _$_)
-            : (buffer_add_char(buf, chr), _$_);
+            ? (buffer_add_string(buf, cst$8), sentinal)
+            : (buffer_add_char(buf, chr), sentinal);
     /*<<camlinternalFormat.ml:482:32>>*/ }
    function bprint_string_literal(buf, str){
      /*<<camlinternalFormat.ml:486:2>>*/ var
-     _dN_ = caml_ml_string_length(str) - 1 | 0,
-      /*<<camlinternalFormat.ml:486:2>>*/ _dM_ = 0;
-    if(_dN_ >= 0){
-     var i = _dM_;
+     _dM_ = caml_ml_string_length(str) - 1 | 0,
+      /*<<camlinternalFormat.ml:486:2>>*/ _dL_ = 0;
+    if(_dM_ >= 0){
+     var i = _dL_;
      for(;;){
        /*<<camlinternalFormat.ml:487:4>>*/ bprint_char_literal
        (buf,  /*<<camlinternalFormat.ml:487:28>>*/ caml_string_get(str, i));
        /*<<camlinternalFormat.ml:487:4>>*/  /*<<camlinternalFormat.ml:487:4>>*/ var
-       _dO_ = i + 1 | 0;
-      if(_dN_ === i) break;
-      var i = _dO_;
+       _dN_ = i + 1 | 0;
+      if(_dM_ === i) break;
+      var i = _dN_;
      }
     }
-    return _$_;
+    return sentinal;
     /*<<camlinternalFormat.ml:488:6>>*/ }
    function bprint_fmtty(buf, fmtty){
      /*<<camlinternalFormat.ml:496:17>>*/ var fmtty$0 = fmtty;
      /*<<camlinternalFormat.ml:496:17>>*/ for(;;){
      if(typeof fmtty$0 === "number")
-       /*<<camlinternalFormat.ml:521:20>>*/ return _$_;
+       /*<<camlinternalFormat.ml:521:20>>*/ return sentinal;
      switch(fmtty$0[0]){
        case 0:
         var fmtty$1 = fmtty$0[1];
@@ -13918,7 +13920,7 @@
       ign_flag$0 = ign_flag;
       /*<<camlinternalFormat.ml:535:22>>*/ for(;;){
       if(typeof fmt$0 === "number")
-        /*<<camlinternalFormat.ml:636:23>>*/ return _$_;
+        /*<<camlinternalFormat.ml:636:23>>*/ return sentinal;
       switch(fmt$0[0]){
         case 0:
          var rest = fmt$0[1];
@@ -14122,11 +14124,17 @@
                  /*<<camlinternalFormat.ml:358:31>>*/ caml_call1
                  (Stdlib[29], i);
              return 37 === c
-                     ? (buffer_add_char(buf, 37), buffer_add_char(buf, 37), _$_)
+                     ? (buffer_add_char
+                        (buf, 37),
+                       buffer_add_char(buf, 37),
+                       sentinal)
                      : 64
                        === c
-                       ? (buffer_add_char(buf, 37), buffer_add_char(buf, 64), _$_)
-                       : (buffer_add_char(buf, c), _$_);
+                       ? (buffer_add_char
+                          (buf, 37),
+                         buffer_add_char(buf, 64),
+                         sentinal)
+                       : (buffer_add_char(buf, c), sentinal);
              /*<<camlinternalFormat.ml:361:35>>*/ };
           /*<<camlinternalFormat.ml:363:2>>*/ buffer_add_char(buf, 91);
           /*<<camlinternalFormat.ml:365:7>>*/ var
@@ -14144,18 +14152,18 @@
                 /*<<camlinternalFormat.ml:316:32>>*/ before =
                   /*<<camlinternalFormat.ml:316:32>>*/ caml_call1
                   (Stdlib_Char[1], c - 1 | 0),
-                /*<<camlinternalFormat.ml:317:6>>*/ _dI_ =
+                /*<<camlinternalFormat.ml:317:6>>*/ _dH_ =
                  is_in_char_set(set, c);
-               /*<<camlinternalFormat.ml:317:6>>*/ if(_dI_)
+               /*<<camlinternalFormat.ml:317:6>>*/ if(_dH_)
                 /*<<camlinternalFormat.ml:318:14>>*/ var
-                 /*<<camlinternalFormat.ml:318:14>>*/ _dJ_ =
+                 /*<<camlinternalFormat.ml:318:14>>*/ _dI_ =
                   is_in_char_set(set, before),
-                 /*<<camlinternalFormat.ml:318:14>>*/ _dK_ =
-                  _dJ_ ? is_in_char_set(set, after) : _dJ_,
-                _dL_ = 1 - _dK_;
+                 /*<<camlinternalFormat.ml:318:14>>*/ _dJ_ =
+                  _dI_ ? is_in_char_set(set, after) : _dI_,
+                _dK_ = 1 - _dJ_;
               else
-               var _dL_ = _dI_;
-               /*<<camlinternalFormat.ml:318:43>>*/ return _dL_;
+               var _dK_ = _dH_;
+               /*<<camlinternalFormat.ml:318:43>>*/ return _dK_;
               /*<<camlinternalFormat.ml:318:68>>*/ }
              return is_alone;
             },
@@ -14289,12 +14297,12 @@
           (buf, ign_flag$0);
          switch(counter){
            case 0:
-            var _dE_ = 108; break;
+            var _dD_ = 108; break;
            case 1:
-            var _dE_ = 110; break;
-           default: var _dE_ = 78;
+            var _dD_ = 110; break;
+           default: var _dD_ = 78;
          }
-          /*<<camlinternalFormat.ml:614:6>>*/ buffer_add_char(buf, _dE_);
+          /*<<camlinternalFormat.ml:614:6>>*/ buffer_add_char(buf, _dD_);
          var fmt$0 = rest$20, ign_flag$0 = 0;
          break;
         case 22:
@@ -14318,20 +14326,20 @@
           /*<<camlinternalFormat.ml:578:20>>*/ var
           rest$23 = fmt$0[3],
           arity = fmt$0[1],
-           /*<<camlinternalFormat.ml:578:20>>*/ _dG_ =
+           /*<<camlinternalFormat.ml:578:20>>*/ _dF_ =
             int_of_custom_arity(arity),
-          _dF_ = 1;
-         if(_dG_ >= 1){
-          var i$8 = _dF_;
+          _dE_ = 1;
+         if(_dF_ >= 1){
+          var i$8 = _dE_;
           for(;;){
             /*<<camlinternalFormat.ml:579:8>>*/ buffer_add_char(buf, 37);
             /*<<camlinternalFormat.ml:579:33>>*/ bprint_ignored_flag
             (buf, ign_flag$0);
             /*<<camlinternalFormat.ml:580:8>>*/ buffer_add_char(buf, 63);
             /*<<camlinternalFormat.ml:580:8>>*/  /*<<camlinternalFormat.ml:580:8>>*/ var
-            _dH_ = i$8 + 1 | 0;
-           if(_dG_ === i$8) break;
-           var i$8 = _dH_;
+            _dG_ = i$8 + 1 | 0;
+           if(_dF_ === i$8) break;
+           var i$8 = _dG_;
           }
          }
          var fmt$0 = rest$23, ign_flag$0 = 0;
@@ -14403,17 +14411,17 @@
          ed = match[3],
          af = match[2],
          fa = match[1],
-         _dj_ =
+         _di_ =
            function(param){
              /*<<camlinternalFormat.ml:698:17>>*/ af(0);
-             /*<<camlinternalFormat.ml:698:39>>*/ return _$_;
+             /*<<camlinternalFormat.ml:698:39>>*/ return sentinal;
             /*<<camlinternalFormat.ml:698:43>>*/ };
          /*<<camlinternalFormat.ml:697:4>>*/ return [0,
                 function(param){
                   /*<<camlinternalFormat.ml:697:17>>*/ fa(0);
-                  /*<<camlinternalFormat.ml:697:39>>*/ return _$_;
+                  /*<<camlinternalFormat.ml:697:39>>*/ return sentinal;
                  /*<<camlinternalFormat.ml:697:43>>*/ },
-                _dj_,
+                _di_,
                 ed,
                 de];
        case 1:
@@ -14424,17 +14432,17 @@
          ed$0 = match$0[3],
          af$0 = match$0[2],
          fa$0 = match$0[1],
-         _dk_ =
+         _dj_ =
            function(param){
              /*<<camlinternalFormat.ml:703:17>>*/ af$0(0);
-             /*<<camlinternalFormat.ml:703:39>>*/ return _$_;
+             /*<<camlinternalFormat.ml:703:39>>*/ return sentinal;
             /*<<camlinternalFormat.ml:703:43>>*/ };
          /*<<camlinternalFormat.ml:702:4>>*/ return [0,
                 function(param){
                   /*<<camlinternalFormat.ml:702:17>>*/ fa$0(0);
-                  /*<<camlinternalFormat.ml:702:39>>*/ return _$_;
+                  /*<<camlinternalFormat.ml:702:39>>*/ return sentinal;
                  /*<<camlinternalFormat.ml:702:43>>*/ },
-                _dk_,
+                _dj_,
                 ed$0,
                 de$0];
        case 2:
@@ -14445,17 +14453,17 @@
          ed$1 = match$1[3],
          af$1 = match$1[2],
          fa$1 = match$1[1],
-         _dl_ =
+         _dk_ =
            function(param){
              /*<<camlinternalFormat.ml:708:17>>*/ af$1(0);
-             /*<<camlinternalFormat.ml:708:39>>*/ return _$_;
+             /*<<camlinternalFormat.ml:708:39>>*/ return sentinal;
             /*<<camlinternalFormat.ml:708:43>>*/ };
          /*<<camlinternalFormat.ml:707:4>>*/ return [0,
                 function(param){
                   /*<<camlinternalFormat.ml:707:17>>*/ fa$1(0);
-                  /*<<camlinternalFormat.ml:707:39>>*/ return _$_;
+                  /*<<camlinternalFormat.ml:707:39>>*/ return sentinal;
                  /*<<camlinternalFormat.ml:707:43>>*/ },
-                _dl_,
+                _dk_,
                 ed$1,
                 de$1];
        case 3:
@@ -14466,17 +14474,17 @@
          ed$2 = match$2[3],
          af$2 = match$2[2],
          fa$2 = match$2[1],
-         _dm_ =
+         _dl_ =
            function(param){
              /*<<camlinternalFormat.ml:713:17>>*/ af$2(0);
-             /*<<camlinternalFormat.ml:713:39>>*/ return _$_;
+             /*<<camlinternalFormat.ml:713:39>>*/ return sentinal;
             /*<<camlinternalFormat.ml:713:43>>*/ };
          /*<<camlinternalFormat.ml:712:4>>*/ return [0,
                 function(param){
                   /*<<camlinternalFormat.ml:712:17>>*/ fa$2(0);
-                  /*<<camlinternalFormat.ml:712:39>>*/ return _$_;
+                  /*<<camlinternalFormat.ml:712:39>>*/ return sentinal;
                  /*<<camlinternalFormat.ml:712:43>>*/ },
-                _dm_,
+                _dl_,
                 ed$2,
                 de$2];
        case 4:
@@ -14487,17 +14495,17 @@
          ed$3 = match$3[3],
          af$3 = match$3[2],
          fa$3 = match$3[1],
-         _dn_ =
+         _dm_ =
            function(param){
              /*<<camlinternalFormat.ml:723:17>>*/ af$3(0);
-             /*<<camlinternalFormat.ml:723:39>>*/ return _$_;
+             /*<<camlinternalFormat.ml:723:39>>*/ return sentinal;
             /*<<camlinternalFormat.ml:723:43>>*/ };
          /*<<camlinternalFormat.ml:722:4>>*/ return [0,
                 function(param){
                   /*<<camlinternalFormat.ml:722:17>>*/ fa$3(0);
-                  /*<<camlinternalFormat.ml:722:39>>*/ return _$_;
+                  /*<<camlinternalFormat.ml:722:39>>*/ return sentinal;
                  /*<<camlinternalFormat.ml:722:43>>*/ },
-                _dn_,
+                _dm_,
                 ed$3,
                 de$3];
        case 5:
@@ -14508,17 +14516,17 @@
          ed$4 = match$4[3],
          af$4 = match$4[2],
          fa$4 = match$4[1],
-         _do_ =
+         _dn_ =
            function(param){
              /*<<camlinternalFormat.ml:718:17>>*/ af$4(0);
-             /*<<camlinternalFormat.ml:718:39>>*/ return _$_;
+             /*<<camlinternalFormat.ml:718:39>>*/ return sentinal;
             /*<<camlinternalFormat.ml:718:43>>*/ };
          /*<<camlinternalFormat.ml:717:4>>*/ return [0,
                 function(param){
                   /*<<camlinternalFormat.ml:717:17>>*/ fa$4(0);
-                  /*<<camlinternalFormat.ml:717:39>>*/ return _$_;
+                  /*<<camlinternalFormat.ml:717:39>>*/ return sentinal;
                  /*<<camlinternalFormat.ml:717:43>>*/ },
-                _do_,
+                _dn_,
                 ed$4,
                 de$4];
        case 6:
@@ -14529,17 +14537,17 @@
          ed$5 = match$5[3],
          af$5 = match$5[2],
          fa$5 = match$5[1],
-         _dp_ =
+         _do_ =
            function(param){
              /*<<camlinternalFormat.ml:728:17>>*/ af$5(0);
-             /*<<camlinternalFormat.ml:728:39>>*/ return _$_;
+             /*<<camlinternalFormat.ml:728:39>>*/ return sentinal;
             /*<<camlinternalFormat.ml:728:43>>*/ };
          /*<<camlinternalFormat.ml:727:4>>*/ return [0,
                 function(param){
                   /*<<camlinternalFormat.ml:727:17>>*/ fa$5(0);
-                  /*<<camlinternalFormat.ml:727:39>>*/ return _$_;
+                  /*<<camlinternalFormat.ml:727:39>>*/ return sentinal;
                  /*<<camlinternalFormat.ml:727:43>>*/ },
-                _dp_,
+                _do_,
                 ed$5,
                 de$5];
        case 7:
@@ -14550,17 +14558,17 @@
          ed$6 = match$6[3],
          af$6 = match$6[2],
          fa$6 = match$6[1],
-         _dq_ =
+         _dp_ =
            function(param){
              /*<<camlinternalFormat.ml:733:17>>*/ af$6(0);
-             /*<<camlinternalFormat.ml:733:39>>*/ return _$_;
+             /*<<camlinternalFormat.ml:733:39>>*/ return sentinal;
             /*<<camlinternalFormat.ml:733:43>>*/ };
          /*<<camlinternalFormat.ml:732:4>>*/ return [0,
                 function(param){
                   /*<<camlinternalFormat.ml:732:17>>*/ fa$6(0);
-                  /*<<camlinternalFormat.ml:732:39>>*/ return _$_;
+                  /*<<camlinternalFormat.ml:732:39>>*/ return sentinal;
                  /*<<camlinternalFormat.ml:732:43>>*/ },
-                _dq_,
+                _dp_,
                 ed$6,
                 de$6];
        case 8:
@@ -14571,17 +14579,17 @@
          ed$7 = match$7[3],
          af$7 = match$7[2],
          fa$7 = match$7[1],
-         _dr_ =
+         _dq_ =
            function(param){
              /*<<camlinternalFormat.ml:766:17>>*/ af$7(0);
-             /*<<camlinternalFormat.ml:766:39>>*/ return _$_;
+             /*<<camlinternalFormat.ml:766:39>>*/ return sentinal;
             /*<<camlinternalFormat.ml:766:43>>*/ };
          /*<<camlinternalFormat.ml:765:4>>*/ return [0,
                 function(param){
                   /*<<camlinternalFormat.ml:765:17>>*/ fa$7(0);
-                  /*<<camlinternalFormat.ml:765:39>>*/ return _$_;
+                  /*<<camlinternalFormat.ml:765:39>>*/ return sentinal;
                  /*<<camlinternalFormat.ml:765:43>>*/ },
-                _dr_,
+                _dq_,
                 ed$7,
                 de$7];
        case 9:
@@ -14600,33 +14608,33 @@
          dj = match$9[3],
          ga = match$9[2],
          ag = match$9[1],
-         _ds_ =
+         _dr_ =
            function(param){
              /*<<camlinternalFormat.ml:775:17>>*/ jd(0);
              /*<<camlinternalFormat.ml:775:50>>*/ de$8(0);
-             /*<<camlinternalFormat.ml:775:61>>*/ return _$_;
+             /*<<camlinternalFormat.ml:775:61>>*/ return sentinal;
             /*<<camlinternalFormat.ml:775:65>>*/ },
-         _dt_ =
+         _ds_ =
            function(param){
              /*<<camlinternalFormat.ml:774:17>>*/ ed$8(0);
              /*<<camlinternalFormat.ml:774:50>>*/ dj(0);
-             /*<<camlinternalFormat.ml:774:61>>*/ return _$_;
+             /*<<camlinternalFormat.ml:774:61>>*/ return sentinal;
             /*<<camlinternalFormat.ml:774:65>>*/ },
-         _du_ =
+         _dt_ =
            function(param){
              /*<<camlinternalFormat.ml:773:17>>*/ ga(0);
              /*<<camlinternalFormat.ml:773:50>>*/ af$8(0);
-             /*<<camlinternalFormat.ml:773:61>>*/ return _$_;
+             /*<<camlinternalFormat.ml:773:61>>*/ return sentinal;
             /*<<camlinternalFormat.ml:773:65>>*/ };
          /*<<camlinternalFormat.ml:772:4>>*/ return [0,
                 function(param){
                   /*<<camlinternalFormat.ml:772:17>>*/ fa$8(0);
                   /*<<camlinternalFormat.ml:772:50>>*/ ag(0);
-                  /*<<camlinternalFormat.ml:772:61>>*/ return _$_;
+                  /*<<camlinternalFormat.ml:772:61>>*/ return sentinal;
                  /*<<camlinternalFormat.ml:772:65>>*/ },
-                _du_,
                 _dt_,
-                _ds_];
+                _ds_,
+                _dr_];
        case 10:
          /*<<camlinternalFormat.ml:742:25>>*/ var
          rest$9 = param[1],
@@ -14636,17 +14644,17 @@
          ed$9 = match$10[3],
          af$9 = match$10[2],
          fa$9 = match$10[1],
-         _dv_ =
+         _du_ =
            function(param){
              /*<<camlinternalFormat.ml:744:17>>*/ af$9(0);
-             /*<<camlinternalFormat.ml:744:39>>*/ return _$_;
+             /*<<camlinternalFormat.ml:744:39>>*/ return sentinal;
             /*<<camlinternalFormat.ml:744:43>>*/ };
          /*<<camlinternalFormat.ml:743:4>>*/ return [0,
                 function(param){
                   /*<<camlinternalFormat.ml:743:17>>*/ fa$9(0);
-                  /*<<camlinternalFormat.ml:743:39>>*/ return _$_;
+                  /*<<camlinternalFormat.ml:743:39>>*/ return sentinal;
                  /*<<camlinternalFormat.ml:743:43>>*/ },
-                _dv_,
+                _du_,
                 ed$9,
                 de$9];
        case 11:
@@ -14658,17 +14666,17 @@
          ed$10 = match$11[3],
          af$10 = match$11[2],
          fa$10 = match$11[1],
-         _dw_ =
+         _dv_ =
            function(param){
              /*<<camlinternalFormat.ml:739:17>>*/ af$10(0);
-             /*<<camlinternalFormat.ml:739:39>>*/ return _$_;
+             /*<<camlinternalFormat.ml:739:39>>*/ return sentinal;
             /*<<camlinternalFormat.ml:739:43>>*/ };
          /*<<camlinternalFormat.ml:738:4>>*/ return [0,
                 function(param){
                   /*<<camlinternalFormat.ml:738:17>>*/ fa$10(0);
-                  /*<<camlinternalFormat.ml:738:39>>*/ return _$_;
+                  /*<<camlinternalFormat.ml:738:39>>*/ return sentinal;
                  /*<<camlinternalFormat.ml:738:43>>*/ },
-                _dw_,
+                _dv_,
                 ed$10,
                 de$10];
        case 12:
@@ -14680,17 +14688,17 @@
          ed$11 = match$12[3],
          af$11 = match$12[2],
          fa$11 = match$12[1],
-         _dx_ =
+         _dw_ =
            function(param){
              /*<<camlinternalFormat.ml:749:17>>*/ af$11(0);
-             /*<<camlinternalFormat.ml:749:39>>*/ return _$_;
+             /*<<camlinternalFormat.ml:749:39>>*/ return sentinal;
             /*<<camlinternalFormat.ml:749:43>>*/ };
          /*<<camlinternalFormat.ml:748:4>>*/ return [0,
                 function(param){
                   /*<<camlinternalFormat.ml:748:17>>*/ fa$11(0);
-                  /*<<camlinternalFormat.ml:748:39>>*/ return _$_;
+                  /*<<camlinternalFormat.ml:748:39>>*/ return sentinal;
                  /*<<camlinternalFormat.ml:748:43>>*/ },
-                _dx_,
+                _dw_,
                 ed$11,
                 de$11];
        case 13:
@@ -14702,29 +14710,29 @@
          ed$12 = match$13[3],
          af$12 = match$13[2],
          fa$12 = match$13[1],
-          /*<<camlinternalFormat.ml:753:4>>*/ _dy_ =
+          /*<<camlinternalFormat.ml:753:4>>*/ _dx_ =
            function(param){
              /*<<camlinternalFormat.ml:756:17>>*/ de$12(0);
-             /*<<camlinternalFormat.ml:756:39>>*/ return _$_;
+             /*<<camlinternalFormat.ml:756:39>>*/ return sentinal;
             /*<<camlinternalFormat.ml:756:43>>*/ },
-         _dz_ =
+         _dy_ =
            function(param){
              /*<<camlinternalFormat.ml:755:17>>*/ ed$12(0);
-             /*<<camlinternalFormat.ml:755:39>>*/ return _$_;
+             /*<<camlinternalFormat.ml:755:39>>*/ return sentinal;
             /*<<camlinternalFormat.ml:755:43>>*/ },
-         _dA_ =
+         _dz_ =
            function(param){
              /*<<camlinternalFormat.ml:754:17>>*/ af$12(0);
-             /*<<camlinternalFormat.ml:754:39>>*/ return _$_;
+             /*<<camlinternalFormat.ml:754:39>>*/ return sentinal;
             /*<<camlinternalFormat.ml:754:43>>*/ };
          /*<<camlinternalFormat.ml:753:4>>*/ return [0,
                 function(param){
                   /*<<camlinternalFormat.ml:753:17>>*/ fa$12(0);
-                  /*<<camlinternalFormat.ml:753:39>>*/ return _$_;
+                  /*<<camlinternalFormat.ml:753:39>>*/ return sentinal;
                  /*<<camlinternalFormat.ml:753:43>>*/ },
-                _dA_,
                 _dz_,
-                _dy_];
+                _dy_,
+                _dx_];
        default:
          /*<<camlinternalFormat.ml:758:25>>*/ var
          rest$13 = param[1],
@@ -14734,46 +14742,46 @@
          ed$13 = match$14[3],
          af$13 = match$14[2],
          fa$13 = match$14[1],
-          /*<<camlinternalFormat.ml:759:4>>*/ _dB_ =
+          /*<<camlinternalFormat.ml:759:4>>*/ _dA_ =
            function(param){
              /*<<camlinternalFormat.ml:762:17>>*/ de$13(0);
-             /*<<camlinternalFormat.ml:762:39>>*/ return _$_;
+             /*<<camlinternalFormat.ml:762:39>>*/ return sentinal;
             /*<<camlinternalFormat.ml:762:43>>*/ },
-         _dC_ =
+         _dB_ =
            function(param){
              /*<<camlinternalFormat.ml:761:17>>*/ ed$13(0);
-             /*<<camlinternalFormat.ml:761:39>>*/ return _$_;
+             /*<<camlinternalFormat.ml:761:39>>*/ return sentinal;
             /*<<camlinternalFormat.ml:761:43>>*/ },
-         _dD_ =
+         _dC_ =
            function(param){
              /*<<camlinternalFormat.ml:760:17>>*/ af$13(0);
-             /*<<camlinternalFormat.ml:760:39>>*/ return _$_;
+             /*<<camlinternalFormat.ml:760:39>>*/ return sentinal;
             /*<<camlinternalFormat.ml:760:43>>*/ };
          /*<<camlinternalFormat.ml:759:4>>*/ return [0,
                 function(param){
                   /*<<camlinternalFormat.ml:759:17>>*/ fa$13(0);
-                  /*<<camlinternalFormat.ml:759:39>>*/ return _$_;
+                  /*<<camlinternalFormat.ml:759:39>>*/ return sentinal;
                  /*<<camlinternalFormat.ml:759:43>>*/ },
-                _dD_,
                 _dC_,
-                _dB_];
+                _dB_,
+                _dA_];
      }
-     /*<<camlinternalFormat.ml:691:4>>*/ function _dg_(param){
-      /*<<camlinternalFormat.ml:694:17>>*/ return _$_;
+     /*<<camlinternalFormat.ml:691:4>>*/ function _df_(param){
+      /*<<camlinternalFormat.ml:694:17>>*/ return sentinal;
      /*<<camlinternalFormat.ml:694:21>>*/ }
-    function _dh_(param){
-      /*<<camlinternalFormat.ml:693:17>>*/ return _$_;
+    function _dg_(param){
+      /*<<camlinternalFormat.ml:693:17>>*/ return sentinal;
      /*<<camlinternalFormat.ml:693:21>>*/ }
-    function _di_(param){
-      /*<<camlinternalFormat.ml:692:17>>*/ return _$_;
+    function _dh_(param){
+      /*<<camlinternalFormat.ml:692:17>>*/ return sentinal;
      /*<<camlinternalFormat.ml:692:21>>*/ }
      /*<<camlinternalFormat.ml:691:4>>*/ return [0,
             function(param){
-              /*<<camlinternalFormat.ml:691:17>>*/ return _$_;
+              /*<<camlinternalFormat.ml:691:17>>*/ return sentinal;
              /*<<camlinternalFormat.ml:691:21>>*/ },
-            _di_,
             _dh_,
-            _dg_];
+            _dg_,
+            _df_];
     /*<<camlinternalFormat.ml:775:66>>*/ }
    function trans(ty1, ty2){
      /*<<camlinternalFormat.ml:803:17>>*/ a:
@@ -14992,11 +15000,11 @@
                     /*<<camlinternalFormat.ml:835:34>>*/ var
                     rest2$7 = ty2[2],
                     ty2$0 = ty2[1],
-                     /*<<camlinternalFormat.ml:835:34>>*/ _df_ =
+                     /*<<camlinternalFormat.ml:835:34>>*/ _de_ =
                       trans(rest1$7, rest2$7);
                     /*<<camlinternalFormat.ml:835:4>>*/ return [8,
                            trans(ty1$0, ty2$0),
-                           _df_];
+                           _de_];
                   case 10:
                    break a;
                   case 11:
@@ -15286,13 +15294,13 @@
          /*<<camlinternalFormat.ml:914:54>>*/ var
          rest$13 = fmtty$0[2],
          formatting_gen = fmtty$0[1],
-          /*<<camlinternalFormat.ml:914:54>>*/ _dc_ = fmtty_of_fmt(rest$13);
+          /*<<camlinternalFormat.ml:914:54>>*/ _db_ = fmtty_of_fmt(rest$13);
         if(0 === formatting_gen[0])
-         var fmt = formatting_gen[1][1], _dd_ = fmtty_of_fmt(fmt);
+         var fmt = formatting_gen[1][1], _dc_ = fmtty_of_fmt(fmt);
         else
-         var fmt$0 = formatting_gen[1][1], _dd_ = fmtty_of_fmt(fmt$0);
+         var fmt$0 = formatting_gen[1][1], _dc_ = fmtty_of_fmt(fmt$0);
          /*<<camlinternalFormat.ml:914:54>>*/ return  /*<<camlinternalFormat.ml:914:54>>*/ caml_call2
-                (CamlinternalFormatBasics[1], _dd_, _dc_);
+                (CamlinternalFormatBasics[1], _dc_, _db_);
        case 19:
         var rest$14 = fmtty$0[1];
          /*<<camlinternalFormat.ml:897:34>>*/ return [13,
@@ -15345,10 +15353,10 @@
            case 9:
              /*<<camlinternalFormat.ml:943:58>>*/ var
              fmtty$6 = ign[2],
-              /*<<camlinternalFormat.ml:943:58>>*/ _de_ =
+              /*<<camlinternalFormat.ml:943:58>>*/ _dd_ =
                fmtty_of_fmt(fmtty$5);
              /*<<camlinternalFormat.ml:943:58>>*/ return  /*<<camlinternalFormat.ml:943:58>>*/ caml_call2
-                    (CamlinternalFormatBasics[1], fmtty$6, _de_);
+                    (CamlinternalFormatBasics[1], fmtty$6, _dd_);
            case 10:
             var fmtty$0 = fmtty$5; break;
            default: var fmtty$0 = fmtty$5;
@@ -15404,11 +15412,11 @@
     /*<<camlinternalFormat.ml:996:54>>*/ }
    function type_format(fmt, fmtty){
      /*<<camlinternalFormat.ml:1008:19>>*/  /*<<camlinternalFormat.ml:1008:25>>*/ var
-     _db_ = type_format_gen(fmt, fmtty);
-    if(typeof _db_[2] !== "number")
+     _da_ = type_format_gen(fmt, fmtty);
+    if(typeof _da_[2] !== "number")
       /*<<camlinternalFormat.ml:1010:9>>*/ throw  /*<<camlinternalFormat.ml:1010:9>>*/ caml_maybe_attach_backtrace
             (Type_mismatch, 1);
-    var fmt$0 = _db_[1];
+    var fmt$0 = _da_[1];
      /*<<camlinternalFormat.ml:1009:42>>*/ return fmt$0;
     /*<<camlinternalFormat.ml:1010:28>>*/ }
    function type_ignored_param_one(ign, fmt, fmtty){
@@ -15693,7 +15701,7 @@
          fmt_rest$13 = fmt[3],
          sub_fmtty$1 = fmt[2],
          pad_opt$0 = fmt[1],
-          /*<<camlinternalFormat.ml:1099:42>>*/ _c$_ =
+          /*<<camlinternalFormat.ml:1099:42>>*/ _c__ =
            [0,
              /*<<camlinternalFormat.ml:1099:52>>*/ caml_call1
              (CamlinternalFormatBasics[2], sub_fmtty1)];
@@ -15702,7 +15710,7 @@
            ([0,
               /*<<camlinternalFormat.ml:1099:17>>*/ caml_call1
               (CamlinternalFormatBasics[2], sub_fmtty$1)],
-            _c$_))
+            _c__))
           /*<<camlinternalFormat.ml:1100:6>>*/ throw  /*<<camlinternalFormat.ml:1100:6>>*/ caml_maybe_attach_backtrace
                 (Type_mismatch, 1);
          /*<<camlinternalFormat.ml:1102:6>>*/ var
@@ -15872,12 +15880,12 @@
             /*<<camlinternalFormat.ml:1176:6>>*/ var
             sub_fmtty$3 = ign[2],
             pad_opt$2 = ign[1],
-             /*<<camlinternalFormat.ml:1176:6>>*/ _da_ =
+             /*<<camlinternalFormat.ml:1176:6>>*/ _c$_ =
               type_ignored_format_substituti(sub_fmtty$3, rest, fmtty0),
-            match$43 = _da_[2],
+            match$43 = _c$_[2],
             fmtty$21 = match$43[2],
             fmt$22 = match$43[1],
-            sub_fmtty$4 = _da_[1];
+            sub_fmtty$4 = _c$_[1];
             /*<<camlinternalFormat.ml:1177:4>>*/ return [0,
                    [23, [9, pad_opt$2, sub_fmtty$4], fmt$22],
                    fmtty$21];
@@ -16069,7 +16077,7 @@
          sub_fmtty_rest$17 = sub_fmtty[3],
          sub2_fmtty$2 = sub_fmtty[2],
          sub1_fmtty$0 = sub_fmtty[1],
-          /*<<camlinternalFormat.ml:1261:43>>*/ _c9_ =
+          /*<<camlinternalFormat.ml:1261:43>>*/ _c8_ =
            [0,
              /*<<camlinternalFormat.ml:1261:53>>*/ caml_call1
              (CamlinternalFormatBasics[2], sub1_fmtty)];
@@ -16078,11 +16086,11 @@
            ([0,
               /*<<camlinternalFormat.ml:1261:17>>*/ caml_call1
               (CamlinternalFormatBasics[2], sub1_fmtty$0)],
-            _c9_))
+            _c8_))
           /*<<camlinternalFormat.ml:1262:9>>*/ throw  /*<<camlinternalFormat.ml:1262:9>>*/ caml_maybe_attach_backtrace
                 (Type_mismatch, 1);
          /*<<camlinternalFormat.ml:1263:43>>*/  /*<<camlinternalFormat.ml:1263:43>>*/ var
-         _c__ =
+         _c9_ =
            [0,
              /*<<camlinternalFormat.ml:1263:53>>*/ caml_call1
              (CamlinternalFormatBasics[2], sub2_fmtty$1)];
@@ -16091,7 +16099,7 @@
            ([0,
               /*<<camlinternalFormat.ml:1263:17>>*/ caml_call1
               (CamlinternalFormatBasics[2], sub2_fmtty$2)],
-            _c__))
+            _c9_))
           /*<<camlinternalFormat.ml:1264:9>>*/ throw  /*<<camlinternalFormat.ml:1264:9>>*/ caml_maybe_attach_backtrace
                 (Type_mismatch, 1);
          /*<<camlinternalFormat.ml:1265:21>>*/ var
@@ -16183,11 +16191,11 @@
     /*<<camlinternalFormat.ml:1277:28>>*/ }
    function recast(fmt, fmtty){
      /*<<camlinternalFormat.ml:1312:2>>*/  /*<<camlinternalFormat.ml:1312:29>>*/ var
-     _c8_ = symm(fmtty);
+     _c7_ = symm(fmtty);
      /*<<camlinternalFormat.ml:1312:18>>*/ return type_format
             (fmt,
               /*<<camlinternalFormat.ml:1312:18>>*/ caml_call1
-              (CamlinternalFormatBasics[2], _c8_));
+              (CamlinternalFormatBasics[2], _c7_));
     /*<<camlinternalFormat.ml:1312:42>>*/ }
    function fix_padding(padty, width, str){
      /*<<camlinternalFormat.ml:1319:2>>*/ var
@@ -16197,10 +16205,10 @@
         /*<<camlinternalFormat.ml:1321:4>>*/ caml_call1(Stdlib[18], width);
     if(width$0 <= len)  /*<<camlinternalFormat.ml:1332:23>>*/ return str;
      /*<<camlinternalFormat.ml:1333:14>>*/ var
-     _c7_ = 2 === padty$0 ? 48 : 32,
+     _c6_ = 2 === padty$0 ? 48 : 32,
       /*<<camlinternalFormat.ml:1333:14>>*/ res =
         /*<<camlinternalFormat.ml:1333:14>>*/ caml_call2
-        (Stdlib_Bytes[1], width$0, _c7_);
+        (Stdlib_Bytes[1], width$0, _c6_);
      /*<<camlinternalFormat.ml:1334:4>>*/ switch(padty$0){
       case 0:
         /*<<camlinternalFormat.ml:1335:15>>*/  /*<<camlinternalFormat.ml:1335:15>>*/ caml_call5
@@ -16392,16 +16400,16 @@
       /*<<camlinternalFormat.ml:1447:9>>*/ return s;
      /*<<camlinternalFormat.ml:1428:14>>*/ var
       /*<<camlinternalFormat.ml:1428:14>>*/ n = [0, 0],
-     _c2_ = caml_ml_string_length(s) - 1 | 0,
-      /*<<camlinternalFormat.ml:1428:14>>*/ _c1_ = 0;
-    if(_c2_ >= 0){
-     var i$0 = _c1_;
+     _c1_ = caml_ml_string_length(s) - 1 | 0,
+      /*<<camlinternalFormat.ml:1428:14>>*/ _c0_ = 0;
+    if(_c1_ >= 0){
+     var i$0 = _c0_;
      for(;;){
       if(9 >= caml_string_unsafe_get(s, i$0) - 48 >>> 0) n[1]++;
        /*<<camlinternalFormat.ml:1429:6>>*/  /*<<camlinternalFormat.ml:1429:6>>*/ var
-       _c6_ = i$0 + 1 | 0;
-      if(_c2_ === i$0) break;
-      var i$0 = _c6_;
+       _c5_ = i$0 + 1 | 0;
+      if(_c1_ === i$0) break;
+      var i$0 = _c5_;
      }
     }
      /*<<camlinternalFormat.ml:1436:14>>*/ var
@@ -16414,15 +16422,15 @@
       /*<<camlinternalFormat.ml:1438:16>>*/  /*<<camlinternalFormat.ml:1438:16>>*/ caml_bytes_set
       (buf, pos[1], c);
      pos[1]++;
-     return _$_;
+     return sentinal;
      /*<<camlinternalFormat.ml:1438:46>>*/ }
      /*<<camlinternalFormat.ml:1439:15>>*/ var
       /*<<camlinternalFormat.ml:1439:15>>*/ left =
        [0, ((digits - 1 | 0) % 3 | 0) + 1 | 0],
-     _c4_ = caml_ml_string_length(s) - 1 | 0,
-      /*<<camlinternalFormat.ml:1439:15>>*/ _c3_ = 0;
-    if(_c4_ >= 0){
-     var i = _c3_;
+     _c3_ = caml_ml_string_length(s) - 1 | 0,
+      /*<<camlinternalFormat.ml:1439:15>>*/ _c2_ = 0;
+    if(_c3_ >= 0){
+     var i = _c2_;
      for(;;){
       var c = caml_string_unsafe_get(s, i);
       if(9 < c - 48 >>> 0)
@@ -16436,9 +16444,9 @@
         /*<<camlinternalFormat.ml:1443:61>>*/ put(c);
       }
        /*<<camlinternalFormat.ml:1440:4>>*/  /*<<camlinternalFormat.ml:1440:4>>*/ var
-       _c5_ = i + 1 | 0;
-      if(_c4_ === i) break;
-      var i = _c5_;
+       _c4_ = i + 1 | 0;
+      if(_c3_ === i) break;
+      var i = _c4_;
      }
     }
      /*<<camlinternalFormat.ml:1446:4>>*/ return  /*<<camlinternalFormat.ml:1446:4>>*/ caml_call1
@@ -16447,139 +16455,139 @@
    function convert_int(iconv, n){
      /*<<camlinternalFormat.ml:1451:2>>*/ switch(iconv){
       case 1:
-       var _c0_ = cst_d$0; break;
+       var _cZ_ = cst_d$0; break;
       case 2:
-       var _c0_ = cst_d$1; break;
+       var _cZ_ = cst_d$1; break;
       case 4:
-       var _c0_ = cst_i$1; break;
+       var _cZ_ = cst_i$1; break;
       case 5:
-       var _c0_ = cst_i$2; break;
+       var _cZ_ = cst_i$2; break;
       case 6:
-       var _c0_ = cst_x; break;
+       var _cZ_ = cst_x; break;
       case 7:
-       var _c0_ = cst_x$0; break;
+       var _cZ_ = cst_x$0; break;
       case 8:
-       var _c0_ = cst_X; break;
+       var _cZ_ = cst_X; break;
       case 9:
-       var _c0_ = cst_X$0; break;
+       var _cZ_ = cst_X$0; break;
       case 10:
-       var _c0_ = cst_o; break;
+       var _cZ_ = cst_o; break;
       case 11:
-       var _c0_ = cst_o$0; break;
+       var _cZ_ = cst_o$0; break;
       case 0:
       case 13:
-       var _c0_ = cst_d; break;
+       var _cZ_ = cst_d; break;
       case 3:
       case 14:
-       var _c0_ = cst_i$0; break;
-      default: var _c0_ = cst_u;
+       var _cZ_ = cst_i$0; break;
+      default: var _cZ_ = cst_u;
     }
      /*<<camlinternalFormat.ml:1451:26>>*/ return transform_int_alt
             (iconv,
-              /*<<camlinternalFormat.ml:1451:26>>*/ caml_format_int(_c0_, n));
+              /*<<camlinternalFormat.ml:1451:26>>*/ caml_format_int(_cZ_, n));
     /*<<camlinternalFormat.ml:1451:64>>*/ }
    function convert_int32(iconv, n){
      /*<<camlinternalFormat.ml:1453:2>>*/ switch(iconv){
       case 1:
-       var _cZ_ = cst_ld$0; break;
+       var _cY_ = cst_ld$0; break;
       case 2:
-       var _cZ_ = cst_ld$1; break;
+       var _cY_ = cst_ld$1; break;
       case 4:
-       var _cZ_ = cst_li$1; break;
+       var _cY_ = cst_li$1; break;
       case 5:
-       var _cZ_ = cst_li$2; break;
+       var _cY_ = cst_li$2; break;
       case 6:
-       var _cZ_ = cst_lx; break;
+       var _cY_ = cst_lx; break;
       case 7:
-       var _cZ_ = cst_lx$0; break;
+       var _cY_ = cst_lx$0; break;
       case 8:
-       var _cZ_ = cst_lX; break;
+       var _cY_ = cst_lX; break;
       case 9:
-       var _cZ_ = cst_lX$0; break;
+       var _cY_ = cst_lX$0; break;
       case 10:
-       var _cZ_ = cst_lo; break;
+       var _cY_ = cst_lo; break;
       case 11:
-       var _cZ_ = cst_lo$0; break;
+       var _cY_ = cst_lo$0; break;
       case 0:
       case 13:
-       var _cZ_ = cst_ld; break;
+       var _cY_ = cst_ld; break;
       case 3:
       case 14:
-       var _cZ_ = cst_li$0; break;
-      default: var _cZ_ = cst_lu;
+       var _cY_ = cst_li$0; break;
+      default: var _cY_ = cst_lu;
     }
      /*<<camlinternalFormat.ml:1453:26>>*/ return transform_int_alt
             (iconv,
-              /*<<camlinternalFormat.ml:1453:26>>*/ caml_format_int(_cZ_, n));
+              /*<<camlinternalFormat.ml:1453:26>>*/ caml_format_int(_cY_, n));
     /*<<camlinternalFormat.ml:1453:67>>*/ }
    function convert_nativeint(iconv, n){
      /*<<camlinternalFormat.ml:1455:2>>*/ switch(iconv){
       case 1:
-       var _cY_ = cst_nd$0; break;
+       var _cX_ = cst_nd$0; break;
       case 2:
-       var _cY_ = cst_nd$1; break;
+       var _cX_ = cst_nd$1; break;
       case 4:
-       var _cY_ = cst_ni$1; break;
+       var _cX_ = cst_ni$1; break;
       case 5:
-       var _cY_ = cst_ni$2; break;
+       var _cX_ = cst_ni$2; break;
       case 6:
-       var _cY_ = cst_nx; break;
+       var _cX_ = cst_nx; break;
       case 7:
-       var _cY_ = cst_nx$0; break;
+       var _cX_ = cst_nx$0; break;
       case 8:
-       var _cY_ = cst_nX; break;
+       var _cX_ = cst_nX; break;
       case 9:
-       var _cY_ = cst_nX$0; break;
+       var _cX_ = cst_nX$0; break;
       case 10:
-       var _cY_ = cst_no; break;
+       var _cX_ = cst_no; break;
       case 11:
-       var _cY_ = cst_no$0; break;
+       var _cX_ = cst_no$0; break;
       case 0:
       case 13:
-       var _cY_ = cst_nd; break;
+       var _cX_ = cst_nd; break;
       case 3:
       case 14:
-       var _cY_ = cst_ni$0; break;
-      default: var _cY_ = cst_nu;
+       var _cX_ = cst_ni$0; break;
+      default: var _cX_ = cst_nu;
     }
      /*<<camlinternalFormat.ml:1455:26>>*/ return transform_int_alt
             (iconv,
-              /*<<camlinternalFormat.ml:1455:26>>*/ caml_format_int(_cY_, n));
+              /*<<camlinternalFormat.ml:1455:26>>*/ caml_format_int(_cX_, n));
     /*<<camlinternalFormat.ml:1455:71>>*/ }
    function convert_int64(iconv, n){
      /*<<camlinternalFormat.ml:1457:2>>*/ switch(iconv){
       case 1:
-       var _cX_ = cst_Ld$0; break;
+       var _cW_ = cst_Ld$0; break;
       case 2:
-       var _cX_ = cst_Ld$1; break;
+       var _cW_ = cst_Ld$1; break;
       case 4:
-       var _cX_ = cst_Li$1; break;
+       var _cW_ = cst_Li$1; break;
       case 5:
-       var _cX_ = cst_Li$2; break;
+       var _cW_ = cst_Li$2; break;
       case 6:
-       var _cX_ = cst_Lx; break;
+       var _cW_ = cst_Lx; break;
       case 7:
-       var _cX_ = cst_Lx$0; break;
+       var _cW_ = cst_Lx$0; break;
       case 8:
-       var _cX_ = cst_LX; break;
+       var _cW_ = cst_LX; break;
       case 9:
-       var _cX_ = cst_LX$0; break;
+       var _cW_ = cst_LX$0; break;
       case 10:
-       var _cX_ = cst_Lo; break;
+       var _cW_ = cst_Lo; break;
       case 11:
-       var _cX_ = cst_Lo$0; break;
+       var _cW_ = cst_Lo$0; break;
       case 0:
       case 13:
-       var _cX_ = cst_Ld; break;
+       var _cW_ = cst_Ld; break;
       case 3:
       case 14:
-       var _cX_ = cst_Li$0; break;
-      default: var _cX_ = cst_Lu;
+       var _cW_ = cst_Li$0; break;
+      default: var _cW_ = cst_Lu;
     }
      /*<<camlinternalFormat.ml:1457:26>>*/ return transform_int_alt
             (iconv,
               /*<<camlinternalFormat.ml:1457:26>>*/ runtime.caml_int64_format
-              (_cX_, n));
+              (_cW_, n));
     /*<<camlinternalFormat.ml:1457:67>>*/ }
    function convert_float(fconv, prec, x){
     function hex(param){
@@ -16611,41 +16619,41 @@
         i = 0;
         /*<<camlinternalFormat.ml:1472:6>>*/ for(;;){
         if(i === len)
-         var _cU_ = 0;
+         var _cT_ = 0;
         else{
           /*<<camlinternalFormat.ml:1473:14>>*/  /*<<camlinternalFormat.ml:1473:14>>*/ var
-          _cT_ =
+          _cS_ =
              /*<<camlinternalFormat.ml:1473:14>>*/ caml_string_get(str, i)
             - 46
             | 0;
          a:
          {
-          if(23 < _cT_ >>> 0){
-           if(55 === _cT_) break a;
+          if(23 < _cS_ >>> 0){
+           if(55 === _cS_) break a;
           }
-          else if(21 < _cT_ - 1 >>> 0) break a;
+          else if(21 < _cS_ - 1 >>> 0) break a;
            /*<<camlinternalFormat.ml:1475:15>>*/ var
             /*<<camlinternalFormat.ml:1475:15>>*/ i$0 = i + 1 | 0,
            i = i$0;
           continue;
          }
-         var _cU_ = 1;
+         var _cT_ = 1;
         }
          /*<<camlinternalFormat.ml:1476:7>>*/  /*<<camlinternalFormat.ml:1476:7>>*/ var
-         _cV_ =
-           _cU_
+         _cU_ =
+           _cT_
             ? str
             :  /*<<camlinternalFormat.ml:1476:32>>*/ caml_call2
               (Stdlib[28], str, cst$17);
-         /*<<camlinternalFormat.ml:1487:21>>*/ return caml_special_val(_cV_);
+         /*<<camlinternalFormat.ml:1487:21>>*/ return caml_special_val(_cU_);
        }
       case 6:
         /*<<camlinternalFormat.ml:1482:15>>*/ return hex(0);
       case 7:
         /*<<camlinternalFormat.ml:1483:38>>*/  /*<<camlinternalFormat.ml:1483:38>>*/ var
-        _cW_ = hex(0);
+        _cV_ = hex(0);
         /*<<camlinternalFormat.ml:1483:38>>*/ return  /*<<camlinternalFormat.ml:1483:38>>*/ caml_call1
-               (Stdlib_String[25], _cW_);
+               (Stdlib_String[25], _cV_);
       case 8:
         /*<<camlinternalFormat.ml:1484:33>>*/ return caml_special_val(hex(0));
       default:
@@ -17030,12 +17038,12 @@
          /*<<camlinternalFormat.ml:1573:4>>*/ return function(param){
           /*<<camlinternalFormat.ml:1573:4>>*/ var
           fmt = param[1],
-           /*<<camlinternalFormat.ml:1574:18>>*/ _cS_ = recast(fmt, fmtty);
+           /*<<camlinternalFormat.ml:1574:18>>*/ _cR_ = recast(fmt, fmtty);
           /*<<camlinternalFormat.ml:1574:6>>*/ return make_printf
                  (k$0,
                   acc$0,
                    /*<<camlinternalFormat.ml:1574:6>>*/ caml_call2
-                   (CamlinternalFormatBasics[3], _cS_, rest$13)); /*<<camlinternalFormat.ml:1574:42>>*/ };
+                   (CamlinternalFormatBasics[3], _cR_, rest$13)); /*<<camlinternalFormat.ml:1574:42>>*/ };
        case 15:
         var rest$14 = fmt$0[1];
          /*<<camlinternalFormat.ml:1544:4>>*/ return function(f, x){
@@ -17062,11 +17070,11 @@
          fmt$0 = rest$16;
         break;
        case 18:
-        var _cQ_ = fmt$0[1];
-        if(0 === _cQ_[0])
+        var _cP_ = fmt$0[1];
+        if(0 === _cP_[0])
          var
           rest$17 = fmt$0[2],
-          fmt$1 = _cQ_[1][1],
+          fmt$1 = _cP_[1][1],
           k$3 =
             function(acc, k, rest){
              function k$0(kacc){
@@ -17082,7 +17090,7 @@
         else
          var
           rest$18 = fmt$0[2],
-          fmt$2 = _cQ_[1][1],
+          fmt$2 = _cP_[1][1],
           k$4 =
             function(acc, k, rest){
              function k$0(kacc){
@@ -17138,14 +17146,14 @@
          rest$23 = fmt$0[3],
          f = fmt$0[2],
          arity = fmt$0[1],
-          /*<<camlinternalFormat.ml:1548:33>>*/ _cR_ =
+          /*<<camlinternalFormat.ml:1548:33>>*/ _cQ_ =
             /*<<camlinternalFormat.ml:1548:33>>*/ caml_call1(f, 0);
          /*<<camlinternalFormat.ml:1548:33>>*/ if(counter >= 50)
           /*<<camlinternalFormat.ml:1548:33>>*/ return  /*<<camlinternalFormat.ml:1548:33>>*/ caml_trampoline_return
-                 (make_custom$0, [0, k$0, acc$0, rest$23, arity, _cR_]);
+                 (make_custom$0, [0, k$0, acc$0, rest$23, arity, _cQ_]);
         var counter$0 = counter + 1 | 0;
          /*<<camlinternalFormat.ml:1548:33>>*/ return make_custom$0
-                (counter$0, k$0, acc$0, rest$23, arity, _cR_);
+                (counter$0, k$0, acc$0, rest$23, arity, _cQ_);
      }
     }
     /*<<camlinternalFormat.ml:1605:9>>*/ }
@@ -17328,7 +17336,7 @@
                   fmt); /*<<camlinternalFormat.ml:1655:61>>*/ };
        case 10:
         var rest$9 = fmtty[1];
-         /*<<camlinternalFormat.ml:1646:31>>*/ return function(param, _cP_){
+         /*<<camlinternalFormat.ml:1646:31>>*/ return function(param, _cO_){
           /*<<camlinternalFormat.ml:1646:42>>*/ return make_from_fmtty
                  (k, acc, rest$9, fmt); /*<<camlinternalFormat.ml:1646:72>>*/ };
        case 11:
@@ -17357,13 +17365,13 @@
     /*<<camlinternalFormat.ml:1655:61>>*/ }
    function make_invalid_arg(counter, k, acc, fmt){
      /*<<camlinternalFormat.ml:1663:2>>*/  /*<<camlinternalFormat.ml:1663:16>>*/ var
-     _cO_ = [8, acc, cst_Printf_bad_conversion$0];
+     _cN_ = [8, acc, cst_Printf_bad_conversion$0];
      /*<<camlinternalFormat.ml:1663:2>>*/ if(counter >= 50)
       /*<<camlinternalFormat.ml:1663:2>>*/ return  /*<<camlinternalFormat.ml:1663:2>>*/ caml_trampoline_return
-             (make_printf$0, [0, k, _cO_, fmt]);
+             (make_printf$0, [0, k, _cN_, fmt]);
     var counter$0 = counter + 1 | 0;
      /*<<camlinternalFormat.ml:1663:2>>*/ return make_printf$0
-            (counter$0, k, _cO_, fmt);
+            (counter$0, k, _cN_, fmt);
     /*<<camlinternalFormat.ml:1663:72>>*/ }
    function make_custom$0(counter, k, acc, rest, arity, f){
      /*<<camlinternalFormat.ml:1778:28>>*/ if(arity){
@@ -17377,13 +17385,13 @@
                 /*<<camlinternalFormat.ml:1782:35>>*/ caml_call1(f, x)); /*<<camlinternalFormat.ml:1782:40>>*/ };
     }
      /*<<camlinternalFormat.ml:1779:33>>*/  /*<<camlinternalFormat.ml:1779:33>>*/ var
-     _cN_ = [4, acc, f];
+     _cM_ = [4, acc, f];
      /*<<camlinternalFormat.ml:1779:19>>*/ if(counter >= 50)
       /*<<camlinternalFormat.ml:1779:19>>*/ return  /*<<camlinternalFormat.ml:1779:19>>*/ caml_trampoline_return
-             (make_printf$0, [0, k, _cN_, rest]);
+             (make_printf$0, [0, k, _cM_, rest]);
     var counter$0 = counter + 1 | 0;
      /*<<camlinternalFormat.ml:1779:19>>*/ return make_printf$0
-            (counter$0, k, _cN_, rest);
+            (counter$0, k, _cM_, rest);
     /*<<camlinternalFormat.ml:1782:40>>*/ }
    function make_printf(k, acc, fmt){
      /*<<?>>*/ return caml_trampoline(make_printf$0(0, k, acc, fmt));
@@ -17404,68 +17412,68 @@
      /*<<camlinternalFormat.ml:1863:26>>*/ if(typeof pad === "number"){
      if(typeof prec !== "number"){
        /*<<camlinternalFormat.ml:1867:14>>*/  /*<<camlinternalFormat.ml:1867:14>>*/ var
-       _cm_ = make_iprintf(k, o, fmt);
-       /*<<camlinternalFormat.ml:1867:14>>*/ return function(_cM_){
-        /*<<?>>*/ return _cm_;};
+       _cl_ = make_iprintf(k, o, fmt);
+       /*<<camlinternalFormat.ml:1867:14>>*/ return function(_cL_){
+        /*<<?>>*/ return _cl_;};
      }
      if(prec){
        /*<<camlinternalFormat.ml:1869:21>>*/ var
-        /*<<camlinternalFormat.ml:1869:21>>*/ _cj_ = make_iprintf(k, o, fmt),
-        /*<<camlinternalFormat.ml:1869:14>>*/ _ck_ =
-         function(_cL_){ /*<<?>>*/ return _cj_;};
-       /*<<camlinternalFormat.ml:1869:14>>*/ return function(_cK_){
-        /*<<?>>*/ return _ck_;};
+        /*<<camlinternalFormat.ml:1869:21>>*/ _ci_ = make_iprintf(k, o, fmt),
+        /*<<camlinternalFormat.ml:1869:14>>*/ _cj_ =
+         function(_cK_){ /*<<?>>*/ return _ci_;};
+       /*<<camlinternalFormat.ml:1869:14>>*/ return function(_cJ_){
+        /*<<?>>*/ return _cj_;};
      }
       /*<<camlinternalFormat.ml:1865:14>>*/  /*<<camlinternalFormat.ml:1865:14>>*/ var
-      _cl_ = make_iprintf(k, o, fmt);
-      /*<<camlinternalFormat.ml:1865:14>>*/ return function(_cJ_){
-       /*<<?>>*/ return _cl_;};
+      _ck_ = make_iprintf(k, o, fmt);
+      /*<<camlinternalFormat.ml:1865:14>>*/ return function(_cI_){
+       /*<<?>>*/ return _ck_;};
     }
     if(0 === pad[0]){
      if(typeof prec !== "number"){
        /*<<camlinternalFormat.ml:1873:14>>*/  /*<<camlinternalFormat.ml:1873:14>>*/ var
-       _cq_ = make_iprintf(k, o, fmt);
-       /*<<camlinternalFormat.ml:1873:14>>*/ return function(_cI_){
-        /*<<?>>*/ return _cq_;};
+       _cp_ = make_iprintf(k, o, fmt);
+       /*<<camlinternalFormat.ml:1873:14>>*/ return function(_cH_){
+        /*<<?>>*/ return _cp_;};
      }
      if(prec){
        /*<<camlinternalFormat.ml:1875:21>>*/ var
-        /*<<camlinternalFormat.ml:1875:21>>*/ _cn_ = make_iprintf(k, o, fmt),
-        /*<<camlinternalFormat.ml:1875:14>>*/ _co_ =
-         function(_cH_){ /*<<?>>*/ return _cn_;};
-       /*<<camlinternalFormat.ml:1875:14>>*/ return function(_cG_){
-        /*<<?>>*/ return _co_;};
+        /*<<camlinternalFormat.ml:1875:21>>*/ _cm_ = make_iprintf(k, o, fmt),
+        /*<<camlinternalFormat.ml:1875:14>>*/ _cn_ =
+         function(_cG_){ /*<<?>>*/ return _cm_;};
+       /*<<camlinternalFormat.ml:1875:14>>*/ return function(_cF_){
+        /*<<?>>*/ return _cn_;};
      }
       /*<<camlinternalFormat.ml:1871:14>>*/  /*<<camlinternalFormat.ml:1871:14>>*/ var
-      _cp_ = make_iprintf(k, o, fmt);
-      /*<<camlinternalFormat.ml:1871:14>>*/ return function(_cF_){
-       /*<<?>>*/ return _cp_;};
+      _co_ = make_iprintf(k, o, fmt);
+      /*<<camlinternalFormat.ml:1871:14>>*/ return function(_cE_){
+       /*<<?>>*/ return _co_;};
     }
     if(typeof prec !== "number"){
       /*<<camlinternalFormat.ml:1879:21>>*/ var
-       /*<<camlinternalFormat.ml:1879:21>>*/ _cw_ = make_iprintf(k, o, fmt),
-       /*<<camlinternalFormat.ml:1879:14>>*/ _cx_ =
-        function(_cE_){ /*<<?>>*/ return _cw_;};
-      /*<<camlinternalFormat.ml:1879:14>>*/ return function(_cD_){
-       /*<<?>>*/ return _cx_;};
+       /*<<camlinternalFormat.ml:1879:21>>*/ _cv_ = make_iprintf(k, o, fmt),
+       /*<<camlinternalFormat.ml:1879:14>>*/ _cw_ =
+        function(_cD_){ /*<<?>>*/ return _cv_;};
+      /*<<camlinternalFormat.ml:1879:14>>*/ return function(_cC_){
+       /*<<?>>*/ return _cw_;};
     }
     if(prec){
       /*<<camlinternalFormat.ml:1881:28>>*/ var
-       /*<<camlinternalFormat.ml:1881:28>>*/ _cr_ = make_iprintf(k, o, fmt),
-       /*<<camlinternalFormat.ml:1881:21>>*/ _cs_ =
-        function(_cC_){ /*<<?>>*/ return _cr_;},
-       /*<<camlinternalFormat.ml:1881:14>>*/ _ct_ =
-        function(_cB_){ /*<<?>>*/ return _cs_;};
-      /*<<camlinternalFormat.ml:1881:14>>*/ return function(_cA_){
-       /*<<?>>*/ return _ct_;};
+       /*<<camlinternalFormat.ml:1881:28>>*/ _cq_ = make_iprintf(k, o, fmt),
+       /*<<camlinternalFormat.ml:1881:21>>*/ _cr_ =
+        function(_cB_){ /*<<?>>*/ return _cq_;},
+       /*<<camlinternalFormat.ml:1881:14>>*/ _cs_ =
+        function(_cA_){ /*<<?>>*/ return _cr_;};
+      /*<<camlinternalFormat.ml:1881:14>>*/ return function(_cz_){
+       /*<<?>>*/ return _cs_;};
     }
      /*<<camlinternalFormat.ml:1877:21>>*/  /*<<camlinternalFormat.ml:1877:21>>*/ var
-     _cu_ = make_iprintf(k, o, fmt);
-     /*<<camlinternalFormat.ml:1877:14>>*/ function _cv_(_cz_){
-      /*<<?>>*/ return _cu_;
+     _ct_ = make_iprintf(k, o, fmt);
+     /*<<camlinternalFormat.ml:1877:14>>*/ function _cu_(_cy_){
+      /*<<?>>*/ return _ct_;
     }
-     /*<<camlinternalFormat.ml:1877:14>>*/ return function(_cy_){
-      /*<<?>>*/ return _cv_;};
+     /*<<camlinternalFormat.ml:1877:14>>*/ return function(_cx_){
+      /*<<?>>*/ return _cu_;};
     /*<<camlinternalFormat.ml:1881:52>>*/ }
    function make_iprintf$0(counter, k, o, fmt){
      /*<<camlinternalFormat.ml:1788:17>>*/ var k$0 = k, fmt$0 = fmt;
@@ -17477,69 +17485,69 @@
        case 0:
          /*<<camlinternalFormat.ml:1790:14>>*/ var
          rest = fmt$0[1],
-          /*<<camlinternalFormat.ml:1790:14>>*/ _bz_ =
+          /*<<camlinternalFormat.ml:1790:14>>*/ _by_ =
            make_iprintf(k$0, o, rest);
-         /*<<camlinternalFormat.ml:1790:14>>*/ return function(_ci_){
-          /*<<?>>*/ return _bz_;};
+         /*<<camlinternalFormat.ml:1790:14>>*/ return function(_ch_){
+          /*<<?>>*/ return _by_;};
        case 1:
          /*<<camlinternalFormat.ml:1792:14>>*/ var
          rest$0 = fmt$0[1],
-          /*<<camlinternalFormat.ml:1792:14>>*/ _bA_ =
+          /*<<camlinternalFormat.ml:1792:14>>*/ _bz_ =
            make_iprintf(k$0, o, rest$0);
-         /*<<camlinternalFormat.ml:1792:14>>*/ return function(_ch_){
-          /*<<?>>*/ return _bA_;};
+         /*<<camlinternalFormat.ml:1792:14>>*/ return function(_cg_){
+          /*<<?>>*/ return _bz_;};
        case 2:
-        var _bB_ = fmt$0[1];
-        if(typeof _bB_ === "number"){
+        var _bA_ = fmt$0[1];
+        if(typeof _bA_ === "number"){
           /*<<camlinternalFormat.ml:1794:14>>*/ var
           rest$1 = fmt$0[2],
-           /*<<camlinternalFormat.ml:1794:14>>*/ _bC_ =
+           /*<<camlinternalFormat.ml:1794:14>>*/ _bB_ =
             make_iprintf(k$0, o, rest$1);
-          /*<<camlinternalFormat.ml:1794:14>>*/ return function(_cg_){
-           /*<<?>>*/ return _bC_;};
+          /*<<camlinternalFormat.ml:1794:14>>*/ return function(_cf_){
+           /*<<?>>*/ return _bB_;};
         }
-        if(0 === _bB_[0]){
+        if(0 === _bA_[0]){
           /*<<camlinternalFormat.ml:1796:14>>*/ var
           rest$2 = fmt$0[2],
-           /*<<camlinternalFormat.ml:1796:14>>*/ _bD_ =
+           /*<<camlinternalFormat.ml:1796:14>>*/ _bC_ =
             make_iprintf(k$0, o, rest$2);
-          /*<<camlinternalFormat.ml:1796:14>>*/ return function(_cf_){
-           /*<<?>>*/ return _bD_;};
+          /*<<camlinternalFormat.ml:1796:14>>*/ return function(_ce_){
+           /*<<?>>*/ return _bC_;};
         }
          /*<<camlinternalFormat.ml:1798:21>>*/ var
          rest$3 = fmt$0[2],
-          /*<<camlinternalFormat.ml:1798:21>>*/ _bE_ =
+          /*<<camlinternalFormat.ml:1798:21>>*/ _bD_ =
            make_iprintf(k$0, o, rest$3),
-          /*<<camlinternalFormat.ml:1798:14>>*/ _bF_ =
-           function(_ce_){ /*<<?>>*/ return _bE_;};
-         /*<<camlinternalFormat.ml:1798:14>>*/ return function(_cd_){
-          /*<<?>>*/ return _bF_;};
+          /*<<camlinternalFormat.ml:1798:14>>*/ _bE_ =
+           function(_cd_){ /*<<?>>*/ return _bD_;};
+         /*<<camlinternalFormat.ml:1798:14>>*/ return function(_cc_){
+          /*<<?>>*/ return _bE_;};
        case 3:
-        var _bG_ = fmt$0[1];
-        if(typeof _bG_ === "number"){
+        var _bF_ = fmt$0[1];
+        if(typeof _bF_ === "number"){
           /*<<camlinternalFormat.ml:1800:14>>*/ var
           rest$4 = fmt$0[2],
-           /*<<camlinternalFormat.ml:1800:14>>*/ _bH_ =
+           /*<<camlinternalFormat.ml:1800:14>>*/ _bG_ =
             make_iprintf(k$0, o, rest$4);
-          /*<<camlinternalFormat.ml:1800:14>>*/ return function(_cc_){
-           /*<<?>>*/ return _bH_;};
+          /*<<camlinternalFormat.ml:1800:14>>*/ return function(_cb_){
+           /*<<?>>*/ return _bG_;};
         }
-        if(0 === _bG_[0]){
+        if(0 === _bF_[0]){
           /*<<camlinternalFormat.ml:1802:14>>*/ var
           rest$5 = fmt$0[2],
-           /*<<camlinternalFormat.ml:1802:14>>*/ _bI_ =
+           /*<<camlinternalFormat.ml:1802:14>>*/ _bH_ =
             make_iprintf(k$0, o, rest$5);
-          /*<<camlinternalFormat.ml:1802:14>>*/ return function(_cb_){
-           /*<<?>>*/ return _bI_;};
+          /*<<camlinternalFormat.ml:1802:14>>*/ return function(_ca_){
+           /*<<?>>*/ return _bH_;};
         }
          /*<<camlinternalFormat.ml:1804:21>>*/ var
          rest$6 = fmt$0[2],
-          /*<<camlinternalFormat.ml:1804:21>>*/ _bJ_ =
+          /*<<camlinternalFormat.ml:1804:21>>*/ _bI_ =
            make_iprintf(k$0, o, rest$6),
-          /*<<camlinternalFormat.ml:1804:14>>*/ _bK_ =
-           function(_ca_){ /*<<?>>*/ return _bJ_;};
-         /*<<camlinternalFormat.ml:1804:14>>*/ return function(_b$_){
-          /*<<?>>*/ return _bK_;};
+          /*<<camlinternalFormat.ml:1804:14>>*/ _bJ_ =
+           function(_b$_){ /*<<?>>*/ return _bI_;};
+         /*<<camlinternalFormat.ml:1804:14>>*/ return function(_b__){
+          /*<<?>>*/ return _bJ_;};
        case 4:
         var rest$7 = fmt$0[4], prec = fmt$0[3], pad = fmt$0[2];
          /*<<camlinternalFormat.ml:1806:8>>*/ return fn_of_padding_precision
@@ -17561,31 +17569,31 @@
          /*<<camlinternalFormat.ml:1814:8>>*/ return fn_of_padding_precision
                 (k$0, o, rest$11, pad$3, prec$3);
        case 9:
-        var _bL_ = fmt$0[1];
-        if(typeof _bL_ === "number"){
+        var _bK_ = fmt$0[1];
+        if(typeof _bK_ === "number"){
           /*<<camlinternalFormat.ml:1816:14>>*/ var
           rest$12 = fmt$0[2],
-           /*<<camlinternalFormat.ml:1816:14>>*/ _bM_ =
+           /*<<camlinternalFormat.ml:1816:14>>*/ _bL_ =
             make_iprintf(k$0, o, rest$12);
-          /*<<camlinternalFormat.ml:1816:14>>*/ return function(_b__){
-           /*<<?>>*/ return _bM_;};
+          /*<<camlinternalFormat.ml:1816:14>>*/ return function(_b9_){
+           /*<<?>>*/ return _bL_;};
         }
-        if(0 === _bL_[0]){
+        if(0 === _bK_[0]){
           /*<<camlinternalFormat.ml:1818:14>>*/ var
           rest$13 = fmt$0[2],
-           /*<<camlinternalFormat.ml:1818:14>>*/ _bN_ =
+           /*<<camlinternalFormat.ml:1818:14>>*/ _bM_ =
             make_iprintf(k$0, o, rest$13);
-          /*<<camlinternalFormat.ml:1818:14>>*/ return function(_b9_){
-           /*<<?>>*/ return _bN_;};
+          /*<<camlinternalFormat.ml:1818:14>>*/ return function(_b8_){
+           /*<<?>>*/ return _bM_;};
         }
          /*<<camlinternalFormat.ml:1820:21>>*/ var
          rest$14 = fmt$0[2],
-          /*<<camlinternalFormat.ml:1820:21>>*/ _bO_ =
+          /*<<camlinternalFormat.ml:1820:21>>*/ _bN_ =
            make_iprintf(k$0, o, rest$14),
-          /*<<camlinternalFormat.ml:1820:14>>*/ _bP_ =
-           function(_b8_){ /*<<?>>*/ return _bO_;};
-         /*<<camlinternalFormat.ml:1820:14>>*/ return function(_b7_){
-          /*<<?>>*/ return _bP_;};
+          /*<<camlinternalFormat.ml:1820:14>>*/ _bO_ =
+           function(_b7_){ /*<<?>>*/ return _bN_;};
+         /*<<camlinternalFormat.ml:1820:14>>*/ return function(_b6_){
+          /*<<?>>*/ return _bO_;};
        case 10:
         var rest$15 = fmt$0[1], fmt$0 = rest$15; break;
        case 11:
@@ -17595,45 +17603,45 @@
        case 13:
          /*<<camlinternalFormat.ml:1838:14>>*/ var
          rest$18 = fmt$0[3],
-          /*<<camlinternalFormat.ml:1838:14>>*/ _bQ_ =
+          /*<<camlinternalFormat.ml:1838:14>>*/ _bP_ =
            make_iprintf(k$0, o, rest$18);
-         /*<<camlinternalFormat.ml:1838:14>>*/ return function(_b6_){
-          /*<<?>>*/ return _bQ_;};
+         /*<<camlinternalFormat.ml:1838:14>>*/ return function(_b5_){
+          /*<<?>>*/ return _bP_;};
        case 14:
         var rest$19 = fmt$0[3], fmtty = fmt$0[2];
          /*<<camlinternalFormat.ml:1840:8>>*/ return function(param){
           /*<<camlinternalFormat.ml:1840:8>>*/ var
           fmt = param[1],
-           /*<<camlinternalFormat.ml:1842:24>>*/ _b5_ = recast(fmt, fmtty);
+           /*<<camlinternalFormat.ml:1842:24>>*/ _b4_ = recast(fmt, fmtty);
           /*<<camlinternalFormat.ml:1842:12>>*/ return make_iprintf
                  (k$0,
                   o,
                    /*<<camlinternalFormat.ml:1842:12>>*/ caml_call2
-                   (CamlinternalFormatBasics[3], _b5_, rest$19)); /*<<camlinternalFormat.ml:1842:48>>*/ };
+                   (CamlinternalFormatBasics[3], _b4_, rest$19)); /*<<camlinternalFormat.ml:1842:48>>*/ };
        case 15:
          /*<<camlinternalFormat.ml:1822:21>>*/ var
          rest$20 = fmt$0[1],
-          /*<<camlinternalFormat.ml:1822:21>>*/ _bR_ =
+          /*<<camlinternalFormat.ml:1822:21>>*/ _bQ_ =
            make_iprintf(k$0, o, rest$20),
-          /*<<camlinternalFormat.ml:1822:14>>*/ _bS_ =
-           function(_b4_){ /*<<?>>*/ return _bR_;};
-         /*<<camlinternalFormat.ml:1822:14>>*/ return function(_b3_){
-          /*<<?>>*/ return _bS_;};
+          /*<<camlinternalFormat.ml:1822:14>>*/ _bR_ =
+           function(_b3_){ /*<<?>>*/ return _bQ_;};
+         /*<<camlinternalFormat.ml:1822:14>>*/ return function(_b2_){
+          /*<<?>>*/ return _bR_;};
        case 16:
          /*<<camlinternalFormat.ml:1824:14>>*/ var
          rest$21 = fmt$0[1],
-          /*<<camlinternalFormat.ml:1824:14>>*/ _bT_ =
+          /*<<camlinternalFormat.ml:1824:14>>*/ _bS_ =
            make_iprintf(k$0, o, rest$21);
-         /*<<camlinternalFormat.ml:1824:14>>*/ return function(_b2_){
-          /*<<?>>*/ return _bT_;};
+         /*<<camlinternalFormat.ml:1824:14>>*/ return function(_b1_){
+          /*<<?>>*/ return _bS_;};
        case 17:
         var rest$22 = fmt$0[2], fmt$0 = rest$22; break;
        case 18:
-        var _bU_ = fmt$0[1];
-        if(0 === _bU_[0])
+        var _bT_ = fmt$0[1];
+        if(0 === _bT_[0])
          var
           rest$23 = fmt$0[2],
-          fmt$1 = _bU_[1][1],
+          fmt$1 = _bT_[1][1],
           k$3 =
             function(k, rest){
              function k$0(koc){
@@ -17648,7 +17656,7 @@
         else
          var
           rest$24 = fmt$0[2],
-          fmt$2 = _bU_[1][1],
+          fmt$2 = _bT_[1][1],
           k$4 =
             function(k, rest){
              function k$0(koc){
@@ -17667,32 +17675,32 @@
        case 20:
          /*<<camlinternalFormat.ml:1844:14>>*/ var
          rest$25 = fmt$0[3],
-          /*<<camlinternalFormat.ml:1844:14>>*/ _bV_ =
+          /*<<camlinternalFormat.ml:1844:14>>*/ _bU_ =
            make_iprintf(k$0, o, rest$25);
-         /*<<camlinternalFormat.ml:1844:14>>*/ return function(_b1_){
-          /*<<?>>*/ return _bV_;};
+         /*<<camlinternalFormat.ml:1844:14>>*/ return function(_b0_){
+          /*<<?>>*/ return _bU_;};
        case 21:
          /*<<camlinternalFormat.ml:1846:14>>*/ var
          rest$26 = fmt$0[2],
-          /*<<camlinternalFormat.ml:1846:14>>*/ _bW_ =
+          /*<<camlinternalFormat.ml:1846:14>>*/ _bV_ =
            make_iprintf(k$0, o, rest$26);
-         /*<<camlinternalFormat.ml:1846:14>>*/ return function(_b0_){
-          /*<<?>>*/ return _bW_;};
+         /*<<camlinternalFormat.ml:1846:14>>*/ return function(_bZ_){
+          /*<<?>>*/ return _bV_;};
        case 22:
          /*<<camlinternalFormat.ml:1848:14>>*/ var
          rest$27 = fmt$0[1],
-          /*<<camlinternalFormat.ml:1848:14>>*/ _bX_ =
+          /*<<camlinternalFormat.ml:1848:14>>*/ _bW_ =
            make_iprintf(k$0, o, rest$27);
-         /*<<camlinternalFormat.ml:1848:14>>*/ return function(_bZ_){
-          /*<<?>>*/ return _bX_;};
+         /*<<camlinternalFormat.ml:1848:14>>*/ return function(_bY_){
+          /*<<?>>*/ return _bW_;};
        case 23:
-        var rest$28 = fmt$0[2], ign = fmt$0[1], _bY_ = 0;
+        var rest$28 = fmt$0[2], ign = fmt$0[1], _bX_ = 0;
          /*<<camlinternalFormat.ml:1850:8>>*/ return make_ignored_param
                 (function(param){
                    /*<<camlinternalFormat.ml:1850:37>>*/ return caml_call1
                           (k$0, o);
                   /*<<camlinternalFormat.ml:1850:40>>*/ },
-                 _bY_,
+                 _bX_,
                  ign,
                  rest$28);
        default:
@@ -17710,10 +17718,10 @@
      /*<<camlinternalFormat.ml:1882:4>>*/ if(param){
       /*<<camlinternalFormat.ml:1889:14>>*/ var
       arity = param[1],
-       /*<<camlinternalFormat.ml:1889:14>>*/ _bx_ =
+       /*<<camlinternalFormat.ml:1889:14>>*/ _bw_ =
         fn_of_custom_arity(k, o, fmt, arity);
-      /*<<camlinternalFormat.ml:1889:14>>*/ return function(_by_){
-       /*<<?>>*/ return _bx_;};
+      /*<<camlinternalFormat.ml:1889:14>>*/ return function(_bx_){
+       /*<<?>>*/ return _bw_;};
     }
      /*<<camlinternalFormat.ml:1887:8>>*/ if(counter >= 50)
       /*<<camlinternalFormat.ml:1887:8>>*/ return  /*<<camlinternalFormat.ml:1887:8>>*/ caml_trampoline_return
@@ -17884,9 +17892,9 @@
         var f = acc$0[2], p$3 = acc$0[1];
          /*<<camlinternalFormat.ml:1950:32>>*/ strput_acc(b, p$3);
          /*<<camlinternalFormat.ml:1950:68>>*/  /*<<camlinternalFormat.ml:1950:68>>*/ var
-         _bw_ =  /*<<camlinternalFormat.ml:1950:68>>*/ caml_call1(f, 0);
+         _bv_ =  /*<<camlinternalFormat.ml:1950:68>>*/ caml_call1(f, 0);
          /*<<camlinternalFormat.ml:1950:68>>*/ return  /*<<camlinternalFormat.ml:1950:68>>*/ caml_call2
-                (Stdlib_Buffer[16], b, _bw_);
+                (Stdlib_Buffer[16], b, _bv_);
        case 7:
         var acc$3 = acc$0[1], acc$0 = acc$3; break;
        case 8:
@@ -17917,11 +17925,11 @@
     function k(acc){
       /*<<camlinternalFormat.ml:1961:14>>*/ strput_acc(buf, acc);
       /*<<camlinternalFormat.ml:1961:43>>*/  /*<<camlinternalFormat.ml:1961:43>>*/ var
-      _bv_ =
+      _bu_ =
          /*<<camlinternalFormat.ml:1961:43>>*/ caml_call1
          (Stdlib_Buffer[2], buf);
       /*<<camlinternalFormat.ml:1961:43>>*/ return  /*<<camlinternalFormat.ml:1961:43>>*/ caml_call1
-             (Stdlib[2], _bv_);
+             (Stdlib[2], _bu_);
      /*<<camlinternalFormat.ml:1961:64>>*/ }
      /*<<camlinternalFormat.ml:1962:2>>*/ return make_printf(k, 0, fmt);
    }
@@ -17996,15 +18004,15 @@
       else
         /*<<camlinternalFormat.ml:1994:8>>*/ try{
          /*<<camlinternalFormat.ml:1994:12>>*/ var
-          /*<<camlinternalFormat.ml:1994:12>>*/ _bt_ =
+          /*<<camlinternalFormat.ml:1994:12>>*/ _bs_ =
             /*<<camlinternalFormat.ml:1994:12>>*/ runtime.caml_int_of_string
             ( /*<<camlinternalFormat.ml:1994:26>>*/ caml_call3
               (Stdlib_String[15], str, nstart, nend - nstart | 0)),
-         indent = _bt_;
+         indent = _bs_;
        }
-       catch(_bu_){
-        var _bs_ = caml_wrap_exception(_bu_);
-        if(_bs_[1] !== Stdlib[7]) throw caml_maybe_attach_backtrace(_bs_, 0);
+       catch(_bt_){
+        var _br_ = caml_wrap_exception(_bt_);
+        if(_br_[1] !== Stdlib[7]) throw caml_maybe_attach_backtrace(_br_, 0);
         var indent = invalid_box(0);
        }
        /*<<camlinternalFormat.ml:1996:18>>*/  /*<<camlinternalFormat.ml:1996:18>>*/ var
@@ -18070,7 +18078,7 @@
     (end_ind){
       /*<<camlinternalFormat.ml:2092:4>>*/ invalid_format_message
       (end_ind, cst_unexpected_end_of_format);
-      /*<<camlinternalFormat.ml:2092:4>>*/ return _$_;
+      /*<<camlinternalFormat.ml:2092:4>>*/ return sentinal;
      /*<<camlinternalFormat.ml:2093:32>>*/ }
     function invalid_format_without(str_ind, c, s){
       /*<<camlinternalFormat.ml:2104:4>>*/ return  /*<<camlinternalFormat.ml:2104:4>>*/ caml_call4
@@ -18208,9 +18216,9 @@
              b:
              try{
               var
-               _bh_ = str_ind$3 === end_ind ? 1 : 0,
-               _bi_ =
-                 _bh_
+               _bg_ = str_ind$3 === end_ind ? 1 : 0,
+               _bh_ =
+                 _bg_
                  ||
                   (60
                     !==
@@ -18218,7 +18226,7 @@
                       (str, str_ind$3)
                     ? 1
                     : 0);
-              if(_bi_)
+              if(_bh_)
                 /*<<camlinternalFormat.ml:2666:58>>*/ throw  /*<<camlinternalFormat.ml:2666:58>>*/ caml_maybe_attach_backtrace
                       (Stdlib[8], 1);
                /*<<camlinternalFormat.ml:2667:24>>*/ var
@@ -18257,12 +18265,12 @@
                      str,
                      str_ind$3 - 2 | 0,
                      (str_ind_3 - str_ind$3 | 0) + 3 | 0),
-                  /*<<camlinternalFormat.ml:2675:31>>*/ _bj_ =
+                  /*<<camlinternalFormat.ml:2675:31>>*/ _bi_ =
                    [0, s, width, 0],
-                  /*<<camlinternalFormat.ml:2675:31>>*/ _bk_ =
+                  /*<<camlinternalFormat.ml:2675:31>>*/ _bj_ =
                    str_ind_3 + 1 | 0,
-                 formatting_lit$0 = _bj_,
-                 next_ind = _bk_;
+                 formatting_lit$0 = _bi_,
+                 next_ind = _bj_;
                 break b;
                }
               }
@@ -18288,21 +18296,21 @@
                     str,
                     str_ind$3 - 2 | 0,
                     (str_ind_5 - str_ind$3 | 0) + 3 | 0),
-                 /*<<camlinternalFormat.ml:2681:31>>*/ _bl_ =
+                 /*<<camlinternalFormat.ml:2681:31>>*/ _bk_ =
                   [0, s$0, width, offset],
-                 /*<<camlinternalFormat.ml:2681:31>>*/ _bm_ =
+                 /*<<camlinternalFormat.ml:2681:31>>*/ _bl_ =
                   str_ind_5 + 1 | 0,
-                formatting_lit$0 = _bl_,
-                next_ind = _bm_;
+                formatting_lit$0 = _bk_,
+                next_ind = _bl_;
                break b;
               }
                /*<<camlinternalFormat.ml:2682:21>>*/ throw  /*<<camlinternalFormat.ml:2682:21>>*/ caml_maybe_attach_backtrace
                      (Stdlib[8], 1);
              }
-             catch(_br_){
-              var _bg_ = caml_wrap_exception(_br_);
-              if(_bg_ !== Stdlib[8] && _bg_[1] !== Stdlib[7])
-               throw caml_maybe_attach_backtrace(_bg_, 0);
+             catch(_bq_){
+              var _bf_ = caml_wrap_exception(_bq_);
+              if(_bf_ !== Stdlib[8] && _bf_[1] !== Stdlib[7])
+               throw caml_maybe_attach_backtrace(_bf_, 0);
               var formatting_lit$0 = formatting_lit, next_ind = str_ind$3;
              }
              var
@@ -18326,7 +18334,7 @@
                  if(58 > match$6) break c;
                 }
                 else if(45 === match$6) break c;
-                var _bp_ = 0;
+                var _bo_ = 0;
                 break b;
                }
                 /*<<camlinternalFormat.ml:2699:32>>*/ var
@@ -18350,28 +18358,28 @@
                     str,
                     str_ind$4 - 2 | 0,
                     (str_ind_3$0 - str_ind$4 | 0) + 3 | 0),
-                _bp_ = [0, [0, str_ind_3$0 + 1 | 0, [1, s$1, size]]];
+                _bo_ = [0, [0, str_ind_3$0 + 1 | 0, [1, s$1, size]]];
               }
-              var _bo_ = _bp_;
+              var _bn_ = _bo_;
              }
-             catch(_bq_){
-              var _bn_ = caml_wrap_exception(_bq_);
-              if(_bn_ !== Stdlib[8] && _bn_[1] !== Stdlib[7])
-               throw caml_maybe_attach_backtrace(_bn_, 0);
-              var _bo_ = 0;
+             catch(_bp_){
+              var _bm_ = caml_wrap_exception(_bp_);
+              if(_bm_ !== Stdlib[8] && _bm_[1] !== Stdlib[7])
+               throw caml_maybe_attach_backtrace(_bm_, 0);
+              var _bn_ = 0;
              }
-             if(_bo_)
+             if(_bn_)
               var
-               match$5 = _bo_[1],
+               match$5 = _bn_[1],
                formatting_lit$1 = match$5[2],
                next_ind$0 = match$5[1],
                fmt_rest$13 = parse(next_ind$0, end_ind)[1],
-               _bf_ = [0, [17, formatting_lit$1, fmt_rest$13]];
+               _be_ = [0, [17, formatting_lit$1, fmt_rest$13]];
              else
               var
                fmt_rest$14 = parse(str_ind$4, end_ind)[1],
-               _bf_ = [0, [17, _Q_, fmt_rest$14]];
-             var match$0 = _bf_;
+               _be_ = [0, [17, _Q_, fmt_rest$14]];
+             var match$0 = _be_;
              break a;
             case 31:
              var
@@ -18529,29 +18537,29 @@
             /*<<camlinternalFormat.ml:2536:22>>*/ var
              /*<<camlinternalFormat.ml:2536:22>>*/ ignored$2 =
               [9, get_pad_opt(95), sub_fmtty],
-            _aO_ = [0, [23, ignored$2, fmt_rest$7]];
+            _aN_ = [0, [23, ignored$2, fmt_rest$7]];
           else
-           var _aO_ = [0, [14, get_pad_opt(40), sub_fmtty, fmt_rest$7]];
-          var fmt_result = _aO_;
+           var _aN_ = [0, [14, get_pad_opt(40), sub_fmtty, fmt_rest$7]];
+          var fmt_result = _aN_;
           break a;
          case 44:
           var fmt_result = parse(str_ind, end_ind); break a;
          case 67:
            /*<<camlinternalFormat.ml:2397:9>>*/ var
            fmt_rest$10 = parse(str_ind, end_ind)[1],
-            /*<<camlinternalFormat.ml:2397:9>>*/ _aQ_ =
+            /*<<camlinternalFormat.ml:2397:9>>*/ _aP_ =
              get_ign(0) ? [0, [23, 1, fmt_rest$10]] : [0, [1, fmt_rest$10]],
-           fmt_result = _aQ_;
+           fmt_result = _aP_;
           break a;
          case 78:
           var fmt_rest$14 = parse(str_ind, end_ind)[1], counter$0 = 2;
            /*<<camlinternalFormat.ml:2433:9>>*/ if(get_ign(0))
             /*<<camlinternalFormat.ml:2434:22>>*/ var
              /*<<camlinternalFormat.ml:2434:22>>*/ ignored$6 = [11, counter$0],
-            _aW_ = [0, [23, ignored$6, fmt_rest$14]];
+            _aV_ = [0, [23, ignored$6, fmt_rest$14]];
           else
-           var _aW_ = [0, [21, counter$0, fmt_rest$14]];
-          var fmt_result = _aW_;
+           var _aV_ = [0, [21, counter$0, fmt_rest$14]];
+          var fmt_result = _aV_;
           break a;
          case 83:
            /*<<camlinternalFormat.ml:2410:16>>*/ var
@@ -18562,15 +18570,15 @@
             /*<<camlinternalFormat.ml:2413:22>>*/ var
              /*<<camlinternalFormat.ml:2413:22>>*/ ignored$7 =
               [1, get_padprec_opt(95)],
-            _aX_ = [0, [23, ignored$7, fmt_rest$15]];
+            _aW_ = [0, [23, ignored$7, fmt_rest$15]];
           else
             /*<<camlinternalFormat.ml:2417:10>>*/ var
              /*<<camlinternalFormat.ml:2417:10>>*/ match$5 =
               make_padding_fmt_ebb(pad$6, fmt_rest$15),
             fmt_rest$16 = match$5[2],
             pad$7 = match$5[1],
-            _aX_ = [0, [3, pad$7, fmt_rest$16]];
-          var fmt_result = _aX_;
+            _aW_ = [0, [3, pad$7, fmt_rest$16]];
+          var fmt_result = _aW_;
           break a;
          case 91:
           if(str_ind === end_ind)
@@ -18583,7 +18591,7 @@
              function(c){
                /*<<camlinternalFormat.ml:2721:6>>*/ add_in_char_set
                (char_set, c);
-               /*<<camlinternalFormat.ml:2721:6>>*/ return _$_;
+               /*<<camlinternalFormat.ml:2721:6>>*/ return sentinal;
               /*<<camlinternalFormat.ml:2721:32>>*/ },
            add_range =
              function(c$0, c){
@@ -18595,12 +18603,12 @@
                    /*<<camlinternalFormat.ml:2725:33>>*/ caml_call1
                    (Stdlib[29], i));
                  /*<<camlinternalFormat.ml:2725:8>>*/  /*<<camlinternalFormat.ml:2725:8>>*/ var
-                 _be_ = i + 1 | 0;
+                 _bd_ = i + 1 | 0;
                 if(c === i) break;
-                var i = _be_;
+                var i = _bd_;
                }
               }
-              return _$_;
+              return sentinal;
               /*<<camlinternalFormat.ml:2726:10>>*/ },
            fail_single_percent =
              function(str_ind){
@@ -18622,13 +18630,13 @@
                 if(93 === c)
                   /*<<camlinternalFormat.ml:2746:8>>*/ return str_ind$0 + 1
                         | 0;
-                var _bd_ = str_ind$0 + 1 | 0;
+                var _bc_ = str_ind$0 + 1 | 0;
                  /*<<camlinternalFormat.ml:2751:8>>*/ if(counter >= 50)
                   /*<<camlinternalFormat.ml:2751:8>>*/ return  /*<<camlinternalFormat.ml:2751:8>>*/ caml_trampoline_return
-                         (parse_char_set_after_char$0, [0, _bd_, end_ind, c]);
+                         (parse_char_set_after_char$0, [0, _bc_, end_ind, c]);
                 var counter$0 = counter + 1 | 0;
                  /*<<camlinternalFormat.ml:2751:8>>*/ return parse_char_set_after_char$0
-                        (counter$0, _bd_, end_ind, c);
+                        (counter$0, _bc_, end_ind, c);
                }
                 /*<<camlinternalFormat.ml:2748:8>>*/ add_char(45);
                var str_ind$1 = str_ind$0 + 1 | 0, str_ind$0 = str_ind$1;
@@ -18679,13 +18687,13 @@
                     /*<<camlinternalFormat.ml:2787:17>>*/ return fail_single_percent
                            (str_ind$2);
                    /*<<camlinternalFormat.ml:2785:12>>*/ add_range(c$0, c$3);
-                  var _bb_ = str_ind$2 + 2 | 0;
+                  var _ba_ = str_ind$2 + 2 | 0;
                    /*<<camlinternalFormat.ml:2785:12>>*/ if(counter >= 50)
                     /*<<camlinternalFormat.ml:2785:12>>*/ return  /*<<camlinternalFormat.ml:2785:12>>*/ caml_trampoline_return
-                           (parse_char_set_content, [0, _bb_, end_ind]);
+                           (parse_char_set_content, [0, _ba_, end_ind]);
                   var counter$2 = counter + 1 | 0;
                    /*<<camlinternalFormat.ml:2785:12>>*/ return parse_char_set_content
-                          (counter$2, _bb_, end_ind);
+                          (counter$2, _ba_, end_ind);
                  }
                  if(93 === c$2){
                    /*<<camlinternalFormat.ml:2778:8>>*/ add_char(c$0);
@@ -18694,23 +18702,23 @@
                          | 0;
                  }
                   /*<<camlinternalFormat.ml:2790:8>>*/ add_range(c$0, c$2);
-                 var _bc_ = str_ind$2 + 1 | 0;
+                 var _bb_ = str_ind$2 + 1 | 0;
                   /*<<camlinternalFormat.ml:2790:8>>*/ if(counter >= 50)
                    /*<<camlinternalFormat.ml:2790:8>>*/ return  /*<<camlinternalFormat.ml:2790:8>>*/ caml_trampoline_return
-                          (parse_char_set_content, [0, _bc_, end_ind]);
+                          (parse_char_set_content, [0, _bb_, end_ind]);
                  var counter$1 = counter + 1 | 0;
                   /*<<camlinternalFormat.ml:2790:8>>*/ return parse_char_set_content
-                         (counter$1, _bc_, end_ind);
+                         (counter$1, _bb_, end_ind);
                 }
                 if(37 === c$0){
                   /*<<camlinternalFormat.ml:2763:8>>*/ add_char(c$1);
-                 var _ba_ = str_ind$0 + 1 | 0;
+                 var _a$_ = str_ind$0 + 1 | 0;
                   /*<<camlinternalFormat.ml:2763:8>>*/ if(counter >= 50)
                    /*<<camlinternalFormat.ml:2763:8>>*/ return  /*<<camlinternalFormat.ml:2763:8>>*/ caml_trampoline_return
-                          (parse_char_set_content, [0, _ba_, end_ind]);
+                          (parse_char_set_content, [0, _a$_, end_ind]);
                  var counter$0 = counter + 1 | 0;
                   /*<<camlinternalFormat.ml:2763:8>>*/ return parse_char_set_content
-                         (counter$0, _ba_, end_ind);
+                         (counter$0, _a$_, end_ind);
                 }
                }
                if(37 === c$0)
@@ -18760,10 +18768,10 @@
             /*<<camlinternalFormat.ml:2544:22>>*/ var
              /*<<camlinternalFormat.ml:2544:22>>*/ ignored$9 =
               [10, get_pad_opt(95), char_set$1],
-            _a2_ = [0, [23, ignored$9, fmt_rest$19]];
+            _a1_ = [0, [23, ignored$9, fmt_rest$19]];
           else
-           var _a2_ = [0, [20, get_pad_opt(91), char_set$1, fmt_rest$19]];
-          var fmt_result = _a2_;
+           var _a1_ = [0, [20, get_pad_opt(91), char_set$1, fmt_rest$19]];
+          var fmt_result = _a1_;
           break a;
          case 97:
           var
@@ -18783,28 +18791,28 @@
           if(match$7){
            if(0 === match$7[1])
              /*<<camlinternalFormat.ml:2382:11>>*/ var
-              /*<<camlinternalFormat.ml:2382:11>>*/ _a3_ =
+              /*<<camlinternalFormat.ml:2382:11>>*/ _a2_ =
                get_ign(0) ? [0, [23, 3, fmt_rest$21]] : [0, [22, fmt_rest$21]],
-             _a4_ = _a3_;
+             _a3_ = _a2_;
            else
             var
-             _a4_ =
+             _a3_ =
                legacy_behavior$0
                 ? char_format(fmt_rest$21)
                 : invalid_format_message
                   (str_ind, cst_non_zero_widths_are_unsupp);
-           var _a5_ = _a4_;
+           var _a4_ = _a3_;
           }
           else
-           var _a5_ = char_format(fmt_rest$21);
-          var fmt_result = _a5_;
+           var _a4_ = char_format(fmt_rest$21);
+          var fmt_result = _a4_;
           break a;
          case 114:
            /*<<camlinternalFormat.ml:2512:9>>*/ var
            fmt_rest$22 = parse(str_ind, end_ind)[1],
-            /*<<camlinternalFormat.ml:2512:9>>*/ _a6_ =
+            /*<<camlinternalFormat.ml:2512:9>>*/ _a5_ =
              get_ign(0) ? [0, [23, 2, fmt_rest$22]] : [0, [19, fmt_rest$22]],
-           fmt_result = _a6_;
+           fmt_result = _a5_;
           break a;
          case 115:
            /*<<camlinternalFormat.ml:2400:16>>*/ var
@@ -18815,15 +18823,15 @@
             /*<<camlinternalFormat.ml:2403:22>>*/ var
              /*<<camlinternalFormat.ml:2403:22>>*/ ignored$10 =
               [0, get_padprec_opt(95)],
-            _a7_ = [0, [23, ignored$10, fmt_rest$23]];
+            _a6_ = [0, [23, ignored$10, fmt_rest$23]];
           else
             /*<<camlinternalFormat.ml:2407:10>>*/ var
              /*<<camlinternalFormat.ml:2407:10>>*/ match$8 =
               make_padding_fmt_ebb(pad$9, fmt_rest$23),
             fmt_rest$24 = match$8[2],
             pad$10 = match$8[1],
-            _a7_ = [0, [2, pad$10, fmt_rest$24]];
-          var fmt_result = _a7_;
+            _a6_ = [0, [2, pad$10, fmt_rest$24]];
+          var fmt_result = _a6_;
           break a;
          case 116:
           var
@@ -18842,10 +18850,10 @@
             /*<<camlinternalFormat.ml:2526:22>>*/ var
              /*<<camlinternalFormat.ml:2526:22>>*/ ignored$11 =
               [8, get_pad_opt(95), sub_fmtty$0],
-            _a8_ = [0, [23, ignored$11, fmt_rest$26]];
+            _a7_ = [0, [23, ignored$11, fmt_rest$26]];
           else
-           var _a8_ = [0, [13, get_pad_opt(123), sub_fmtty$0, fmt_rest$26]];
-          var fmt_result = _a8_;
+           var _a7_ = [0, [13, get_pad_opt(123), sub_fmtty$0, fmt_rest$26]];
+          var fmt_result = _a7_;
           break a;
          case 66:
          case 98:
@@ -18857,15 +18865,15 @@
             /*<<camlinternalFormat.ml:2498:22>>*/ var
              /*<<camlinternalFormat.ml:2498:22>>*/ ignored$3 =
               [7, get_padprec_opt(95)],
-            _aP_ = [0, [23, ignored$3, fmt_rest$8]];
+            _aO_ = [0, [23, ignored$3, fmt_rest$8]];
           else
             /*<<camlinternalFormat.ml:2502:10>>*/ var
              /*<<camlinternalFormat.ml:2502:10>>*/ match$3 =
               make_padding_fmt_ebb(pad$3, fmt_rest$8),
             fmt_rest$9 = match$3[2],
             pad$4 = match$3[1],
-            _aP_ = [0, [9, pad$4, fmt_rest$9]];
-          var fmt_result = _aP_;
+            _aO_ = [0, [9, pad$4, fmt_rest$9]];
+          var fmt_result = _aO_;
           break a;
          case 37:
          case 64:
@@ -18881,22 +18889,22 @@
              /*<<camlinternalFormat.ml:2438:63>>*/ symb$0 =
                /*<<camlinternalFormat.ml:2438:63>>*/ caml_string_get
                (str, str_ind),
-             /*<<camlinternalFormat.ml:2892:25>>*/ _a9_ = symb$0 - 88 | 0;
+             /*<<camlinternalFormat.ml:2892:25>>*/ _a8_ = symb$0 - 88 | 0;
            b:
            {
-            if(32 >= _a9_ >>> 0)
-             switch(_a9_){
+            if(32 >= _a8_ >>> 0)
+             switch(_a8_){
                case 0:
                case 12:
                case 17:
                case 23:
                case 29:
                case 32:
-                var _aV_ = 1; break b;
+                var _aU_ = 1; break b;
              }
-            var _aV_ = 0;
+            var _aU_ = 0;
            }
-            /*<<camlinternalFormat.ml:2438:50>>*/ if(_aV_) break;
+            /*<<camlinternalFormat.ml:2438:50>>*/ if(_aU_) break;
           }
           var fmt_rest$13 = parse(str_ind, end_ind)[1];
           b:
@@ -18917,10 +18925,10 @@
            /*<<camlinternalFormat.ml:2441:9>>*/ if(get_ign(0))
             /*<<camlinternalFormat.ml:2442:22>>*/ var
              /*<<camlinternalFormat.ml:2442:22>>*/ ignored$5 = [11, counter],
-            _aU_ = [0, [23, ignored$5, fmt_rest$13]];
+            _aT_ = [0, [23, ignored$5, fmt_rest$13]];
           else
-           var _aU_ = [0, [21, counter, fmt_rest$13]];
-          var fmt_result = _aU_;
+           var _aT_ = [0, [21, counter, fmt_rest$13]];
+          var fmt_result = _aT_;
           break a;
          case 32:
          case 35:
@@ -18939,26 +18947,26 @@
          case 117:
          case 120:
            /*<<camlinternalFormat.ml:2421:8>>*/ var
-            /*<<camlinternalFormat.ml:2421:8>>*/ _aY_ = get_space(0),
-            /*<<camlinternalFormat.ml:2420:65>>*/ _aZ_ = get_hash(0),
+            /*<<camlinternalFormat.ml:2421:8>>*/ _aX_ = get_space(0),
+            /*<<camlinternalFormat.ml:2420:65>>*/ _aY_ = get_hash(0),
             /*<<camlinternalFormat.ml:2420:18>>*/ iconv$2 =
-             compute_int_conv(pct_ind, str_ind, get_plus(0), _aZ_, _aY_, symb),
+             compute_int_conv(pct_ind, str_ind, get_plus(0), _aY_, _aX_, symb),
            fmt_rest$17 = parse(str_ind, end_ind)[1];
            /*<<camlinternalFormat.ml:2423:9>>*/ if(get_ign(0))
             /*<<camlinternalFormat.ml:2424:22>>*/ var
              /*<<camlinternalFormat.ml:2424:22>>*/ ignored$8 =
               [2, iconv$2, get_pad_opt(95)],
-            _a0_ = [0, [23, ignored$8, fmt_rest$17]];
+            _aZ_ = [0, [23, ignored$8, fmt_rest$17]];
           else
             /*<<camlinternalFormat.ml:2428:48>>*/ var
-             /*<<camlinternalFormat.ml:2428:48>>*/ _a1_ = get_prec(0),
+             /*<<camlinternalFormat.ml:2428:48>>*/ _a0_ = get_prec(0),
              /*<<camlinternalFormat.ml:2428:10>>*/ match$6 =
-              make_padprec_fmt_ebb(get_int_pad(0), _a1_, fmt_rest$17),
+              make_padprec_fmt_ebb(get_int_pad(0), _a0_, fmt_rest$17),
             fmt_rest$18 = match$6[3],
             prec$4 = match$6[2],
             pad$8 = match$6[1],
-            _a0_ = [0, [4, iconv$2, pad$8, prec$4, fmt_rest$18]];
-          var fmt_result = _a0_;
+            _aZ_ = [0, [4, iconv$2, pad$8, prec$4, fmt_rest$18]];
+          var fmt_result = _aZ_;
           break a;
          case 69:
          case 70:
@@ -18988,28 +18996,28 @@
             if(3 >= switcher >>> 0){
              switch(switcher){
                case 0:
-                var _a__ = 1; break;
+                var _a9_ = 1; break;
                case 1:
-                var _a__ = 0; break;
+                var _a9_ = 0; break;
                case 2:
-                var _a__ = 3; break;
-               default: var _a__ = 6;
+                var _a9_ = 3; break;
+               default: var _a9_ = 6;
              }
-             var kind = _a__;
+             var kind = _a9_;
              break b;
             }
            }
            else if(69 <= symb){
             switch(symb - 69 | 0){
               case 0:
-               var _a$_ = 2; break;
+               var _a__ = 2; break;
               case 1:
                break c;
               case 2:
-               var _a$_ = 4; break;
-              default: var _a$_ = 7;
+               var _a__ = 4; break;
+              default: var _a__ = 7;
             }
-            var kind = _a$_;
+            var kind = _a__;
             break b;
            }
            if(hash$1){
@@ -19027,25 +19035,25 @@
             match = get_prec(0);
            if(typeof match === "number")
             var
-             _aR_ =
+             _aQ_ =
                match ? incompatible_flag(pct_ind, str_ind, 95, cst$26) : 0;
            else
-            var ndec = match[1], _aR_ = [0, ndec];
+            var ndec = match[1], _aQ_ = [0, ndec];
             /*<<camlinternalFormat.ml:2488:22>>*/ var
              /*<<camlinternalFormat.ml:2488:22>>*/ ignored$4 =
-              [6, get_pad_opt(95), _aR_],
-            _aS_ = [0, [23, ignored$4, fmt_rest$11]];
+              [6, get_pad_opt(95), _aQ_],
+            _aR_ = [0, [23, ignored$4, fmt_rest$11]];
           }
           else
             /*<<camlinternalFormat.ml:2492:44>>*/ var
-             /*<<camlinternalFormat.ml:2492:44>>*/ _aT_ = get_prec(0),
+             /*<<camlinternalFormat.ml:2492:44>>*/ _aS_ = get_prec(0),
              /*<<camlinternalFormat.ml:2492:10>>*/ match$4 =
-              make_padprec_fmt_ebb(get_pad(0), _aT_, fmt_rest$11),
+              make_padprec_fmt_ebb(get_pad(0), _aS_, fmt_rest$11),
             fmt_rest$12 = match$4[3],
             prec$3 = match$4[2],
             pad$5 = match$4[1],
-            _aS_ = [0, [8, fconv, pad$5, prec$3, fmt_rest$12]];
-          var fmt_result = _aS_;
+            _aR_ = [0, [8, fconv, pad$5, prec$3, fmt_rest$12]];
+          var fmt_result = _aR_;
           break a;
        }
       b:
@@ -19054,89 +19062,89 @@
         switch(symb - 108 | 0){
           case 0:
             /*<<camlinternalFormat.ml:2449:25>>*/ var
-             /*<<camlinternalFormat.ml:2449:25>>*/ _ay_ =
+             /*<<camlinternalFormat.ml:2449:25>>*/ _ax_ =
                /*<<camlinternalFormat.ml:2449:25>>*/ caml_string_get
                (str, str_ind),
-             /*<<camlinternalFormat.ml:2449:10>>*/ _az_ = get_space(0),
-             /*<<camlinternalFormat.ml:2448:61>>*/ _aA_ = get_hash(0),
+             /*<<camlinternalFormat.ml:2449:10>>*/ _ay_ = get_space(0),
+             /*<<camlinternalFormat.ml:2448:61>>*/ _az_ = get_hash(0),
              /*<<camlinternalFormat.ml:2448:8>>*/ iconv =
               compute_int_conv
-               (pct_ind, str_ind + 1 | 0, get_plus(0), _aA_, _az_, _ay_),
+               (pct_ind, str_ind + 1 | 0, get_plus(0), _az_, _ay_, _ax_),
             fmt_rest = parse(str_ind + 1 | 0, end_ind)[1];
             /*<<camlinternalFormat.ml:2451:9>>*/ if(get_ign(0))
              /*<<camlinternalFormat.ml:2452:22>>*/ var
               /*<<camlinternalFormat.ml:2452:22>>*/ ignored =
                [3, iconv, get_pad_opt(95)],
-             _aB_ = [0, [23, ignored, fmt_rest]];
+             _aA_ = [0, [23, ignored, fmt_rest]];
            else
              /*<<camlinternalFormat.ml:2456:48>>*/ var
-              /*<<camlinternalFormat.ml:2456:48>>*/ _aD_ = get_prec(0),
+              /*<<camlinternalFormat.ml:2456:48>>*/ _aC_ = get_prec(0),
               /*<<camlinternalFormat.ml:2456:10>>*/ match$0 =
-               make_padprec_fmt_ebb(get_int_pad(0), _aD_, fmt_rest),
+               make_padprec_fmt_ebb(get_int_pad(0), _aC_, fmt_rest),
              fmt_rest$0 = match$0[3],
              prec$0 = match$0[2],
              pad$0 = match$0[1],
-             _aB_ = [0, [5, iconv, pad$0, prec$0, fmt_rest$0]];
-           var _aC_ = _aB_;
+             _aA_ = [0, [5, iconv, pad$0, prec$0, fmt_rest$0]];
+           var _aB_ = _aA_;
            break;
           case 1:
            break b;
           default:
             /*<<camlinternalFormat.ml:2461:39>>*/ var
-             /*<<camlinternalFormat.ml:2461:39>>*/ _aE_ =
+             /*<<camlinternalFormat.ml:2461:39>>*/ _aD_ =
                /*<<camlinternalFormat.ml:2461:39>>*/ caml_string_get
                (str, str_ind),
-             /*<<camlinternalFormat.ml:2461:24>>*/ _aF_ = get_space(0),
-             /*<<camlinternalFormat.ml:2461:10>>*/ _aG_ = get_hash(0),
+             /*<<camlinternalFormat.ml:2461:24>>*/ _aE_ = get_space(0),
+             /*<<camlinternalFormat.ml:2461:10>>*/ _aF_ = get_hash(0),
              /*<<camlinternalFormat.ml:2460:8>>*/ iconv$0 =
               compute_int_conv
-               (pct_ind, str_ind + 1 | 0, get_plus(0), _aG_, _aF_, _aE_),
+               (pct_ind, str_ind + 1 | 0, get_plus(0), _aF_, _aE_, _aD_),
             fmt_rest$1 = parse(str_ind + 1 | 0, end_ind)[1];
             /*<<camlinternalFormat.ml:2463:9>>*/ if(get_ign(0))
              /*<<camlinternalFormat.ml:2464:22>>*/ var
               /*<<camlinternalFormat.ml:2464:22>>*/ ignored$0 =
                [4, iconv$0, get_pad_opt(95)],
-             _aH_ = [0, [23, ignored$0, fmt_rest$1]];
+             _aG_ = [0, [23, ignored$0, fmt_rest$1]];
            else
              /*<<camlinternalFormat.ml:2468:48>>*/ var
-              /*<<camlinternalFormat.ml:2468:48>>*/ _aI_ = get_prec(0),
+              /*<<camlinternalFormat.ml:2468:48>>*/ _aH_ = get_prec(0),
               /*<<camlinternalFormat.ml:2468:10>>*/ match$1 =
-               make_padprec_fmt_ebb(get_int_pad(0), _aI_, fmt_rest$1),
+               make_padprec_fmt_ebb(get_int_pad(0), _aH_, fmt_rest$1),
              fmt_rest$2 = match$1[3],
              prec$1 = match$1[2],
              pad$1 = match$1[1],
-             _aH_ = [0, [6, iconv$0, pad$1, prec$1, fmt_rest$2]];
-           var _aC_ = _aH_;
+             _aG_ = [0, [6, iconv$0, pad$1, prec$1, fmt_rest$2]];
+           var _aB_ = _aG_;
         }
-        var fmt_result = _aC_;
+        var fmt_result = _aB_;
         break a;
        }
       }
       else if(76 === symb){
         /*<<camlinternalFormat.ml:2473:25>>*/ var
-         /*<<camlinternalFormat.ml:2473:25>>*/ _aJ_ =
+         /*<<camlinternalFormat.ml:2473:25>>*/ _aI_ =
            /*<<camlinternalFormat.ml:2473:25>>*/ caml_string_get(str, str_ind),
-         /*<<camlinternalFormat.ml:2473:10>>*/ _aK_ = get_space(0),
-         /*<<camlinternalFormat.ml:2472:61>>*/ _aL_ = get_hash(0),
+         /*<<camlinternalFormat.ml:2473:10>>*/ _aJ_ = get_space(0),
+         /*<<camlinternalFormat.ml:2472:61>>*/ _aK_ = get_hash(0),
          /*<<camlinternalFormat.ml:2472:8>>*/ iconv$1 =
           compute_int_conv
-           (pct_ind, str_ind + 1 | 0, get_plus(0), _aL_, _aK_, _aJ_),
+           (pct_ind, str_ind + 1 | 0, get_plus(0), _aK_, _aJ_, _aI_),
         fmt_rest$3 = parse(str_ind + 1 | 0, end_ind)[1];
         /*<<camlinternalFormat.ml:2475:9>>*/ if(get_ign(0))
          /*<<camlinternalFormat.ml:2476:22>>*/ var
           /*<<camlinternalFormat.ml:2476:22>>*/ ignored$1 =
            [5, iconv$1, get_pad_opt(95)],
-         _aM_ = [0, [23, ignored$1, fmt_rest$3]];
+         _aL_ = [0, [23, ignored$1, fmt_rest$3]];
        else
          /*<<camlinternalFormat.ml:2480:48>>*/ var
-          /*<<camlinternalFormat.ml:2480:48>>*/ _aN_ = get_prec(0),
+          /*<<camlinternalFormat.ml:2480:48>>*/ _aM_ = get_prec(0),
           /*<<camlinternalFormat.ml:2480:10>>*/ match$2 =
-           make_padprec_fmt_ebb(get_int_pad(0), _aN_, fmt_rest$3),
+           make_padprec_fmt_ebb(get_int_pad(0), _aM_, fmt_rest$3),
          fmt_rest$4 = match$2[3],
          prec$2 = match$2[2],
          pad$2 = match$2[1],
-         _aM_ = [0, [7, iconv$1, pad$2, prec$2, fmt_rest$4]];
-       var fmt_result = _aM_;
+         _aL_ = [0, [7, iconv$1, pad$2, prec$2, fmt_rest$4]];
+       var fmt_result = _aL_;
        break a;
       }
       var
@@ -19145,46 +19153,46 @@
           (failwith_message(_J_), str, str_ind - 1 | 0, symb);
      }
      if(1 - legacy_behavior$0){
-      var _ap_ = 1 - plus_used[1], plus$0 = _ap_ ? plus : _ap_;
+      var _ao_ = 1 - plus_used[1], plus$0 = _ao_ ? plus : _ao_;
       if(plus$0)
         /*<<camlinternalFormat.ml:2564:6>>*/ incompatible_flag
         (pct_ind, str_ind, symb, cst$27);
-      var _aq_ = 1 - hash_used[1], hash$0 = _aq_ ? hash : _aq_;
+      var _ap_ = 1 - hash_used[1], hash$0 = _ap_ ? hash : _ap_;
       if(hash$0)
         /*<<camlinternalFormat.ml:2566:6>>*/ incompatible_flag
         (pct_ind, str_ind, symb, cst$28);
-      var _ar_ = 1 - space_used[1], space$0 = _ar_ ? space : _ar_;
+      var _aq_ = 1 - space_used[1], space$0 = _aq_ ? space : _aq_;
       if(space$0)
         /*<<camlinternalFormat.ml:2568:6>>*/ incompatible_flag
         (pct_ind, str_ind, symb, cst$29);
       var
-       _as_ = 1 - pad_used[1],
-       _at_ =
-         _as_
+       _ar_ = 1 - pad_used[1],
+       _as_ =
+         _ar_
           ?  /*<<camlinternalFormat.ml:2569:25>>*/ caml_notequal
             ([0, pad], _K_)
-          : _as_;
-       /*<<camlinternalFormat.ml:2569:25>>*/ if(_at_)
+          : _ar_;
+       /*<<camlinternalFormat.ml:2569:25>>*/ if(_as_)
         /*<<camlinternalFormat.ml:2570:6>>*/ incompatible_flag
         (pct_ind, str_ind, symb, cst_padding$0);
       var
-       _au_ = 1 - prec_used[1],
-       _av_ =
-         _au_
+       _at_ = 1 - prec_used[1],
+       _au_ =
+         _at_
           ?  /*<<camlinternalFormat.ml:2571:25>>*/ caml_notequal
             ([0, prec], _L_)
-          : _au_;
-       /*<<camlinternalFormat.ml:2571:25>>*/ if(_av_){
-       var _aw_ = ign ? 95 : symb;
+          : _at_;
+       /*<<camlinternalFormat.ml:2571:25>>*/ if(_au_){
+       var _av_ = ign ? 95 : symb;
         /*<<camlinternalFormat.ml:2572:6>>*/ incompatible_flag
-        (pct_ind, str_ind, _aw_, cst_precision$2);
+        (pct_ind, str_ind, _av_, cst_precision$2);
       }
       var plus$1 = ign ? plus : ign;
       if(plus$1)
         /*<<camlinternalFormat.ml:2574:24>>*/ incompatible_flag
         (pct_ind, str_ind, 95, cst$30);
      }
-     var _ax_ = 1 - ign_used[1], ign$0 = _ax_ ? ign : _ax_;
+     var _aw_ = 1 - ign_used[1], ign$0 = _aw_ ? ign : _aw_;
      a:
      if(ign$0){
       b:
@@ -19301,10 +19309,10 @@
         case 3:
          if(legacy_behavior$0){
            /*<<camlinternalFormat.ml:2249:6>>*/ var
-            /*<<camlinternalFormat.ml:2249:6>>*/ _ao_ = str_ind$0 + 1 | 0,
+            /*<<camlinternalFormat.ml:2249:6>>*/ _an_ = str_ind$0 + 1 | 0,
            minus$0 = minus || (45 === symb$0 ? 1 : 0);
            /*<<camlinternalFormat.ml:2249:6>>*/ return parse_literal
-                  (minus$0, _ao_);
+                  (minus$0, _an_);
          }
          break;
       }
@@ -19331,17 +19339,17 @@
        /*<<camlinternalFormat.ml:2151:15>>*/ hash = [0, 0];
      function set_flag(str_ind, flag){
        /*<<camlinternalFormat.ml:2154:6>>*/ var
-       _al_ = flag[1],
-       _am_ = _al_ ? 1 - legacy_behavior$0 : _al_;
-      if(_am_){
+       _ak_ = flag[1],
+       _al_ = _ak_ ? 1 - legacy_behavior$0 : _ak_;
+      if(_al_){
         /*<<camlinternalFormat.ml:2157:22>>*/  /*<<camlinternalFormat.ml:2157:22>>*/ var
-        _an_ =
+        _am_ =
            /*<<camlinternalFormat.ml:2157:22>>*/ caml_string_get(str, str_ind);
         /*<<camlinternalFormat.ml:2155:8>>*/  /*<<camlinternalFormat.ml:2155:8>>*/ caml_call3
-        (failwith_message(_C_), str, str_ind, _an_);
+        (failwith_message(_C_), str, str_ind, _am_);
       }
       flag[1] = 1;
-      return _$_;
+      return sentinal;
       /*<<camlinternalFormat.ml:2158:19>>*/ }
      var str_ind$0 = str_ind;
       /*<<camlinternalFormat.ml:2161:6>>*/ for(;;){
@@ -19511,13 +19519,13 @@
          [0, sub_fmt, sub_str],
         /*<<camlinternalFormat.ml:2649:8>>*/ formatting$0 =
          is_open_tag ? [0, sub_format$0] : [1, sub_format$0],
-        /*<<camlinternalFormat.ml:2651:8>>*/ _aj_ =
+        /*<<camlinternalFormat.ml:2651:8>>*/ _ai_ =
          [0, [18, formatting$0, fmt_rest$0]];
-       /*<<camlinternalFormat.ml:2651:8>>*/ return _aj_;
+       /*<<camlinternalFormat.ml:2651:8>>*/ return _ai_;
      }
-     catch(_ak_){
-      var _ai_ = caml_wrap_exception(_ak_);
-      if(_ai_ !== Stdlib[8]) throw caml_maybe_attach_backtrace(_ai_, 0);
+     catch(_aj_){
+      var _ah_ = caml_wrap_exception(_aj_);
+      if(_ah_ !== Stdlib[8]) throw caml_maybe_attach_backtrace(_ah_, 0);
        /*<<camlinternalFormat.ml:2657:6>>*/ var
        fmt_rest = parse(str_ind, end_ind)[1],
         /*<<camlinternalFormat.ml:2657:6>>*/ formatting =
@@ -19557,9 +19565,9 @@
       var new_acc = (acc$0 * 10 | 0) + (c - 48 | 0) | 0;
       if(Stdlib_Sys[12] < new_acc){
         /*<<camlinternalFormat.ml:2815:8>>*/  /*<<camlinternalFormat.ml:2815:8>>*/ var
-        _ah_ = Stdlib_Sys[12];
+        _ag_ = Stdlib_Sys[12];
         /*<<camlinternalFormat.ml:2815:8>>*/ return  /*<<camlinternalFormat.ml:2815:8>>*/ caml_call3
-               (failwith_message(_S_), str, new_acc, _ah_);
+               (failwith_message(_S_), str, new_acc, _ag_);
       }
       var
        str_ind$1 = str_ind$0 + 1 | 0,
@@ -19813,16 +19821,16 @@
      fmt = fmt_ebb_of_string(0, str)[1];
      /*<<camlinternalFormat.ml:2978:2>>*/ try{
       /*<<camlinternalFormat.ml:2978:6>>*/  /*<<camlinternalFormat.ml:2978:6>>*/ var
-      _af_ = [0, type_format(fmt, fmtty), str];
-      /*<<camlinternalFormat.ml:2978:6>>*/ return _af_;
+      _ae_ = [0, type_format(fmt, fmtty), str];
+      /*<<camlinternalFormat.ml:2978:6>>*/ return _ae_;
     }
-    catch(_ag_){
-     var _ad_ = caml_wrap_exception(_ag_);
-     if(_ad_ !== Type_mismatch) throw caml_maybe_attach_backtrace(_ad_, 0);
+    catch(_af_){
+     var _ac_ = caml_wrap_exception(_af_);
+     if(_ac_ !== Type_mismatch) throw caml_maybe_attach_backtrace(_ac_, 0);
       /*<<camlinternalFormat.ml:2982:10>>*/  /*<<camlinternalFormat.ml:2982:10>>*/ var
-      _ae_ = string_of_fmtty(fmtty);
+      _ad_ = string_of_fmtty(fmtty);
       /*<<camlinternalFormat.ml:2982:10>>*/ return  /*<<camlinternalFormat.ml:2982:10>>*/ caml_call2
-             (failwith_message(_Z_), str, _ae_);
+             (failwith_message(_Z_), str, _ad_);
     }
     /*<<camlinternalFormat.ml:2982:33>>*/ }
    function format_of_string_format(str, param){
@@ -19832,15 +19840,15 @@
      fmt$0 = fmt_ebb_of_string(0, str)[1];
      /*<<camlinternalFormat.ml:2988:2>>*/ try{
       /*<<camlinternalFormat.ml:2988:6>>*/  /*<<camlinternalFormat.ml:2988:6>>*/ var
-      _ab_ = [0, type_format(fmt$0, fmtty_of_fmt(fmt)), str];
-      /*<<camlinternalFormat.ml:2988:6>>*/ return _ab_;
+      _aa_ = [0, type_format(fmt$0, fmtty_of_fmt(fmt)), str];
+      /*<<camlinternalFormat.ml:2988:6>>*/ return _aa_;
     }
-    catch(_ac_){
-     var _aa_ = caml_wrap_exception(_ac_);
-     if(_aa_ === Type_mismatch)
+    catch(_ab_){
+     var _$_ = caml_wrap_exception(_ab_);
+     if(_$_ === Type_mismatch)
        /*<<camlinternalFormat.ml:2990:4>>*/ return  /*<<camlinternalFormat.ml:2990:4>>*/ caml_call2
               (failwith_message(___), str, str$0);
-     throw caml_maybe_attach_backtrace(_aa_, 0);
+     throw caml_maybe_attach_backtrace(_$_, 0);
     }
    }
    var
@@ -20048,7 +20056,7 @@
             : runtime.caml_call_gen(f, [a0, a1, a2, a3, a4, a5]);
    }
     /*<<arg.ml:50:0>>*/ var
-    _y_ = undefined,
+    sentinal = undefined,
     global_data = runtime.caml_get_global_data(),
     cst$6 = "\n",
     cst$3 = cst$7,
@@ -20139,18 +20147,18 @@
      /*<<arg.ml:79:53>>*/ var
      t = l[2],
      h = l[1],
-      /*<<arg.ml:79:53>>*/ _aE_ =
+      /*<<arg.ml:79:53>>*/ _aD_ =
         /*<<arg.ml:79:53>>*/ caml_call2(Stdlib[28], prefix, h);
-    function _aF_(x, y){
+    function _aE_(x, y){
       /*<<arg.ml:79:40>>*/  /*<<arg.ml:79:44>>*/ var
-      _aH_ =  /*<<arg.ml:79:44>>*/ caml_call2(Stdlib[28], sep, y);
+      _aG_ =  /*<<arg.ml:79:44>>*/ caml_call2(Stdlib[28], sep, y);
       /*<<arg.ml:79:44>>*/ return  /*<<arg.ml:79:44>>*/ caml_call2
-             (Stdlib[28], x, _aH_);
+             (Stdlib[28], x, _aG_);
      /*<<arg.ml:79:51>>*/ }
      /*<<arg.ml:79:12>>*/  /*<<arg.ml:79:12>>*/ var
-     _aG_ =  /*<<arg.ml:79:12>>*/ caml_call3(Stdlib_List[25], _aF_, _aE_, t);
+     _aF_ =  /*<<arg.ml:79:12>>*/ caml_call3(Stdlib_List[25], _aE_, _aD_, t);
      /*<<arg.ml:79:12>>*/ return  /*<<arg.ml:79:12>>*/ caml_call2
-            (Stdlib[28], _aG_, suffix);
+            (Stdlib[28], _aF_, suffix);
     /*<<arg.ml:79:77>>*/ }
    function help_action(param){
      /*<<arg.ml:91:21>>*/ throw  /*<<arg.ml:91:21>>*/ caml_maybe_attach_backtrace
@@ -20159,11 +20167,11 @@
    function add_help(speclist){
      /*<<arg.ml:94:2>>*/ try{
       /*<<arg.ml:95:15>>*/ assoc3(cst_help$2, speclist);
-      /*<<arg.ml:95:42>>*/ var  /*<<arg.ml:95:42>>*/ _aB_ = 0, add1 = _aB_;
+      /*<<arg.ml:95:42>>*/ var  /*<<arg.ml:95:42>>*/ _aA_ = 0, add1 = _aA_;
     }
-    catch(_aD_){
-     var _ax_ = caml_wrap_exception(_aD_);
-     if(_ax_ !== Stdlib[8]) throw caml_maybe_attach_backtrace(_ax_, 0);
+    catch(_aC_){
+     var _aw_ = caml_wrap_exception(_aC_);
+     if(_aw_ !== Stdlib[8]) throw caml_maybe_attach_backtrace(_aw_, 0);
      var
       add1 =
         [0,
@@ -20172,11 +20180,11 @@
     }
     try{
       /*<<arg.ml:99:15>>*/ assoc3(cst_help$1, speclist);
-      /*<<arg.ml:99:43>>*/ var  /*<<arg.ml:99:43>>*/ _aA_ = 0, add2 = _aA_;
+      /*<<arg.ml:99:43>>*/ var  /*<<arg.ml:99:43>>*/ _az_ = 0, add2 = _az_;
     }
-    catch(_aC_){
-     var _ay_ = caml_wrap_exception(_aC_);
-     if(_ay_ !== Stdlib[8]) throw caml_maybe_attach_backtrace(_ay_, 0);
+    catch(_aB_){
+     var _ax_ = caml_wrap_exception(_aB_);
+     if(_ax_ !== Stdlib[8]) throw caml_maybe_attach_backtrace(_ax_, 0);
      var
       add2 =
         [0,
@@ -20184,34 +20192,34 @@
          0];
     }
      /*<<arg.ml:103:13>>*/  /*<<arg.ml:103:13>>*/ var
-     _az_ =  /*<<arg.ml:103:13>>*/ caml_call2(Stdlib[37], add1, add2);
+     _ay_ =  /*<<arg.ml:103:13>>*/ caml_call2(Stdlib[37], add1, add2);
      /*<<arg.ml:103:13>>*/ return  /*<<arg.ml:103:13>>*/ caml_call2
-            (Stdlib[37], speclist, _az_);
+            (Stdlib[37], speclist, _ay_);
     /*<<arg.ml:103:26>>*/ }
    function usage_b(buf, speclist, errmsg){
      /*<<arg.ml:107:2>>*/  /*<<arg.ml:107:2>>*/ caml_call3
      (Stdlib_Printf[5], buf, _d_, errmsg);
      /*<<arg.ml:108:29>>*/  /*<<arg.ml:108:29>>*/ var
-     _at_ = add_help(speclist);
-     /*<<arg.ml:108:12>>*/ function _au_(param){
+     _as_ = add_help(speclist);
+     /*<<arg.ml:108:12>>*/ function _at_(param){
      var
       doc = param[3],
       spec = param[2],
       key = param[1],
-      _av_ = 0 <  /*<<arg.ml:83:2>>*/ caml_ml_string_length(doc) ? 1 : 0;
-     if(! _av_) return _av_;
+      _au_ = 0 <  /*<<arg.ml:83:2>>*/ caml_ml_string_length(doc) ? 1 : 0;
+     if(! _au_) return _au_;
      if(11 !== spec[0])
        /*<<arg.ml:88:8>>*/ return  /*<<arg.ml:88:8>>*/ caml_call4
               (Stdlib_Printf[5], buf, _a_, key, doc);
       /*<<arg.ml:86:38>>*/ var
       l = spec[1],
-       /*<<arg.ml:86:38>>*/ _aw_ = make_symlist(cst$1, cst$0, cst, l);
+       /*<<arg.ml:86:38>>*/ _av_ = make_symlist(cst$1, cst$0, cst, l);
       /*<<arg.ml:86:8>>*/ return  /*<<arg.ml:86:8>>*/ caml_call5
-             (Stdlib_Printf[5], buf, _b_, key, _aw_, doc);
+             (Stdlib_Printf[5], buf, _b_, key, _av_, doc);
     }
      /*<<arg.ml:108:29>>*/  /*<<arg.ml:108:29>>*/ caml_call2
-     (Stdlib_List[17], _au_, _at_);
-     /*<<arg.ml:108:29>>*/ return _y_;
+     (Stdlib_List[17], _at_, _as_);
+     /*<<arg.ml:108:29>>*/ return sentinal;
     /*<<arg.ml:108:48>>*/ }
    function usage_string(speclist, errmsg){
      /*<<arg.ml:112:2>>*/  /*<<arg.ml:112:10>>*/ var
@@ -20222,33 +20230,33 @@
     /*<<arg.ml:114:19>>*/ }
    function usage(speclist, errmsg){
      /*<<arg.ml:118:2>>*/  /*<<arg.ml:118:15>>*/ var
-     _as_ = usage_string(speclist, errmsg);
+     _ar_ = usage_string(speclist, errmsg);
      /*<<arg.ml:118:15>>*/ return  /*<<arg.ml:118:15>>*/ caml_call2
-            (Stdlib_Printf[3], _e_, _as_);
+            (Stdlib_Printf[3], _e_, _ar_);
     /*<<arg.ml:118:45>>*/ }
     /*<<arg.ml:121:14>>*/  /*<<arg.ml:121:14>>*/ var current = [0, 0];
    function int_of_string_opt(x){
      /*<<arg.ml:128:2>>*/ try{
       /*<<arg.ml:128:6>>*/  /*<<arg.ml:128:6>>*/ var
-      _aq_ = [0,  /*<<arg.ml:128:11>>*/ runtime.caml_int_of_string(x)];
-      /*<<arg.ml:128:6>>*/ return _aq_;
+      _ap_ = [0,  /*<<arg.ml:128:11>>*/ runtime.caml_int_of_string(x)];
+      /*<<arg.ml:128:6>>*/ return _ap_;
     }
-    catch(_ar_){
-     var _ap_ = caml_wrap_exception(_ar_);
-     if(_ap_[1] === Stdlib[7])  /*<<arg.ml:129:20>>*/ return 0;
-     throw caml_maybe_attach_backtrace(_ap_, 0);
+    catch(_aq_){
+     var _ao_ = caml_wrap_exception(_aq_);
+     if(_ao_[1] === Stdlib[7])  /*<<arg.ml:129:20>>*/ return 0;
+     throw caml_maybe_attach_backtrace(_ao_, 0);
     }
     /*<<arg.ml:129:24>>*/ }
    function float_of_string_opt(x){
      /*<<arg.ml:132:2>>*/ try{
       /*<<arg.ml:132:6>>*/  /*<<arg.ml:132:6>>*/ var
-      _an_ = [0,  /*<<arg.ml:132:11>>*/ runtime.caml_float_of_string(x)];
-      /*<<arg.ml:132:6>>*/ return _an_;
+      _am_ = [0,  /*<<arg.ml:132:11>>*/ runtime.caml_float_of_string(x)];
+      /*<<arg.ml:132:6>>*/ return _am_;
     }
-    catch(_ao_){
-     var _am_ = caml_wrap_exception(_ao_);
-     if(_am_[1] === Stdlib[7])  /*<<arg.ml:133:20>>*/ return 0;
-     throw caml_maybe_attach_backtrace(_am_, 0);
+    catch(_an_){
+     var _al_ = caml_wrap_exception(_an_);
+     if(_al_[1] === Stdlib[7])  /*<<arg.ml:133:20>>*/ return 0;
+     throw caml_maybe_attach_backtrace(_al_, 0);
     }
     /*<<arg.ml:133:24>>*/ }
    function parse_and_expand_argv_dynamic_
@@ -20303,8 +20311,8 @@
      if(current[1] >= argv[1].length - 1) return 0;
       /*<<arg.ml:166:4>>*/ try{
        /*<<arg.ml:167:14>>*/ var
-       _Z_ = current[1],
-        /*<<arg.ml:167:14>>*/ s = caml_check_bound(argv[1], _Z_)[1 + _Z_];
+       _Y_ = current[1],
+        /*<<arg.ml:167:14>>*/ s = caml_check_bound(argv[1], _Y_)[1 + _Y_];
       a:
       {
         /*<<arg.ml:168:33>>*/ if
@@ -20313,13 +20321,13 @@
         try{
           /*<<arg.ml:170:14>>*/ var
           follow$1 = 0,
-           /*<<arg.ml:170:14>>*/ _ab_ = assoc3(s, speclist[1]),
+           /*<<arg.ml:170:14>>*/ _aa_ = assoc3(s, speclist[1]),
           follow$0 = follow$1,
-          action = _ab_;
+          action = _aa_;
         }
-        catch(_ak_){
-         var ___ = caml_wrap_exception(_ak_);
-         if(___ !== Stdlib[8]) throw caml_maybe_attach_backtrace(___, 0);
+        catch(_aj_){
+         var _Z_ = caml_wrap_exception(_aj_);
+         if(_Z_ !== Stdlib[8]) throw caml_maybe_attach_backtrace(_Z_, 0);
           /*<<arg.ml:172:10>>*/ try{
            /*<<arg.ml:71:10>>*/ var
             /*<<arg.ml:71:10>>*/ i =
@@ -20332,16 +20340,16 @@
             /*<<arg.ml:73:2>>*/ keyword =
               /*<<arg.ml:73:2>>*/ caml_call3(Stdlib_String[15], s, 0, i),
             /*<<arg.ml:174:38>>*/ follow = [0, arg],
-            /*<<arg.ml:174:12>>*/ _aa_ = assoc3(keyword, speclist[1]),
+            /*<<arg.ml:174:12>>*/ _$_ = assoc3(keyword, speclist[1]),
            follow$0 = follow,
-           action = _aa_;
+           action = _$_;
          }
-         catch(_al_){
-          var _$_ = caml_wrap_exception(_al_);
-          if(_$_ === Stdlib[8])
+         catch(_ak_){
+          var ___ = caml_wrap_exception(_ak_);
+          if(___ === Stdlib[8])
             /*<<arg.ml:175:28>>*/ throw  /*<<arg.ml:175:28>>*/ caml_maybe_attach_backtrace
                   ([0, Stop, [0, s]], 1);
-          throw caml_maybe_attach_backtrace(_$_, 0);
+          throw caml_maybe_attach_backtrace(___, 0);
          }
         }
         var
@@ -20349,7 +20357,7 @@
            function(s, follow){
             function no_arg(param){
               /*<<arg.ml:178:10>>*/ if(! follow)
-               /*<<arg.ml:179:20>>*/ return _y_;
+               /*<<arg.ml:179:20>>*/ return sentinal;
              var arg = follow[1];
               /*<<arg.ml:180:24>>*/ throw  /*<<arg.ml:180:24>>*/ caml_maybe_attach_backtrace
                     ([0, Stop, [1, s, arg, cst_no_argument]], 1);
@@ -20367,9 +20375,9 @@
              if((current[1] + 1 | 0) >= argv[1].length - 1)
                /*<<arg.ml:185:19>>*/ throw  /*<<arg.ml:185:19>>*/ caml_maybe_attach_backtrace
                      ([0, Stop, [2, s]], 1);
-             var _aj_ = current[1] + 1 | 0;
-              /*<<arg.ml:184:58>>*/ return caml_check_bound(argv[1], _aj_)
-                     [1 + _aj_];
+             var _ai_ = current[1] + 1 | 0;
+              /*<<arg.ml:184:58>>*/ return caml_check_bound(argv[1], _ai_)
+                     [1 + _ai_];
              /*<<arg.ml:186:27>>*/ }
             return get_arg;
            },
@@ -20397,14 +20405,14 @@
                   /*<<arg.ml:196:22>>*/ arg = get_arg(0);
                  /*<<arg.ml:124:2>>*/ try{
                   /*<<arg.ml:124:6>>*/ var
-                   /*<<arg.ml:124:6>>*/ _ad_ =
+                   /*<<arg.ml:124:6>>*/ _ac_ =
                     [0,  /*<<arg.ml:124:11>>*/ caml_call1(Stdlib[32], arg)],
-                  match = _ad_;
+                  match = _ac_;
                 }
-                catch(_ai_){
-                 var _ac_ = caml_wrap_exception(_ai_);
-                 if(_ac_[1] !== Stdlib[6])
-                  throw caml_maybe_attach_backtrace(_ac_, 0);
+                catch(_ah_){
+                 var _ab_ = caml_wrap_exception(_ah_);
+                 if(_ab_[1] !== Stdlib[6])
+                  throw caml_maybe_attach_backtrace(_ab_, 0);
                  var match = 0;
                 }
                 if(! match)
@@ -20499,7 +20507,7 @@
                   /*<<arg.ml:211:14>>*/ return consume_arg(0);
                 }
                  /*<<arg.ml:215:44>>*/  /*<<arg.ml:215:44>>*/ var
-                 _ae_ = make_symlist(cst$5, cst$4, cst$3, symb);
+                 _ad_ = make_symlist(cst$5, cst$4, cst$3, symb);
                  /*<<arg.ml:213:21>>*/ throw  /*<<arg.ml:213:21>>*/ caml_maybe_attach_backtrace
                        ([0,
                          Stop,
@@ -20507,16 +20515,16 @@
                           s,
                           arg$5,
                            /*<<arg.ml:214:42>>*/ caml_call2
-                           (Stdlib[28], cst_one_of, _ae_)]],
+                           (Stdlib[28], cst_one_of, _ad_)]],
                         1);
                case 12:
                 var f$5 = param[1];
                  /*<<arg.ml:252:12>>*/ no_arg(0);
                  /*<<arg.ml:255:14>>*/ for(;;){
                  if(current[1] >= (argv[1].length - 1 - 1 | 0)) return 0;
-                 var _af_ = current[1] + 1 | 0;
+                 var _ae_ = current[1] + 1 | 0;
                   /*<<arg.ml:254:14>>*/  /*<<arg.ml:254:14>>*/ caml_call1
-                  (f$5, caml_check_bound(argv[1], _af_)[1 + _af_]);
+                  (f$5, caml_check_bound(argv[1], _ae_)[1 + _ae_]);
                   /*<<arg.ml:255:14>>*/ consume_arg(0);
                 }
                 break;
@@ -20530,8 +20538,8 @@
                    /*<<arg.ml:264:14>>*/ return  /*<<arg.ml:264:14>>*/ caml_call1
                           (f$6,
                             /*<<arg.ml:264:14>>*/ caml_call1(Stdlib_List[9], acc[1]));
-                 var _ah_ = current[1] + 1 | 0, _ag_ = acc[1];
-                 acc[1] = [0, caml_check_bound(argv[1], _ah_)[1 + _ah_], _ag_];
+                 var _ag_ = current[1] + 1 | 0, _af_ = acc[1];
+                 acc[1] = [0, caml_check_bound(argv[1], _ag_)[1 + _ag_], _af_];
                   /*<<arg.ml:262:14>>*/ consume_arg(0);
                 }
                 break;
@@ -20609,8 +20617,8 @@
    function parse(l, f, msg){
      /*<<arg.ml:299:2>>*/ try{
       /*<<arg.ml:300:4>>*/  /*<<arg.ml:300:4>>*/ var
-      _Y_ = parse_argv(0, caml_sys_argv(0), l, f, msg);
-      /*<<arg.ml:300:4>>*/ return _Y_;
+      _X_ = parse_argv(0, caml_sys_argv(0), l, f, msg);
+      /*<<arg.ml:300:4>>*/ return _X_;
     }
     catch(exn$0){
      var exn = caml_wrap_exception(exn$0);
@@ -20632,8 +20640,8 @@
    function parse_dynamic(l, f, msg){
      /*<<arg.ml:307:2>>*/ try{
       /*<<arg.ml:308:4>>*/  /*<<arg.ml:308:4>>*/ var
-      _X_ = parse_argv_dynamic(0, caml_sys_argv(0), l, f, msg);
-      /*<<arg.ml:308:4>>*/ return _X_;
+      _W_ = parse_argv_dynamic(0, caml_sys_argv(0), l, f, msg);
+      /*<<arg.ml:308:4>>*/ return _W_;
     }
     catch(exn$0){
      var exn = caml_wrap_exception(exn$0);
@@ -20658,9 +20666,9 @@
        /*<<arg.ml:315:15>>*/ argv = [0, caml_sys_argv(0)],
        /*<<arg.ml:316:15>>*/ spec = [0, l],
        /*<<arg.ml:317:18>>*/ current$0 = [0, current[1]],
-       /*<<arg.ml:318:4>>*/ _W_ =
+       /*<<arg.ml:318:4>>*/ _V_ =
         parse_and_expand_argv_dynamic(current$0, argv, spec, f, msg);
-      /*<<arg.ml:318:4>>*/ return _W_;
+      /*<<arg.ml:318:4>>*/ return _V_;
     }
     catch(exn$0){
      var exn = caml_wrap_exception(exn$0);
@@ -20697,17 +20705,17 @@
       /*<<arg.ml:331:8>>*/  /*<<arg.ml:331:8>>*/ var
       n$0 =  /*<<arg.ml:331:8>>*/ caml_call2(Stdlib_String[35], s, 9);
     }
-    catch(_U_){
-     var _S_ = caml_wrap_exception(_U_);
-     if(_S_ !== Stdlib[8]) throw caml_maybe_attach_backtrace(_S_, 0);
+    catch(_T_){
+     var _R_ = caml_wrap_exception(_T_);
+     if(_R_ !== Stdlib[8]) throw caml_maybe_attach_backtrace(_R_, 0);
       /*<<arg.ml:334:6>>*/ try{
        /*<<arg.ml:334:18>>*/  /*<<arg.ml:334:18>>*/ var
        n =  /*<<arg.ml:334:18>>*/ caml_call2(Stdlib_String[35], s, 32);
      }
-     catch(_V_){
-      var _T_ = caml_wrap_exception(_V_);
-      if(_T_ === Stdlib[8])  /*<<arg.ml:336:31>>*/ return len;
-      throw caml_maybe_attach_backtrace(_T_, 0);
+     catch(_U_){
+      var _S_ = caml_wrap_exception(_U_);
+      if(_S_ === Stdlib[8])  /*<<arg.ml:336:31>>*/ return len;
+      throw caml_maybe_attach_backtrace(_S_, 0);
      }
       /*<<arg.ml:334:18>>*/ return loop(n + 1 | 0);
     }
@@ -20717,12 +20725,12 @@
     var doc = param[3], spec = param[2], kwd = param[1];
      /*<<arg.ml:341:2>>*/ if(11 === spec[0])
      return caml_call2(Stdlib_Int[11], cur, caml_ml_string_length(kwd));
-    var _R_ = caml_ml_string_length(kwd) + second_word(doc) | 0;
-    return caml_call2(Stdlib_Int[11], cur, _R_);
+    var _Q_ = caml_ml_string_length(kwd) + second_word(doc) | 0;
+    return caml_call2(Stdlib_Int[11], cur, _Q_);
    }
    function replace_leading_tab(s){
      /*<<arg.ml:347:2>>*/  /*<<arg.ml:347:13>>*/ var seen = [0, 0];
-    function _Q_(c){
+    function _P_(c){
       /*<<arg.ml:348:13>>*/ if(9 === c && ! seen[1]){
       seen[1] = 1;
        /*<<arg.ml:348:60>>*/ return 32;
@@ -20730,7 +20738,7 @@
       /*<<arg.ml:348:71>>*/ return c;
      /*<<arg.ml:348:73>>*/ }
      /*<<arg.ml:348:2>>*/ return  /*<<arg.ml:348:2>>*/ caml_call2
-            (Stdlib_String[17], _Q_, s);
+            (Stdlib_String[17], _P_, s);
     /*<<arg.ml:348:75>>*/ }
    function align(opt, speclist){
      /*<<arg.ml:374:2>>*/ if(opt)
@@ -20744,7 +20752,7 @@
         (Stdlib_List[25], max_arg_len, 0, completed),
       /*<<arg.ml:376:12>>*/ len$0 =
         /*<<arg.ml:376:12>>*/ caml_call2(Stdlib_Int[10], len, limit);
-     /*<<arg.ml:377:11>>*/ function _K_(ksd){
+     /*<<arg.ml:377:11>>*/ function _J_(ksd){
      var kwd = ksd[1], spec = ksd[2];
      if(! caml_string_notequal(ksd[3], cst$7))
        /*<<arg.ml:355:6>>*/ return ksd;
@@ -20752,20 +20760,20 @@
        /*<<arg.ml:357:19>>*/ var
        msg$0 = ksd[3],
         /*<<arg.ml:357:19>>*/ cutcol$0 = second_word(msg$0),
-        /*<<arg.ml:358:32>>*/ _N_ =
+        /*<<arg.ml:358:32>>*/ _M_ =
           /*<<arg.ml:358:32>>*/ caml_call2
           (Stdlib_Int[11], 0, len$0 - cutcol$0 | 0)
          + 3
          | 0,
         /*<<arg.ml:358:19>>*/ spaces$0 =
-          /*<<arg.ml:358:19>>*/ caml_call2(Stdlib_String[1], _N_, 32),
-        /*<<arg.ml:359:34>>*/ _O_ = replace_leading_tab(msg$0),
-        /*<<arg.ml:359:25>>*/ _P_ =
-          /*<<arg.ml:359:25>>*/ caml_call2(Stdlib[28], spaces$0, _O_);
+          /*<<arg.ml:358:19>>*/ caml_call2(Stdlib_String[1], _M_, 32),
+        /*<<arg.ml:359:34>>*/ _N_ = replace_leading_tab(msg$0),
+        /*<<arg.ml:359:25>>*/ _O_ =
+          /*<<arg.ml:359:25>>*/ caml_call2(Stdlib[28], spaces$0, _N_);
        /*<<arg.ml:359:6>>*/ return [0,
               kwd,
               spec,
-               /*<<arg.ml:359:18>>*/ caml_call2(Stdlib[28], cst$6, _P_)];
+               /*<<arg.ml:359:18>>*/ caml_call2(Stdlib[28], cst$6, _O_)];
      }
       /*<<arg.ml:361:19>>*/ var
       msg = ksd[3],
@@ -20779,24 +20787,24 @@
       /*<<arg.ml:367:21>>*/ var
        /*<<arg.ml:367:21>>*/ spaces =
          /*<<arg.ml:367:21>>*/ caml_call2(Stdlib_String[1], diff, 32),
-       /*<<arg.ml:368:32>>*/ _L_ = replace_leading_tab(msg),
+       /*<<arg.ml:368:32>>*/ _K_ = replace_leading_tab(msg),
        /*<<arg.ml:368:21>>*/ prefix =
-         /*<<arg.ml:368:21>>*/ caml_call3(Stdlib_String[15], _L_, 0, cutcol),
+         /*<<arg.ml:368:21>>*/ caml_call3(Stdlib_String[15], _K_, 0, cutcol),
        /*<<arg.ml:369:21>>*/ suffix =
          /*<<arg.ml:369:21>>*/ caml_call3
          (Stdlib_String[15],
           msg,
           cutcol,
           caml_ml_string_length(msg) - cutcol | 0),
-       /*<<arg.ml:370:29>>*/ _M_ =
+       /*<<arg.ml:370:29>>*/ _L_ =
          /*<<arg.ml:370:29>>*/ caml_call2(Stdlib[28], spaces, suffix);
       /*<<arg.ml:370:8>>*/ return [0,
              kwd,
              spec$0,
-              /*<<arg.ml:370:20>>*/ caml_call2(Stdlib[28], prefix, _M_)];
+              /*<<arg.ml:370:20>>*/ caml_call2(Stdlib[28], prefix, _L_)];
     }
      /*<<arg.ml:377:2>>*/ return  /*<<arg.ml:377:2>>*/ caml_call2
-            (Stdlib_List[19], _K_, completed);
+            (Stdlib_List[19], _J_, completed);
     /*<<arg.ml:377:38>>*/ }
    function read_aux(trim, sep, file){
      /*<<arg.ml:387:2>>*/ var
@@ -20816,21 +20824,21 @@
         (0 < len
          && 13 ===  /*<<arg.ml:381:16>>*/ caml_string_get(word, len - 1 | 0)){
         var
-         _J_ =
+         _I_ =
             /*<<arg.ml:382:4>>*/ caml_call3
             (Stdlib_String[15], word, 0, len - 1 | 0);
         break a;
        }
-       var _J_ = word;
+       var _I_ = word;
       }
-      var word$0 = _J_;
+      var word$0 = _I_;
      }
      else
       var word$0 = word;
      words[1] = [0, word$0, words[1]];
       /*<<arg.ml:390:2>>*/  /*<<arg.ml:390:2>>*/ caml_call1
       (Stdlib_Buffer[8], buf);
-      /*<<arg.ml:390:2>>*/ return _y_;
+      /*<<arg.ml:390:2>>*/ return sentinal;
      /*<<arg.ml:394:20>>*/ }
      /*<<arg.ml:396:2>>*/ try{
      for(;;){
@@ -20843,45 +20851,45 @@
         (Stdlib_Buffer[12], buf, c);
      }
     }
-    catch(_I_){
-     var _G_ = caml_wrap_exception(_I_);
-     if(_G_ !== Stdlib[12]) throw caml_maybe_attach_backtrace(_G_, 0);
+    catch(_H_){
+     var _F_ = caml_wrap_exception(_H_);
+     if(_F_ !== Stdlib[12]) throw caml_maybe_attach_backtrace(_F_, 0);
      if(0 <  /*<<arg.ml:403:5>>*/ caml_call1(Stdlib_Buffer[7], buf))
        /*<<arg.ml:403:32>>*/ stash(0);
       /*<<arg.ml:404:2>>*/  /*<<arg.ml:404:2>>*/ caml_call1(Stdlib[93], ic);
       /*<<arg.ml:405:16>>*/  /*<<arg.ml:405:16>>*/ var
-      _H_ =  /*<<arg.ml:405:16>>*/ caml_call1(Stdlib_List[9], words[1]);
+      _G_ =  /*<<arg.ml:405:16>>*/ caml_call1(Stdlib_List[9], words[1]);
       /*<<arg.ml:405:16>>*/ return  /*<<arg.ml:405:16>>*/ caml_call1
-             (Stdlib_Array[10], _H_);
+             (Stdlib_Array[10], _G_);
     }
     /*<<arg.ml:405:33>>*/ }
    var _r_ = 10, _s_ = 1;
-    /*<<arg.ml:407:15>>*/ function read_arg(_F_){
-     /*<<?>>*/ return read_aux(_s_, _r_, _F_);
+    /*<<arg.ml:407:15>>*/ function read_arg(_E_){
+     /*<<?>>*/ return read_aux(_s_, _r_, _E_);
    }
     /*<<arg.ml:407:15>>*/ var  /*<<arg.ml:407:15>>*/ _t_ = 0, _u_ = 0;
-    /*<<arg.ml:409:16>>*/ function read_arg0(_E_){
-     /*<<?>>*/ return read_aux(_u_, _t_, _E_);
+    /*<<arg.ml:409:16>>*/ function read_arg0(_D_){
+     /*<<?>>*/ return read_aux(_u_, _t_, _D_);
    }
    function write_aux(sep, file, args){
      /*<<arg.ml:412:2>>*/  /*<<arg.ml:412:11>>*/ var
      oc =  /*<<arg.ml:412:11>>*/ caml_call1(Stdlib[61], file);
-    function _D_(s){
+    function _C_(s){
       /*<<arg.ml:413:23>>*/ return caml_call4
              (Stdlib_Printf[1], oc, _v_, s, sep);
      /*<<arg.ml:413:46>>*/ }
      /*<<arg.ml:413:2>>*/  /*<<arg.ml:413:2>>*/ caml_call2
-     (Stdlib_Array[11], _D_, args);
+     (Stdlib_Array[11], _C_, args);
      /*<<arg.ml:413:2>>*/ return  /*<<arg.ml:413:2>>*/ caml_call1
             (Stdlib[76], oc);
     /*<<arg.ml:414:14>>*/ }
    var _w_ = 10;
-    /*<<arg.ml:416:16>>*/ function write_arg(_B_, _C_){
-     /*<<?>>*/ return write_aux(_w_, _B_, _C_);
+    /*<<arg.ml:416:16>>*/ function write_arg(_A_, _B_){
+     /*<<?>>*/ return write_aux(_w_, _A_, _B_);
    }
     /*<<arg.ml:416:16>>*/  /*<<arg.ml:416:16>>*/ var _x_ = 0;
-    /*<<arg.ml:418:17>>*/ function write_arg0(_z_, _A_){
-     /*<<?>>*/ return write_aux(_x_, _z_, _A_);
+    /*<<arg.ml:418:17>>*/ function write_arg0(_y_, _z_){
+     /*<<?>>*/ return write_aux(_x_, _y_, _z_);
    }
    var
     Stdlib_Arg =
@@ -21544,10 +21552,10 @@
             : runtime.caml_call_gen(f, [a0, a1]);
    }
    var
+    sentinal = undefined,
     global_data = runtime.caml_get_global_data(),
     Stdlib_Printexc = global_data.Stdlib__Printexc,
     Stdlib = global_data.Stdlib,
-    _b_ = undefined,
     cst_Fun_Finally_raised = "Fun.Finally_raised: ",
     cst_Stdlib_Fun_Finally_raised = "Stdlib.Fun.Finally_raised";
    function const$0(c, param){
@@ -21567,11 +21575,11 @@
       /*<<fun.ml:25:7>>*/ return 0;
      /*<<fun.ml:24:55>>*/ var
      exn = param[2],
-      /*<<fun.ml:24:55>>*/ _c_ =
+      /*<<fun.ml:24:55>>*/ _b_ =
         /*<<fun.ml:24:55>>*/ caml_call1(Stdlib_Printexc[1], exn);
      /*<<fun.ml:24:24>>*/ return [0,
              /*<<fun.ml:24:29>>*/ caml_call2
-             (Stdlib[28], cst_Fun_Finally_raised, _c_)];
+             (Stdlib[28], cst_Fun_Finally_raised, _b_)];
     /*<<fun.ml:25:11>>*/ }
     /*<<fun.ml:23:9>>*/  /*<<fun.ml:23:9>>*/ caml_call1
     (Stdlib_Printexc[9], _a_);
@@ -21579,7 +21587,7 @@
     function finally_no_exn(param){
       /*<<fun.ml:29:4>>*/ try{
        /*<<fun.ml:29:8>>*/  /*<<fun.ml:29:8>>*/ caml_call1(finally$0, 0);
-       /*<<fun.ml:29:8>>*/ return _b_;
+       /*<<fun.ml:29:8>>*/ return sentinal;
      }
      catch(e$0){
        /*<<fun.ml:30:15>>*/ var
@@ -22037,7 +22045,7 @@
             : runtime.caml_call_gen(f, [a0, a1, a2]);
    }
    var
-    _a_ = undefined,
+    sentinal = undefined,
     global_data = runtime.caml_get_global_data(),
     Stdlib = global_data.Stdlib,
     Stdlib_Array = global_data.Stdlib__Array,
@@ -22099,46 +22107,46 @@
      /*<<bigarray.ml:104:4>>*/ if(col === idx.length - 1){
       /*<<bigarray.ml:104:35>>*/  /*<<bigarray.ml:104:35>>*/ caml_ba_set_generic
       (arr, idx,  /*<<bigarray.ml:104:47>>*/ caml_call1(f, idx));
-      /*<<bigarray.ml:104:35>>*/ return _a_;
+      /*<<bigarray.ml:104:35>>*/ return sentinal;
     }
      /*<<bigarray.ml:105:27>>*/ var
-      /*<<bigarray.ml:105:27>>*/ _an_ =
+      /*<<bigarray.ml:105:27>>*/ _am_ =
        caml_check_bound(max, col)[1 + col] - 1 | 0,
-      /*<<bigarray.ml:105:9>>*/ _am_ = 0;
-    if(_an_ >= 0){
-     var j = _am_;
+      /*<<bigarray.ml:105:9>>*/ _al_ = 0;
+    if(_am_ >= 0){
+     var j = _al_;
      for(;;){
        /*<<bigarray.ml:106:11>>*/ caml_check_bound(idx, col)[1 + col] = j;
        /*<<bigarray.ml:107:11>>*/ cloop(arr, idx, f, col + 1 | 0, max);
        /*<<bigarray.ml:107:11>>*/  /*<<bigarray.ml:107:11>>*/ var
-       _ao_ = j + 1 | 0;
-      if(_an_ === j) break;
-      var j = _ao_;
+       _an_ = j + 1 | 0;
+      if(_am_ === j) break;
+      var j = _an_;
      }
     }
-    return _a_;
+    return sentinal;
     /*<<bigarray.ml:108:13>>*/ }
    function floop(arr, idx, f, col, max){
      /*<<bigarray.ml:110:4>>*/ if(0 > col){
       /*<<bigarray.ml:110:20>>*/  /*<<bigarray.ml:110:20>>*/ caml_ba_set_generic
       (arr, idx,  /*<<bigarray.ml:110:32>>*/ caml_call1(f, idx));
-      /*<<bigarray.ml:110:20>>*/ return _a_;
+      /*<<bigarray.ml:110:20>>*/ return sentinal;
     }
      /*<<bigarray.ml:111:22>>*/ var
-      /*<<bigarray.ml:111:22>>*/ _ak_ = caml_check_bound(max, col)[1 + col],
-      /*<<bigarray.ml:111:9>>*/ _aj_ = 1;
-    if(_ak_ >= 1){
-     var j = _aj_;
+      /*<<bigarray.ml:111:22>>*/ _aj_ = caml_check_bound(max, col)[1 + col],
+      /*<<bigarray.ml:111:9>>*/ _ai_ = 1;
+    if(_aj_ >= 1){
+     var j = _ai_;
      for(;;){
        /*<<bigarray.ml:112:11>>*/ caml_check_bound(idx, col)[1 + col] = j;
        /*<<bigarray.ml:113:11>>*/ floop(arr, idx, f, col - 1 | 0, max);
        /*<<bigarray.ml:113:11>>*/  /*<<bigarray.ml:113:11>>*/ var
-       _al_ = j + 1 | 0;
-      if(_ak_ === j) break;
-      var j = _al_;
+       _ak_ = j + 1 | 0;
+      if(_aj_ === j) break;
+      var j = _ak_;
      }
     }
-    return _a_;
+    return sentinal;
     /*<<bigarray.ml:114:13>>*/ }
    function init(kind, layout, dims, f){
      /*<<bigarray.ml:116:4>>*/ var
@@ -22167,31 +22175,31 @@
         /*<<bigarray.ml:125:12>>*/ caml_ba_num_dims(a),
       /*<<bigarray.ml:126:12>>*/ d =
         /*<<bigarray.ml:126:12>>*/ caml_make_vect(n, 0),
-      /*<<bigarray.ml:127:4>>*/ _ag_ = n - 1 | 0,
-      /*<<bigarray.ml:126:12>>*/ _af_ = 0;
-    if(_ag_ >= 0){
-     var i = _af_;
+      /*<<bigarray.ml:127:4>>*/ _af_ = n - 1 | 0,
+      /*<<bigarray.ml:126:12>>*/ _ae_ = 0;
+    if(_af_ >= 0){
+     var i = _ae_;
      for(;;){
        /*<<bigarray.ml:127:33>>*/  /*<<bigarray.ml:127:33>>*/ var
-       _ah_ =  /*<<bigarray.ml:127:33>>*/ runtime.caml_ba_dim(a, i);
-       /*<<bigarray.ml:127:24>>*/ caml_check_bound(d, i)[1 + i] = _ah_;
+       _ag_ =  /*<<bigarray.ml:127:33>>*/ runtime.caml_ba_dim(a, i);
+       /*<<bigarray.ml:127:24>>*/ caml_check_bound(d, i)[1 + i] = _ag_;
        /*<<bigarray.ml:127:24>>*/  /*<<bigarray.ml:127:24>>*/ var
-       _ai_ = i + 1 | 0;
-      if(_ag_ === i) break;
-      var i = _ai_;
+       _ah_ = i + 1 | 0;
+      if(_af_ === i) break;
+      var i = _ah_;
      }
     }
      /*<<bigarray.ml:128:4>>*/ return d;
     /*<<bigarray.ml:128:5>>*/ }
    function size_in_bytes(arr){
      /*<<bigarray.ml:136:4>>*/ var
-      /*<<bigarray.ml:136:63>>*/ _ad_ = dims(arr),
-      /*<<bigarray.ml:136:38>>*/ _ae_ =
+      /*<<bigarray.ml:136:63>>*/ _ac_ = dims(arr),
+      /*<<bigarray.ml:136:38>>*/ _ad_ =
         /*<<bigarray.ml:136:38>>*/ caml_call3
-        (Stdlib_Array[15], caml_mul, 1, _ad_);
+        (Stdlib_Array[15], caml_mul, 1, _ac_);
      /*<<bigarray.ml:136:4>>*/ return  /*<<bigarray.ml:136:4>>*/ caml_mul
             (kind_size_in_bytes( /*<<bigarray.ml:136:24>>*/ caml_ba_kind(arr)),
-             _ae_);
+             _ad_);
     /*<<bigarray.ml:136:74>>*/ }
    function create(kind, layout){
      /*<<bigarray.ml:157:4>>*/ return  /*<<bigarray.ml:157:4>>*/ caml_ba_create
@@ -22202,9 +22210,9 @@
             (arr, [0]);
     /*<<bigarray.ml:158:37>>*/ }
    function set(arr){
-     /*<<bigarray.ml:159:16>>*/  /*<<bigarray.ml:159:16>>*/ var _ab_ = [0];
-     /*<<bigarray.ml:159:33>>*/ return function(_ac_){
-      /*<<?>>*/ return caml_ba_set_generic(arr, _ab_, _ac_);};
+     /*<<bigarray.ml:159:16>>*/  /*<<bigarray.ml:159:16>>*/ var _aa_ = [0];
+     /*<<bigarray.ml:159:33>>*/ return function(_ab_){
+      /*<<?>>*/ return caml_ba_set_generic(arr, _aa_, _ab_);};
     /*<<bigarray.ml:159:37>>*/ }
    function size_in_bytes$0(arr){
      /*<<bigarray.ml:166:26>>*/ return kind_size_in_bytes
@@ -22222,10 +22230,10 @@
     /*<<bigarray.ml:181:39>>*/ }
    function size_in_bytes$1(arr){
      /*<<bigarray.ml:195:4>>*/  /*<<bigarray.ml:195:38>>*/ var
-     _aa_ =  /*<<bigarray.ml:195:38>>*/ caml_ba_dim_1(arr);
+     _$_ =  /*<<bigarray.ml:195:38>>*/ caml_ba_dim_1(arr);
      /*<<bigarray.ml:195:4>>*/ return  /*<<bigarray.ml:195:4>>*/ caml_mul
             (kind_size_in_bytes( /*<<bigarray.ml:195:24>>*/ caml_ba_kind(arr)),
-             _aa_);
+             _$_);
     /*<<bigarray.ml:195:47>>*/ }
    function slice(a, n){
      /*<<bigarray.ml:199:4>>*/ return  /*<<bigarray.ml:199:10>>*/ runtime.caml_ba_layout
@@ -22237,32 +22245,32 @@
      /*<<bigarray.ml:209:4>>*/  /*<<bigarray.ml:209:14>>*/ var
      arr = create$0(kind, layout, dim);
      /*<<bigarray.ml:210:4>>*/ if(layout){
-      /*<<bigarray.ml:207:4>>*/  /*<<bigarray.ml:207:4>>*/ var ___ = 1;
+      /*<<bigarray.ml:207:4>>*/  /*<<bigarray.ml:207:4>>*/ var _Z_ = 1;
      if(dim >= 1){
-      var i$0 = ___;
+      var i$0 = _Z_;
       for(;;){
         /*<<bigarray.ml:207:24>>*/  /*<<bigarray.ml:207:24>>*/ caml_ba_set_1
         (arr, i$0,  /*<<bigarray.ml:207:41>>*/ caml_call1(f, i$0));
         /*<<bigarray.ml:207:24>>*/  /*<<bigarray.ml:207:24>>*/ var
-        _$_ = i$0 + 1 | 0;
+        ___ = i$0 + 1 | 0;
        if(dim === i$0) break;
-       var i$0 = _$_;
+       var i$0 = ___;
       }
      }
       /*<<bigarray.ml:212:24>>*/ return arr;
     }
      /*<<bigarray.ml:205:4>>*/ var
-     _Y_ = dim - 1 | 0,
-      /*<<bigarray.ml:205:4>>*/ _X_ = 0;
-    if(_Y_ >= 0){
-     var i = _X_;
+     _X_ = dim - 1 | 0,
+      /*<<bigarray.ml:205:4>>*/ _W_ = 0;
+    if(_X_ >= 0){
+     var i = _W_;
      for(;;){
        /*<<bigarray.ml:205:29>>*/  /*<<bigarray.ml:205:29>>*/ caml_ba_set_1
        (arr, i,  /*<<bigarray.ml:205:46>>*/ caml_call1(f, i));
        /*<<bigarray.ml:205:29>>*/  /*<<bigarray.ml:205:29>>*/ var
-       _Z_ = i + 1 | 0;
-      if(_Y_ === i) break;
-      var i = _Z_;
+       _Y_ = i + 1 | 0;
+      if(_X_ === i) break;
+      var i = _Y_;
      }
     }
      /*<<bigarray.ml:211:18>>*/ return arr;
@@ -22271,17 +22279,17 @@
      /*<<bigarray.ml:214:4>>*/ var
       /*<<bigarray.ml:214:13>>*/ ba = create$0(kind, layout, data.length - 1),
       /*<<bigarray.ml:215:4>>*/ ofs = layout ? 1 : 0,
-     _V_ = data.length - 1 - 1 | 0,
-     _U_ = 0;
-    if(_V_ >= 0){
-     var i = _U_;
+     _U_ = data.length - 1 - 1 | 0,
+     _T_ = 0;
+    if(_U_ >= 0){
+     var i = _T_;
      for(;;){
        /*<<bigarray.ml:220:42>>*/  /*<<bigarray.ml:220:42>>*/ caml_ba_set_1
        (ba, i + ofs | 0, caml_check_bound(data, i)[1 + i]);
        /*<<bigarray.ml:220:42>>*/  /*<<bigarray.ml:220:42>>*/ var
-       _W_ = i + 1 | 0;
-      if(_V_ === i) break;
-      var i = _W_;
+       _V_ = i + 1 | 0;
+      if(_U_ === i) break;
+      var i = _V_;
      }
     }
      /*<<bigarray.ml:221:4>>*/ return ba;
@@ -22292,16 +22300,16 @@
     /*<<bigarray.ml:227:46>>*/ }
    function size_in_bytes$2(arr){
      /*<<bigarray.ml:243:4>>*/ var
-      /*<<bigarray.ml:243:51>>*/ _S_ =
+      /*<<bigarray.ml:243:51>>*/ _R_ =
         /*<<bigarray.ml:243:51>>*/ caml_ba_dim_2(arr),
-      /*<<bigarray.ml:243:38>>*/ _T_ =
+      /*<<bigarray.ml:243:38>>*/ _S_ =
         /*<<bigarray.ml:243:38>>*/ caml_ba_dim_1(arr);
     return caml_mul
             ( /*<<bigarray.ml:243:4>>*/ caml_mul
               (kind_size_in_bytes
                 ( /*<<bigarray.ml:243:24>>*/ caml_ba_kind(arr)),
-               _T_),
-             _S_);
+               _S_),
+             _R_);
     /*<<bigarray.ml:243:61>>*/ }
    function slice_left(a, n){
      /*<<bigarray.ml:250:23>>*/ return  /*<<bigarray.ml:250:23>>*/ caml_ba_slice
@@ -22315,54 +22323,54 @@
      /*<<bigarray.ml:267:4>>*/  /*<<bigarray.ml:267:14>>*/ var
      arr = create$1(kind, layout, dim1, dim2);
      /*<<bigarray.ml:268:4>>*/ if(layout){
-      /*<<bigarray.ml:261:4>>*/  /*<<bigarray.ml:261:4>>*/ var _O_ = 1;
+      /*<<bigarray.ml:261:4>>*/  /*<<bigarray.ml:261:4>>*/ var _N_ = 1;
      if(dim2 >= 1){
-      var j$0 = _O_;
+      var j$0 = _N_;
       for(;;){
-        /*<<bigarray.ml:262:6>>*/  /*<<bigarray.ml:262:6>>*/ var _P_ = 1;
+        /*<<bigarray.ml:262:6>>*/  /*<<bigarray.ml:262:6>>*/ var _O_ = 1;
        if(dim1 >= 1){
-        var i$0 = _P_;
+        var i$0 = _O_;
         for(;;){
           /*<<bigarray.ml:263:8>>*/  /*<<bigarray.ml:263:8>>*/ caml_ba_set_2
           (arr, i$0, j$0,  /*<<bigarray.ml:263:27>>*/ caml_call2(f, i$0, j$0));
           /*<<bigarray.ml:263:8>>*/  /*<<bigarray.ml:263:8>>*/ var
-          _R_ = i$0 + 1 | 0;
+          _Q_ = i$0 + 1 | 0;
          if(dim1 === i$0) break;
-         var i$0 = _R_;
+         var i$0 = _Q_;
         }
        }
         /*<<bigarray.ml:261:4>>*/  /*<<bigarray.ml:261:4>>*/ var
-        _Q_ = j$0 + 1 | 0;
+        _P_ = j$0 + 1 | 0;
        if(dim2 === j$0) break;
-       var j$0 = _Q_;
+       var j$0 = _P_;
       }
      }
       /*<<bigarray.ml:270:24>>*/ return arr;
     }
      /*<<bigarray.ml:255:4>>*/ var
-     _J_ = dim1 - 1 | 0,
-      /*<<bigarray.ml:255:4>>*/ _I_ = 0;
-    if(_J_ >= 0){
-     var i = _I_;
+     _I_ = dim1 - 1 | 0,
+      /*<<bigarray.ml:255:4>>*/ _H_ = 0;
+    if(_I_ >= 0){
+     var i = _H_;
      for(;;){
        /*<<bigarray.ml:256:6>>*/ var
-       _L_ = dim2 - 1 | 0,
-        /*<<bigarray.ml:256:6>>*/ _K_ = 0;
-      if(_L_ >= 0){
-       var j = _K_;
+       _K_ = dim2 - 1 | 0,
+        /*<<bigarray.ml:256:6>>*/ _J_ = 0;
+      if(_K_ >= 0){
+       var j = _J_;
        for(;;){
          /*<<bigarray.ml:257:8>>*/  /*<<bigarray.ml:257:8>>*/ caml_ba_set_2
          (arr, i, j,  /*<<bigarray.ml:257:27>>*/ caml_call2(f, i, j));
          /*<<bigarray.ml:257:8>>*/  /*<<bigarray.ml:257:8>>*/ var
-         _N_ = j + 1 | 0;
-        if(_L_ === j) break;
-        var j = _N_;
+         _M_ = j + 1 | 0;
+        if(_K_ === j) break;
+        var j = _M_;
        }
       }
        /*<<bigarray.ml:255:4>>*/  /*<<bigarray.ml:255:4>>*/ var
-       _M_ = i + 1 | 0;
-      if(_J_ === i) break;
-      var i = _M_;
+       _L_ = i + 1 | 0;
+      if(_I_ === i) break;
+      var i = _L_;
      }
     }
      /*<<bigarray.ml:269:18>>*/ return arr;
@@ -22374,10 +22382,10 @@
        0 === dim1 ? 0 : caml_check_bound(data, 0)[1].length - 1,
       /*<<bigarray.ml:274:13>>*/ ba = create$1(kind, layout, dim1, dim2),
       /*<<bigarray.ml:275:4>>*/ ofs = layout ? 1 : 0,
-      /*<<bigarray.ml:280:4>>*/ _D_ = dim1 - 1 | 0,
-     _C_ = 0;
-    if(_D_ >= 0){
-     var i = _C_;
+      /*<<bigarray.ml:280:4>>*/ _C_ = dim1 - 1 | 0,
+     _B_ = 0;
+    if(_C_ >= 0){
+     var i = _B_;
      for(;;){
        /*<<bigarray.ml:281:16>>*/  /*<<bigarray.ml:281:16>>*/ var
        row = caml_check_bound(data, i)[1 + i];
@@ -22385,23 +22393,23 @@
         /*<<bigarray.ml:283:8>>*/  /*<<bigarray.ml:283:8>>*/ caml_call1
         (Stdlib[1], cst_Bigarray_Array2_of_array_n);
        /*<<bigarray.ml:273:32>>*/ var
-        /*<<bigarray.ml:273:32>>*/ _F_ = dim2 - 1 | 0,
-        /*<<bigarray.ml:283:8>>*/ _E_ = 0;
-      if(_F_ >= 0){
-       var j = _E_;
+        /*<<bigarray.ml:273:32>>*/ _E_ = dim2 - 1 | 0,
+        /*<<bigarray.ml:283:8>>*/ _D_ = 0;
+      if(_E_ >= 0){
+       var j = _D_;
        for(;;){
          /*<<bigarray.ml:285:8>>*/  /*<<bigarray.ml:285:8>>*/ caml_ba_set_2
          (ba, i + ofs | 0, j + ofs | 0, caml_check_bound(row, j)[1 + j]);
          /*<<bigarray.ml:285:8>>*/  /*<<bigarray.ml:285:8>>*/ var
-         _H_ = j + 1 | 0;
-        if(_F_ === j) break;
-        var j = _H_;
+         _G_ = j + 1 | 0;
+        if(_E_ === j) break;
+        var j = _G_;
        }
       }
        /*<<bigarray.ml:280:4>>*/  /*<<bigarray.ml:280:4>>*/ var
-       _G_ = i + 1 | 0;
-      if(_D_ === i) break;
-      var i = _G_;
+       _F_ = i + 1 | 0;
+      if(_C_ === i) break;
+      var i = _F_;
      }
     }
      /*<<bigarray.ml:288:4>>*/ return ba;
@@ -22412,20 +22420,20 @@
     /*<<bigarray.ml:294:52>>*/ }
    function size_in_bytes$3(arr){
      /*<<bigarray.ml:312:4>>*/ var
-      /*<<bigarray.ml:312:64>>*/ _z_ =
+      /*<<bigarray.ml:312:64>>*/ _y_ =
         /*<<bigarray.ml:312:64>>*/ runtime.caml_ba_dim_3(arr),
-      /*<<bigarray.ml:312:51>>*/ _A_ =
+      /*<<bigarray.ml:312:51>>*/ _z_ =
         /*<<bigarray.ml:312:51>>*/ caml_ba_dim_2(arr),
-      /*<<bigarray.ml:312:38>>*/ _B_ =
+      /*<<bigarray.ml:312:38>>*/ _A_ =
         /*<<bigarray.ml:312:38>>*/ caml_ba_dim_1(arr);
     return caml_mul
             (caml_mul
               ( /*<<bigarray.ml:312:4>>*/ caml_mul
                 (kind_size_in_bytes
                   ( /*<<bigarray.ml:312:24>>*/ caml_ba_kind(arr)),
-                 _B_),
-               _A_),
-             _z_);
+                 _A_),
+               _z_),
+             _y_);
     /*<<bigarray.ml:312:74>>*/ }
    function slice_left_1(a, n, m){
      /*<<bigarray.ml:319:27>>*/ return  /*<<bigarray.ml:319:27>>*/ caml_ba_slice
@@ -22447,17 +22455,17 @@
      /*<<bigarray.ml:342:4>>*/  /*<<bigarray.ml:342:14>>*/ var
      arr = create$2(kind, layout, dim1, dim2, dim3);
      /*<<bigarray.ml:343:4>>*/ if(layout){
-      /*<<bigarray.ml:334:4>>*/  /*<<bigarray.ml:334:4>>*/ var _t_ = 1;
+      /*<<bigarray.ml:334:4>>*/  /*<<bigarray.ml:334:4>>*/ var _s_ = 1;
      if(dim3 >= 1){
-      var k$0 = _t_;
+      var k$0 = _s_;
       for(;;){
-        /*<<bigarray.ml:335:6>>*/  /*<<bigarray.ml:335:6>>*/ var _u_ = 1;
+        /*<<bigarray.ml:335:6>>*/  /*<<bigarray.ml:335:6>>*/ var _t_ = 1;
        if(dim2 >= 1){
-        var j$0 = _u_;
+        var j$0 = _t_;
         for(;;){
-          /*<<bigarray.ml:336:8>>*/  /*<<bigarray.ml:336:8>>*/ var _w_ = 1;
+          /*<<bigarray.ml:336:8>>*/  /*<<bigarray.ml:336:8>>*/ var _v_ = 1;
          if(dim1 >= 1){
-          var i$0 = _w_;
+          var i$0 = _v_;
           for(;;){
             /*<<bigarray.ml:337:10>>*/  /*<<bigarray.ml:337:10>>*/ caml_ba_set_3
             (arr,
@@ -22466,61 +22474,61 @@
              k$0,
               /*<<bigarray.ml:337:31>>*/ caml_call3(f, i$0, j$0, k$0));
             /*<<bigarray.ml:337:10>>*/  /*<<bigarray.ml:337:10>>*/ var
-            _y_ = i$0 + 1 | 0;
+            _x_ = i$0 + 1 | 0;
            if(dim1 === i$0) break;
-           var i$0 = _y_;
+           var i$0 = _x_;
           }
          }
           /*<<bigarray.ml:335:6>>*/  /*<<bigarray.ml:335:6>>*/ var
-          _x_ = j$0 + 1 | 0;
+          _w_ = j$0 + 1 | 0;
          if(dim2 === j$0) break;
-         var j$0 = _x_;
+         var j$0 = _w_;
         }
        }
         /*<<bigarray.ml:334:4>>*/  /*<<bigarray.ml:334:4>>*/ var
-        _v_ = k$0 + 1 | 0;
+        _u_ = k$0 + 1 | 0;
        if(dim3 === k$0) break;
-       var k$0 = _v_;
+       var k$0 = _u_;
       }
      }
       /*<<bigarray.ml:345:24>>*/ return arr;
     }
      /*<<bigarray.ml:326:4>>*/ var
-     _l_ = dim1 - 1 | 0,
-      /*<<bigarray.ml:326:4>>*/ _k_ = 0;
-    if(_l_ >= 0){
-     var i = _k_;
+     _k_ = dim1 - 1 | 0,
+      /*<<bigarray.ml:326:4>>*/ _j_ = 0;
+    if(_k_ >= 0){
+     var i = _j_;
      for(;;){
        /*<<bigarray.ml:327:6>>*/ var
-       _n_ = dim2 - 1 | 0,
-        /*<<bigarray.ml:327:6>>*/ _m_ = 0;
-      if(_n_ >= 0){
-       var j = _m_;
+       _m_ = dim2 - 1 | 0,
+        /*<<bigarray.ml:327:6>>*/ _l_ = 0;
+      if(_m_ >= 0){
+       var j = _l_;
        for(;;){
          /*<<bigarray.ml:328:8>>*/ var
-         _q_ = dim3 - 1 | 0,
-          /*<<bigarray.ml:328:8>>*/ _p_ = 0;
-        if(_q_ >= 0){
-         var k = _p_;
+         _p_ = dim3 - 1 | 0,
+          /*<<bigarray.ml:328:8>>*/ _o_ = 0;
+        if(_p_ >= 0){
+         var k = _o_;
          for(;;){
            /*<<bigarray.ml:329:10>>*/  /*<<bigarray.ml:329:10>>*/ caml_ba_set_3
            (arr, i, j, k,  /*<<bigarray.ml:329:31>>*/ caml_call3(f, i, j, k));
            /*<<bigarray.ml:329:10>>*/  /*<<bigarray.ml:329:10>>*/ var
-           _s_ = k + 1 | 0;
-          if(_q_ === k) break;
-          var k = _s_;
+           _r_ = k + 1 | 0;
+          if(_p_ === k) break;
+          var k = _r_;
          }
         }
          /*<<bigarray.ml:327:6>>*/  /*<<bigarray.ml:327:6>>*/ var
-         _r_ = j + 1 | 0;
-        if(_n_ === j) break;
-        var j = _r_;
+         _q_ = j + 1 | 0;
+        if(_m_ === j) break;
+        var j = _q_;
        }
       }
        /*<<bigarray.ml:326:4>>*/  /*<<bigarray.ml:326:4>>*/ var
-       _o_ = i + 1 | 0;
-      if(_l_ === i) break;
-      var i = _o_;
+       _n_ = i + 1 | 0;
+      if(_k_ === i) break;
+      var i = _n_;
      }
     }
      /*<<bigarray.ml:344:18>>*/ return arr;
@@ -22536,10 +22544,10 @@
         : caml_check_bound(caml_check_bound(data, 0)[1], 0)[1].length - 1,
       /*<<bigarray.ml:350:13>>*/ ba = create$2(kind, layout, dim1, dim2, dim3),
       /*<<bigarray.ml:351:4>>*/ ofs = layout ? 1 : 0,
-      /*<<bigarray.ml:356:4>>*/ _c_ = dim1 - 1 | 0,
-     _b_ = 0;
-    if(_c_ >= 0){
-     var i = _b_;
+      /*<<bigarray.ml:356:4>>*/ _b_ = dim1 - 1 | 0,
+     _a_ = 0;
+    if(_b_ >= 0){
+     var i = _a_;
      for(;;){
        /*<<bigarray.ml:357:16>>*/  /*<<bigarray.ml:357:16>>*/ var
        row = caml_check_bound(data, i)[1 + i];
@@ -22547,10 +22555,10 @@
         /*<<bigarray.ml:359:8>>*/  /*<<bigarray.ml:359:8>>*/ caml_call1
         (Stdlib[1], cst_Bigarray_Array3_of_array_n);
        /*<<bigarray.ml:348:32>>*/ var
-        /*<<bigarray.ml:348:32>>*/ _e_ = dim2 - 1 | 0,
-        /*<<bigarray.ml:359:8>>*/ _d_ = 0;
-      if(_e_ >= 0){
-       var j = _d_;
+        /*<<bigarray.ml:348:32>>*/ _d_ = dim2 - 1 | 0,
+        /*<<bigarray.ml:359:8>>*/ _c_ = 0;
+      if(_d_ >= 0){
+       var j = _c_;
        for(;;){
          /*<<bigarray.ml:361:18>>*/  /*<<bigarray.ml:361:18>>*/ var
          col = caml_check_bound(row, j)[1 + j];
@@ -22558,10 +22566,10 @@
           /*<<bigarray.ml:363:10>>*/  /*<<bigarray.ml:363:10>>*/ caml_call1
           (Stdlib[1], cst_Bigarray_Array3_of_array_n$0);
          /*<<bigarray.ml:349:32>>*/ var
-          /*<<bigarray.ml:349:32>>*/ _h_ = dim3 - 1 | 0,
-          /*<<bigarray.ml:363:10>>*/ _g_ = 0;
-        if(_h_ >= 0){
-         var k = _g_;
+          /*<<bigarray.ml:349:32>>*/ _g_ = dim3 - 1 | 0,
+          /*<<bigarray.ml:363:10>>*/ _f_ = 0;
+        if(_g_ >= 0){
+         var k = _f_;
          for(;;){
            /*<<bigarray.ml:365:10>>*/  /*<<bigarray.ml:365:10>>*/ caml_ba_set_3
            (ba,
@@ -22570,21 +22578,21 @@
             k + ofs | 0,
             caml_check_bound(col, k)[1 + k]);
            /*<<bigarray.ml:365:10>>*/  /*<<bigarray.ml:365:10>>*/ var
-           _j_ = k + 1 | 0;
-          if(_h_ === k) break;
-          var k = _j_;
+           _i_ = k + 1 | 0;
+          if(_g_ === k) break;
+          var k = _i_;
          }
         }
          /*<<bigarray.ml:359:8>>*/  /*<<bigarray.ml:359:8>>*/ var
-         _i_ = j + 1 | 0;
-        if(_e_ === j) break;
-        var j = _i_;
+         _h_ = j + 1 | 0;
+        if(_d_ === j) break;
+        var j = _h_;
        }
       }
        /*<<bigarray.ml:356:4>>*/  /*<<bigarray.ml:356:4>>*/ var
-       _f_ = i + 1 | 0;
-      if(_c_ === i) break;
-      var i = _f_;
+       _e_ = i + 1 | 0;
+      if(_b_ === i) break;
+      var i = _e_;
      }
     }
      /*<<bigarray.ml:369:4>>*/ return ba;
@@ -24163,13 +24171,13 @@
             : runtime.caml_call_gen(f, [a0, a1, a2, a3, a4]);
    }
    var
+    sentinal = undefined,
     global_data = runtime.caml_get_global_data(),
     Stdlib = global_data.Stdlib,
     Stdlib_Sys = global_data.Stdlib__Sys,
     Stdlib_Int = global_data.Stdlib__Int,
     Stdlib_Array = global_data.Stdlib__Array,
     Stdlib_Obj = global_data.Stdlib__Obj,
-    _a_ = undefined,
     cst_Weak_Make_hash_bucket_cann = "Weak.Make: hash bucket cannot grow more",
     cst_Weak_fill = "Weak.fill",
     cst_Weak_blit = "Weak.blit",
@@ -24180,9 +24188,9 @@
     cst_Weak_create = "Weak.create";
    function create(l){
      /*<<weak.ml:28:2>>*/ var
-     _X_ = 0 <= l ? 1 : 0,
-     _Y_ = _X_ ? l <= Stdlib_Obj[24][15] ? 1 : 0 : _X_;
-    if(1 - _Y_)
+     _W_ = 0 <= l ? 1 : 0,
+     _X_ = _W_ ? l <= Stdlib_Obj[24][15] ? 1 : 0 : _W_;
+    if(1 - _X_)
       /*<<weak.ml:29:4>>*/  /*<<weak.ml:29:4>>*/ caml_call1
       (Stdlib[1], cst_Weak_create);
      /*<<weak.ml:30:2>>*/ return  /*<<weak.ml:30:2>>*/ runtime.caml_weak_create
@@ -24193,10 +24201,12 @@
     /*<<weak.ml:33:55>>*/ }
    function raise_if_invalid_offset(e, o, msg){
      /*<<weak.ml:36:2>>*/ var
-     _U_ = 0 <= o ? 1 : 0,
-     _V_ = _U_ ? o < length(e) ? 1 : 0 : _U_,
-     _W_ = 1 - _V_;
-    return _W_ ? ( /*<<weak.ml:37:4>>*/ caml_call1(Stdlib[1], msg), _a_) : _W_;
+     _T_ = 0 <= o ? 1 : 0,
+     _U_ = _T_ ? o < length(e) ? 1 : 0 : _T_,
+     _V_ = 1 - _U_;
+    return _V_
+            ? ( /*<<weak.ml:37:4>>*/ caml_call1(Stdlib[1], msg), sentinal)
+            : _V_;
     /*<<weak.ml:37:20>>*/ }
    function set(e, o, x){
      /*<<weak.ml:42:2>>*/ raise_if_invalid_offset(e, o, cst_Weak_set);
@@ -24229,13 +24239,13 @@
        0 <= o1
        && (length(e1) - l | 0) >= o1 && 0 <= o2 && (length(e2) - l | 0) >= o2){
      var
-      _S_ = 0 !== l ? 1 : 0,
-      _T_ =
-        _S_
+      _R_ = 0 !== l ? 1 : 0,
+      _S_ =
+        _R_
          ?  /*<<weak.ml:69:22>>*/ runtime.caml_ephe_blit_key
            (e1, o1, e2, o2, l)
-         : _S_;
-      /*<<weak.ml:69:22>>*/ return _T_;
+         : _R_;
+      /*<<weak.ml:69:22>>*/ return _S_;
     }
      /*<<weak.ml:68:7>>*/ return  /*<<weak.ml:68:7>>*/ caml_call1
             (Stdlib[1], cst_Weak_blit);
@@ -24243,14 +24253,14 @@
    function fill(ar, ofs, len, x){
      /*<<weak.ml:72:2>>*/ if
      (0 <= ofs && 0 <= len && (length(ar) - len | 0) >= ofs){
-     var _Q_ = (ofs + len | 0) - 1 | 0;
-     if(_Q_ >= ofs){
+     var _P_ = (ofs + len | 0) - 1 | 0;
+     if(_P_ >= ofs){
       var i = ofs;
       for(;;){
         /*<<weak.ml:76:6>>*/ set(ar, i, x);
-        /*<<weak.ml:76:6>>*/  /*<<weak.ml:76:6>>*/ var _R_ = i + 1 | 0;
-       if(_Q_ === i) break;
-       var i = _R_;
+        /*<<weak.ml:76:6>>*/  /*<<weak.ml:76:6>>*/ var _Q_ = i + 1 | 0;
+       if(_P_ === i) break;
+       var i = _Q_;
       }
      }
      return 0;
@@ -24278,16 +24288,16 @@
      /*<<weak.ml:131:5>>*/ }
     function clear(t){
       /*<<weak.ml:134:4>>*/ var
-      _O_ = t[1].length - 1 - 1 | 0,
-       /*<<weak.ml:134:4>>*/ _N_ = 0;
-     if(_O_ >= 0){
-      var i = _N_;
+      _N_ = t[1].length - 1 - 1 | 0,
+       /*<<weak.ml:134:4>>*/ _M_ = 0;
+     if(_N_ >= 0){
+      var i = _M_;
       for(;;){
         /*<<weak.ml:135:6>>*/ caml_check_bound(t[1], i)[1 + i] = emptybucket;
         /*<<weak.ml:136:6>>*/ caml_check_bound(t[2], i)[1 + i] = [0];
-        /*<<weak.ml:136:6>>*/  /*<<weak.ml:136:6>>*/ var _P_ = i + 1 | 0;
-       if(_O_ === i) break;
-       var i = _P_;
+        /*<<weak.ml:136:6>>*/  /*<<weak.ml:136:6>>*/ var _O_ = i + 1 | 0;
+       if(_N_ === i) break;
+       var i = _O_;
       }
      }
      t[3] = limit;
@@ -24295,8 +24305,8 @@
      return 0;
      /*<<weak.ml:139:19>>*/ }
     function fold(f, t, init){
-      /*<<weak.ml:143:4>>*/ var _L_ = t[1], i = 0;
-      /*<<weak.ml:149:21>>*/ function _M_(b, accu$1){
+      /*<<weak.ml:143:4>>*/ var _K_ = t[1], i = 0;
+      /*<<weak.ml:149:21>>*/ function _L_(b, accu$1){
       var i$0 = i, accu = accu$1;
        /*<<weak.ml:144:6>>*/ for(;;){
        if(length(b) <= i$0)  /*<<weak.ml:144:28>>*/ return accu;
@@ -24315,11 +24325,11 @@
       }
      }
       /*<<weak.ml:149:4>>*/ return  /*<<weak.ml:149:4>>*/ caml_call3
-             (Stdlib_Array[17], _M_, _L_, init);
+             (Stdlib_Array[17], _L_, _K_, init);
      /*<<weak.ml:149:49>>*/ }
     function iter(f, t){
-      /*<<weak.ml:153:4>>*/ var _J_ = t[1], i = 0;
-      /*<<weak.ml:159:15>>*/ function _K_(b){
+      /*<<weak.ml:153:4>>*/ var _I_ = t[1], i = 0;
+      /*<<weak.ml:159:15>>*/ function _J_(b){
       var i$0 = i;
        /*<<weak.ml:154:6>>*/ for(;;){
        if(length(b) <= i$0)  /*<<weak.ml:154:28>>*/ return 0;
@@ -24335,15 +24345,15 @@
       }
      }
       /*<<weak.ml:159:15>>*/ return  /*<<weak.ml:159:15>>*/ caml_call2
-             (Stdlib_Array[11], _K_, _J_);
+             (Stdlib_Array[11], _J_, _I_);
      /*<<weak.ml:159:38>>*/ }
     function count_bucket(i, b, accu){
       /*<<weak.ml:173:4>>*/ var i$0 = i, accu$0 = accu;
       /*<<weak.ml:173:4>>*/ for(;;){
       if(length(b) <= i$0)  /*<<weak.ml:173:26>>*/ return accu$0;
        /*<<weak.ml:174:37>>*/ var
-        /*<<weak.ml:174:37>>*/ _I_ = check(b, i$0) ? 1 : 0,
-       accu$1 = accu$0 + _I_ | 0,
+        /*<<weak.ml:174:37>>*/ _H_ = check(b, i$0) ? 1 : 0,
+       accu$1 = accu$0 + _H_ | 0,
        i$1 = i$0 + 1 | 0,
        i$0 = i$1,
        accu$0 = accu$1;
@@ -24351,14 +24361,14 @@
      /*<<weak.ml:174:62>>*/ }
     function count(t){
       /*<<weak.ml:178:4>>*/ var
-       /*<<weak.ml:178:4>>*/ _C_ = 0,
-      _D_ = t[1],
-      _E_ = 0;
-      /*<<weak.ml:178:21>>*/ function _F_(_G_, _H_){
-       /*<<?>>*/ return count_bucket(_E_, _G_, _H_);
+       /*<<weak.ml:178:4>>*/ _B_ = 0,
+      _C_ = t[1],
+      _D_ = 0;
+      /*<<weak.ml:178:21>>*/ function _E_(_F_, _G_){
+       /*<<?>>*/ return count_bucket(_D_, _F_, _G_);
      }
       /*<<weak.ml:178:4>>*/ return  /*<<weak.ml:178:4>>*/ caml_call3
-             (Stdlib_Array[17], _F_, _D_, _C_);
+             (Stdlib_Array[17], _E_, _C_, _B_);
      /*<<weak.ml:178:47>>*/ }
     function add_aux(t, setter, d, h, index){
       /*<<weak.ml:238:4>>*/ var
@@ -24391,18 +24401,18 @@
         /*<<weak.ml:252:8>>*/ caml_check_bound(newhashes, sz)[1 + sz] = h;
         /*<<weak.ml:253:8>>*/ caml_check_bound(t[1], index)[1 + index] = newbucket$0;
         /*<<weak.ml:254:8>>*/ caml_check_bound(t[2], index)[1 + index] = newhashes;
-       var _y_ = sz <= t[3] ? 1 : 0, _z_ = _y_ ? t[3] < newsz ? 1 : 0 : _y_;
-       if(_z_){
+       var _x_ = sz <= t[3] ? 1 : 0, _y_ = _x_ ? t[3] < newsz ? 1 : 0 : _x_;
+       if(_y_){
         t[4] = t[4] + 1 | 0;
         var i$4 = 0;
         for(;;){
           /*<<weak.ml:185:17>>*/ var
-          _o_ = t[5],
+          _n_ = t[5],
            /*<<weak.ml:185:17>>*/ bucket =
-            caml_check_bound(t[1], _o_)[1 + _o_],
-           /*<<weak.ml:186:4>>*/ _p_ = t[5],
+            caml_check_bound(t[1], _n_)[1 + _n_],
+           /*<<weak.ml:186:4>>*/ _o_ = t[5],
            /*<<weak.ml:186:18>>*/ hbucket =
-            caml_check_bound(t[2], _p_)[1 + _p_],
+            caml_check_bound(t[2], _o_)[1 + _o_],
            /*<<weak.ml:187:14>>*/ len = length(bucket),
           prev_len = (((len - 3 | 0) * 2 | 0) + 2 | 0) / 3 | 0,
            /*<<weak.ml:189:15>>*/ live = count_bucket(0, bucket, 0);
@@ -24414,28 +24424,28 @@
            /*<<weak.ml:192:8>>*/ for(;;){
            if(prev_len > j){
             if(0 === prev_len){
+             var _q_ = t[5];
+              /*<<weak.ml:203:8>>*/ caml_check_bound(t[1], _q_)[1 + _q_] = emptybucket;
              var _r_ = t[5];
-              /*<<weak.ml:203:8>>*/ caml_check_bound(t[1], _r_)[1 + _r_] = emptybucket;
-             var _s_ = t[5];
-              /*<<weak.ml:204:8>>*/ caml_check_bound(t[2], _s_)[1 + _s_] = [0];
+              /*<<weak.ml:204:8>>*/ caml_check_bound(t[2], _r_)[1 + _r_] = [0];
             }
             else{
               /*<<weak.ml:206:24>>*/  /*<<weak.ml:206:24>>*/ var
               newbucket = create(prev_len);
               /*<<weak.ml:207:8>>*/ blit(bucket, 0, newbucket, 0, prev_len);
-             var _v_ = t[5];
-              /*<<weak.ml:208:8>>*/ caml_check_bound(t[1], _v_)[1 + _v_] = newbucket;
+             var _u_ = t[5];
+              /*<<weak.ml:208:8>>*/ caml_check_bound(t[1], _u_)[1 + _u_] = newbucket;
               /*<<weak.ml:209:30>>*/ var
-               /*<<weak.ml:209:30>>*/ _w_ =
+               /*<<weak.ml:209:30>>*/ _v_ =
                  /*<<weak.ml:209:30>>*/ caml_call3
                  (Stdlib_Array[5], hbucket, 0, prev_len),
-              _x_ = t[5];
-              /*<<weak.ml:209:8>>*/ caml_check_bound(t[2], _x_)[1 + _x_] = _w_;
+              _w_ = t[5];
+              /*<<weak.ml:209:8>>*/ caml_check_bound(t[2], _w_)[1 + _w_] = _v_;
             }
             var
-             _t_ = t[3] < len ? 1 : 0,
-             _u_ = _t_ ? prev_len <= t[3] ? 1 : 0 : _t_;
-            if(_u_) t[4] = t[4] - 1 | 0;
+             _s_ = t[3] < len ? 1 : 0,
+             _t_ = _s_ ? prev_len <= t[3] ? 1 : 0 : _s_;
+            if(_t_) t[4] = t[4] - 1 | 0;
             break;
            }
             /*<<weak.ml:193:13>>*/ if(check(bucket, i$0))
@@ -24443,8 +24453,8 @@
            else if(check(bucket, j)){
              /*<<weak.ml:195:12>>*/ blit(bucket, j, bucket, i$0, 1);
              /*<<weak.ml:196:27>>*/  /*<<weak.ml:196:27>>*/ var
-             _q_ = caml_check_bound(hbucket, j)[1 + j];
-             /*<<weak.ml:196:12>>*/ caml_check_bound(hbucket, i$0)[1 + i$0] = _q_;
+             _p_ = caml_check_bound(hbucket, j)[1 + j];
+             /*<<weak.ml:196:12>>*/ caml_check_bound(hbucket, i$0)[1 + i$0] = _p_;
              /*<<weak.ml:196:12>>*/ var
               /*<<weak.ml:196:12>>*/ j$0 = j - 1 | 0,
              i$2 = i$0 + 1 | 0,
@@ -24459,13 +24469,13 @@
          }
          t[5] = caml_mod(t[5] + 1 | 0, t[1].length - 1);
           /*<<weak.ml:257:38>>*/  /*<<weak.ml:257:38>>*/ var
-          _B_ = i$4 + 1 | 0;
+          _A_ = i$4 + 1 | 0;
          if(2 === i$4) break;
-         var i$4 = _B_;
+         var i$4 = _A_;
         }
        }
-       var _A_ = ((t[1].length - 1) / 2 | 0) < t[4] ? 1 : 0;
-       if(! _A_) return _A_;
+       var _z_ = ((t[1].length - 1) / 2 | 0) < t[4] ? 1 : 0;
+       if(! _z_) return _z_;
         /*<<weak.ml:181:18>>*/ var
         oldlen = t[1].length - 1,
          /*<<weak.ml:181:18>>*/ newlen =
@@ -24476,9 +24486,9 @@
        if(oldlen < newlen){
          /*<<weak.ml:220:17>>*/ var
           /*<<weak.ml:220:17>>*/ newt = create$0(newlen),
-         _m_ = t[1],
+         _l_ = t[1],
          i = 0,
-          /*<<weak.ml:169:16>>*/ _n_ =
+          /*<<weak.ml:169:16>>*/ _m_ =
            function(j, ob){
             var oi = i;
              /*<<weak.ml:164:6>>*/ for(;;){
@@ -24504,7 +24514,7 @@
             }
            };
          /*<<weak.ml:169:16>>*/  /*<<weak.ml:169:16>>*/ caml_call2
-         (Stdlib_Array[12], _n_, _m_);
+         (Stdlib_Array[12], _m_, _l_);
         t[1] = newt[1];
         t[2] = newt[2];
         t[3] = newt[3];
@@ -24665,24 +24675,24 @@
      }
      /*<<weak.ml:337:10>>*/ }
     function remove(t, d){
-      /*<<weak.ml:340:19>>*/  /*<<weak.ml:340:19>>*/ var _l_ = 0;
+      /*<<weak.ml:340:19>>*/  /*<<weak.ml:340:19>>*/ var _k_ = 0;
       /*<<weak.ml:340:19>>*/ return find_shadow
              (t,
               d,
               function(w, i){
                 /*<<weak.ml:340:47>>*/ return set(w, i, 0);
                /*<<weak.ml:340:59>>*/ },
-              _l_);
+              _k_);
      /*<<weak.ml:340:63>>*/ }
     function mem(t, d){
-      /*<<weak.ml:343:16>>*/  /*<<weak.ml:343:16>>*/ var _k_ = 0;
+      /*<<weak.ml:343:16>>*/  /*<<weak.ml:343:16>>*/ var _j_ = 0;
       /*<<weak.ml:343:16>>*/ return find_shadow
              (t,
               d,
               function(w, i){
                 /*<<weak.ml:343:46>>*/ return 1;
                /*<<weak.ml:343:50>>*/ },
-              _k_);
+              _j_);
      /*<<weak.ml:343:57>>*/ }
     function find_all(t, d){
       /*<<weak.ml:347:4>>*/ var
@@ -24732,17 +24742,17 @@
          /*<<weak.ml:369:15>>*/ caml_call2(Stdlib_Array[13], length, t[1]);
       /*<<weak.ml:370:4>>*/  /*<<weak.ml:370:4>>*/ caml_call2
       (Stdlib_Array[30], runtime.caml_int_compare, lens);
-     var _b_ = 0;
-     function _c_(_j_, _i_){ /*<<?>>*/ return _j_ + _i_ | 0;}
+     var _a_ = 0;
+     function _b_(_i_, _h_){ /*<<?>>*/ return _i_ + _h_ | 0;}
       /*<<weak.ml:371:17>>*/ var
        /*<<weak.ml:371:17>>*/ totlen =
-         /*<<weak.ml:371:17>>*/ caml_call3(Stdlib_Array[15], _c_, _b_, lens),
-       /*<<weak.ml:371:17>>*/ _d_ = len - 1 | 0,
-      _f_ = len / 2 | 0,
-       /*<<weak.ml:372:51>>*/ _e_ = caml_check_bound(lens, _d_)[1 + _d_],
-       /*<<weak.ml:372:37>>*/ _g_ = caml_check_bound(lens, _f_)[1 + _f_],
-       /*<<weak.ml:372:27>>*/ _h_ = caml_check_bound(lens, 0)[1];
-      /*<<weak.ml:372:4>>*/ return [0, len, count(t), totlen, _h_, _g_, _e_];
+         /*<<weak.ml:371:17>>*/ caml_call3(Stdlib_Array[15], _b_, _a_, lens),
+       /*<<weak.ml:371:17>>*/ _c_ = len - 1 | 0,
+      _e_ = len / 2 | 0,
+       /*<<weak.ml:372:51>>*/ _d_ = caml_check_bound(lens, _c_)[1 + _c_],
+       /*<<weak.ml:372:37>>*/ _f_ = caml_check_bound(lens, _e_)[1 + _e_],
+       /*<<weak.ml:372:27>>*/ _g_ = caml_check_bound(lens, 0)[1];
+      /*<<weak.ml:372:4>>*/ return [0, len, count(t), totlen, _g_, _f_, _d_];
      /*<<weak.ml:372:64>>*/ }
      /*<<weak.ml:101:66>>*/ return [0,
             create$0,
@@ -24799,7 +24809,7 @@
             : runtime.caml_call_gen(f, [a0, a1, a2, a3]);
    }
    var
-    _m_ = undefined,
+    sentinal = undefined,
     global_data = runtime.caml_get_global_data(),
     cst$14 = ".",
     cst$11 = cst$15,
@@ -24849,25 +24859,25 @@
    function pp_output_string(state, s){
      /*<<format.ml:251:31>>*/ caml_call3
      (state[17], s, 0, caml_ml_string_length(s));
-    return _m_;
+    return sentinal;
     /*<<format.ml:251:72>>*/ }
    function pp_output_newline(state){
      /*<<format.ml:252:30>>*/  /*<<format.ml:252:30>>*/ caml_call1
      (state[19], 0);
-     /*<<format.ml:252:30>>*/ return _m_;
+     /*<<format.ml:252:30>>*/ return sentinal;
     /*<<format.ml:252:53>>*/ }
    function format_pp_text(state, size, text){
      /*<<format.ml:258:2>>*/ state[9] = state[9] - size | 0;
      /*<<format.ml:259:2>>*/ pp_output_string(state, text);
     state[11] = 0;
-    return _m_;
+    return sentinal;
     /*<<format.ml:260:31>>*/ }
    function format_string(state, s){
      /*<<format.ml:264:2>>*/  /*<<format.ml:264:5>>*/ var
-     _bO_ =  /*<<format.ml:264:5>>*/ runtime.caml_string_notequal(s, cst$16);
-     /*<<format.ml:264:5>>*/ return _bO_
-            ? (format_pp_text(state, caml_ml_string_length(s), s), _m_)
-            : _bO_;
+     _bN_ =  /*<<format.ml:264:5>>*/ runtime.caml_string_notequal(s, cst$16);
+     /*<<format.ml:264:5>>*/ return _bN_
+            ? (format_pp_text(state, caml_ml_string_length(s), s), sentinal)
+            : _bN_;
     /*<<format.ml:264:58>>*/ }
    function break_new_line(state, param, width){
     var after = param[3], offset = param[2], before = param[1];
@@ -24884,11 +24894,11 @@
      /*<<format.ml:254:31>>*/  /*<<format.ml:254:31>>*/ caml_call1
      (state[21], n);
      /*<<format.ml:276:2>>*/ format_string(state, after);
-     /*<<format.ml:276:2>>*/ return _m_;
+     /*<<format.ml:276:2>>*/ return sentinal;
    }
    function break_line(state, width){
      /*<<format.ml:281:29>>*/ break_new_line(state, _a_, width);
-     /*<<format.ml:281:29>>*/ return _m_;
+     /*<<format.ml:281:29>>*/ return sentinal;
     /*<<format.ml:281:67>>*/ }
    function break_same_line(state, param){
     var after = param[3], width = param[2], before = param[1];
@@ -24897,7 +24907,7 @@
      /*<<format.ml:253:31>>*/  /*<<format.ml:253:31>>*/ caml_call1
      (state[20], width);
      /*<<format.ml:287:2>>*/ format_string(state, after);
-     /*<<format.ml:287:2>>*/ return _m_;
+     /*<<format.ml:287:2>>*/ return sentinal;
    }
    function format_pp_token(state, size$0, param){
      /*<<?>>*/ if(typeof param === "number")
@@ -24906,7 +24916,7 @@
          /*<<format.ml:348:16>>*/  /*<<format.ml:348:16>>*/ var
          match$3 =
             /*<<format.ml:348:16>>*/ caml_call1(Stdlib_Stack[7], state[3]);
-        if(! match$3)  /*<<format.ml:349:14>>*/ return _m_;
+        if(! match$3)  /*<<format.ml:349:14>>*/ return sentinal;
          /*<<format.ml:351:6>>*/ var
          tabs = match$3[1][1],
           /*<<format.ml:351:6>>*/ add_tab =
@@ -24919,15 +24929,15 @@
                     : [0, x, add_tab(n, l)];
            };
         tabs[1] = add_tab(state[6] - state[9] | 0, tabs[1]);
-        return _m_;
+        return sentinal;
        case 1:
          /*<<format.ml:339:4>>*/  /*<<format.ml:339:4>>*/ caml_call1
          (Stdlib_Stack[5], state[2]);
-         /*<<format.ml:339:4>>*/ return _m_;
+         /*<<format.ml:339:4>>*/ return sentinal;
        case 2:
          /*<<format.ml:345:4>>*/  /*<<format.ml:345:4>>*/ caml_call1
          (Stdlib_Stack[5], state[3]);
-         /*<<format.ml:345:4>>*/ return _m_;
+         /*<<format.ml:345:4>>*/ return sentinal;
        case 3:
          /*<<format.ml:378:16>>*/  /*<<format.ml:378:16>>*/ var
          match$4 =
@@ -24935,38 +24945,38 @@
         if(match$4){
          var width$0 = match$4[1][2];
           /*<<format.ml:380:26>>*/ break_line(state, width$0);
-          /*<<format.ml:380:26>>*/ return _m_;
+          /*<<format.ml:380:26>>*/ return sentinal;
         }
          /*<<format.ml:379:14>>*/ pp_output_newline(state);
-         /*<<format.ml:379:14>>*/ return _m_;
+         /*<<format.ml:379:14>>*/ return sentinal;
        case 4:
-        var _bM_ = state[10] !== (state[6] - state[9] | 0) ? 1 : 0;
-        if(! _bM_) return _bM_;
+        var _bL_ = state[10] !== (state[6] - state[9] | 0) ? 1 : 0;
+        if(! _bL_) return _bL_;
          /*<<format.ml:306:8>>*/  /*<<format.ml:306:8>>*/ var
          match$1 =
             /*<<format.ml:306:8>>*/ caml_call1(Stdlib_Queue[6], state[28]);
-        if(! match$1)  /*<<format.ml:307:12>>*/ return _m_;
+        if(! match$1)  /*<<format.ml:307:12>>*/ return sentinal;
         var match$2 = match$1[1], size = match$2[1], length = match$2[3];
         state[12] = state[12] - length | 0;
         state[9] = state[9] + size | 0;
-        return _m_;
+        return sentinal;
        default:
          /*<<format.ml:419:17>>*/  /*<<format.ml:419:17>>*/ var
          match$5 =
             /*<<format.ml:419:17>>*/ caml_call1(Stdlib_Stack[5], state[5]);
-        if(! match$5)  /*<<format.ml:420:15>>*/ return _m_;
+        if(! match$5)  /*<<format.ml:420:15>>*/ return sentinal;
          /*<<format.ml:422:20>>*/ var
          tag_name = match$5[1],
           /*<<format.ml:422:20>>*/ marker =
             /*<<format.ml:422:20>>*/ caml_call1(state[25], tag_name);
          /*<<format.ml:423:7>>*/ pp_output_string(state, marker);
-         /*<<format.ml:423:7>>*/ return _m_;
+         /*<<format.ml:423:7>>*/ return sentinal;
      }
     switch(param[0]){
       case 0:
        var s = param[1];
         /*<<format.ml:323:4>>*/ format_pp_text(state, size$0, s);
-        /*<<format.ml:323:4>>*/ return _m_;
+        /*<<format.ml:323:4>>*/ return sentinal;
       case 1:
         /*<<format.ml:388:4>>*/ var
         breaks = param[2],
@@ -24975,7 +24985,7 @@
         before = breaks[1],
          /*<<format.ml:389:16>>*/ match$6 =
            /*<<format.ml:389:16>>*/ caml_call1(Stdlib_Stack[7], state[2]);
-       if(! match$6)  /*<<format.ml:390:14>>*/ return _m_;
+       if(! match$6)  /*<<format.ml:390:14>>*/ return sentinal;
        var
         match$7 = match$6[1],
         width$1 = match$7[2],
@@ -24983,24 +24993,24 @@
         /*<<format.ml:392:6>>*/ switch(box_type$0){
          case 0:
            /*<<format.ml:409:19>>*/ break_same_line(state, fits);
-           /*<<format.ml:409:19>>*/ return _m_;
+           /*<<format.ml:409:19>>*/ return sentinal;
          case 1:
            /*<<format.ml:408:19>>*/ break_new_line(state, breaks, width$1);
-           /*<<format.ml:408:19>>*/ return _m_;
+           /*<<format.ml:408:19>>*/ return sentinal;
          case 2:
            /*<<format.ml:406:20>>*/ break_new_line(state, breaks, width$1);
-           /*<<format.ml:406:20>>*/ return _m_;
+           /*<<format.ml:406:20>>*/ return sentinal;
          case 3:
           return state[9] < (size$0 + caml_ml_string_length(before) | 0)
-                  ? (break_new_line(state, breaks, width$1), _m_)
-                  : (break_same_line(state, fits), _m_);
+                  ? (break_new_line(state, breaks, width$1), sentinal)
+                  : (break_same_line(state, fits), sentinal);
          case 4:
           return state[11]
-                  ? (break_same_line(state, fits), _m_)
+                  ? (break_same_line(state, fits), sentinal)
                   : state
                      [9]
                     < (size$0 + caml_ml_string_length(before) | 0)
-                    ? (break_new_line(state, breaks, width$1), _m_)
+                    ? (break_new_line(state, breaks, width$1), sentinal)
                     : ((state
                        [6]
                       - width$1
@@ -25008,11 +25018,11 @@
                       + off
                       | 0)
                       < state[10]
-                      ? (break_new_line(state, breaks, width$1), _m_)
-                      : (break_same_line(state, fits), _m_);
+                      ? (break_new_line(state, breaks, width$1), sentinal)
+                      : (break_same_line(state, fits), sentinal);
          default:
            /*<<format.ml:407:19>>*/ break_same_line(state, fits);
-           /*<<format.ml:407:19>>*/ return _m_;
+           /*<<format.ml:407:19>>*/ return sentinal;
        }
       case 2:
         /*<<format.ml:359:16>>*/ var
@@ -25021,7 +25031,7 @@
         insertion_point = state[6] - state[9] | 0,
          /*<<format.ml:359:16>>*/ match$8 =
            /*<<format.ml:359:16>>*/ caml_call1(Stdlib_Stack[7], state[3]);
-       if(! match$8)  /*<<format.ml:360:14>>*/ return _m_;
+       if(! match$8)  /*<<format.ml:360:14>>*/ return sentinal;
         /*<<format.ml:362:6>>*/ var
         tabs$0 = match$8[1][1],
          /*<<format.ml:362:6>>*/ match$9 = tabs$0[1];
@@ -25031,11 +25041,11 @@
          if(param$0){
           var tail = param$0[2], head = param$0[1];
           if(insertion_point > head){var param$0 = tail; continue;}
-          var _bN_ = head;
+          var _bM_ = head;
          }
          else
-          var _bN_ = first;
-         var tab = _bN_;
+          var _bM_ = first;
+         var tab = _bM_;
          break;
         }
        }
@@ -25045,10 +25055,10 @@
         /*<<format.ml:372:6>>*/ return 0 <= offset
                ? (break_same_line
                   (state, [0, cst$0, offset + n | 0, cst]),
-                 _m_)
+                 sentinal)
                : (break_new_line
                   (state, [0, cst$2, tab + off$0 | 0, cst$1], state[6]),
-                 _m_);
+                 sentinal);
       case 3:
        var
         ty = param[2],
@@ -25072,12 +25082,12 @@
           1 === ty ? 1 : state[9] < size$0 ? ty : 5;
         /*<<format.ml:336:4>>*/  /*<<format.ml:336:4>>*/ caml_call2
         (Stdlib_Stack[3], [0, box_type$1, width$2], state[2]);
-        /*<<format.ml:336:4>>*/ return _m_;
+        /*<<format.ml:336:4>>*/ return sentinal;
       case 4:
        var tbox = param[1];
         /*<<format.ml:342:4>>*/  /*<<format.ml:342:4>>*/ caml_call2
         (Stdlib_Stack[3], tbox, state[3]);
-        /*<<format.ml:342:4>>*/ return _m_;
+        /*<<format.ml:342:4>>*/ return sentinal;
       default:
         /*<<format.ml:414:18>>*/ var
         tag_name$0 = param[1],
@@ -25085,7 +25095,7 @@
            /*<<format.ml:414:18>>*/ caml_call1(state[24], tag_name$0);
         /*<<format.ml:415:5>>*/ pp_output_string(state, marker$0);
        caml_call2(Stdlib_Stack[3], tag_name$0, state[5]);
-       return _m_;
+       return sentinal;
     }
    }
    function advance_left(state){
@@ -25099,10 +25109,10 @@
       length = match$0[3],
       token = match$0[2],
       pending_count = state[13] - state[12] | 0,
-       /*<<format.ml:435:7>>*/ _bK_ = 0 <= size ? 1 : 0,
-       /*<<format.ml:435:7>>*/ _bL_ =
-        _bK_ || (state[9] <= pending_count ? 1 : 0);
-     if(! _bL_)  /*<<format.ml:435:7>>*/ return _bL_;
+       /*<<format.ml:435:7>>*/ _bJ_ = 0 <= size ? 1 : 0,
+       /*<<format.ml:435:7>>*/ _bK_ =
+        _bJ_ || (state[9] <= pending_count ? 1 : 0);
+     if(! _bK_)  /*<<format.ml:435:7>>*/ return _bK_;
       /*<<format.ml:436:6>>*/  /*<<format.ml:436:6>>*/ caml_call1
       (Stdlib_Queue[5], state[28]);
       /*<<format.ml:437:20>>*/  /*<<format.ml:437:20>>*/ var
@@ -25126,28 +25136,31 @@
      queue_elem = [0, unknown, _b_, 0];
      /*<<format.ml:464:2>>*/  /*<<format.ml:464:2>>*/ caml_call2
      (Stdlib_Stack[3], [0, -1, queue_elem], stack);
-     /*<<format.ml:464:2>>*/ return _m_;
+     /*<<format.ml:464:2>>*/ return sentinal;
     /*<<format.ml:464:50>>*/ }
    function set_size(state, ty){
      /*<<format.ml:476:2>>*/  /*<<format.ml:476:8>>*/ var
      match =  /*<<format.ml:476:8>>*/ caml_call1(Stdlib_Stack[7], state[1]);
-    if(! match)  /*<<format.ml:477:12>>*/ return _m_;
+    if(! match)  /*<<format.ml:477:12>>*/ return sentinal;
      /*<<format.ml:479:4>>*/ var
      match$0 = match[1],
      queue_elem = match$0[2],
      left_total = match$0[1],
       /*<<format.ml:479:4>>*/ size = queue_elem[1];
-    if(left_total < state[12]){initialize_scan_stack(state[1]); return _m_;}
-    var _bJ_ = queue_elem[2];
-    if(typeof _bJ_ !== "number")
-     switch(_bJ_[0]){
+    if(left_total < state[12]){
+     initialize_scan_stack(state[1]);
+     return sentinal;
+    }
+    var _bI_ = queue_elem[2];
+    if(typeof _bI_ !== "number")
+     switch(_bI_[0]){
        case 3:
         if(1 - ty){
          queue_elem[1] = state[13] + size | 0;
           /*<<format.ml:493:10>>*/  /*<<format.ml:493:10>>*/ caml_call1
           (Stdlib_Stack[5], state[1]);
         }
-         /*<<format.ml:493:10>>*/ return _m_;
+         /*<<format.ml:493:10>>*/ return sentinal;
        case 1:
        case 2:
         if(ty){
@@ -25155,9 +25168,9 @@
           /*<<format.ml:488:10>>*/  /*<<format.ml:488:10>>*/ caml_call1
           (Stdlib_Stack[5], state[1]);
         }
-         /*<<format.ml:488:10>>*/ return _m_;
+         /*<<format.ml:488:10>>*/ return sentinal;
      }
-     /*<<format.ml:497:8>>*/ return _m_;
+     /*<<format.ml:497:8>>*/ return sentinal;
     /*<<format.ml:497:10>>*/ }
    function scan_push(state, b, token){
      /*<<format.ml:503:2>>*/ pp_enqueue(state, token);
@@ -25175,26 +25188,26 @@
        /*<<format.ml:516:15>>*/ elem = [0, size, [3, indent, br_ty], 0];
       /*<<format.ml:517:4>>*/ return scan_push(state, 0, elem);
     }
-    var _bI_ = state[14] === state[15] ? 1 : 0;
-    if(! _bI_) return _bI_;
+    var _bH_ = state[14] === state[15] ? 1 : 0;
+    if(! _bH_) return _bH_;
     var s = state[16];
      /*<<format.ml:454:2>>*/ return enqueue_string_as
             (state, caml_ml_string_length(s), s);
     /*<<format.ml:519:45>>*/ }
    function pp_close_box(state, param){
-     /*<<format.ml:527:2>>*/ var _bG_ = 1 < state[14] ? 1 : 0;
-    if(_bG_){
+     /*<<format.ml:527:2>>*/ var _bF_ = 1 < state[14] ? 1 : 0;
+    if(_bF_){
      if(state[14] < state[15]){
        /*<<format.ml:531:6>>*/ pp_enqueue(state, [0, zero, 1, 0]);
        /*<<format.ml:532:6>>*/ set_size(state, 1);
        /*<<format.ml:532:27>>*/ set_size(state, 0);
      }
      state[14] = state[14] - 1 | 0;
-     var _bH_ = 0;
+     var _bG_ = 0;
     }
     else
-     var _bH_ = _bG_;
-    return _bH_;
+     var _bG_ = _bF_;
+    return _bG_;
     /*<<format.ml:535:5>>*/ }
    function pp_open_stag(state, tag_name){
      /*<<format.ml:540:2>>*/ if(state[22]){
@@ -25203,8 +25216,8 @@
       /*<<format.ml:543:4>>*/  /*<<format.ml:543:4>>*/ caml_call1
       (state[26], tag_name);
     }
-    var _bF_ = state[23];
-    if(! _bF_) return _bF_;
+    var _bE_ = state[23];
+    if(! _bE_) return _bE_;
      /*<<format.ml:546:16>>*/  /*<<format.ml:546:16>>*/ var
      token = [5, tag_name];
      /*<<format.ml:547:21>>*/ return pp_enqueue(state, [0, zero, token, 0]);
@@ -25212,8 +25225,8 @@
    function pp_close_stag(state, param){
      /*<<format.ml:552:2>>*/ if(state[23])
       /*<<format.ml:553:4>>*/ pp_enqueue(state, [0, zero, 5, 0]);
-    var _bD_ = state[22];
-    if(_bD_){
+    var _bC_ = state[22];
+    if(_bC_){
       /*<<format.ml:555:10>>*/  /*<<format.ml:555:10>>*/ var
       match =  /*<<format.ml:555:10>>*/ caml_call1(Stdlib_Stack[5], state[4]);
      if(match){
@@ -25221,11 +25234,11 @@
        /*<<format.ml:558:6>>*/ return  /*<<format.ml:558:6>>*/ caml_call1
               (state[27], tag_name);
      }
-     var _bE_ = 0;
+     var _bD_ = 0;
     }
     else
-     var _bE_ = _bD_;
-     /*<<format.ml:556:14>>*/ return _bE_;
+     var _bD_ = _bC_;
+     /*<<format.ml:556:14>>*/ return _bD_;
     /*<<format.ml:558:39>>*/ }
    function pp_set_print_tags(state, b){
      /*<<format.ml:560:32>>*/ state[22] = b;
@@ -25279,26 +25292,26 @@
      /*<<format.ml:523:28>>*/ return pp_open_box_gen(state, 0, 3);
     /*<<format.ml:600:23>>*/ }
    function pp_flush_queue(state, b){
-     /*<<format.ml:608:2>>*/ var _bB_ = state[4];
-    function _bC_(param){
+     /*<<format.ml:608:2>>*/ var _bA_ = state[4];
+    function _bB_(param){
       /*<<format.ml:603:23>>*/ return pp_close_stag(state, 0);
      /*<<format.ml:603:45>>*/ }
      /*<<format.ml:603:13>>*/  /*<<format.ml:603:13>>*/ caml_call2
-     (Stdlib_Stack[12], _bC_, _bB_);
+     (Stdlib_Stack[12], _bB_, _bA_);
      /*<<format.ml:610:4>>*/ for(;;){
      if(1 >= state[14]){
       state[13] = pp_infinity;
        /*<<format.ml:613:2>>*/ advance_left(state);
       if(b)  /*<<format.ml:614:12>>*/ pp_output_newline(state);
        /*<<format.ml:614:12>>*/ pp_rinit(state);
-       /*<<format.ml:614:12>>*/ return _m_;
+       /*<<format.ml:614:12>>*/ return sentinal;
      }
       /*<<format.ml:610:4>>*/ pp_close_box(state, 0);
     }
     /*<<format.ml:615:16>>*/ }
    function pp_print_as_size(state, size, s){
-     /*<<format.ml:625:2>>*/ var _bA_ = state[14] < state[15] ? 1 : 0;
-    return _bA_ ? enqueue_string_as(state, size, s) : _bA_;
+     /*<<format.ml:625:2>>*/ var _bz_ = state[14] < state[15] ? 1 : 0;
+    return _bz_ ? enqueue_string_as(state, size, s) : _bz_;
     /*<<format.ml:626:37>>*/ }
    function pp_print_as(state, isize, s){
      /*<<format.ml:630:2>>*/ return pp_print_as_size(state, isize, s);
@@ -25357,20 +25370,20 @@
             (state[18], 0);
     /*<<format.ml:673:51>>*/ }
    function pp_force_newline(state, param){
-     /*<<format.ml:678:2>>*/ var _bz_ = state[14] < state[15] ? 1 : 0;
-    return _bz_ ? enqueue_advance(state, [0, zero, 3, 0]) : _bz_;
+     /*<<format.ml:678:2>>*/ var _by_ = state[14] < state[15] ? 1 : 0;
+    return _by_ ? enqueue_advance(state, [0, zero, 3, 0]) : _by_;
     /*<<format.ml:679:78>>*/ }
    function pp_print_if_newline(state, param){
-     /*<<format.ml:684:2>>*/ var _by_ = state[14] < state[15] ? 1 : 0;
-    return _by_ ? enqueue_advance(state, [0, zero, 4, 0]) : _by_;
+     /*<<format.ml:684:2>>*/ var _bx_ = state[14] < state[15] ? 1 : 0;
+    return _bx_ ? enqueue_advance(state, [0, zero, 4, 0]) : _bx_;
     /*<<format.ml:686:61>>*/ }
    function pp_print_custom_break(state, fits, breaks){
      /*<<format.ml:692:2>>*/ var
      after = fits[3],
      width = fits[2],
      before = fits[1],
-     _bx_ = state[14] < state[15] ? 1 : 0;
-    if(! _bx_) return _bx_;
+     _bw_ = state[14] < state[15] ? 1 : 0;
+    if(! _bw_) return _bw_;
      /*<<format.ml:695:25>>*/ var
      size = - state[13] | 0,
       /*<<format.ml:695:25>>*/ token = [1, fits, breaks],
@@ -25393,33 +25406,33 @@
     /*<<format.ml:715:52>>*/ }
    function pp_open_tbox(state, param){
      /*<<format.ml:720:2>>*/ state[14] = state[14] + 1 | 0;
-    var _bw_ = state[14] < state[15] ? 1 : 0;
-    if(! _bw_) return _bw_;
+    var _bv_ = state[14] < state[15] ? 1 : 0;
+    if(! _bv_) return _bv_;
      /*<<format.ml:723:15>>*/  /*<<format.ml:723:15>>*/ var
      elem = [0, zero, [4, [0, [0, 0]]], 0];
      /*<<format.ml:724:4>>*/ return enqueue_advance(state, elem);
     /*<<format.ml:724:30>>*/ }
    function pp_close_tbox(state, param){
-     /*<<format.ml:729:2>>*/ var _bt_ = 1 < state[14] ? 1 : 0;
-    if(_bt_){
-     var _bu_ = state[14] < state[15] ? 1 : 0;
-     if(_bu_){
+     /*<<format.ml:729:2>>*/ var _bs_ = 1 < state[14] ? 1 : 0;
+    if(_bs_){
+     var _bt_ = state[14] < state[15] ? 1 : 0;
+     if(_bt_){
        /*<<format.ml:732:16>>*/  /*<<format.ml:732:16>>*/ var
        elem = [0, zero, 2, 0];
        /*<<format.ml:733:5>>*/ enqueue_advance(state, elem);
       state[14] = state[14] - 1 | 0;
-      var _bv_ = 0;
+      var _bu_ = 0;
      }
      else
-      var _bv_ = _bu_;
+      var _bu_ = _bt_;
     }
     else
-     var _bv_ = _bt_;
-    return _bv_;
+     var _bu_ = _bs_;
+    return _bu_;
     /*<<format.ml:735:5>>*/ }
    function pp_print_tbreak(state, width, offset){
-     /*<<format.ml:740:2>>*/ var _bs_ = state[14] < state[15] ? 1 : 0;
-    if(! _bs_) return _bs_;
+     /*<<format.ml:740:2>>*/ var _br_ = state[14] < state[15] ? 1 : 0;
+    if(! _br_) return _br_;
      /*<<format.ml:742:15>>*/ var
      size = - state[13] | 0,
       /*<<format.ml:742:15>>*/ elem = [0, size, [2, width, offset], width];
@@ -25429,17 +25442,17 @@
      /*<<format.ml:746:28>>*/ return pp_print_tbreak(state, 0, 0);
     /*<<format.ml:746:53>>*/ }
    function pp_set_tab(state, param){
-     /*<<format.ml:749:2>>*/ var _br_ = state[14] < state[15] ? 1 : 0;
-    if(! _br_) return _br_;
+     /*<<format.ml:749:2>>*/ var _bq_ = state[14] < state[15] ? 1 : 0;
+    if(! _bq_) return _bq_;
      /*<<format.ml:750:15>>*/  /*<<format.ml:750:15>>*/ var
      elem = [0, zero, 0, 0];
      /*<<format.ml:751:4>>*/ return enqueue_advance(state, elem);
     /*<<format.ml:751:30>>*/ }
    function pp_set_max_boxes(state, n){
      /*<<format.ml:761:31>>*/ var
-     _bp_ = 1 < n ? 1 : 0,
-     _bq_ = _bp_ ? (state[15] = n, 0) : _bp_;
-    return _bq_;
+     _bo_ = 1 < n ? 1 : 0,
+     _bp_ = _bo_ ? (state[15] = n, 0) : _bo_;
+    return _bp_;
     /*<<format.ml:761:68>>*/ }
    function pp_get_max_boxes(state, param){
      /*<<format.ml:764:32>>*/ return state[15];
@@ -25458,10 +25471,10 @@
      /*<<format.ml:775:2>>*/ return n < 1000000010 ? n : 1000000009;
     /*<<format.ml:775:49>>*/ }
    function pp_set_max_indent(state, n$0){
-     /*<<format.ml:791:2>>*/ var _bo_ = 1 < n$0 ? 1 : 0;
-    if(! _bo_) return _bo_;
-    var n$1 = state[6] - n$0 | 0, _bn_ = 1 <= n$1 ? 1 : 0;
+     /*<<format.ml:791:2>>*/ var _bn_ = 1 < n$0 ? 1 : 0;
     if(! _bn_) return _bn_;
+    var n$1 = state[6] - n$0 | 0, _bm_ = 1 <= n$1 ? 1 : 0;
+    if(! _bm_) return _bm_;
      /*<<format.ml:781:12>>*/  /*<<format.ml:781:12>>*/ var n = pp_limit(n$1);
     state[7] = n;
     state[8] = state[6] - state[7] | 0;
@@ -25471,19 +25484,19 @@
      /*<<format.ml:795:33>>*/ return state[8];
     /*<<format.ml:795:52>>*/ }
    function pp_set_margin(state, n){
-     /*<<format.ml:798:2>>*/ var _bl_ = 1 <= n ? 1 : 0;
-    if(! _bl_) return _bl_;
+     /*<<format.ml:798:2>>*/ var _bk_ = 1 <= n ? 1 : 0;
+    if(! _bk_) return _bk_;
      /*<<format.ml:799:12>>*/  /*<<format.ml:799:12>>*/ var n$0 = pp_limit(n);
     state[6] = n$0;
     if(state[8] <= state[6])
      var new_max_indent = state[8];
     else
       /*<<format.ml:808:15>>*/ var
-       /*<<format.ml:808:15>>*/ _bm_ =
+       /*<<format.ml:808:15>>*/ _bl_ =
          /*<<format.ml:808:15>>*/ caml_call2
          (Stdlib_Int[11], state[6] - state[7] | 0, state[6] / 2 | 0),
       new_max_indent =
-         /*<<format.ml:808:7>>*/ caml_call2(Stdlib_Int[11], _bm_, 1);
+         /*<<format.ml:808:7>>*/ caml_call2(Stdlib_Int[11], _bl_, 1);
      /*<<format.ml:811:4>>*/ return pp_set_max_indent(state, new_max_indent);
     /*<<format.ml:811:42>>*/ }
    function validate_geometry(param){
@@ -25514,11 +25527,11 @@
       /*<<format.ml:842:4>>*/ return pp_set_full_geometry(state, geometry);
      /*<<format.ml:840:28>>*/ var
      msg = match[1],
-      /*<<format.ml:840:28>>*/ _bk_ =
+      /*<<format.ml:840:28>>*/ _bj_ =
         /*<<format.ml:840:28>>*/ caml_call2
         (Stdlib[28], cst_Format_pp_set_geometry, msg);
      /*<<format.ml:840:4>>*/ throw  /*<<format.ml:840:4>>*/ caml_maybe_attach_backtrace
-           ([0, Stdlib[6], _bk_], 1);
+           ([0, Stdlib[6], _bj_], 1);
     /*<<format.ml:842:39>>*/ }
    function pp_safe_set_geometry(state, max_indent, margin){
      /*<<format.ml:845:2>>*/  /*<<format.ml:845:17>>*/ var
@@ -25571,8 +25584,8 @@
    function display_blanks(state, n){
      /*<<format.ml:896:2>>*/ var n$0 = n;
      /*<<format.ml:896:2>>*/ for(;;){
-     var _bj_ = 0 < n$0 ? 1 : 0;
-     if(! _bj_) return _bj_;
+     var _bi_ = 0 < n$0 ? 1 : 0;
+     if(! _bi_) return _bi_;
      if(80 >= n$0)
        /*<<format.ml:897:18>>*/ return  /*<<format.ml:897:18>>*/ caml_call3
               (state[17], blank_line, 0, n$0);
@@ -25592,9 +25605,9 @@
               (Stdlib[63], oc);
       /*<<format.ml:911:43>>*/ };
     state[19] =
-     function(_bi_){ /*<<?>>*/ return display_newline(state, _bi_);};
-    state[20] = function(_bh_){ /*<<?>>*/ return display_blanks(state, _bh_);};
-    state[21] = function(_bg_){ /*<<?>>*/ return display_blanks(state, _bg_);};
+     function(_bh_){ /*<<?>>*/ return display_newline(state, _bh_);};
+    state[20] = function(_bg_){ /*<<?>>*/ return display_blanks(state, _bg_);};
+    state[21] = function(_bf_){ /*<<?>>*/ return display_blanks(state, _bf_);};
     return 0;
     /*<<format.ml:914:45>>*/ }
    function default_pp_mark_open_tag(param){
@@ -25602,23 +25615,23 @@
       /*<<format.ml:924:9>>*/ return cst$10;
      /*<<format.ml:923:26>>*/ var
      s = param[2],
-      /*<<format.ml:923:26>>*/ _bf_ =
+      /*<<format.ml:923:26>>*/ _be_ =
         /*<<format.ml:923:26>>*/ caml_call2(Stdlib[28], s, cst$8);
      /*<<format.ml:923:26>>*/ return  /*<<format.ml:923:26>>*/ caml_call2
-            (Stdlib[28], cst$9, _bf_);
+            (Stdlib[28], cst$9, _be_);
     /*<<format.ml:924:11>>*/ }
    function default_pp_mark_close_tag(param){
      /*<<format.ml:925:32>>*/ if(param[1] !== String_tag)
       /*<<format.ml:927:9>>*/ return cst$13;
      /*<<format.ml:926:27>>*/ var
      s = param[2],
-      /*<<format.ml:926:27>>*/ _be_ =
+      /*<<format.ml:926:27>>*/ _bd_ =
         /*<<format.ml:926:27>>*/ caml_call2(Stdlib[28], s, cst$11);
      /*<<format.ml:926:27>>*/ return  /*<<format.ml:926:27>>*/ caml_call2
-            (Stdlib[28], cst$12, _be_);
+            (Stdlib[28], cst$12, _bd_);
     /*<<format.ml:927:11>>*/ }
-   function default_pp_print_open_tag(_bd_){ /*<<?>>*/ return 0;}
-   function default_pp_print_close_tag(_bc_){ /*<<?>>*/ return 0;}
+   function default_pp_print_open_tag(_bc_){ /*<<?>>*/ return 0;}
+   function default_pp_print_close_tag(_bb_){ /*<<?>>*/ return 0;}
    function pp_make_formatter(f, g, h, i, j){
      /*<<format.ml:936:17>>*/ var
       /*<<format.ml:936:17>>*/ pp_queue =
@@ -25632,19 +25645,19 @@
      /*<<format.ml:942:2>>*/  /*<<format.ml:942:2>>*/ caml_call2
      (Stdlib_Stack[3], [0, 1, sys_tok], scan_stack);
      /*<<format.ml:950:20>>*/ var
-     _a__ = Stdlib[19],
-      /*<<format.ml:950:20>>*/ _a$_ =
+     _a9_ = Stdlib[19],
+      /*<<format.ml:950:20>>*/ _a__ =
         /*<<format.ml:950:20>>*/ caml_call1(Stdlib_Stack[2], 0),
-      /*<<format.ml:949:19>>*/ _ba_ =
+      /*<<format.ml:949:19>>*/ _a$_ =
         /*<<format.ml:949:19>>*/ caml_call1(Stdlib_Stack[2], 0),
-      /*<<format.ml:948:20>>*/ _bb_ =
+      /*<<format.ml:948:20>>*/ _ba_ =
         /*<<format.ml:948:20>>*/ caml_call1(Stdlib_Stack[2], 0);
      /*<<format.ml:945:2>>*/ return [0,
             scan_stack,
              /*<<format.ml:947:22>>*/ caml_call1(Stdlib_Stack[2], 0),
-            _bb_,
             _ba_,
             _a$_,
+            _a__,
             78,
             10,
             68,
@@ -25654,7 +25667,7 @@
             1,
             1,
             1,
-            _a__,
+            _a9_,
             cst$14,
             f,
             g,
@@ -25674,30 +25687,30 @@
             (out_funs[1], out_funs[2], out_funs[3], out_funs[4], out_funs[5]);
     /*<<format.ml:984:23>>*/ }
    function make_formatter(output, flush){
-    function _a2_(_a9_){ /*<<?>>*/ return 0;}
-    function _a3_(_a8_){ /*<<?>>*/ return 0;}
+    function _a1_(_a8_){ /*<<?>>*/ return 0;}
+    function _a2_(_a7_){ /*<<?>>*/ return 0;}
      /*<<format.ml:990:12>>*/  /*<<format.ml:990:12>>*/ var
      ppf =
        pp_make_formatter
-        (output, flush, function(_a7_){ /*<<?>>*/ return 0;}, _a3_, _a2_);
-    ppf[19] = function(_a6_){ /*<<?>>*/ return display_newline(ppf, _a6_);};
-    ppf[20] = function(_a5_){ /*<<?>>*/ return display_blanks(ppf, _a5_);};
-    ppf[21] = function(_a4_){ /*<<?>>*/ return display_blanks(ppf, _a4_);};
+        (output, flush, function(_a6_){ /*<<?>>*/ return 0;}, _a2_, _a1_);
+    ppf[19] = function(_a5_){ /*<<?>>*/ return display_newline(ppf, _a5_);};
+    ppf[20] = function(_a4_){ /*<<?>>*/ return display_blanks(ppf, _a4_);};
+    ppf[21] = function(_a3_){ /*<<?>>*/ return display_blanks(ppf, _a3_);};
      /*<<format.ml:994:2>>*/ return ppf;
     /*<<format.ml:994:5>>*/ }
    function formatter_of_out_channel(oc){
-    function _a1_(param){
+    function _a0_(param){
       /*<<format.ml:999:50>>*/ return  /*<<format.ml:999:2>>*/ caml_call1
              (Stdlib[63], oc);
      /*<<format.ml:999:58>>*/ }
      /*<<format.ml:999:39>>*/ return make_formatter
-            ( /*<<format.ml:999:17>>*/ caml_call1(Stdlib[69], oc), _a1_);
+            ( /*<<format.ml:999:17>>*/ caml_call1(Stdlib[69], oc), _a0_);
     /*<<format.ml:999:59>>*/ }
    function formatter_of_buffer(b){
-     /*<<format.ml:1004:2>>*/ function _aZ_(_a0_){ /*<<?>>*/ return 0;}
+     /*<<format.ml:1004:2>>*/ function _aY_(_aZ_){ /*<<?>>*/ return 0;}
      /*<<format.ml:1004:42>>*/ return make_formatter
             ( /*<<format.ml:1004:17>>*/ caml_call1(Stdlib_Buffer[18], b),
-             _aZ_);
+             _aY_);
     /*<<format.ml:1004:48>>*/ }
    var pp_buffer_size = 512;
    function pp_make_buffer(param){
@@ -25728,9 +25741,9 @@
     (Stdlib_Domain[10][3], str_formatter_key, str_formatter);
     /*<<format.ml:1030:8>>*/ function buffered_out_string(key, str, ofs, len){
      /*<<format.ml:1033:2>>*/  /*<<format.ml:1033:23>>*/ var
-     _aY_ =  /*<<format.ml:1033:23>>*/ caml_call1(Stdlib_Domain[10][2], key);
+     _aX_ =  /*<<format.ml:1033:23>>*/ caml_call1(Stdlib_Domain[10][2], key);
      /*<<format.ml:1033:2>>*/ return  /*<<format.ml:1033:2>>*/ caml_call4
-            (Stdlib_Buffer[18], _aY_, str, ofs, len);
+            (Stdlib_Buffer[18], _aX_, str, ofs, len);
     /*<<format.ml:1033:55>>*/ }
    function buffered_out_flush(oc, key, param){
      /*<<format.ml:1036:2>>*/ var
@@ -25762,31 +25775,31 @@
     err_buf_key =
        /*<<format.ml:1044:18>>*/ caml_call2(Stdlib_Domain[10][1], 0, _i_);
    function _j_(param){
-    function _aH_(_aX_){ /*<<?>>*/ return 0;}
-    function _aI_(_aW_){ /*<<?>>*/ return 0;}
-    function _aJ_(_aV_){ /*<<?>>*/ return 0;}
-    var _aK_ = Stdlib[39];
-     /*<<format.ml:1049:6>>*/ function _aL_(_aU_){
-      /*<<?>>*/ return buffered_out_flush(_aK_, std_buf_key, _aU_);
+    function _aG_(_aW_){ /*<<?>>*/ return 0;}
+    function _aH_(_aV_){ /*<<?>>*/ return 0;}
+    function _aI_(_aU_){ /*<<?>>*/ return 0;}
+    var _aJ_ = Stdlib[39];
+     /*<<format.ml:1049:6>>*/ function _aK_(_aT_){
+      /*<<?>>*/ return buffered_out_flush(_aJ_, std_buf_key, _aT_);
     }
      /*<<format.ml:1048:4>>*/  /*<<format.ml:1048:4>>*/ var
      ppf =
        pp_make_formatter
-        (function(_aR_, _aS_, _aT_){
-           /*<<?>>*/ return buffered_out_string(std_buf_key, _aR_, _aS_, _aT_);
+        (function(_aQ_, _aR_, _aS_){
+           /*<<?>>*/ return buffered_out_string(std_buf_key, _aQ_, _aR_, _aS_);
          },
-         _aL_,
-         _aJ_,
+         _aK_,
          _aI_,
-         _aH_);
-    ppf[19] = function(_aQ_){ /*<<?>>*/ return display_newline(ppf, _aQ_);};
-    ppf[20] = function(_aP_){ /*<<?>>*/ return display_blanks(ppf, _aP_);};
-    ppf[21] = function(_aO_){ /*<<?>>*/ return display_blanks(ppf, _aO_);};
-     /*<<format.ml:1054:17>>*/ function _aM_(_aN_){
-      /*<<?>>*/ return pp_print_flush(ppf, _aN_);
+         _aH_,
+         _aG_);
+    ppf[19] = function(_aP_){ /*<<?>>*/ return display_newline(ppf, _aP_);};
+    ppf[20] = function(_aO_){ /*<<?>>*/ return display_blanks(ppf, _aO_);};
+    ppf[21] = function(_aN_){ /*<<?>>*/ return display_blanks(ppf, _aN_);};
+     /*<<format.ml:1054:17>>*/ function _aL_(_aM_){
+      /*<<?>>*/ return pp_print_flush(ppf, _aM_);
     }
      /*<<format.ml:1054:2>>*/  /*<<format.ml:1054:2>>*/ caml_call1
-     (Stdlib_Domain[6], _aM_);
+     (Stdlib_Domain[6], _aL_);
      /*<<format.ml:1054:2>>*/ return ppf;
     /*<<format.ml:1055:5>>*/ }
     /*<<format.ml:1046:24>>*/  /*<<format.ml:1046:24>>*/ var
@@ -25795,31 +25808,31 @@
     /*<<format.ml:1056:8>>*/  /*<<format.ml:1056:8>>*/ caml_call2
     (Stdlib_Domain[10][3], std_formatter_key, std_formatter);
    function _k_(param){
-    function _aq_(_aG_){ /*<<?>>*/ return 0;}
-    function _ar_(_aF_){ /*<<?>>*/ return 0;}
-    function _as_(_aE_){ /*<<?>>*/ return 0;}
-    var _at_ = Stdlib[40];
-     /*<<format.ml:1061:6>>*/ function _au_(_aD_){
-      /*<<?>>*/ return buffered_out_flush(_at_, err_buf_key, _aD_);
+    function _ap_(_aF_){ /*<<?>>*/ return 0;}
+    function _aq_(_aE_){ /*<<?>>*/ return 0;}
+    function _ar_(_aD_){ /*<<?>>*/ return 0;}
+    var _as_ = Stdlib[40];
+     /*<<format.ml:1061:6>>*/ function _at_(_aC_){
+      /*<<?>>*/ return buffered_out_flush(_as_, err_buf_key, _aC_);
     }
      /*<<format.ml:1060:4>>*/  /*<<format.ml:1060:4>>*/ var
      ppf =
        pp_make_formatter
-        (function(_aA_, _aB_, _aC_){
-           /*<<?>>*/ return buffered_out_string(err_buf_key, _aA_, _aB_, _aC_);
+        (function(_az_, _aA_, _aB_){
+           /*<<?>>*/ return buffered_out_string(err_buf_key, _az_, _aA_, _aB_);
          },
-         _au_,
-         _as_,
+         _at_,
          _ar_,
-         _aq_);
-    ppf[19] = function(_az_){ /*<<?>>*/ return display_newline(ppf, _az_);};
-    ppf[20] = function(_ay_){ /*<<?>>*/ return display_blanks(ppf, _ay_);};
-    ppf[21] = function(_ax_){ /*<<?>>*/ return display_blanks(ppf, _ax_);};
-     /*<<format.ml:1066:17>>*/ function _av_(_aw_){
-      /*<<?>>*/ return pp_print_flush(ppf, _aw_);
+         _aq_,
+         _ap_);
+    ppf[19] = function(_ay_){ /*<<?>>*/ return display_newline(ppf, _ay_);};
+    ppf[20] = function(_ax_){ /*<<?>>*/ return display_blanks(ppf, _ax_);};
+    ppf[21] = function(_aw_){ /*<<?>>*/ return display_blanks(ppf, _aw_);};
+     /*<<format.ml:1066:17>>*/ function _au_(_av_){
+      /*<<?>>*/ return pp_print_flush(ppf, _av_);
     }
      /*<<format.ml:1066:2>>*/  /*<<format.ml:1066:2>>*/ caml_call1
-     (Stdlib_Domain[6], _av_);
+     (Stdlib_Domain[6], _au_);
      /*<<format.ml:1066:2>>*/ return ppf;
     /*<<format.ml:1067:5>>*/ }
     /*<<format.ml:1058:24>>*/  /*<<format.ml:1058:24>>*/ var
@@ -25862,7 +25875,7 @@
             (stdbuf, str_formatter);
     /*<<format.ml:1089:45>>*/ }
    function make_synchronized_formatter(output, flush){
-    function _ao_(param){
+    function _an_(param){
       /*<<format.ml:1093:4>>*/ var
        /*<<format.ml:1093:14>>*/ buf =
          /*<<format.ml:1093:14>>*/ caml_call1
@@ -25871,12 +25884,12 @@
          /*<<format.ml:1094:18>>*/ caml_call1(Stdlib_Buffer[18], buf);
      function flush$0(param){
        /*<<format.ml:1096:6>>*/  /*<<format.ml:1096:37>>*/ var
-       _ap_ =  /*<<format.ml:1096:37>>*/ caml_call1(Stdlib_Buffer[7], buf);
+       _ao_ =  /*<<format.ml:1096:37>>*/ caml_call1(Stdlib_Buffer[7], buf);
        /*<<format.ml:1096:6>>*/  /*<<format.ml:1096:6>>*/ caml_call3
        (output,
          /*<<format.ml:1096:13>>*/ caml_call1(Stdlib_Buffer[2], buf),
         0,
-        _ap_);
+        _ao_);
        /*<<format.ml:1097:6>>*/  /*<<format.ml:1097:6>>*/ caml_call1
        (Stdlib_Buffer[8], buf);
        /*<<format.ml:1097:6>>*/ return  /*<<format.ml:1097:6>>*/ caml_call1
@@ -25885,15 +25898,15 @@
       /*<<format.ml:1100:4>>*/ return make_formatter(output$0, flush$0);
      /*<<format.ml:1100:33>>*/ }
      /*<<format.ml:1092:14>>*/ return  /*<<format.ml:1092:14>>*/ caml_call2
-            (Stdlib_Domain[10][1], 0, _ao_);
+            (Stdlib_Domain[10][1], 0, _an_);
     /*<<format.ml:1100:34>>*/ }
    function synchronized_formatter_of_out_(oc){
-    function _an_(param){
+    function _am_(param){
       /*<<format.ml:1103:63>>*/ return  /*<<format.ml:1103:2>>*/ caml_call1
              (Stdlib[63], oc);
      /*<<format.ml:1103:71>>*/ }
      /*<<format.ml:1103:52>>*/ return make_synchronized_formatter
-            ( /*<<format.ml:1103:30>>*/ caml_call1(Stdlib[69], oc), _an_);
+            ( /*<<format.ml:1103:30>>*/ caml_call1(Stdlib[69], oc), _am_);
     /*<<format.ml:1103:72>>*/ }
    function make_symbolic_output_buffer(param){ /*<<format.ml:1130:2>>*/ return [0, 0];
     /*<<format.ml:1130:35>>*/ }
@@ -25922,10 +25935,10 @@
                 /*<<format.ml:1152:48>>*/ caml_call3
                 (Stdlib_String[15], s, i, n)]);
     }
-     /*<<format.ml:1159:10>>*/ function g(_am_){
+     /*<<format.ml:1159:10>>*/ function g(_al_){
       /*<<format.ml:1148:4>>*/ return add_symbolic_output_item(sob, 0);
     }
-     /*<<format.ml:1160:10>>*/ function h(_al_){
+     /*<<format.ml:1160:10>>*/ function h(_ak_){
       /*<<format.ml:1150:4>>*/ return add_symbolic_output_item(sob, 1);
     }
      /*<<format.ml:1161:10>>*/ function i(n){
@@ -26312,8 +26325,8 @@
      /*<<format.ml:1285:31>>*/ }
     for(;;){
      if(right[1] === len){
-      var _ak_ = left[1] !== len ? 1 : 0;
-      return _ak_ ? flush(0) : _ak_;
+      var _aj_ = left[1] !== len ? 1 : 0;
+      return _aj_ ? flush(0) : _aj_;
      }
       /*<<format.ml:1288:10>>*/  /*<<format.ml:1288:10>>*/ var
       match =  /*<<format.ml:1288:10>>*/ runtime.caml_string_get(s, right[1]);
@@ -26335,7 +26348,7 @@
     else
      var
       none =
-        function(param, _aj_){
+        function(param, _ai_){
           /*<<format.ml:1300:41>>*/ return 0;
          /*<<format.ml:1300:43>>*/ };
      /*<<format.ml:1300:56>>*/ if(! param)
@@ -26434,56 +26447,56 @@
           var acc$1 = match[1];
            /*<<format.ml:1366:4>>*/ output_acc(ppf, p$0);
            /*<<format.ml:1367:43>>*/ var
-            /*<<format.ml:1367:43>>*/ _aa_ = compute_tag(output_acc, acc$1),
+            /*<<format.ml:1367:43>>*/ _$_ = compute_tag(output_acc, acc$1),
             /*<<format.ml:1367:24>>*/ match$0 =
               /*<<format.ml:1367:24>>*/ caml_call1
-              (CamlinternalFormat[20], _aa_),
+              (CamlinternalFormat[20], _$_),
            bty = match$0[2],
            indent = match$0[1];
            /*<<format.ml:1368:4>>*/ return pp_open_box_gen(ppf, indent, bty);
          case 2:
-          var _ab_ = acc[1];
-          if(typeof _ab_ !== "number" && 0 === _ab_[0]){
-           var _ac_ = _ab_[2];
-           if(typeof _ac_ !== "number" && 1 === _ac_[0]){
-            var s$0 = acc[2], size = _ac_[2], p$2 = _ab_[1];
+          var _aa_ = acc[1];
+          if(typeof _aa_ !== "number" && 0 === _aa_[0]){
+           var _ab_ = _aa_[2];
+           if(typeof _ab_ !== "number" && 1 === _ab_[0]){
+            var s$0 = acc[2], size = _ab_[2], p$2 = _aa_[1];
             break b;
            }
           }
-          var s = acc[2], p$1 = _ab_;
+          var s = acc[2], p$1 = _aa_;
           break a;
          case 3:
-          var _ad_ = acc[1];
-          if(typeof _ad_ !== "number" && 0 === _ad_[0]){
-           var _ae_ = _ad_[2];
-           if(typeof _ae_ !== "number" && 1 === _ae_[0]){
-            var c$0 = acc[2], size$0 = _ae_[2], p$4 = _ad_[1];
+          var _ac_ = acc[1];
+          if(typeof _ac_ !== "number" && 0 === _ac_[0]){
+           var _ad_ = _ac_[2];
+           if(typeof _ad_ !== "number" && 1 === _ad_[0]){
+            var c$0 = acc[2], size$0 = _ad_[2], p$4 = _ac_[1];
             break;
            }
           }
-          var c = acc[2], p$3 = _ad_;
+          var c = acc[2], p$3 = _ac_;
           break c;
          case 4:
-          var _af_ = acc[1];
-          if(typeof _af_ !== "number" && 0 === _af_[0]){
-           var _ag_ = _af_[2];
-           if(typeof _ag_ !== "number" && 1 === _ag_[0]){
-            var s$0 = acc[2], size = _ag_[2], p$2 = _af_[1];
+          var _ae_ = acc[1];
+          if(typeof _ae_ !== "number" && 0 === _ae_[0]){
+           var _af_ = _ae_[2];
+           if(typeof _af_ !== "number" && 1 === _af_[0]){
+            var s$0 = acc[2], size = _af_[2], p$2 = _ae_[1];
             break b;
            }
           }
-          var s = acc[2], p$1 = _af_;
+          var s = acc[2], p$1 = _ae_;
           break a;
          case 5:
-          var _ah_ = acc[1];
-          if(typeof _ah_ !== "number" && 0 === _ah_[0]){
-           var _ai_ = _ah_[2];
-           if(typeof _ai_ !== "number" && 1 === _ai_[0]){
-            var c$0 = acc[2], size$0 = _ai_[2], p$4 = _ah_[1];
+          var _ag_ = acc[1];
+          if(typeof _ag_ !== "number" && 0 === _ag_[0]){
+           var _ah_ = _ag_[2];
+           if(typeof _ah_ !== "number" && 1 === _ah_[0]){
+            var c$0 = acc[2], size$0 = _ah_[2], p$4 = _ag_[1];
             break;
            }
           }
-          var c = acc[2], p$3 = _ah_;
+          var c = acc[2], p$3 = _ag_;
           break c;
          case 6:
           var f$0 = acc[2], p$5 = acc[1];
@@ -26541,56 +26554,56 @@
           var acc$1 = match[1];
            /*<<format.ml:1401:4>>*/ strput_acc(ppf, p$0);
            /*<<format.ml:1402:43>>*/ var
-            /*<<format.ml:1402:43>>*/ _T_ = compute_tag(strput_acc, acc$1),
+            /*<<format.ml:1402:43>>*/ _S_ = compute_tag(strput_acc, acc$1),
             /*<<format.ml:1402:24>>*/ match$0 =
               /*<<format.ml:1402:24>>*/ caml_call1
-              (CamlinternalFormat[20], _T_),
+              (CamlinternalFormat[20], _S_),
            bty = match$0[2],
            indent = match$0[1];
            /*<<format.ml:1403:4>>*/ return pp_open_box_gen(ppf, indent, bty);
          case 2:
-          var _U_ = acc[1];
-          if(typeof _U_ !== "number" && 0 === _U_[0]){
-           var _V_ = _U_[2];
-           if(typeof _V_ !== "number" && 1 === _V_[0]){
-            var s$0 = acc[2], size = _V_[2], p$2 = _U_[1];
+          var _T_ = acc[1];
+          if(typeof _T_ !== "number" && 0 === _T_[0]){
+           var _U_ = _T_[2];
+           if(typeof _U_ !== "number" && 1 === _U_[0]){
+            var s$0 = acc[2], size = _U_[2], p$2 = _T_[1];
             break b;
            }
           }
-          var s = acc[2], p$1 = _U_;
+          var s = acc[2], p$1 = _T_;
           break a;
          case 3:
-          var _W_ = acc[1];
-          if(typeof _W_ !== "number" && 0 === _W_[0]){
-           var _X_ = _W_[2];
-           if(typeof _X_ !== "number" && 1 === _X_[0]){
-            var c$0 = acc[2], size$0 = _X_[2], p$4 = _W_[1];
+          var _V_ = acc[1];
+          if(typeof _V_ !== "number" && 0 === _V_[0]){
+           var _W_ = _V_[2];
+           if(typeof _W_ !== "number" && 1 === _W_[0]){
+            var c$0 = acc[2], size$0 = _W_[2], p$4 = _V_[1];
             break;
            }
           }
-          var c = acc[2], p$3 = _W_;
+          var c = acc[2], p$3 = _V_;
           break c;
          case 4:
-          var _Y_ = acc[1];
-          if(typeof _Y_ !== "number" && 0 === _Y_[0]){
-           var _Z_ = _Y_[2];
-           if(typeof _Z_ !== "number" && 1 === _Z_[0]){
-            var s$0 = acc[2], size = _Z_[2], p$2 = _Y_[1];
+          var _X_ = acc[1];
+          if(typeof _X_ !== "number" && 0 === _X_[0]){
+           var _Y_ = _X_[2];
+           if(typeof _Y_ !== "number" && 1 === _Y_[0]){
+            var s$0 = acc[2], size = _Y_[2], p$2 = _X_[1];
             break b;
            }
           }
-          var s = acc[2], p$1 = _Y_;
+          var s = acc[2], p$1 = _X_;
           break a;
          case 5:
-          var ___ = acc[1];
-          if(typeof ___ !== "number" && 0 === ___[0]){
-           var _$_ = ___[2];
-           if(typeof _$_ !== "number" && 1 === _$_[0]){
-            var c$0 = acc[2], size$0 = _$_[2], p$4 = ___[1];
+          var _Z_ = acc[1];
+          if(typeof _Z_ !== "number" && 0 === _Z_[0]){
+           var ___ = _Z_[2];
+           if(typeof ___ !== "number" && 1 === ___[0]){
+            var c$0 = acc[2], size$0 = ___[2], p$4 = _Z_[1];
             break;
            }
           }
-          var c = acc[2], p$3 = ___;
+          var c = acc[2], p$3 = _Z_;
           break c;
          case 6:
           var p$5 = acc[1];
@@ -26636,13 +26649,13 @@
    function kfprintf(k, ppf, param){
      /*<<format.ml:1420:2>>*/ var
      fmt = param[1],
-      /*<<format.ml:1420:2>>*/ _R_ = 0;
-    function _S_(acc){
+      /*<<format.ml:1420:2>>*/ _Q_ = 0;
+    function _R_(acc){
       /*<<format.ml:1421:16>>*/ output_acc(ppf, acc);
      return caml_call1(k, ppf);
      /*<<format.ml:1421:41>>*/ }
      /*<<format.ml:1420:2>>*/ return  /*<<format.ml:1420:2>>*/ caml_call3
-            (CamlinternalFormat[7], _S_, _R_, fmt);
+            (CamlinternalFormat[7], _R_, _Q_, fmt);
    }
    function ikfprintf(k, ppf, param){
     var fmt = param[1];
@@ -26652,47 +26665,47 @@
    function ifprintf(ppf, param){
      /*<<format.ml:1428:2>>*/ var
      fmt = param[1],
-      /*<<format.ml:1428:2>>*/ _O_ = 0;
-    function _P_(_Q_){ /*<<?>>*/ return 0;}
+      /*<<format.ml:1428:2>>*/ _N_ = 0;
+    function _O_(_P_){ /*<<?>>*/ return 0;}
      /*<<format.ml:1428:2>>*/ return  /*<<format.ml:1428:2>>*/ caml_call3
-            (CamlinternalFormat[8], _P_, _O_, fmt);
+            (CamlinternalFormat[8], _O_, _N_, fmt);
    }
    function fprintf(ppf){
-    function _L_(_N_){ /*<<?>>*/ return 0;}
-     /*<<format.ml:1430:18>>*/ return function(_M_){
-      /*<<?>>*/ return kfprintf(_L_, ppf, _M_);};
+    function _K_(_M_){ /*<<?>>*/ return 0;}
+     /*<<format.ml:1430:18>>*/ return function(_L_){
+      /*<<?>>*/ return kfprintf(_K_, ppf, _L_);};
     /*<<format.ml:1430:37>>*/ }
    function printf(param){
      /*<<format.ml:1433:2>>*/ var
      fmt = param[1],
-      /*<<format.ml:1433:2>>*/ _J_ = 0;
-    function _K_(acc){
+      /*<<format.ml:1433:2>>*/ _I_ = 0;
+    function _J_(acc){
       /*<<format.ml:1434:16>>*/ return output_acc
              ( /*<<format.ml:1434:27>>*/ caml_call1
                (Stdlib_Domain[10][2], std_formatter_key),
               acc);
      /*<<format.ml:1434:58>>*/ }
      /*<<format.ml:1433:2>>*/ return  /*<<format.ml:1433:2>>*/ caml_call3
-            (CamlinternalFormat[7], _K_, _J_, fmt);
+            (CamlinternalFormat[7], _J_, _I_, fmt);
    }
    function eprintf(param){
      /*<<format.ml:1438:2>>*/ var
      fmt = param[1],
-      /*<<format.ml:1438:2>>*/ _H_ = 0;
-    function _I_(acc){
+      /*<<format.ml:1438:2>>*/ _G_ = 0;
+    function _H_(acc){
       /*<<format.ml:1439:16>>*/ return output_acc
              ( /*<<format.ml:1439:27>>*/ caml_call1
                (Stdlib_Domain[10][2], err_formatter_key),
               acc);
      /*<<format.ml:1439:58>>*/ }
      /*<<format.ml:1438:2>>*/ return  /*<<format.ml:1438:2>>*/ caml_call3
-            (CamlinternalFormat[7], _I_, _H_, fmt);
+            (CamlinternalFormat[7], _H_, _G_, fmt);
    }
    function kdprintf(k, param){
      /*<<format.ml:1443:2>>*/ var
      fmt = param[1],
-      /*<<format.ml:1443:2>>*/ _F_ = 0;
-    function _G_(acc){
+      /*<<format.ml:1443:2>>*/ _E_ = 0;
+    function _F_(acc){
       /*<<format.ml:1444:16>>*/ return  /*<<format.ml:1444:18>>*/ caml_call1
              (k,
               function(ppf){
@@ -26700,7 +26713,7 @@
                /*<<format.ml:1444:48>>*/ });
      /*<<format.ml:1444:49>>*/ }
      /*<<format.ml:1443:2>>*/ return  /*<<format.ml:1443:2>>*/ caml_call3
-            (CamlinternalFormat[7], _G_, _F_, fmt);
+            (CamlinternalFormat[7], _F_, _E_, fmt);
    }
    function dprintf(fmt){
      /*<<format.ml:1447:18>>*/ return kdprintf
@@ -26758,44 +26771,44 @@
      /*<<format.ml:1481:11>>*/ var
       /*<<format.ml:1481:11>>*/ fs =
        pp_get_formatter_out_functions(std_formatter, 0),
-     _n_ = fs[5],
-     _o_ = fs[4],
-     _p_ = fs[3],
-     _q_ = Stdlib[39];
-     /*<<format.ml:1484:25>>*/ function _r_(_E_){
-      /*<<?>>*/ return buffered_out_flush(_q_, std_buf_key, _E_);
+     _m_ = fs[5],
+     _n_ = fs[4],
+     _o_ = fs[3],
+     _p_ = Stdlib[39];
+     /*<<format.ml:1484:25>>*/ function _q_(_D_){
+      /*<<?>>*/ return buffered_out_flush(_p_, std_buf_key, _D_);
     }
      /*<<format.ml:1482:2>>*/ pp_set_formatter_out_functions
      (std_formatter,
       [0,
-       function(_B_, _C_, _D_){
-         /*<<?>>*/ return buffered_out_string(std_buf_key, _B_, _C_, _D_);
+       function(_A_, _B_, _C_){
+         /*<<?>>*/ return buffered_out_string(std_buf_key, _A_, _B_, _C_);
        },
-       _r_,
-       _p_,
+       _q_,
        _o_,
-       _n_]);
+       _n_,
+       _m_]);
      /*<<format.ml:1486:11>>*/ var
       /*<<format.ml:1486:11>>*/ fs$0 =
        pp_get_formatter_out_functions(err_formatter, 0),
-     _s_ = fs$0[5],
-     _t_ = fs$0[4],
-     _u_ = fs$0[3],
-     _v_ = Stdlib[40];
-     /*<<format.ml:1489:25>>*/ function _w_(_A_){
-      /*<<?>>*/ return buffered_out_flush(_v_, err_buf_key, _A_);
+     _r_ = fs$0[5],
+     _s_ = fs$0[4],
+     _t_ = fs$0[3],
+     _u_ = Stdlib[40];
+     /*<<format.ml:1489:25>>*/ function _v_(_z_){
+      /*<<?>>*/ return buffered_out_flush(_u_, err_buf_key, _z_);
     }
      /*<<format.ml:1488:4>>*/ return pp_set_formatter_out_functions
             (err_formatter,
              [0,
-              function(_x_, _y_, _z_){
+              function(_w_, _x_, _y_){
                 /*<<?>>*/ return buffered_out_string
-                       (err_buf_key, _x_, _y_, _z_);
+                       (err_buf_key, _w_, _x_, _y_);
               },
-              _w_,
-              _u_,
+              _v_,
               _t_,
-              _s_]);
+              _s_,
+              _r_]);
     /*<<format.ml:1489:71>>*/ }
     /*<<format.ml:1479:9>>*/  /*<<format.ml:1479:9>>*/ caml_call1
     (Stdlib_Domain[5], _l_);
@@ -26996,7 +27009,7 @@
             : runtime.caml_call_gen(f, [a0, a1, a2, a3]);
    }
    var
-    _u_ = undefined,
+    sentinal = undefined,
     global_data = runtime.caml_get_global_data(),
     cst$3 = cst$5,
     cst$4 = cst$5,
@@ -27120,9 +27133,9 @@
      if(10 === c) ib[5] = ib[5] + 1 | 0;
       /*<<scanf.ml:171:6>>*/ return c;
     }
-    catch(_bc_){
-     var _bb_ = caml_wrap_exception(_bc_);
-     if(_bb_ !== Stdlib[12]) throw caml_maybe_attach_backtrace(_bb_, 0);
+    catch(_bb_){
+     var _ba_ = caml_wrap_exception(_bb_);
+     if(_ba_ !== Stdlib[12]) throw caml_maybe_attach_backtrace(_ba_, 0);
      ib[2] = null_char;
      ib[3] = 0;
      ib[1] = 1;
@@ -27215,8 +27228,8 @@
      /*<<scanf.ml:271:4>>*/ return create(1, next);
     /*<<scanf.ml:271:27>>*/ }
    var _a_ = 0;
-    /*<<scanf.ml:274:22>>*/ function from_function(_ba_){
-     /*<<?>>*/ return create(_a_, _ba_);
+    /*<<scanf.ml:274:22>>*/ function from_function(_a$_){
+     /*<<?>>*/ return create(_a_, _a$_);
    }
     /*<<scanf.ml:274:22>>*/  /*<<scanf.ml:274:22>>*/ var len = 1024;
    function scan_close_at_end(ic){
@@ -27263,12 +27276,12 @@
     return from_ic(scan_close_at_end, [1, fname, ic], ic);
     /*<<scanf.ml:371:53>>*/ }
    var _b_ = Stdlib[79];
-    /*<<scanf.ml:374:16>>*/ function open_in(_a$_){
-     /*<<?>>*/ return open_in_file(_b_, _a$_);
+    /*<<scanf.ml:374:16>>*/ function open_in(_a__){
+     /*<<?>>*/ return open_in_file(_b_, _a__);
    }
     /*<<scanf.ml:374:16>>*/  /*<<scanf.ml:374:16>>*/ var _c_ = Stdlib[80];
-    /*<<scanf.ml:375:20>>*/ function open_in_bin(_a__){
-     /*<<?>>*/ return open_in_file(_c_, _a__);
+    /*<<scanf.ml:375:20>>*/ function open_in_bin(_a9_){
+     /*<<?>>*/ return open_in_file(_c_, _a9_);
    }
    function from_channel(ic){
      /*<<scanf.ml:381:4>>*/ return from_ic(scan_raise_at_end, [0, ic], ic);
@@ -27331,15 +27344,15 @@
      /*<<scanf.ml:444:2>>*/ for(;;){
       /*<<scanf.ml:444:10>>*/ var
        /*<<scanf.ml:444:10>>*/ c = peek_char(ib),
-       /*<<scanf.ml:445:9>>*/ _a8_ = 1 - ib[1];
-     if(! _a8_)  /*<<scanf.ml:445:9>>*/ return _a8_;
-      /*<<scanf.ml:445:32>>*/  /*<<scanf.ml:445:32>>*/ var _a9_ = c - 9 | 0;
+       /*<<scanf.ml:445:9>>*/ _a7_ = 1 - ib[1];
+     if(! _a7_)  /*<<scanf.ml:445:9>>*/ return _a7_;
+      /*<<scanf.ml:445:32>>*/  /*<<scanf.ml:445:32>>*/ var _a8_ = c - 9 | 0;
      a:
      {
-      if(4 < _a9_ >>> 0){
-       if(23 === _a9_) break a;
+      if(4 < _a8_ >>> 0){
+       if(23 === _a8_) break a;
       }
-      else if(1 < _a9_ - 2 >>> 0) break a;
+      else if(1 < _a8_ - 2 >>> 0) break a;
        /*<<scanf.ml:449:11>>*/ return 0;
      }
       /*<<scanf.ml:448:6>>*/ invalidate_current_char(ib);
@@ -27385,23 +27398,23 @@
      /*<<scanf.ml:523:2>>*/ switch(conv){
       case 0:
         /*<<scanf.ml:529:29>>*/ var
-         /*<<scanf.ml:529:29>>*/ _a4_ = token_string(ib),
-        tok =  /*<<scanf.ml:529:22>>*/ caml_call2(Stdlib[28], cst_0b, _a4_);
+         /*<<scanf.ml:529:29>>*/ _a3_ = token_string(ib),
+        tok =  /*<<scanf.ml:529:22>>*/ caml_call2(Stdlib[28], cst_0b, _a3_);
        break;
       case 3:
         /*<<scanf.ml:527:29>>*/ var
-         /*<<scanf.ml:527:29>>*/ _a5_ = token_string(ib),
-        tok =  /*<<scanf.ml:527:22>>*/ caml_call2(Stdlib[28], cst_0o, _a5_);
+         /*<<scanf.ml:527:29>>*/ _a4_ = token_string(ib),
+        tok =  /*<<scanf.ml:527:22>>*/ caml_call2(Stdlib[28], cst_0o, _a4_);
        break;
       case 4:
         /*<<scanf.ml:526:29>>*/ var
-         /*<<scanf.ml:526:29>>*/ _a6_ = token_string(ib),
-        tok =  /*<<scanf.ml:526:22>>*/ caml_call2(Stdlib[28], cst_0u, _a6_);
+         /*<<scanf.ml:526:29>>*/ _a5_ = token_string(ib),
+        tok =  /*<<scanf.ml:526:22>>*/ caml_call2(Stdlib[28], cst_0u, _a5_);
        break;
       case 5:
         /*<<scanf.ml:528:29>>*/ var
-         /*<<scanf.ml:528:29>>*/ _a7_ = token_string(ib),
-        tok =  /*<<scanf.ml:528:22>>*/ caml_call2(Stdlib[28], cst_0x, _a7_);
+         /*<<scanf.ml:528:29>>*/ _a6_ = token_string(ib),
+        tok =  /*<<scanf.ml:528:22>>*/ caml_call2(Stdlib[28], cst_0x, _a6_);
        break;
       default: var tok = token_string(ib);
     }
@@ -27486,31 +27499,31 @@
    function is_binary_digit(param){
      /*<<scanf.ml:629:22>>*/ return 1 < param - 48 >>> 0 ? 0 : 1;
     /*<<scanf.ml:631:14>>*/ }
-    /*<<scanf.ml:634:22>>*/ function scan_binary_int(_a2_, _a3_){
-     /*<<?>>*/ return scan_digit_plus(cst_binary, is_binary_digit, _a2_, _a3_);
+    /*<<scanf.ml:634:22>>*/ function scan_binary_int(_a1_, _a2_){
+     /*<<?>>*/ return scan_digit_plus(cst_binary, is_binary_digit, _a1_, _a2_);
    }
    function is_octal_digit(param){
      /*<<scanf.ml:636:21>>*/ return 7 < param - 48 >>> 0 ? 0 : 1;
     /*<<scanf.ml:638:14>>*/ }
-    /*<<scanf.ml:641:21>>*/ function scan_octal_int(_a0_, _a1_){
-     /*<<?>>*/ return scan_digit_plus(cst_octal, is_octal_digit, _a0_, _a1_);
+    /*<<scanf.ml:641:21>>*/ function scan_octal_int(_aZ_, _a0_){
+     /*<<?>>*/ return scan_digit_plus(cst_octal, is_octal_digit, _aZ_, _a0_);
    }
    function is_hexa_digit(param){
      /*<<scanf.ml:643:20>>*/  /*<<scanf.ml:643:20>>*/ var
-     _aZ_ = param - 48 | 0;
+     _aY_ = param - 48 | 0;
     a:
     {
-     if(22 < _aZ_ >>> 0){
-      if(5 < _aZ_ - 49 >>> 0) break a;
+     if(22 < _aY_ >>> 0){
+      if(5 < _aY_ - 49 >>> 0) break a;
      }
-     else if(6 >= _aZ_ - 10 >>> 0) break a;
+     else if(6 >= _aY_ - 10 >>> 0) break a;
       /*<<scanf.ml:644:44>>*/ return 1;
     }
      /*<<scanf.ml:645:9>>*/ return 0;
     /*<<scanf.ml:645:14>>*/ }
-    /*<<scanf.ml:648:27>>*/ function scan_hexadecimal_int(_aX_, _aY_){
+    /*<<scanf.ml:648:27>>*/ function scan_hexadecimal_int(_aW_, _aX_){
      /*<<?>>*/ return scan_digit_plus
-            (cst_hexadecimal, is_hexa_digit, _aX_, _aY_);
+            (cst_hexadecimal, is_hexa_digit, _aW_, _aX_);
    }
    function scan_sign(width, ib){
      /*<<scanf.ml:654:2>>*/ var
@@ -27630,38 +27643,38 @@
       /*<<scanf.ml:785:2>>*/ len =
         /*<<scanf.ml:785:2>>*/ caml_ml_string_length(str),
       /*<<scanf.ml:786:14>>*/ width$0 = [0, width],
-      /*<<scanf.ml:787:2>>*/ _aU_ = len - 1 | 0,
-      /*<<scanf.ml:786:14>>*/ _aT_ = 0;
-    if(_aU_ >= 0){
-     var i = _aT_;
+      /*<<scanf.ml:787:2>>*/ _aT_ = len - 1 | 0,
+      /*<<scanf.ml:786:14>>*/ _aS_ = 0;
+    if(_aT_ >= 0){
+     var i = _aS_;
      for(;;){
        /*<<scanf.ml:788:12>>*/ var
         /*<<scanf.ml:788:12>>*/ c = peek_char(ib),
-        /*<<scanf.ml:789:22>>*/ _aV_ =
+        /*<<scanf.ml:789:22>>*/ _aU_ =
          lowercase( /*<<scanf.ml:789:32>>*/ caml_string_get(str, i));
-      if(lowercase(c) !== _aV_)
+      if(lowercase(c) !== _aU_)
         /*<<scanf.ml:789:45>>*/  /*<<scanf.ml:789:45>>*/ caml_call1(error, 0);
       if(0 === width$0[1])
         /*<<scanf.ml:790:23>>*/  /*<<scanf.ml:790:23>>*/ caml_call1(error, 0);
       width$0[1] = store_char(width$0[1], ib, c);
-       /*<<scanf.ml:787:2>>*/  /*<<scanf.ml:787:2>>*/ var _aW_ = i + 1 | 0;
-      if(_aU_ === i) break;
-      var i = _aW_;
+       /*<<scanf.ml:787:2>>*/  /*<<scanf.ml:787:2>>*/ var _aV_ = i + 1 | 0;
+      if(_aT_ === i) break;
+      var i = _aV_;
      }
     }
     return width$0[1];
     /*<<scanf.ml:793:8>>*/ }
    function scan_hex_float(width, precision, ib){
      /*<<scanf.ml:797:2>>*/ var
-     _aG_ = 0 === width ? 1 : 0,
-     _aH_ = _aG_ || end_of_input(ib);
-     /*<<scanf.ml:797:18>>*/ if(_aH_)
+     _aF_ = 0 === width ? 1 : 0,
+     _aG_ = _aF_ || end_of_input(ib);
+     /*<<scanf.ml:797:18>>*/ if(_aG_)
       /*<<scanf.ml:797:48>>*/ bad_hex_float(0);
      /*<<scanf.ml:798:14>>*/ var
       /*<<scanf.ml:798:14>>*/ width$0 = scan_sign(width, ib),
-     _aI_ = 0 === width$0 ? 1 : 0,
-     _aJ_ = _aI_ || end_of_input(ib);
-     /*<<scanf.ml:799:18>>*/ if(_aJ_)
+     _aH_ = 0 === width$0 ? 1 : 0,
+     _aI_ = _aH_ || end_of_input(ib);
+     /*<<scanf.ml:799:18>>*/ if(_aI_)
       /*<<scanf.ml:799:48>>*/ bad_hex_float(0);
      /*<<scanf.ml:800:8>>*/  /*<<scanf.ml:800:8>>*/ var c = peek_char(ib);
     a:
@@ -27673,9 +27686,9 @@
        if(32 <= switcher) break a;
         /*<<scanf.ml:830:16>>*/ var
          /*<<scanf.ml:830:16>>*/ width$1 = store_char(width$0, ib, c),
-        _aK_ = 0 === width$1 ? 1 : 0,
-        _aL_ = _aK_ || end_of_input(ib);
-        /*<<scanf.ml:831:20>>*/ if(_aL_)
+        _aJ_ = 0 === width$1 ? 1 : 0,
+        _aK_ = _aJ_ || end_of_input(ib);
+        /*<<scanf.ml:831:20>>*/ if(_aK_)
          /*<<scanf.ml:831:50>>*/ bad_hex_float(0);
         /*<<scanf.ml:831:50>>*/ return check_case_insensitive_string
                (width$1, ib, bad_hex_float, cst_an);
@@ -27686,24 +27699,24 @@
       if(48 === c){
         /*<<scanf.ml:802:16>>*/ var
          /*<<scanf.ml:802:16>>*/ width$3 = store_char(width$0, ib, c),
-        _aO_ = 0 === width$3 ? 1 : 0,
-        _aP_ = _aO_ || end_of_input(ib);
-        /*<<scanf.ml:803:20>>*/ if(_aP_)
+        _aN_ = 0 === width$3 ? 1 : 0,
+        _aO_ = _aN_ || end_of_input(ib);
+        /*<<scanf.ml:803:20>>*/ if(_aO_)
          /*<<scanf.ml:803:50>>*/ bad_hex_float(0);
         /*<<scanf.ml:804:16>>*/  /*<<scanf.ml:804:16>>*/ var
         width$4 =
           check_case_insensitive_string(width$3, ib, bad_hex_float, cst_x);
         /*<<scanf.ml:805:20>>*/ if(0 !== width$4 && ! end_of_input(ib)){
          /*<<scanf.ml:806:24>>*/  /*<<scanf.ml:806:24>>*/ var
-         _aQ_ = peek_char(ib) - 46 | 0;
+         _aP_ = peek_char(ib) - 46 | 0;
         b:
         {
          c:
          {
-          if(34 < _aQ_ >>> 0){
-           if(66 === _aQ_) break c;
+          if(34 < _aP_ >>> 0){
+           if(66 === _aP_) break c;
           }
-          else if(32 < _aQ_ - 1 >>> 0) break c;
+          else if(32 < _aP_ - 1 >>> 0) break c;
           var width$5 = scan_hexadecimal_int(width$4, ib);
           break b;
          }
@@ -27751,9 +27764,9 @@
             /*<<scanf.ml:827:17>>*/ return width$8;
            /*<<scanf.ml:824:24>>*/ var
             /*<<scanf.ml:824:24>>*/ width$9 = store_char(width$8, ib, c$1),
-           _aR_ = 0 === width$9 ? 1 : 0,
-           _aS_ = _aR_ || end_of_input(ib);
-           /*<<scanf.ml:825:28>>*/ if(_aS_)
+           _aQ_ = 0 === width$9 ? 1 : 0,
+           _aR_ = _aQ_ || end_of_input(ib);
+           /*<<scanf.ml:825:28>>*/ if(_aR_)
             /*<<scanf.ml:825:58>>*/ bad_hex_float(0);
            /*<<scanf.ml:825:58>>*/ return scan_optionally_signed_decimal
                   (width$9, ib);
@@ -27768,9 +27781,9 @@
      }
       /*<<scanf.ml:834:16>>*/ var
        /*<<scanf.ml:834:16>>*/ width$2 = store_char(width$0, ib, c),
-      _aM_ = 0 === width$2 ? 1 : 0,
-      _aN_ = _aM_ || end_of_input(ib);
-      /*<<scanf.ml:835:20>>*/ if(_aN_)
+      _aL_ = 0 === width$2 ? 1 : 0,
+      _aM_ = _aL_ || end_of_input(ib);
+      /*<<scanf.ml:835:20>>*/ if(_aM_)
        /*<<scanf.ml:835:50>>*/ bad_hex_float(0);
       /*<<scanf.ml:835:50>>*/ return check_case_insensitive_string
              (width$2, ib, bad_hex_float, cst_nfinity);
@@ -27779,14 +27792,14 @@
     /*<<scanf.ml:837:25>>*/ }
    function scan_caml_float_rest(width, precision, ib){
      /*<<scanf.ml:841:2>>*/ var
-     _aC_ = 0 === width ? 1 : 0,
-     _aD_ = _aC_ || end_of_input(ib);
-     /*<<scanf.ml:841:18>>*/ if(_aD_)  /*<<scanf.ml:841:48>>*/ bad_float(0);
+     _aB_ = 0 === width ? 1 : 0,
+     _aC_ = _aB_ || end_of_input(ib);
+     /*<<scanf.ml:841:18>>*/ if(_aC_)  /*<<scanf.ml:841:48>>*/ bad_float(0);
      /*<<scanf.ml:842:14>>*/ var
       /*<<scanf.ml:842:14>>*/ width$0 = scan_decimal_digit_star(width, ib),
-     _aE_ = 0 === width$0 ? 1 : 0,
-     _aF_ = _aE_ || end_of_input(ib);
-     /*<<scanf.ml:843:18>>*/ if(_aF_)  /*<<scanf.ml:843:48>>*/ bad_float(0);
+     _aD_ = 0 === width$0 ? 1 : 0,
+     _aE_ = _aD_ || end_of_input(ib);
+     /*<<scanf.ml:843:18>>*/ if(_aE_)  /*<<scanf.ml:843:48>>*/ bad_float(0);
      /*<<scanf.ml:844:10>>*/ var
       /*<<scanf.ml:844:10>>*/ c = peek_char(ib),
       /*<<scanf.ml:844:10>>*/ switcher = c - 69 | 0;
@@ -27810,22 +27823,22 @@
     /*<<scanf.ml:862:21>>*/ }
    function scan_caml_float(width, precision, ib){
      /*<<scanf.ml:866:2>>*/ var
-     _ao_ = 0 === width ? 1 : 0,
-     _ap_ = _ao_ || end_of_input(ib);
-     /*<<scanf.ml:866:18>>*/ if(_ap_)  /*<<scanf.ml:866:48>>*/ bad_float(0);
+     _an_ = 0 === width ? 1 : 0,
+     _ao_ = _an_ || end_of_input(ib);
+     /*<<scanf.ml:866:18>>*/ if(_ao_)  /*<<scanf.ml:866:48>>*/ bad_float(0);
      /*<<scanf.ml:867:14>>*/ var
       /*<<scanf.ml:867:14>>*/ width$0 = scan_sign(width, ib),
-     _aq_ = 0 === width$0 ? 1 : 0,
-     _ar_ = _aq_ || end_of_input(ib);
-     /*<<scanf.ml:868:18>>*/ if(_ar_)  /*<<scanf.ml:868:48>>*/ bad_float(0);
+     _ap_ = 0 === width$0 ? 1 : 0,
+     _aq_ = _ap_ || end_of_input(ib);
+     /*<<scanf.ml:868:18>>*/ if(_aq_)  /*<<scanf.ml:868:48>>*/ bad_float(0);
      /*<<scanf.ml:869:8>>*/  /*<<scanf.ml:869:8>>*/ var c = peek_char(ib);
     if(49 <= c){
      if(58 > c){
        /*<<scanf.ml:903:16>>*/ var
         /*<<scanf.ml:903:16>>*/ width$1 = store_char(width$0, ib, c),
-       _as_ = 0 === width$1 ? 1 : 0,
-       _at_ = _as_ || end_of_input(ib);
-       /*<<scanf.ml:904:20>>*/ if(_at_)  /*<<scanf.ml:904:50>>*/ bad_float(0);
+       _ar_ = 0 === width$1 ? 1 : 0,
+       _as_ = _ar_ || end_of_input(ib);
+       /*<<scanf.ml:904:20>>*/ if(_as_)  /*<<scanf.ml:904:50>>*/ bad_float(0);
        /*<<scanf.ml:904:50>>*/ return scan_caml_float_rest
               (width$1, precision, ib);
      }
@@ -27833,9 +27846,9 @@
     else if(48 <= c){
       /*<<scanf.ml:871:16>>*/ var
        /*<<scanf.ml:871:16>>*/ width$2 = store_char(width$0, ib, c),
-      _au_ = 0 === width$2 ? 1 : 0,
-      _av_ = _au_ || end_of_input(ib);
-      /*<<scanf.ml:872:20>>*/ if(_av_)  /*<<scanf.ml:872:50>>*/ bad_float(0);
+      _at_ = 0 === width$2 ? 1 : 0,
+      _au_ = _at_ || end_of_input(ib);
+      /*<<scanf.ml:872:20>>*/ if(_au_)  /*<<scanf.ml:872:50>>*/ bad_float(0);
       /*<<scanf.ml:873:10>>*/  /*<<scanf.ml:873:10>>*/ var
       c$0 = peek_char(ib);
      if(88 !== c$0 && 120 !== c$0)
@@ -27843,14 +27856,14 @@
               (width$2, precision, ib);
       /*<<scanf.ml:875:18>>*/ var
        /*<<scanf.ml:875:18>>*/ width$3 = store_char(width$2, ib, c$0),
-      _aw_ = 0 === width$3 ? 1 : 0,
-      _ax_ = _aw_ || end_of_input(ib);
-      /*<<scanf.ml:876:22>>*/ if(_ax_)  /*<<scanf.ml:876:52>>*/ bad_float(0);
+      _av_ = 0 === width$3 ? 1 : 0,
+      _aw_ = _av_ || end_of_input(ib);
+      /*<<scanf.ml:876:22>>*/ if(_aw_)  /*<<scanf.ml:876:52>>*/ bad_float(0);
       /*<<scanf.ml:877:18>>*/ var
        /*<<scanf.ml:877:18>>*/ width$4 = scan_hexadecimal_int(width$3, ib),
-      _ay_ = 0 === width$4 ? 1 : 0,
-      _az_ = _ay_ || end_of_input(ib);
-      /*<<scanf.ml:878:22>>*/ if(_az_)  /*<<scanf.ml:878:52>>*/ bad_float(0);
+      _ax_ = 0 === width$4 ? 1 : 0,
+      _ay_ = _ax_ || end_of_input(ib);
+      /*<<scanf.ml:878:22>>*/ if(_ay_)  /*<<scanf.ml:878:52>>*/ bad_float(0);
       /*<<scanf.ml:879:24>>*/ var
        /*<<scanf.ml:879:24>>*/ c$1 = peek_char(ib),
        /*<<scanf.ml:879:24>>*/ switcher = c$1 - 80 | 0;
@@ -27903,9 +27916,9 @@
       if(80 !== c$2 && 112 !== c$2)  /*<<scanf.ml:897:15>>*/ return width$8;
        /*<<scanf.ml:894:22>>*/ var
         /*<<scanf.ml:894:22>>*/ width$9 = store_char(width$8, ib, c$2),
-       _aA_ = 0 === width$9 ? 1 : 0,
-       _aB_ = _aA_ || end_of_input(ib);
-       /*<<scanf.ml:895:26>>*/ if(_aB_)
+       _az_ = 0 === width$9 ? 1 : 0,
+       _aA_ = _az_ || end_of_input(ib);
+       /*<<scanf.ml:895:26>>*/ if(_aA_)
         /*<<scanf.ml:895:56>>*/ bad_hex_float(0);
        /*<<scanf.ml:895:56>>*/ return scan_optionally_signed_decimal
               (width$9, ib);
@@ -27922,13 +27935,13 @@
       /*<<scanf.ml:923:7>>*/ if(ib[1])
        /*<<scanf.ml:923:28>>*/ return width$0;
      if(! stp){
-       /*<<scanf.ml:928:8>>*/  /*<<scanf.ml:928:8>>*/ var _an_ = c - 9 | 0;
+       /*<<scanf.ml:928:8>>*/  /*<<scanf.ml:928:8>>*/ var _am_ = c - 9 | 0;
       a:
       {
-       if(4 < _an_ >>> 0){
-        if(23 === _an_) break a;
+       if(4 < _am_ >>> 0){
+        if(23 === _am_) break a;
        }
-       else if(1 < _an_ - 2 >>> 0) break a;
+       else if(1 < _am_ - 2 >>> 0) break a;
         /*<<scanf.ml:930:20>>*/ var
          /*<<scanf.ml:930:20>>*/ width$2 = store_char(width$0, ib, c),
         width$0 = width$2;
@@ -27958,11 +27971,11 @@
                 (Stdlib_Printf[4], _f_, message))
             : c;
     /*<<scanf.ml:998:3>>*/ }
-    /*<<scanf.ml:1001:31>>*/ function check_next_char_for_char(_al_, _am_){
-     /*<<?>>*/ return check_next_char(cst_a_Char, _al_, _am_);
+    /*<<scanf.ml:1001:31>>*/ function check_next_char_for_char(_ak_, _al_){
+     /*<<?>>*/ return check_next_char(cst_a_Char, _ak_, _al_);
    }
-    /*<<scanf.ml:1002:33>>*/ function check_next_char_for_string(_aj_, _ak_){
-     /*<<?>>*/ return check_next_char(cst_a_String, _aj_, _ak_);
+    /*<<scanf.ml:1002:33>>*/ function check_next_char_for_string(_ai_, _aj_){
+     /*<<?>>*/ return check_next_char(cst_a_String, _ai_, _aj_);
    }
    function scan_backslash_char(width, ib){
      /*<<scanf.ml:1005:2>>*/  /*<<scanf.ml:1005:8>>*/ var
@@ -27988,16 +28001,16 @@
        b:
        {
         if(0 <= c && 255 >= c){
-         var _ah_ =  /*<<scanf.ml:963:2>>*/ caml_call1(Stdlib[29], c);
+         var _ag_ =  /*<<scanf.ml:963:2>>*/ caml_call1(Stdlib[29], c);
          break b;
         }
         var
-         _ah_ =
+         _ag_ =
            bad_input
             ( /*<<scanf.ml:961:6>>*/ caml_call4
               (Stdlib_Printf[4], _l_, c0, c1$0, c2$0));
        }
-        /*<<scanf.ml:1017:39>>*/ return store_char(width - 2 | 0, ib, _ah_);
+        /*<<scanf.ml:1017:39>>*/ return store_char(width - 2 | 0, ib, _ag_);
       }
        /*<<scanf.ml:1005:8>>*/  /*<<scanf.ml:1005:8>>*/ var
        switcher = c0 - 92 | 0;
@@ -28009,34 +28022,34 @@
             function(param){
               /*<<scanf.ml:1020:6>>*/ var
                /*<<scanf.ml:1020:14>>*/ c = next_char(ib),
-               /*<<scanf.ml:1020:14>>*/ _ai_ = c - 48 | 0;
+               /*<<scanf.ml:1020:14>>*/ _ah_ = c - 48 | 0;
              a:
              {
-              if(22 < _ai_ >>> 0){
-               if(5 < _ai_ - 49 >>> 0) break a;
+              if(22 < _ah_ >>> 0){
+               if(5 < _ah_ - 49 >>> 0) break a;
               }
-              else if(6 >= _ai_ - 10 >>> 0) break a;
+              else if(6 >= _ah_ - 10 >>> 0) break a;
                /*<<scanf.ml:1022:53>>*/ return c;
              }
               /*<<scanf.ml:1023:13>>*/ return bad_input_escape(c);
              /*<<scanf.ml:1023:31>>*/ },
            /*<<scanf.ml:1024:13>>*/ c1 = get_digit(0),
            /*<<scanf.ml:1025:13>>*/ c2 = get_digit(0),
-           /*<<scanf.ml:985:9>>*/ _ae_ = hexadecimal_value_of_char(c2),
-          c$0 = (16 * hexadecimal_value_of_char(c1) | 0) + _ae_ | 0;
+           /*<<scanf.ml:985:9>>*/ _ad_ = hexadecimal_value_of_char(c2),
+          c$0 = (16 * hexadecimal_value_of_char(c1) | 0) + _ad_ | 0;
          b:
          {
           if(0 <= c$0 && 255 >= c$0){
-           var _ag_ =  /*<<scanf.ml:989:2>>*/ caml_call1(Stdlib[29], c$0);
+           var _af_ =  /*<<scanf.ml:989:2>>*/ caml_call1(Stdlib[29], c$0);
            break b;
           }
           var
-           _ag_ =
+           _af_ =
              bad_input
               ( /*<<scanf.ml:988:6>>*/ caml_call3
                 (Stdlib_Printf[4], _m_, c1, c2));
          }
-          /*<<scanf.ml:1026:39>>*/ return store_char(width - 2 | 0, ib, _ag_);
+          /*<<scanf.ml:1026:39>>*/ return store_char(width - 2 | 0, ib, _af_);
         case 0:
         case 6:
         case 18:
@@ -28052,17 +28065,17 @@
        if(117 > c0)
         switch(c0 - 110 | 0){
           case 0:
-           var _af_ = 10; break b;
+           var _ae_ = 10; break b;
           case 4:
-           var _af_ = 13; break b;
+           var _ae_ = 13; break b;
           case 6:
-           var _af_ = 9; break b;
+           var _ae_ = 9; break b;
         }
       }
-      else if(98 === c0){var _af_ = 8; break b;}
-      var _af_ = c0;
+      else if(98 === c0){var _ae_ = 8; break b;}
+      var _ae_ = c0;
      }
-      /*<<scanf.ml:1007:33>>*/ return store_char(width, ib, _af_);
+      /*<<scanf.ml:1007:33>>*/ return store_char(width, ib, _ae_);
     }
      /*<<scanf.ml:1028:4>>*/ return bad_input_escape(c0);
     /*<<scanf.ml:1028:22>>*/ }
@@ -28080,24 +28093,24 @@
           check_next_char_for_string(width$1, ib);
        if(10 === match){
          /*<<scanf.ml:1071:26>>*/  /*<<scanf.ml:1071:26>>*/ var
-         _ac_ = ignore_char(width$1, ib);
+         _ab_ = ignore_char(width$1, ib);
          /*<<scanf.ml:1071:26>>*/ if(counter >= 50)
           /*<<scanf.ml:1071:26>>*/ return  /*<<scanf.ml:1071:26>>*/ caml_trampoline_return
-                 (skip_spaces, [0, _ac_]);
+                 (skip_spaces, [0, _ab_]);
         var counter$0 = counter + 1 | 0;
-         /*<<scanf.ml:1071:26>>*/ return skip_spaces(counter$0, _ac_);
+         /*<<scanf.ml:1071:26>>*/ return skip_spaces(counter$0, _ab_);
        }
        if(13 === match){
          /*<<scanf.ml:1070:27>>*/  /*<<scanf.ml:1070:27>>*/ var
          width$3 = ignore_char(width$1, ib);
         if(10 === check_next_char_for_string(width$3, ib)){
           /*<<scanf.ml:1076:26>>*/  /*<<scanf.ml:1076:26>>*/ var
-          _ad_ = ignore_char(width$3, ib);
+          _ac_ = ignore_char(width$3, ib);
           /*<<scanf.ml:1076:26>>*/ if(counter >= 50)
            /*<<scanf.ml:1076:26>>*/ return  /*<<scanf.ml:1076:26>>*/ caml_trampoline_return
-                  (skip_spaces, [0, _ad_]);
+                  (skip_spaces, [0, _ac_]);
          var counter$1 = counter + 1 | 0;
-          /*<<scanf.ml:1076:26>>*/ return skip_spaces(counter$1, _ad_);
+          /*<<scanf.ml:1076:26>>*/ return skip_spaces(counter$1, _ac_);
         }
          /*<<scanf.ml:1077:21>>*/ var
           /*<<scanf.ml:1077:21>>*/ width$5 = store_char(width$3, ib, 13),
@@ -28144,39 +28157,39 @@
       /*<<scanf.ml:1104:4>>*/ for(;;){
        /*<<scanf.ml:1104:12>>*/ var
         /*<<scanf.ml:1104:12>>*/ c = peek_char(ib),
-       ___ = 0 < i$0 ? 1 : 0;
-      if(___){
+       _Z_ = 0 < i$0 ? 1 : 0;
+      if(_Z_){
         /*<<scanf.ml:1105:20>>*/  /*<<scanf.ml:1105:20>>*/ var
-        _$_ = 1 - ib[1];
-       if(_$_)
+        ___ = 1 - ib[1];
+       if(___)
          /*<<scanf.ml:1106:7>>*/ var
-          /*<<scanf.ml:1106:7>>*/ _aa_ =
+          /*<<scanf.ml:1106:7>>*/ _$_ =
             /*<<scanf.ml:1106:7>>*/ caml_call2
             (CamlinternalFormat[1], char_set, c),
-          /*<<scanf.ml:1106:7>>*/ _ab_ = _aa_ ? c !== stp ? 1 : 0 : _aa_;
+          /*<<scanf.ml:1106:7>>*/ _aa_ = _$_ ? c !== stp ? 1 : 0 : _$_;
        else
-        var _ab_ = _$_;
+        var _aa_ = ___;
       }
       else
-       var _ab_ = ___;
-      if(! _ab_) return _ab_;
+       var _aa_ = _Z_;
+      if(! _aa_) return _aa_;
        /*<<scanf.ml:1108:14>>*/ store_char(Stdlib[19], ib, c);
       var i$1 = i$0 - 1 | 0, i$0 = i$1;
      }
      /*<<scanf.ml:1109:28>>*/ }
     if(! scan_indic){
       /*<<scanf.ml:1111:12>>*/ scan_chars(width, -1);
-      /*<<scanf.ml:1111:12>>*/ return _u_;
+      /*<<scanf.ml:1111:12>>*/ return sentinal;
     }
     var c = scan_indic[1];
      /*<<scanf.ml:1113:4>>*/ scan_chars(width, c);
-     /*<<scanf.ml:1114:11>>*/  /*<<scanf.ml:1114:11>>*/ var _Z_ = 1 - ib[1];
-    if(! _Z_)  /*<<scanf.ml:1114:11>>*/ return _Z_;
+     /*<<scanf.ml:1114:11>>*/  /*<<scanf.ml:1114:11>>*/ var _Y_ = 1 - ib[1];
+    if(! _Y_)  /*<<scanf.ml:1114:11>>*/ return _Y_;
      /*<<scanf.ml:1115:15>>*/  /*<<scanf.ml:1115:15>>*/ var
      ci = peek_char(ib);
     return c === ci
-            ? (invalidate_current_char(ib), _u_)
-            : (character_mismatch(c, ci), _u_);
+            ? (invalidate_current_char(ib), sentinal)
+            : (character_mismatch(c, ci), sentinal);
     /*<<scanf.ml:1118:34>>*/ }
    function scanf_bad_input(ib, x){
      /*<<?>>*/ if(x[1] === Scan_failure)
@@ -28253,17 +28266,17 @@
          /*<<scanf.ml:1195:44>>*/ var
          rest$13 = fmt$0[3],
          fmtty = fmt$0[2],
-          /*<<scanf.ml:1195:44>>*/ _W_ =
+          /*<<scanf.ml:1195:44>>*/ _V_ =
             /*<<scanf.ml:1195:44>>*/ caml_call1(CamlinternalFormat[21], fmtty),
-          /*<<scanf.ml:1195:33>>*/ _X_ =
+          /*<<scanf.ml:1195:33>>*/ _W_ =
             /*<<scanf.ml:1195:33>>*/ caml_call1
-            (CamlinternalFormatBasics[2], _W_);
+            (CamlinternalFormatBasics[2], _V_);
          /*<<scanf.ml:1195:5>>*/ if(counter >= 50)
           /*<<scanf.ml:1195:5>>*/ return  /*<<scanf.ml:1195:5>>*/ caml_trampoline_return
-                 (take_fmtty_format_readers$0, [0, k, _X_, rest$13]);
+                 (take_fmtty_format_readers$0, [0, k, _W_, rest$13]);
         var counter$0 = counter + 1 | 0;
          /*<<scanf.ml:1195:5>>*/ return take_fmtty_format_readers$0
-                (counter$0, k, _X_, rest$13);
+                (counter$0, k, _W_, rest$13);
        case 15:
         var rest$14 = fmt$0[1], fmt$0 = rest$14; break;
        case 16:
@@ -28271,11 +28284,11 @@
        case 17:
         var rest$16 = fmt$0[2], fmt$0 = rest$16; break;
        case 18:
-        var _Y_ = fmt$0[1];
-        if(0 === _Y_[0])
+        var _X_ = fmt$0[1];
+        if(0 === _X_[0])
           /*<<scanf.ml:1189:28>>*/ var
           rest$17 = fmt$0[2],
-          fmt$1 = _Y_[1][1],
+          fmt$1 = _X_[1][1],
            /*<<scanf.ml:1189:28>>*/ fmt$2 =
              /*<<scanf.ml:1189:28>>*/ caml_call2
              (CamlinternalFormatBasics[3], fmt$1, rest$17),
@@ -28283,7 +28296,7 @@
         else
           /*<<scanf.ml:1191:28>>*/ var
           rest$18 = fmt$0[2],
-          fmt$3 = _Y_[1][1],
+          fmt$3 = _X_[1][1],
            /*<<scanf.ml:1191:28>>*/ fmt$4 =
              /*<<scanf.ml:1191:28>>*/ caml_call2
              (CamlinternalFormatBasics[3], fmt$3, rest$18),
@@ -28393,11 +28406,11 @@
          rest = fmtty$0[3],
          ty2 = fmtty$0[2],
          ty1 = fmtty$0[1],
-          /*<<scanf.ml:1227:19>>*/ _V_ =
+          /*<<scanf.ml:1227:19>>*/ _U_ =
             /*<<scanf.ml:1227:19>>*/ caml_call1(CamlinternalFormat[21], ty1),
           /*<<scanf.ml:1227:13>>*/ ty =
             /*<<scanf.ml:1227:13>>*/ caml_call2
-            (CamlinternalFormat[22], _V_, ty2),
+            (CamlinternalFormat[22], _U_, ty2),
           /*<<scanf.ml:1228:32>>*/ fmtty$10 =
             /*<<scanf.ml:1228:32>>*/ caml_call2
             (CamlinternalFormatBasics[1], ty, rest),
@@ -28502,8 +28515,8 @@
              /*<<scanf.ml:1047:4>>*/  /*<<scanf.ml:1047:10>>*/ var
              c = check_next_char_for_char(width, ib);
             return 39 === c
-                    ? (ignore_char(width, ib), _u_)
-                    : (character_mismatch(39, c), _u_);
+                    ? (ignore_char(width, ib), sentinal)
+                    : (character_mismatch(39, c), sentinal);
             /*<<scanf.ml:1049:36>>*/ },
           /*<<scanf.ml:1035:10>>*/ c = checked_peek_char(ib);
         if(39 === c){
@@ -28544,11 +28557,11 @@
              /*<<scanf.ml:1280:4>>*/ return pad_prec_scanf
                     (ib, str_rest, readers, pad, 0, scan$0, token_string);
            case 18:
-            var _H_ = match[1];
-            if(0 === _H_[0]){
+            var _G_ = match[1];
+            if(0 === _G_[0]){
               /*<<scanf.ml:1282:4>>*/ var
               rest$3 = match[2],
-              fmt$1 = _H_[1][1],
+              fmt$1 = _G_[1][1],
                /*<<scanf.ml:1282:4>>*/ scan$1 =
                 function(width, param, ib){
                   /*<<scanf.ml:1282:26>>*/ return scan_string(_q_, width, ib);
@@ -28565,7 +28578,7 @@
             }
              /*<<scanf.ml:1286:4>>*/ var
              rest$4 = match[2],
-             fmt$2 = _H_[1][1],
+             fmt$2 = _G_[1][1],
               /*<<scanf.ml:1286:4>>*/ scan$2 =
                function(width, param, ib){
                  /*<<scanf.ml:1286:26>>*/ return scan_string(_r_, width, ib);
@@ -28742,7 +28755,7 @@
          rest$13 = fmt$0[2],
          pad$8 = fmt$0[1],
           /*<<scanf.ml:1320:4>>*/ scan$8 =
-           function(param, _U_, ib){
+           function(param, _T_, ib){
              /*<<scanf.ml:1320:22>>*/ var
               /*<<scanf.ml:1089:10>>*/ c = checked_peek_char(ib),
               /*<<scanf.ml:1090:2>>*/ m =
@@ -28768,10 +28781,10 @@
          /*<<scanf.ml:1341:16>>*/ var
          rest$15 = fmt$0[2],
          str$0 = fmt$0[1],
-          /*<<scanf.ml:1341:16>>*/ _I_ =
-           function(_T_){ /*<<?>>*/ return check_char(ib, _T_);};
+          /*<<scanf.ml:1341:16>>*/ _H_ =
+           function(_S_){ /*<<?>>*/ return check_char(ib, _S_);};
          /*<<scanf.ml:1341:4>>*/  /*<<scanf.ml:1341:4>>*/ caml_call2
-         (Stdlib_String[29], _I_, str$0);
+         (Stdlib_String[29], _H_, str$0);
         var fmt$0 = rest$15;
         break;
        case 12:
@@ -28787,10 +28800,10 @@
          s = token_string(ib);
          /*<<scanf.ml:1350:4>>*/ try{
           /*<<scanf.ml:1351:10>>*/ var
-           /*<<scanf.ml:1351:10>>*/ _J_ =
+           /*<<scanf.ml:1351:10>>*/ _I_ =
              /*<<scanf.ml:1351:10>>*/ caml_call2
              (CamlinternalFormat[14], s, fmtty),
-          fmt$3 = _J_;
+          fmt$3 = _I_;
         }
         catch(exn$0){
          var exn = caml_wrap_exception(exn$0);
@@ -28816,23 +28829,23 @@
              /*<<scanf.ml:1361:27>>*/ caml_call2
               (CamlinternalFormat[13], 0, s$0)
              [1],
-           /*<<scanf.ml:1375:36>>*/ _L_ =
+           /*<<scanf.ml:1375:36>>*/ _K_ =
              /*<<scanf.ml:1375:36>>*/ caml_call1
              (CamlinternalFormat[21], fmtty$0),
-           /*<<scanf.ml:1375:25>>*/ _M_ =
+           /*<<scanf.ml:1375:25>>*/ _L_ =
              /*<<scanf.ml:1375:25>>*/ caml_call1
-             (CamlinternalFormatBasics[2], _L_),
+             (CamlinternalFormatBasics[2], _K_),
            /*<<scanf.ml:1375:8>>*/ fmt$8 =
              /*<<scanf.ml:1375:8>>*/ caml_call2
-             (CamlinternalFormat[12], fmt$7, _M_),
-           /*<<scanf.ml:1374:24>>*/ _N_ =
+             (CamlinternalFormat[12], fmt$7, _L_),
+           /*<<scanf.ml:1374:24>>*/ _M_ =
              /*<<scanf.ml:1374:24>>*/ caml_call1
              (CamlinternalFormatBasics[2], fmtty$0),
-           /*<<scanf.ml:1374:8>>*/ _O_ =
+           /*<<scanf.ml:1374:8>>*/ _N_ =
              /*<<scanf.ml:1374:8>>*/ caml_call2
-             (CamlinternalFormat[12], fmt$6, _N_),
+             (CamlinternalFormat[12], fmt$6, _M_),
           fmt$5 = fmt$8,
-          fmt$4 = _O_;
+          fmt$4 = _N_;
         }
         catch(exn){
          var exn$0 = caml_wrap_exception(exn);
@@ -28840,9 +28853,9 @@
           throw caml_maybe_attach_backtrace(exn$0, 0);
          var
           msg$0 = exn$0[2],
-          _K_ = bad_input(msg$0),
-          fmt$5 = _K_[2],
-          fmt$4 = _K_[1];
+          _J_ = bad_input(msg$0),
+          fmt$5 = _J_[2],
+          fmt$4 = _J_[1];
         }
          /*<<scanf.ml:1378:4>>*/ return [0,
                 [0, fmt$4, s$0],
@@ -28861,19 +28874,19 @@
          /*<<scanf.ml:1401:32>>*/ var
          rest$19 = fmt$0[2],
          formatting_lit = fmt$0[1],
-          /*<<scanf.ml:1401:32>>*/ _P_ =
+          /*<<scanf.ml:1401:32>>*/ _O_ =
             /*<<scanf.ml:1401:32>>*/ caml_call1
             (CamlinternalFormat[17], formatting_lit),
-          /*<<scanf.ml:1401:16>>*/ _Q_ =
-           function(_S_){ /*<<?>>*/ return check_char(ib, _S_);};
+          /*<<scanf.ml:1401:16>>*/ _P_ =
+           function(_R_){ /*<<?>>*/ return check_char(ib, _R_);};
          /*<<scanf.ml:1401:4>>*/  /*<<scanf.ml:1401:4>>*/ caml_call2
-         (Stdlib_String[29], _Q_, _P_);
+         (Stdlib_String[29], _P_, _O_);
         var fmt$0 = rest$19;
         break;
        case 18:
-        var _R_ = fmt$0[1];
-        if(0 === _R_[0]){
-         var rest$20 = fmt$0[2], fmt$9 = _R_[1][1];
+        var _Q_ = fmt$0[1];
+        if(0 === _Q_[0]){
+         var rest$20 = fmt$0[2], fmt$9 = _Q_[1][1];
           /*<<scanf.ml:1404:4>>*/ check_char(ib, 64);
           /*<<scanf.ml:1404:23>>*/ check_char(ib, 123);
           /*<<scanf.ml:1405:18>>*/ var
@@ -28883,7 +28896,7 @@
           fmt$0 = fmt$10;
         }
         else{
-         var rest$21 = fmt$0[2], fmt$11 = _R_[1][1];
+         var rest$21 = fmt$0[2], fmt$11 = _Q_[1][1];
           /*<<scanf.ml:1407:4>>*/ check_char(ib, 64);
           /*<<scanf.ml:1407:23>>*/ check_char(ib, 91);
           /*<<scanf.ml:1408:18>>*/ var
@@ -28992,16 +29005,16 @@
        if(exc[1] !== Stdlib[6]) throw caml_maybe_attach_backtrace(exc, 0);
         /*<<scanf.ml:1470:45>>*/ var
         msg = exc[2],
-         /*<<scanf.ml:1470:45>>*/ _D_ =
+         /*<<scanf.ml:1470:45>>*/ _C_ =
            /*<<scanf.ml:1470:45>>*/ caml_call1(Stdlib_String[24], str),
-         /*<<scanf.ml:1470:45>>*/ _E_ =
-           /*<<scanf.ml:1470:45>>*/ caml_call2(Stdlib[28], _D_, cst$0),
-         /*<<scanf.ml:1470:27>>*/ _F_ =
-           /*<<scanf.ml:1470:27>>*/ caml_call2(Stdlib[28], cst_in_format, _E_),
-         /*<<scanf.ml:1470:20>>*/ _G_ =
-           /*<<scanf.ml:1470:20>>*/ caml_call2(Stdlib[28], msg, _F_);
+         /*<<scanf.ml:1470:45>>*/ _D_ =
+           /*<<scanf.ml:1470:45>>*/ caml_call2(Stdlib[28], _C_, cst$0),
+         /*<<scanf.ml:1470:27>>*/ _E_ =
+           /*<<scanf.ml:1470:27>>*/ caml_call2(Stdlib[28], cst_in_format, _D_),
+         /*<<scanf.ml:1470:20>>*/ _F_ =
+           /*<<scanf.ml:1470:20>>*/ caml_call2(Stdlib[28], msg, _E_);
         /*<<scanf.ml:1470:20>>*/ return  /*<<scanf.ml:1470:20>>*/ caml_call1
-               (Stdlib[1], _G_);
+               (Stdlib[1], _F_);
       }
        /*<<scanf.ml:1468:8>>*/ return  /*<<scanf.ml:1468:8>>*/ caml_call2
               (ef, ib, exc);
@@ -29032,15 +29045,15 @@
              fmt);
     /*<<scanf.ml:1477:35>>*/ }
    function kscanf_opt(ib, fmt){
-    function _B_(x){
+    function _A_(x){
       /*<<scanf.ml:1480:44>>*/ return [0, x];
      /*<<scanf.ml:1480:50>>*/ }
      /*<<scanf.ml:1480:2>>*/ return kscanf_gen
             (ib,
-             function(param, _C_){
+             function(param, _B_){
                /*<<scanf.ml:1480:28>>*/ return 0;
               /*<<scanf.ml:1480:32>>*/ },
-             _B_,
+             _A_,
              fmt);
     /*<<scanf.ml:1480:55>>*/ }
    function bscanf(ib, fmt){
@@ -29071,10 +29084,10 @@
      str = token_string(ib);
      /*<<scanf.ml:1504:4>>*/ try{
       /*<<scanf.ml:1505:10>>*/ var
-       /*<<scanf.ml:1505:10>>*/ _A_ =
+       /*<<scanf.ml:1505:10>>*/ _z_ =
          /*<<scanf.ml:1505:10>>*/ caml_call2
          (CamlinternalFormat[15], str, format),
-      fmt = _A_;
+      fmt = _z_;
     }
     catch(exn$0){
      var exn = caml_wrap_exception(exn$0);
@@ -29088,30 +29101,30 @@
      /*<<scanf.ml:1513:20>>*/ return bscanf_format(from_string(s), format, f);
     /*<<scanf.ml:1513:67>>*/ }
    function format_from_string(s, fmt){
-     /*<<scanf.ml:1517:2>>*/ function _x_(x){
+     /*<<scanf.ml:1517:2>>*/ function _w_(x){
       /*<<scanf.ml:1517:63>>*/ return x;
      /*<<scanf.ml:1517:64>>*/ }
      /*<<scanf.ml:1517:24>>*/ var
-      /*<<scanf.ml:1517:24>>*/ _y_ =
+      /*<<scanf.ml:1517:24>>*/ _x_ =
         /*<<scanf.ml:1517:24>>*/ caml_call1(Stdlib_String[24], s),
-      /*<<scanf.ml:1517:24>>*/ _z_ =
-        /*<<scanf.ml:1517:24>>*/ caml_call2(Stdlib[28], _y_, cst$1);
+      /*<<scanf.ml:1517:24>>*/ _y_ =
+        /*<<scanf.ml:1517:24>>*/ caml_call2(Stdlib[28], _x_, cst$1);
      /*<<scanf.ml:1517:53>>*/ return sscanf_format
-            ( /*<<scanf.ml:1517:16>>*/ caml_call2(Stdlib[28], cst$2, _z_),
+            ( /*<<scanf.ml:1517:16>>*/ caml_call2(Stdlib[28], cst$2, _y_),
              fmt,
-             _x_);
+             _w_);
     /*<<scanf.ml:1517:65>>*/ }
    function unescaped(s){
-     /*<<scanf.ml:1521:2>>*/ function _v_(x){
+     /*<<scanf.ml:1521:2>>*/ function _u_(x){
       /*<<scanf.ml:1521:44>>*/ return x;
      /*<<scanf.ml:1521:45>>*/ }
      /*<<scanf.ml:1521:17>>*/  /*<<scanf.ml:1521:17>>*/ var
-     _w_ =  /*<<scanf.ml:1521:17>>*/ caml_call2(Stdlib[28], s, cst$3);
+     _v_ =  /*<<scanf.ml:1521:17>>*/ caml_call2(Stdlib[28], s, cst$3);
      /*<<scanf.ml:1521:34>>*/ return  /*<<scanf.ml:1521:34>>*/ caml_call1
             (sscanf
-              ( /*<<scanf.ml:1521:9>>*/ caml_call2(Stdlib[28], cst$4, _w_),
+              ( /*<<scanf.ml:1521:9>>*/ caml_call2(Stdlib[28], cst$4, _v_),
                _t_),
-             _v_);
+             _u_);
     /*<<scanf.ml:1521:46>>*/ }
    var
     Stdlib_Scanf =
@@ -30476,7 +30489,7 @@
             : runtime.caml_call_gen(f, [a0, a1, a2]);
    }
    var
-    _d_ = undefined,
+    sentinal = undefined,
     global_data = runtime.caml_get_global_data(),
     Stdlib_List = global_data.Stdlib__List,
     Stdlib = global_data.Stdlib,
@@ -30495,7 +30508,7 @@
      /*<<ephemeron.ml:105:20>>*/  /*<<ephemeron.ml:105:20>>*/ var
      prng =
        [246,
-        function(_aN_){ /*<<?>>*/ return caml_call1(Stdlib_Random[15][2], 0);}];
+        function(_aM_){ /*<<?>>*/ return caml_call1(Stdlib_Random[15][2], 0);}];
     function create(opt, initial_size){
       /*<<ephemeron.ml:108:6>>*/ if(opt)
       var sth = opt[1], random = sth;
@@ -30506,17 +30519,17 @@
       /*<<ephemeron.ml:101:6>>*/ for(;;){
       if(initial_size > x && Stdlib_Sys[13] >= (x * 2 | 0)){var x$0 = x * 2 | 0, x = x$0; continue;}
        /*<<ephemeron.ml:109:6>>*/ if(random){
-       var _aL_ = runtime.caml_obj_tag(prng);
+       var _aK_ = runtime.caml_obj_tag(prng);
        a:
-       if(250 === _aL_)
-        var _aM_ = prng[1];
+       if(250 === _aK_)
+        var _aL_ = prng[1];
        else{
-        if(246 !== _aL_ && 244 !== _aL_){var _aM_ = prng; break a;}
-        var _aM_ = caml_call1(CamlinternalLazy[2], prng);
+        if(246 !== _aK_ && 244 !== _aK_){var _aL_ = prng; break a;}
+        var _aL_ = caml_call1(CamlinternalLazy[2], prng);
        }
        var
         seed =
-           /*<<ephemeron.ml:109:32>>*/ caml_call1(Stdlib_Random[15][4], _aM_);
+           /*<<ephemeron.ml:109:32>>*/ caml_call1(Stdlib_Random[15][4], _aL_);
       }
       else
        var seed = 0;
@@ -30531,16 +30544,16 @@
       /*<<ephemeron.ml:113:6>>*/ h[1] = 0;
       /*<<ephemeron.ml:115:6>>*/ var
       len = h[2].length - 1,
-       /*<<ephemeron.ml:115:6>>*/ _aJ_ = len - 1 | 0,
-      _aI_ = 0;
-     if(_aJ_ >= 0){
-      var i = _aI_;
+       /*<<ephemeron.ml:115:6>>*/ _aI_ = len - 1 | 0,
+      _aH_ = 0;
+     if(_aI_ >= 0){
+      var i = _aH_;
       for(;;){
         /*<<ephemeron.ml:116:8>>*/ caml_check_bound(h[2], i)[1 + i] = 0;
         /*<<ephemeron.ml:116:8>>*/  /*<<ephemeron.ml:116:8>>*/ var
-        _aK_ = i + 1 | 0;
-       if(_aJ_ === i) break;
-       var i = _aK_;
+        _aJ_ = i + 1 | 0;
+       if(_aI_ === i) break;
+       var i = _aJ_;
       }
      }
      return 0;
@@ -30557,11 +30570,11 @@
      /*<<ephemeron.ml:126:9>>*/ }
     function copy(h){
       /*<<ephemeron.ml:128:17>>*/ var
-      _aF_ = h[4],
-      _aG_ = h[3],
-       /*<<ephemeron.ml:128:33>>*/ _aH_ =
+      _aE_ = h[4],
+      _aF_ = h[3],
+       /*<<ephemeron.ml:128:33>>*/ _aG_ =
          /*<<ephemeron.ml:128:33>>*/ caml_call1(Stdlib_Array[6], h[2]);
-      /*<<ephemeron.ml:128:17>>*/ return [0, h[1], _aH_, _aG_, _aF_];
+      /*<<ephemeron.ml:128:17>>*/ return [0, h[1], _aG_, _aF_, _aE_];
      /*<<ephemeron.ml:128:52>>*/ }
     function key_index(h, hkey){
       /*<<ephemeron.ml:131:6>>*/ return hkey & (h[2].length - 1 - 1 | 0);
@@ -30581,16 +30594,16 @@
        var param$0 = rest;
       }
       /*<<ephemeron.ml:141:41>>*/ }
-     var d = h[2], _aD_ = d.length - 1 - 1 | 0, _aC_ = 0;
-     if(_aD_ >= 0){
-      var i = _aC_;
+     var d = h[2], _aC_ = d.length - 1 - 1 | 0, _aB_ = 0;
+     if(_aC_ >= 0){
+      var i = _aB_;
       for(;;){
         /*<<ephemeron.ml:145:8>>*/ d[1 + i] =
         do_bucket(caml_check_bound(d, i)[1 + i]);
         /*<<ephemeron.ml:145:8>>*/  /*<<ephemeron.ml:145:8>>*/ var
-        _aE_ = i + 1 | 0;
-       if(_aD_ === i) break;
-       var i = _aE_;
+        _aD_ = i + 1 | 0;
+       if(_aC_ === i) break;
+       var i = _aD_;
       }
      }
      return 0;
@@ -30602,9 +30615,9 @@
       nsize = osize * 2 | 0;
       /*<<ephemeron.ml:172:6>>*/ clean(h);
      var
-      _aw_ = nsize < Stdlib_Sys[13] ? 1 : 0,
-      _ax_ = _aw_ ? (osize >>> 1 | 0) <= h[1] ? 1 : 0 : _aw_;
-     if(_ax_){
+      _av_ = nsize < Stdlib_Sys[13] ? 1 : 0,
+      _aw_ = _av_ ? (osize >>> 1 | 0) <= h[1] ? 1 : 0 : _av_;
+     if(_aw_){
        /*<<ephemeron.ml:174:20>>*/  /*<<ephemeron.ml:174:20>>*/ var
        ndata =  /*<<ephemeron.ml:174:20>>*/ caml_make_vect(nsize, 0);
       h[2] = ndata;
@@ -30612,33 +30625,33 @@
        insert_bucket =
          function(param){
            /*<<ephemeron.ml:176:32>>*/ if(! param)
-            /*<<ephemeron.ml:177:21>>*/ return _d_;
+            /*<<ephemeron.ml:177:21>>*/ return sentinal;
           var rest = param[3], data = param[2], hkey = param[1];
            /*<<ephemeron.ml:179:14>>*/ insert_bucket(rest);
            /*<<ephemeron.ml:180:25>>*/  /*<<ephemeron.ml:180:25>>*/ var
            nidx = key_index(h, hkey);
            /*<<ephemeron.ml:181:14>>*/ ndata[1 + nidx] =
            [0, hkey, data, caml_check_bound(ndata, nidx)[1 + nidx]];
-           /*<<ephemeron.ml:181:14>>*/ return _d_;
+           /*<<ephemeron.ml:181:14>>*/ return sentinal;
           /*<<ephemeron.ml:181:60>>*/ },
-        /*<<ephemeron.ml:170:6>>*/ _az_ = osize - 1 | 0,
-        /*<<ephemeron.ml:182:8>>*/ _ay_ = 0;
-      if(_az_ >= 0){
-       var i = _ay_;
+        /*<<ephemeron.ml:170:6>>*/ _ay_ = osize - 1 | 0,
+        /*<<ephemeron.ml:182:8>>*/ _ax_ = 0;
+      if(_ay_ >= 0){
+       var i = _ax_;
        for(;;){
          /*<<ephemeron.ml:183:10>>*/ insert_bucket
          (caml_check_bound(odata, i)[1 + i]);
          /*<<ephemeron.ml:183:10>>*/  /*<<ephemeron.ml:183:10>>*/ var
-         _aB_ = i + 1 | 0;
-        if(_az_ === i) break;
-        var i = _aB_;
+         _aA_ = i + 1 | 0;
+        if(_ay_ === i) break;
+        var i = _aA_;
        }
       }
-      var _aA_ = 0;
+      var _az_ = 0;
      }
      else
-      var _aA_ = _ax_;
-     return _aA_;
+      var _az_ = _aw_;
+     return _az_;
      /*<<ephemeron.ml:185:9>>*/ }
     function add(h, key, info){
       /*<<ephemeron.ml:188:6>>*/ var
@@ -30651,8 +30664,8 @@
         [0, hkey, container, caml_check_bound(h[2], i)[1 + i]];
       /*<<ephemeron.ml:192:6>>*/ caml_check_bound(h[2], i)[1 + i] = bucket;
      h[1] = h[1] + 1 | 0;
-     var _av_ = h[2].length - 1 << 1 < h[1] ? 1 : 0;
-     return _av_ ? resize(h) : _av_;
+     var _au_ = h[2].length - 1 << 1 < h[1] ? 1 : 0;
+     return _au_ ? resize(h) : _au_;
      /*<<ephemeron.ml:194:57>>*/ }
     function remove(h, key){
       /*<<ephemeron.ml:197:6>>*/  /*<<ephemeron.ml:197:17>>*/ var
@@ -30680,17 +30693,17 @@
       /*<<ephemeron.ml:210:60>>*/ }
       /*<<ephemeron.ml:211:14>>*/ var
        /*<<ephemeron.ml:211:14>>*/ i = key_index(h, hkey),
-       /*<<ephemeron.ml:212:20>>*/ _au_ =
+       /*<<ephemeron.ml:212:20>>*/ _at_ =
         remove_bucket(caml_check_bound(h[2], i)[1 + i]);
-      /*<<ephemeron.ml:212:6>>*/ caml_check_bound(h[2], i)[1 + i] = _au_;
+      /*<<ephemeron.ml:212:6>>*/ caml_check_bound(h[2], i)[1 + i] = _at_;
       /*<<ephemeron.ml:212:6>>*/ return 0;
      /*<<ephemeron.ml:212:44>>*/ }
     function find(h, key){
       /*<<ephemeron.ml:239:6>>*/ var
        /*<<ephemeron.ml:239:17>>*/ hkey =
          /*<<ephemeron.ml:239:17>>*/ caml_call2(H[2], h[3], key),
-       /*<<ephemeron.ml:241:33>>*/ _at_ = key_index(h, hkey),
-      param = caml_check_bound(h[2], _at_)[1 + _at_];
+       /*<<ephemeron.ml:241:33>>*/ _as_ = key_index(h, hkey),
+      param = caml_check_bound(h[2], _as_)[1 + _as_];
      for(;;){
       if(! param)
         /*<<ephemeron.ml:220:10>>*/ throw  /*<<ephemeron.ml:220:10>>*/ caml_maybe_attach_backtrace
@@ -30716,8 +30729,8 @@
       /*<<ephemeron.ml:264:6>>*/ var
        /*<<ephemeron.ml:264:17>>*/ hkey =
          /*<<ephemeron.ml:264:17>>*/ caml_call2(H[2], h[3], key),
-       /*<<ephemeron.ml:266:37>>*/ _as_ = key_index(h, hkey),
-      param = caml_check_bound(h[2], _as_)[1 + _as_];
+       /*<<ephemeron.ml:266:37>>*/ _ar_ = key_index(h, hkey),
+      param = caml_check_bound(h[2], _ar_)[1 + _ar_];
      for(;;){
       if(! param)  /*<<ephemeron.ml:245:10>>*/ return 0;
       var hk = param[1], rest = param[3], c = param[2];
@@ -30765,9 +30778,9 @@
       }
       /*<<ephemeron.ml:284:29>>*/ }
       /*<<ephemeron.ml:285:29>>*/  /*<<ephemeron.ml:285:29>>*/ var
-      _ar_ = key_index(h, hkey);
+      _aq_ = key_index(h, hkey);
       /*<<ephemeron.ml:285:21>>*/ return find_in_bucket
-             (caml_check_bound(h[2], _ar_)[1 + _ar_]);
+             (caml_check_bound(h[2], _aq_)[1 + _aq_]);
      /*<<ephemeron.ml:285:46>>*/ }
     function replace(h, key, info){
       /*<<ephemeron.ml:289:6>>*/ var
@@ -30785,8 +30798,8 @@
        if(hkey === hk){
         if(!  /*<<ephemeron.ml:293:24>>*/ caml_call2(H[3], c, key)){
           /*<<ephemeron.ml:290:6>>*/  /*<<ephemeron.ml:290:6>>*/ var
-          _an_ =  /*<<ephemeron.ml:290:6>>*/ caml_call3(H[5], c, key, info);
-          /*<<ephemeron.ml:302:8>>*/ return _an_;
+          _am_ =  /*<<ephemeron.ml:290:6>>*/ caml_call3(H[5], c, key, info);
+          /*<<ephemeron.ml:302:8>>*/ return _am_;
         }
         var param = next;
        }
@@ -30794,23 +30807,23 @@
         var next$0 = param[3], param = next$0;
       }
      }
-     catch(_aq_){
-      var _ao_ = caml_wrap_exception(_aq_);
-      if(_ao_ !== Stdlib[8]) throw caml_maybe_attach_backtrace(_ao_, 0);
+     catch(_ap_){
+      var _an_ = caml_wrap_exception(_ap_);
+      if(_an_ !== Stdlib[8]) throw caml_maybe_attach_backtrace(_an_, 0);
        /*<<ephemeron.ml:304:24>>*/  /*<<ephemeron.ml:304:24>>*/ var
        container =  /*<<ephemeron.ml:304:24>>*/ caml_call2(H[1], key, info);
        /*<<ephemeron.ml:305:8>>*/ caml_check_bound(h[2], i)[1 + i] = [0, hkey, container, l];
       h[1] = h[1] + 1 | 0;
-      var _ap_ = h[2].length - 1 << 1 < h[1] ? 1 : 0;
-      return _ap_ ? resize(h) : _ap_;
+      var _ao_ = h[2].length - 1 << 1 < h[1] ? 1 : 0;
+      return _ao_ ? resize(h) : _ao_;
      }
      /*<<ephemeron.ml:307:59>>*/ }
     function mem(h, key){
       /*<<ephemeron.ml:310:6>>*/ var
        /*<<ephemeron.ml:310:17>>*/ hkey =
          /*<<ephemeron.ml:310:17>>*/ caml_call2(H[2], h[3], key),
-       /*<<ephemeron.ml:320:28>>*/ _am_ = key_index(h, hkey),
-      param = caml_check_bound(h[2], _am_)[1 + _am_];
+       /*<<ephemeron.ml:320:28>>*/ _al_ = key_index(h, hkey),
+      param = caml_check_bound(h[2], _al_)[1 + _al_];
       /*<<ephemeron.ml:311:30>>*/ for(;;){
       if(! param)  /*<<ephemeron.ml:313:10>>*/ return 0;
       var hk = param[1], rest = param[3], c = param[2];
@@ -30838,21 +30851,21 @@
      }
     }
     function stats(h){
-      /*<<ephemeron.ml:329:6>>*/ var _ag_ = h[2], _ah_ = 0;
-     function _ai_(m, b){
+      /*<<ephemeron.ml:329:6>>*/ var _af_ = h[2], _ag_ = 0;
+     function _ah_(m, b){
        /*<<ephemeron.ml:330:36>>*/  /*<<ephemeron.ml:330:46>>*/ var
-       _al_ = bucket_length(0, b);
+       _ak_ = bucket_length(0, b);
        /*<<ephemeron.ml:330:46>>*/ return  /*<<ephemeron.ml:330:46>>*/ caml_call2
-              (Stdlib_Int[11], m, _al_);
+              (Stdlib_Int[11], m, _ak_);
       /*<<ephemeron.ml:330:65>>*/ }
       /*<<ephemeron.ml:330:8>>*/ var
        /*<<ephemeron.ml:330:8>>*/ mbl =
          /*<<ephemeron.ml:330:8>>*/ caml_call3
-         (Stdlib_Array[15], _ai_, _ah_, _ag_),
+         (Stdlib_Array[15], _ah_, _ag_, _af_),
        /*<<ephemeron.ml:331:18>>*/ histo =
          /*<<ephemeron.ml:331:18>>*/ caml_make_vect(mbl + 1 | 0, 0),
-       /*<<ephemeron.ml:332:6>>*/ _aj_ = h[2];
-     function _ak_(b){
+       /*<<ephemeron.ml:332:6>>*/ _ai_ = h[2];
+     function _aj_(b){
        /*<<ephemeron.ml:334:11>>*/  /*<<ephemeron.ml:334:19>>*/ var
        l = bucket_length(0, b);
        /*<<ephemeron.ml:335:11>>*/ histo[1 + l] =
@@ -30860,7 +30873,7 @@
        /*<<ephemeron.ml:335:11>>*/ return 0;
       /*<<ephemeron.ml:335:37>>*/ }
       /*<<ephemeron.ml:332:6>>*/  /*<<ephemeron.ml:332:6>>*/ caml_call2
-      (Stdlib_Array[11], _ak_, _aj_);
+      (Stdlib_Array[11], _aj_, _ai_);
       /*<<ephemeron.ml:337:6>>*/ return [0, h[1], h[2].length - 1, mbl, histo];
      /*<<ephemeron.ml:340:34>>*/ }
     function bucket_length_alive(accu, param){
@@ -30878,22 +30891,22 @@
     function stats_alive(h){
       /*<<ephemeron.ml:349:6>>*/ var
        /*<<ephemeron.ml:349:17>>*/ size = [0, 0],
-       /*<<ephemeron.ml:350:6>>*/ _aa_ = h[2],
-      _ab_ = 0;
-     function _ac_(m, b){
+       /*<<ephemeron.ml:350:6>>*/ _$_ = h[2],
+      _aa_ = 0;
+     function _ab_(m, b){
        /*<<ephemeron.ml:352:22>>*/  /*<<ephemeron.ml:352:32>>*/ var
-       _af_ = bucket_length_alive(0, b);
+       _ae_ = bucket_length_alive(0, b);
        /*<<ephemeron.ml:352:32>>*/ return  /*<<ephemeron.ml:352:32>>*/ caml_call2
-              (Stdlib_Int[11], m, _af_);
+              (Stdlib_Int[11], m, _ae_);
       /*<<ephemeron.ml:352:57>>*/ }
       /*<<ephemeron.ml:351:8>>*/ var
        /*<<ephemeron.ml:351:8>>*/ mbl =
          /*<<ephemeron.ml:351:8>>*/ caml_call3
-         (Stdlib_Array[15], _ac_, _ab_, _aa_),
+         (Stdlib_Array[15], _ab_, _aa_, _$_),
        /*<<ephemeron.ml:354:18>>*/ histo =
          /*<<ephemeron.ml:354:18>>*/ caml_make_vect(mbl + 1 | 0, 0),
-       /*<<ephemeron.ml:355:6>>*/ _ad_ = h[2];
-     function _ae_(b){
+       /*<<ephemeron.ml:355:6>>*/ _ac_ = h[2];
+     function _ad_(b){
        /*<<ephemeron.ml:357:11>>*/  /*<<ephemeron.ml:357:19>>*/ var
        l = bucket_length_alive(0, b);
       size[1] = size[1] + l | 0;
@@ -30902,7 +30915,7 @@
        /*<<ephemeron.ml:359:11>>*/ return 0;
       /*<<ephemeron.ml:359:37>>*/ }
       /*<<ephemeron.ml:355:6>>*/  /*<<ephemeron.ml:355:6>>*/ caml_call2
-      (Stdlib_Array[11], _ae_, _ad_);
+      (Stdlib_Array[11], _ad_, _ac_);
       /*<<ephemeron.ml:361:6>>*/ return [0,
              size[1],
              h[2].length - 1,
@@ -30910,20 +30923,20 @@
              histo];
      /*<<ephemeron.ml:364:34>>*/ }
     function add_seq(tbl, i){
-     function _$_(param){
+     function ___(param){
        /*<<ephemeron.ml:367:15>>*/ var v = param[2], k = param[1];
        /*<<ephemeron.ml:367:29>>*/ return add(tbl, k, v);
       /*<<ephemeron.ml:367:41>>*/ }
       /*<<ephemeron.ml:367:6>>*/ return  /*<<ephemeron.ml:367:6>>*/ caml_call2
-             (Stdlib_Seq[4], _$_, i);
+             (Stdlib_Seq[4], ___, i);
      /*<<ephemeron.ml:367:43>>*/ }
     function replace_seq(tbl, i){
-     function ___(param){
+     function _Z_(param){
        /*<<ephemeron.ml:370:15>>*/ var v = param[2], k = param[1];
        /*<<ephemeron.ml:370:29>>*/ return replace(tbl, k, v);
       /*<<ephemeron.ml:370:45>>*/ }
       /*<<ephemeron.ml:370:6>>*/ return  /*<<ephemeron.ml:370:6>>*/ caml_call2
-             (Stdlib_Seq[4], ___, i);
+             (Stdlib_Seq[4], _Z_, i);
      /*<<ephemeron.ml:370:47>>*/ }
     function of_seq(i){
       /*<<ephemeron.ml:373:6>>*/  /*<<ephemeron.ml:373:16>>*/ var
@@ -30962,7 +30975,7 @@
    function set_key(t, k){
      /*<<ephemeron.ml:397:44>>*/  /*<<ephemeron.ml:397:44>>*/ caml_call3
      (Stdlib_Obj[24][5], t, 0, k);
-     /*<<ephemeron.ml:397:44>>*/ return _d_;
+     /*<<ephemeron.ml:397:44>>*/ return sentinal;
     /*<<ephemeron.ml:397:75>>*/ }
    function check_key(t){
      /*<<ephemeron.ml:398:39>>*/ return  /*<<ephemeron.ml:398:39>>*/ caml_call2
@@ -31048,10 +31061,10 @@
      replace_seq = include[15],
      clean = include[17],
      stats_alive = include[18],
-     _Z_ = include[1];
+     _Y_ = include[1];
     function create(sz){
       /*<<ephemeron.ml:448:20>>*/ return  /*<<ephemeron.ml:448:20>>*/ caml_call2
-             (_Z_, _a_, sz);
+             (_Y_, _a_, sz);
      /*<<ephemeron.ml:448:43>>*/ }
     function of_seq(i){
       /*<<ephemeron.ml:450:6>>*/  /*<<ephemeron.ml:450:16>>*/ var
@@ -31084,8 +31097,8 @@
      /*<<ephemeron.ml:459:18>>*/ return [0, 0];
     /*<<ephemeron.ml:459:24>>*/ }
    function add(b, k, d){
-     /*<<ephemeron.ml:460:20>>*/ var _Y_ = b[1];
-    b[1] = [0, make(k, d), _Y_];
+     /*<<ephemeron.ml:460:20>>*/ var _X_ = b[1];
+    b[1] = [0, make(k, d), _X_];
     return 0;
     /*<<ephemeron.ml:460:42>>*/ }
    function test_key(k, e){
@@ -31114,13 +31127,13 @@
     }
     /*<<ephemeron.ml:474:16>>*/ }
    function find(b, k){
-     /*<<ephemeron.ml:477:6>>*/ var _V_ = b[1];
-     /*<<ephemeron.ml:477:26>>*/ function _W_(_X_){
-      /*<<?>>*/ return test_key(k, _X_);
+     /*<<ephemeron.ml:477:6>>*/ var _U_ = b[1];
+     /*<<ephemeron.ml:477:26>>*/ function _V_(_W_){
+      /*<<?>>*/ return test_key(k, _W_);
     }
      /*<<ephemeron.ml:477:12>>*/  /*<<ephemeron.ml:477:12>>*/ var
      match =
-        /*<<ephemeron.ml:477:12>>*/ caml_call2(Stdlib_List[39], _W_, _V_);
+        /*<<ephemeron.ml:477:12>>*/ caml_call2(Stdlib_List[39], _V_, _U_);
     if(! match)  /*<<ephemeron.ml:479:16>>*/ return 0;
     var e = match[1];
      /*<<ephemeron.ml:478:18>>*/ return get_data(e);
@@ -31143,7 +31156,7 @@
    function set_key1(t, k){
      /*<<ephemeron.ml:495:4>>*/  /*<<ephemeron.ml:495:4>>*/ caml_call3
      (Stdlib_Obj[24][5], t, 0, k);
-     /*<<ephemeron.ml:495:4>>*/ return _d_;
+     /*<<ephemeron.ml:495:4>>*/ return sentinal;
     /*<<ephemeron.ml:495:35>>*/ }
    function get_key2(t){
      /*<<ephemeron.ml:498:49>>*/ return  /*<<ephemeron.ml:498:57>>*/ caml_call2
@@ -31152,7 +31165,7 @@
    function set_key2(t, k){
      /*<<ephemeron.ml:500:4>>*/  /*<<ephemeron.ml:500:4>>*/ caml_call3
      (Stdlib_Obj[24][5], t, 1, k);
-     /*<<ephemeron.ml:500:4>>*/ return _d_;
+     /*<<ephemeron.ml:500:4>>*/ return sentinal;
     /*<<ephemeron.ml:500:35>>*/ }
    function get_data$0(t){
      /*<<ephemeron.ml:503:48>>*/ return  /*<<ephemeron.ml:503:56>>*/ caml_call1
@@ -31197,11 +31210,11 @@
       /*<<ephemeron.ml:539:33>>*/ var
       k2 = param[2],
       k1 = param[1],
-       /*<<ephemeron.ml:539:33>>*/ _U_ =
+       /*<<ephemeron.ml:539:33>>*/ _T_ =
          /*<<ephemeron.ml:539:33>>*/ caml_call2(H2[2], seed, k2) * 65599 | 0;
       /*<<ephemeron.ml:539:8>>*/ return  /*<<ephemeron.ml:539:8>>*/ caml_call2
              (H1[2], seed, k1)
-            + _U_
+            + _T_
             | 0;
     }
     function equal(c, param){
@@ -31230,11 +31243,11 @@
     }
     function check_key(c){
       /*<<ephemeron.ml:551:24>>*/  /*<<ephemeron.ml:496:45>>*/ var
-      _T_ =  /*<<ephemeron.ml:496:45>>*/ caml_call2(Stdlib_Obj[24][7], c, 0);
-      /*<<ephemeron.ml:551:24>>*/ return _T_
+      _S_ =  /*<<ephemeron.ml:496:45>>*/ caml_call2(Stdlib_Obj[24][7], c, 0);
+      /*<<ephemeron.ml:551:24>>*/ return _S_
              ?  /*<<ephemeron.ml:501:45>>*/ caml_call2
                (Stdlib_Obj[24][7], c, 1)
-             : _T_;
+             : _S_;
      /*<<ephemeron.ml:551:52>>*/ }
      /*<<ephemeron.ml:530:28>>*/ return MakeSeeded
             ([0,
@@ -31253,13 +31266,13 @@
      /*<<ephemeron.ml:566:52>>*/ }
      /*<<ephemeron.ml:563:9>>*/ var
      equal$0 = H1[1],
-      /*<<ephemeron.ml:563:9>>*/ _R_ = [0, equal, seeded_hash];
+      /*<<ephemeron.ml:563:9>>*/ _Q_ = [0, equal, seeded_hash];
     function seeded_hash$0(seed, x){
       /*<<ephemeron.ml:561:43>>*/ return  /*<<ephemeron.ml:561:43>>*/ caml_call1
              (H1[2], x);
      /*<<ephemeron.ml:561:52>>*/ }
     var
-     include = MakeSeeded$1([0, equal$0, seeded_hash$0], _R_),
+     include = MakeSeeded$1([0, equal$0, seeded_hash$0], _Q_),
      clear = include[2],
      reset = include[3],
      copy = include[4],
@@ -31276,10 +31289,10 @@
      replace_seq = include[15],
      clean = include[17],
      stats_alive = include[18],
-     _S_ = include[1];
+     _R_ = include[1];
     function create(sz){
       /*<<ephemeron.ml:568:20>>*/ return  /*<<ephemeron.ml:568:20>>*/ caml_call2
-             (_S_, _b_, sz);
+             (_R_, _b_, sz);
      /*<<ephemeron.ml:568:43>>*/ }
     function of_seq(i){
       /*<<ephemeron.ml:570:6>>*/  /*<<ephemeron.ml:570:16>>*/ var
@@ -31312,8 +31325,8 @@
      /*<<ephemeron.ml:579:18>>*/ return [0, 0];
     /*<<ephemeron.ml:579:24>>*/ }
    function add$0(b, k1, k2, d){
-     /*<<ephemeron.ml:580:24>>*/ var _Q_ = b[1];
-    b[1] = [0, make$1(k1, k2, d), _Q_];
+     /*<<ephemeron.ml:580:24>>*/ var _P_ = b[1];
+    b[1] = [0, make$1(k1, k2, d), _P_];
     return 0;
     /*<<ephemeron.ml:580:50>>*/ }
    function test_keys(k1, k2, e){
@@ -31343,13 +31356,13 @@
     }
     /*<<ephemeron.ml:594:16>>*/ }
    function find$0(b, k1, k2){
-     /*<<ephemeron.ml:597:6>>*/ var _N_ = b[1];
-     /*<<ephemeron.ml:597:26>>*/ function _O_(_P_){
-      /*<<?>>*/ return test_keys(k1, k2, _P_);
+     /*<<ephemeron.ml:597:6>>*/ var _M_ = b[1];
+     /*<<ephemeron.ml:597:26>>*/ function _N_(_O_){
+      /*<<?>>*/ return test_keys(k1, k2, _O_);
     }
      /*<<ephemeron.ml:597:12>>*/  /*<<ephemeron.ml:597:12>>*/ var
      match =
-        /*<<ephemeron.ml:597:12>>*/ caml_call2(Stdlib_List[39], _O_, _N_);
+        /*<<ephemeron.ml:597:12>>*/ caml_call2(Stdlib_List[39], _N_, _M_);
     if(! match)  /*<<ephemeron.ml:599:16>>*/ return 0;
     var e = match[1];
      /*<<ephemeron.ml:598:18>>*/ return get_data$0(e);
@@ -31376,7 +31389,7 @@
    function set_key$0(t, n, k){
      /*<<ephemeron.ml:616:4>>*/  /*<<ephemeron.ml:616:4>>*/ caml_call3
      (Stdlib_Obj[24][5], t, n, k);
-     /*<<ephemeron.ml:616:4>>*/ return _d_;
+     /*<<ephemeron.ml:616:4>>*/ return sentinal;
     /*<<ephemeron.ml:616:35>>*/ }
    function get_data$1(t){
      /*<<ephemeron.ml:619:43>>*/ return  /*<<ephemeron.ml:619:51>>*/ caml_call1
@@ -31392,17 +31405,17 @@
       /*<<ephemeron.ml:625:14>>*/ eph = create$1(l);
      /*<<ephemeron.ml:626:4>>*/ set_data$1(eph, data);
      /*<<ephemeron.ml:626:4>>*/ var
-     _L_ = l - 1 | 0,
-      /*<<ephemeron.ml:626:4>>*/ _K_ = 0;
-    if(_L_ >= 0){
-     var i = _K_;
+     _K_ = l - 1 | 0,
+      /*<<ephemeron.ml:626:4>>*/ _J_ = 0;
+    if(_K_ >= 0){
+     var i = _J_;
      for(;;){
        /*<<ephemeron.ml:627:26>>*/ set_key$0
        (eph, i, caml_check_bound(keys, i)[1 + i]);
        /*<<ephemeron.ml:627:26>>*/  /*<<ephemeron.ml:627:26>>*/ var
-       _M_ = i + 1 | 0;
-      if(_L_ === i) break;
-      var i = _M_;
+       _L_ = i + 1 | 0;
+      if(_K_ === i) break;
+      var i = _L_;
      }
     }
      /*<<ephemeron.ml:628:4>>*/ return eph;
@@ -31415,10 +31428,10 @@
        /*<<ephemeron.ml:633:37>>*/ throw  /*<<ephemeron.ml:633:37>>*/ caml_maybe_attach_backtrace
              (Stdlib[3], 1);
       /*<<ephemeron.ml:631:12>>*/ var
-       /*<<ephemeron.ml:631:12>>*/ _G_ = l - 1 | 0,
-       /*<<ephemeron.ml:634:6>>*/ _F_ = 0;
-     if(_G_ >= 0){
-      var i = _F_;
+       /*<<ephemeron.ml:631:12>>*/ _F_ = l - 1 | 0,
+       /*<<ephemeron.ml:634:6>>*/ _E_ = 0;
+     if(_F_ >= 0){
+      var i = _E_;
       for(;;){
         /*<<ephemeron.ml:635:14>>*/  /*<<ephemeron.ml:635:14>>*/ var
         match = get_key$0(eph, i);
@@ -31430,19 +31443,19 @@
          /*<<ephemeron.ml:638:20>>*/ throw  /*<<ephemeron.ml:638:20>>*/ caml_maybe_attach_backtrace
                (Stdlib[3], 1);
         /*<<ephemeron.ml:634:6>>*/  /*<<ephemeron.ml:634:6>>*/ var
-        _I_ = i + 1 | 0;
-       if(_G_ === i) break;
-       var i = _I_;
+        _H_ = i + 1 | 0;
+       if(_F_ === i) break;
+       var i = _H_;
       }
      }
       /*<<ephemeron.ml:640:6>>*/  /*<<ephemeron.ml:640:6>>*/ var
-      _H_ = get_data$1(eph);
-      /*<<ephemeron.ml:640:6>>*/ return _H_;
+      _G_ = get_data$1(eph);
+      /*<<ephemeron.ml:640:6>>*/ return _G_;
     }
-    catch(_J_){
-     var _E_ = caml_wrap_exception(_J_);
-     if(_E_ === Stdlib[3])  /*<<ephemeron.ml:641:17>>*/ return 0;
-     throw caml_maybe_attach_backtrace(_E_, 0);
+    catch(_I_){
+     var _D_ = caml_wrap_exception(_I_);
+     if(_D_ === Stdlib[3])  /*<<ephemeron.ml:641:17>>*/ return 0;
+     throw caml_maybe_attach_backtrace(_D_, 0);
     }
     /*<<ephemeron.ml:641:21>>*/ }
    function MakeSeeded$2(H){
@@ -31451,17 +31464,17 @@
       c = create$1(k.length - 1);
       /*<<ephemeron.ml:649:8>>*/ set_data$1(c, d);
       /*<<ephemeron.ml:649:8>>*/ var
-      _C_ = k.length - 1 - 1 | 0,
-       /*<<ephemeron.ml:649:8>>*/ _B_ = 0;
-     if(_C_ >= 0){
-      var i = _B_;
+      _B_ = k.length - 1 - 1 | 0,
+       /*<<ephemeron.ml:649:8>>*/ _A_ = 0;
+     if(_B_ >= 0){
+      var i = _A_;
       for(;;){
         /*<<ephemeron.ml:651:10>>*/ set_key$0
         (c, i, caml_check_bound(k, i)[1 + i]);
         /*<<ephemeron.ml:651:10>>*/  /*<<ephemeron.ml:651:10>>*/ var
-        _D_ = i + 1 | 0;
-       if(_C_ === i) break;
-       var i = _D_;
+        _C_ = i + 1 | 0;
+       if(_B_ === i) break;
+       var i = _C_;
       }
      }
       /*<<ephemeron.ml:653:8>>*/ return c;
@@ -31469,22 +31482,22 @@
     function seeded_hash(seed, k){
       /*<<ephemeron.ml:655:8>>*/ var
        /*<<ephemeron.ml:655:16>>*/ h = [0, 0],
-      _x_ = k.length - 1 - 1 | 0,
-       /*<<ephemeron.ml:655:16>>*/ _w_ = 0;
-     if(_x_ >= 0){
-      var i = _w_;
+      _w_ = k.length - 1 - 1 | 0,
+       /*<<ephemeron.ml:655:16>>*/ _v_ = 0;
+     if(_w_ >= 0){
+      var i = _v_;
       for(;;){
         /*<<ephemeron.ml:657:34>>*/ var
-        _y_ = h[1],
-         /*<<ephemeron.ml:657:34>>*/ _z_ = caml_check_bound(k, i)[1 + i];
+        _x_ = h[1],
+         /*<<ephemeron.ml:657:34>>*/ _y_ = caml_check_bound(k, i)[1 + i];
        h[1] =
-        ( /*<<ephemeron.ml:657:15>>*/ caml_call2(H[2], seed, _z_) * 65599 | 0)
-        + _y_
+        ( /*<<ephemeron.ml:657:15>>*/ caml_call2(H[2], seed, _y_) * 65599 | 0)
+        + _x_
         | 0;
         /*<<ephemeron.ml:656:8>>*/  /*<<ephemeron.ml:656:8>>*/ var
-        _A_ = i + 1 | 0;
-       if(_x_ === i) break;
-       var i = _A_;
+        _z_ = i + 1 | 0;
+       if(_w_ === i) break;
+       var i = _z_;
       }
      }
      return h[1];
@@ -31504,9 +31517,9 @@
       if(! match)  /*<<ephemeron.ml:669:24>>*/ return 2;
        /*<<ephemeron.ml:671:29>>*/ var
        ki = match[1],
-        /*<<ephemeron.ml:671:29>>*/ _v_ = caml_check_bound(k, i)[1 + i];
+        /*<<ephemeron.ml:671:29>>*/ _u_ = caml_check_bound(k, i)[1 + i];
        /*<<ephemeron.ml:671:21>>*/ if
-       (!  /*<<ephemeron.ml:671:21>>*/ caml_call2(H[1], _v_, ki))
+       (!  /*<<ephemeron.ml:671:21>>*/ caml_call2(H[1], _u_, ki))
         /*<<ephemeron.ml:673:23>>*/ return 1;
        /*<<ephemeron.ml:672:23>>*/ var
         /*<<ephemeron.ml:672:23>>*/ i$0 = i - 1 | 0,
@@ -31517,17 +31530,17 @@
       /*<<ephemeron.ml:678:8>>*/  /*<<ephemeron.ml:621:40>>*/ caml_call1
       (Stdlib_Obj[24][12], c);
       /*<<ephemeron.ml:678:8>>*/ var
-      _t_ = k.length - 1 - 1 | 0,
-       /*<<ephemeron.ml:678:8>>*/ _s_ = 0;
-     if(_t_ >= 0){
-      var i = _s_;
+      _s_ = k.length - 1 - 1 | 0,
+       /*<<ephemeron.ml:678:8>>*/ _r_ = 0;
+     if(_s_ >= 0){
+      var i = _r_;
       for(;;){
         /*<<ephemeron.ml:680:10>>*/ set_key$0
         (c, i, caml_check_bound(k, i)[1 + i]);
         /*<<ephemeron.ml:680:10>>*/  /*<<ephemeron.ml:680:10>>*/ var
-        _u_ = i + 1 | 0;
-       if(_t_ === i) break;
-       var i = _u_;
+        _t_ = i + 1 | 0;
+       if(_s_ === i) break;
+       var i = _t_;
       }
      }
       /*<<ephemeron.ml:682:8>>*/ return set_data$1(c, d);
@@ -31537,19 +31550,19 @@
        /*<<ephemeron.ml:686:17>>*/ i$1 = length$1(c) - 1 | 0,
       i = i$1;
       /*<<ephemeron.ml:685:10>>*/ for(;;){
-      var _q_ = i < 0 ? 1 : 0;
-      if(_q_)
-       var _r_ = _q_;
+      var _p_ = i < 0 ? 1 : 0;
+      if(_p_)
+       var _q_ = _p_;
       else{
         /*<<ephemeron.ml:617:47>>*/  /*<<ephemeron.ml:617:47>>*/ var
-        _p_ =  /*<<ephemeron.ml:617:47>>*/ caml_call2(Stdlib_Obj[24][7], c, i);
-        /*<<ephemeron.ml:685:20>>*/ if(_p_){
+        _o_ =  /*<<ephemeron.ml:617:47>>*/ caml_call2(Stdlib_Obj[24][7], c, i);
+        /*<<ephemeron.ml:685:20>>*/ if(_o_){
         var i$0 = i - 1 | 0, i = i$0;
         continue;
        }
-       var _r_ = _p_;
+       var _q_ = _o_;
       }
-      return _r_;
+      return _q_;
      }
      /*<<ephemeron.ml:686:30>>*/ }
      /*<<ephemeron.ml:644:28>>*/ return MakeSeeded
@@ -31585,10 +31598,10 @@
      replace_seq = include[15],
      clean = include[17],
      stats_alive = include[18],
-     _o_ = include[1];
+     _n_ = include[1];
     function create(sz){
       /*<<ephemeron.ml:696:20>>*/ return  /*<<ephemeron.ml:696:20>>*/ caml_call2
-             (_o_, _c_, sz);
+             (_n_, _c_, sz);
      /*<<ephemeron.ml:696:43>>*/ }
     function of_seq(i){
       /*<<ephemeron.ml:698:6>>*/  /*<<ephemeron.ml:698:16>>*/ var
@@ -31621,8 +31634,8 @@
      /*<<ephemeron.ml:707:18>>*/ return [0, 0];
     /*<<ephemeron.ml:707:24>>*/ }
    function add$1(b, k, d){
-     /*<<ephemeron.ml:708:20>>*/ var _n_ = b[1];
-    b[1] = [0, make$3(k, d), _n_];
+     /*<<ephemeron.ml:708:20>>*/ var _m_ = b[1];
+    b[1] = [0, make$3(k, d), _m_];
     return 0;
     /*<<ephemeron.ml:708:42>>*/ }
    function test_keys$0(k, e){
@@ -31631,10 +31644,10 @@
        /*<<ephemeron.ml:712:43>>*/ throw  /*<<ephemeron.ml:712:43>>*/ caml_maybe_attach_backtrace
              (Stdlib[3], 1);
       /*<<ephemeron.ml:713:8>>*/ var
-      _j_ = k.length - 1 - 1 | 0,
-       /*<<ephemeron.ml:713:8>>*/ _i_ = 0;
-     if(_j_ >= 0){
-      var i = _i_;
+      _i_ = k.length - 1 - 1 | 0,
+       /*<<ephemeron.ml:713:8>>*/ _h_ = 0;
+     if(_i_ >= 0){
+      var i = _h_;
       for(;;){
         /*<<ephemeron.ml:714:16>>*/  /*<<ephemeron.ml:714:16>>*/ var
         match = get_key$0(e, i);
@@ -31642,9 +31655,9 @@
         var x = match[1];
         if(x === caml_check_bound(k, i)[1 + i]){
           /*<<ephemeron.ml:713:8>>*/  /*<<ephemeron.ml:713:8>>*/ var
-          _l_ = i + 1 | 0;
-         if(_j_ === i) break;
-         var i = _l_;
+          _k_ = i + 1 | 0;
+         if(_i_ === i) break;
+         var i = _k_;
          continue;
         }
        }
@@ -31652,13 +31665,13 @@
               (Stdlib[3], 1);
       }
      }
-      /*<<ephemeron.ml:718:8>>*/  /*<<ephemeron.ml:718:8>>*/ var _k_ = 1;
-      /*<<ephemeron.ml:718:8>>*/ return _k_;
+      /*<<ephemeron.ml:718:8>>*/  /*<<ephemeron.ml:718:8>>*/ var _j_ = 1;
+      /*<<ephemeron.ml:718:8>>*/ return _j_;
     }
-    catch(_m_){
-     var _h_ = caml_wrap_exception(_m_);
-     if(_h_ === Stdlib[3])  /*<<ephemeron.ml:719:19>>*/ return 0;
-     throw caml_maybe_attach_backtrace(_h_, 0);
+    catch(_l_){
+     var _g_ = caml_wrap_exception(_l_);
+     if(_g_ === Stdlib[3])  /*<<ephemeron.ml:719:19>>*/ return 0;
+     throw caml_maybe_attach_backtrace(_g_, 0);
     }
     /*<<ephemeron.ml:719:24>>*/ }
    function remove$1(b, k){
@@ -31678,13 +31691,13 @@
     }
     /*<<ephemeron.ml:728:16>>*/ }
    function find$1(b, k){
-     /*<<ephemeron.ml:731:6>>*/ var _e_ = b[1];
-     /*<<ephemeron.ml:731:26>>*/ function _f_(_g_){
-      /*<<?>>*/ return test_keys$0(k, _g_);
+     /*<<ephemeron.ml:731:6>>*/ var _d_ = b[1];
+     /*<<ephemeron.ml:731:26>>*/ function _e_(_f_){
+      /*<<?>>*/ return test_keys$0(k, _f_);
     }
      /*<<ephemeron.ml:731:12>>*/  /*<<ephemeron.ml:731:12>>*/ var
      match =
-        /*<<ephemeron.ml:731:12>>*/ caml_call2(Stdlib_List[39], _f_, _e_);
+        /*<<ephemeron.ml:731:12>>*/ caml_call2(Stdlib_List[39], _e_, _d_);
     if(! match)  /*<<ephemeron.ml:733:16>>*/ return 0;
     var e = match[1];
      /*<<ephemeron.ml:732:18>>*/ return get_data$1(e);
@@ -31771,7 +31784,7 @@
             : runtime.caml_call_gen(f, [a0, a1, a2, a3]);
    }
    var
-    _l_ = undefined,
+    sentinal = undefined,
     global_data = runtime.caml_get_global_data(),
     cst$18 = cst$19,
     cst$17 = cst$19,
@@ -31907,39 +31920,39 @@
     /*<<filename.ml:96:34>>*/ }
    function is_relative(n){
      /*<<filename.ml:97:22>>*/ var
-     _aI_ = caml_ml_string_length(n) < 1 ? 1 : 0,
-     _aJ_ =
-       _aI_
+     _aH_ = caml_ml_string_length(n) < 1 ? 1 : 0,
+     _aI_ =
+       _aH_
        || (47 !==  /*<<filename.ml:97:45>>*/ caml_string_get(n, 0) ? 1 : 0);
-    return _aJ_;
+    return _aI_;
     /*<<filename.ml:97:57>>*/ }
    function is_implicit(n){
      /*<<filename.ml:99:4>>*/  /*<<filename.ml:99:4>>*/ var
-     _aD_ = is_relative(n);
-     /*<<filename.ml:99:4>>*/ if(_aD_){
+     _aC_ = is_relative(n);
+     /*<<filename.ml:99:4>>*/ if(_aC_){
      var
-      _aE_ = caml_ml_string_length(n) < 2 ? 1 : 0,
-      _aF_ =
-        _aE_
+      _aD_ = caml_ml_string_length(n) < 2 ? 1 : 0,
+      _aE_ =
+        _aD_
         ||
           /*<<filename.ml:100:31>>*/ caml_string_notequal
           ( /*<<filename.ml:100:31>>*/ caml_call3(Stdlib_String[15], n, 0, 2),
            cst$27);
-      /*<<filename.ml:100:31>>*/ if(_aF_)
+      /*<<filename.ml:100:31>>*/ if(_aE_)
       var
-       _aG_ = caml_ml_string_length(n) < 3 ? 1 : 0,
-       _aH_ =
-         _aG_
+       _aF_ = caml_ml_string_length(n) < 3 ? 1 : 0,
+       _aG_ =
+         _aF_
          ||
            /*<<filename.ml:101:31>>*/ caml_string_notequal
            ( /*<<filename.ml:101:31>>*/ caml_call3(Stdlib_String[15], n, 0, 3),
             cst$28);
      else
-      var _aH_ = _aF_;
+      var _aG_ = _aE_;
     }
     else
-     var _aH_ = _aD_;
-     /*<<filename.ml:101:31>>*/ return _aH_;
+     var _aG_ = _aC_;
+     /*<<filename.ml:101:31>>*/ return _aG_;
     /*<<filename.ml:101:57>>*/ }
    function check_suffix(name, suff){
      /*<<filename.ml:103:4>>*/ return  /*<<filename.ml:103:4>>*/ caml_call2
@@ -31967,8 +31980,8 @@
         /*<<filename.ml:117:8>>*/ caml_sys_getenv("TMPDIR"),
      temp_dir_name = _k_;
    }
-   catch(_aC_){
-    var _a_ = caml_wrap_exception(_aC_);
+   catch(_aB_){
+    var _a_ = caml_wrap_exception(_aB_);
     if(_a_ !== Stdlib[8]) throw caml_maybe_attach_backtrace(_a_, 0);
     var temp_dir_name = cst_tmp;
    }
@@ -31980,10 +31993,10 @@
      /*<<filename.ml:19:2>>*/  /*<<filename.ml:19:2>>*/ caml_call2
      (Stdlib_Buffer[12], b, 39);
      /*<<filename.ml:19:2>>*/ var
-     _az_ = l - 1 | 0,
-      /*<<filename.ml:19:2>>*/ _ay_ = 0;
-    if(_az_ >= 0){
-     var i = _ay_;
+     _ay_ = l - 1 | 0,
+      /*<<filename.ml:19:2>>*/ _ax_ = 0;
+    if(_ay_ >= 0){
+     var i = _ax_;
      for(;;){
        /*<<filename.ml:21:7>>*/ if
        (39 ===  /*<<filename.ml:21:7>>*/ caml_string_get(s, i))
@@ -31991,14 +32004,14 @@
         (Stdlib_Buffer[16], b, quotequote);
       else{
         /*<<filename.ml:23:28>>*/  /*<<filename.ml:23:28>>*/ var
-        _aB_ =  /*<<filename.ml:23:28>>*/ caml_string_get(s, i);
+        _aA_ =  /*<<filename.ml:23:28>>*/ caml_string_get(s, i);
         /*<<filename.ml:23:9>>*/  /*<<filename.ml:23:9>>*/ caml_call2
-        (Stdlib_Buffer[12], b, _aB_);
+        (Stdlib_Buffer[12], b, _aA_);
       }
        /*<<filename.ml:23:9>>*/  /*<<filename.ml:23:9>>*/ var
-       _aA_ = i + 1 | 0;
-      if(_az_ === i) break;
-      var i = _aA_;
+       _az_ = i + 1 | 0;
+      if(_ay_ === i) break;
+      var i = _az_;
      }
     }
      /*<<filename.ml:25:2>>*/  /*<<filename.ml:25:2>>*/ caml_call2
@@ -32011,47 +32024,47 @@
      var f = stderr[1];
       /*<<filename.ml:123:51>>*/ if
       ( /*<<filename.ml:123:51>>*/ caml_equal(stderr, stdout))
-      var _an_ = cst_2_1;
+      var _am_ = cst_2_1;
      else
        /*<<filename.ml:125:61>>*/ var
-        /*<<filename.ml:125:61>>*/ _ax_ = quote(f),
-       _an_ =  /*<<filename.ml:125:53>>*/ caml_call2(Stdlib[28], cst_2, _ax_);
-     var _ao_ = _an_;
+        /*<<filename.ml:125:61>>*/ _aw_ = quote(f),
+       _am_ =  /*<<filename.ml:125:53>>*/ caml_call2(Stdlib[28], cst_2, _aw_);
+     var _an_ = _am_;
     }
     else
-     var _ao_ = cst$4;
+     var _an_ = cst$4;
     if(stdout)
       /*<<filename.ml:122:55>>*/ var
       f$0 = stdout[1],
-       /*<<filename.ml:122:55>>*/ _ap_ = quote(f$0),
-      _aq_ =  /*<<filename.ml:122:48>>*/ caml_call2(Stdlib[28], cst, _ap_);
+       /*<<filename.ml:122:55>>*/ _ao_ = quote(f$0),
+      _ap_ =  /*<<filename.ml:122:48>>*/ caml_call2(Stdlib[28], cst, _ao_);
     else
-     var _aq_ = cst$3;
+     var _ap_ = cst$3;
      /*<<filename.ml:122:6>>*/  /*<<filename.ml:122:6>>*/ var
-     _ar_ =  /*<<filename.ml:122:6>>*/ caml_call2(Stdlib[28], _aq_, _ao_);
+     _aq_ =  /*<<filename.ml:122:6>>*/ caml_call2(Stdlib[28], _ap_, _an_);
     if(stdin)
       /*<<filename.ml:121:55>>*/ var
       f$1 = stdin[1],
-       /*<<filename.ml:121:55>>*/ _as_ = quote(f$1),
-      _at_ =  /*<<filename.ml:121:48>>*/ caml_call2(Stdlib[28], cst$0, _as_);
+       /*<<filename.ml:121:55>>*/ _ar_ = quote(f$1),
+      _as_ =  /*<<filename.ml:121:48>>*/ caml_call2(Stdlib[28], cst$0, _ar_);
     else
-     var _at_ = cst$2;
+     var _as_ = cst$2;
      /*<<filename.ml:121:6>>*/ var
-      /*<<filename.ml:121:6>>*/ _au_ =
-        /*<<filename.ml:121:6>>*/ caml_call2(Stdlib[28], _at_, _ar_),
-      /*<<filename.ml:120:22>>*/ _av_ =
+      /*<<filename.ml:121:6>>*/ _at_ =
+        /*<<filename.ml:121:6>>*/ caml_call2(Stdlib[28], _as_, _aq_),
+      /*<<filename.ml:120:22>>*/ _au_ =
         /*<<filename.ml:120:22>>*/ caml_call2
         (Stdlib_List[19], quote, [0, cmd, args]),
-      /*<<filename.ml:120:4>>*/ _aw_ =
-        /*<<filename.ml:120:4>>*/ caml_call2(Stdlib_String[6], cst$1, _av_);
+      /*<<filename.ml:120:4>>*/ _av_ =
+        /*<<filename.ml:120:4>>*/ caml_call2(Stdlib_String[6], cst$1, _au_);
      /*<<filename.ml:121:6>>*/ return  /*<<filename.ml:121:6>>*/ caml_call2
-            (Stdlib[28], _aw_, _au_);
+            (Stdlib[28], _av_, _at_);
     /*<<filename.ml:125:69>>*/ }
-    /*<<filename.ml:126:17>>*/ function basename(_am_){
-     /*<<?>>*/ return generic_basename(is_dir_sep, current_dir_name, _am_);
+    /*<<filename.ml:126:17>>*/ function basename(_al_){
+     /*<<?>>*/ return generic_basename(is_dir_sep, current_dir_name, _al_);
    }
-    /*<<filename.ml:127:16>>*/ function dirname(_al_){
-     /*<<?>>*/ return generic_dirname(is_dir_sep, current_dir_name, _al_);
+    /*<<filename.ml:127:16>>*/ function dirname(_ak_){
+     /*<<?>>*/ return generic_dirname(is_dir_sep, current_dir_name, _ak_);
    }
     /*<<filename.ml:91:24>>*/  /*<<filename.ml:91:24>>*/ var
     Unix =
@@ -32074,96 +32087,96 @@
      /*<<filename.ml:135:23>>*/ var
       /*<<filename.ml:135:31>>*/ c =
         /*<<filename.ml:135:31>>*/ caml_string_get(s, i),
-     _ai_ = 47 === c ? 1 : 0;
-    if(_ai_)
-     var _aj_ = _ai_;
+     _ah_ = 47 === c ? 1 : 0;
+    if(_ah_)
+     var _ai_ = _ah_;
     else
-     var _ak_ = 92 === c ? 1 : 0, _aj_ = _ak_ || (58 === c ? 1 : 0);
-    return _aj_;
+     var _aj_ = 92 === c ? 1 : 0, _ai_ = _aj_ || (58 === c ? 1 : 0);
+    return _ai_;
     /*<<filename.ml:135:70>>*/ }
    function is_relative$0(n){
      /*<<filename.ml:137:4>>*/ var
-     _ac_ = caml_ml_string_length(n) < 1 ? 1 : 0,
-     _ad_ =
-       _ac_
+     _ab_ = caml_ml_string_length(n) < 1 ? 1 : 0,
+     _ac_ =
+       _ab_
        || (47 !==  /*<<filename.ml:137:28>>*/ caml_string_get(n, 0) ? 1 : 0);
-    if(_ad_){
+    if(_ac_){
      var
-      _ae_ = caml_ml_string_length(n) < 1 ? 1 : 0,
-      _af_ =
-        _ae_
+      _ad_ = caml_ml_string_length(n) < 1 ? 1 : 0,
+      _ae_ =
+        _ad_
         || (92 !==  /*<<filename.ml:138:31>>*/ caml_string_get(n, 0) ? 1 : 0);
-     if(_af_)
+     if(_ae_)
       var
-       _ag_ = caml_ml_string_length(n) < 2 ? 1 : 0,
-       _ah_ =
-         _ag_
+       _af_ = caml_ml_string_length(n) < 2 ? 1 : 0,
+       _ag_ =
+         _af_
          || (58 !==  /*<<filename.ml:139:31>>*/ caml_string_get(n, 1) ? 1 : 0);
      else
-      var _ah_ = _af_;
+      var _ag_ = _ae_;
     }
     else
-     var _ah_ = _ad_;
-    return _ah_;
+     var _ag_ = _ac_;
+    return _ag_;
     /*<<filename.ml:139:44>>*/ }
    function is_implicit$0(n){
      /*<<filename.ml:141:4>>*/  /*<<filename.ml:141:4>>*/ var
-     _V_ = is_relative$0(n);
-     /*<<filename.ml:141:4>>*/ if(_V_){
+     _U_ = is_relative$0(n);
+     /*<<filename.ml:141:4>>*/ if(_U_){
      var
-      _W_ = caml_ml_string_length(n) < 2 ? 1 : 0,
-      _X_ =
-        _W_
+      _V_ = caml_ml_string_length(n) < 2 ? 1 : 0,
+      _W_ =
+        _V_
         ||
           /*<<filename.ml:142:31>>*/ caml_string_notequal
           ( /*<<filename.ml:142:31>>*/ caml_call3(Stdlib_String[15], n, 0, 2),
            cst$27);
-      /*<<filename.ml:142:31>>*/ if(_X_){
+      /*<<filename.ml:142:31>>*/ if(_W_){
       var
-       _Y_ = caml_ml_string_length(n) < 2 ? 1 : 0,
-       _Z_ =
-         _Y_
+       _X_ = caml_ml_string_length(n) < 2 ? 1 : 0,
+       _Y_ =
+         _X_
          ||
            /*<<filename.ml:143:31>>*/ caml_string_notequal
            ( /*<<filename.ml:143:31>>*/ caml_call3(Stdlib_String[15], n, 0, 2),
             ".\\");
-       /*<<filename.ml:143:31>>*/ if(_Z_){
+       /*<<filename.ml:143:31>>*/ if(_Y_){
        var
-        ___ = caml_ml_string_length(n) < 3 ? 1 : 0,
-        _$_ =
-          ___
+        _Z_ = caml_ml_string_length(n) < 3 ? 1 : 0,
+        ___ =
+          _Z_
           ||
             /*<<filename.ml:144:31>>*/ caml_string_notequal
             ( /*<<filename.ml:144:31>>*/ caml_call3
               (Stdlib_String[15], n, 0, 3),
              cst$28);
-        /*<<filename.ml:144:31>>*/ if(_$_)
+        /*<<filename.ml:144:31>>*/ if(___)
         var
-         _aa_ = caml_ml_string_length(n) < 3 ? 1 : 0,
-         _ab_ =
-           _aa_
+         _$_ = caml_ml_string_length(n) < 3 ? 1 : 0,
+         _aa_ =
+           _$_
            ||
              /*<<filename.ml:145:31>>*/ caml_string_notequal
              ( /*<<filename.ml:145:31>>*/ caml_call3
                (Stdlib_String[15], n, 0, 3),
               "..\\");
        else
-        var _ab_ = _$_;
+        var _aa_ = ___;
       }
       else
-       var _ab_ = _Z_;
+       var _aa_ = _Y_;
      }
      else
-      var _ab_ = _X_;
+      var _aa_ = _W_;
     }
     else
-     var _ab_ = _V_;
-     /*<<filename.ml:145:31>>*/ return _ab_;
+     var _aa_ = _U_;
+     /*<<filename.ml:145:31>>*/ return _aa_;
     /*<<filename.ml:145:58>>*/ }
    function check_suffix$0(name, suff){
      /*<<filename.ml:147:3>>*/ var
-     _S_ = caml_ml_string_length(suff) <= caml_ml_string_length(name) ? 1 : 0;
-    if(_S_)
+     _R_ = caml_ml_string_length(suff) <= caml_ml_string_length(name) ? 1 : 0;
+    if(_R_)
       /*<<filename.ml:148:12>>*/ var
        /*<<filename.ml:148:12>>*/ s =
          /*<<filename.ml:148:12>>*/ caml_call3
@@ -32171,14 +32184,14 @@
           name,
           caml_ml_string_length(name) - caml_ml_string_length(suff) | 0,
           caml_ml_string_length(suff)),
-       /*<<filename.ml:150:31>>*/ _T_ =
+       /*<<filename.ml:150:31>>*/ _S_ =
          /*<<filename.ml:150:31>>*/ caml_call1(Stdlib_String[26], suff),
-      _U_ =
+      _T_ =
          /*<<filename.ml:150:4>>*/ caml_string_equal
-         ( /*<<filename.ml:150:4>>*/ caml_call1(Stdlib_String[26], s), _T_);
+         ( /*<<filename.ml:150:4>>*/ caml_call1(Stdlib_String[26], s), _S_);
     else
-     var _U_ = _S_;
-     /*<<filename.ml:150:4>>*/ return _U_;
+     var _T_ = _R_;
+     /*<<filename.ml:150:4>>*/ return _T_;
     /*<<filename.ml:150:59>>*/ }
    function chop_suffix_opt$0(suffix, filename){
      /*<<filename.ml:153:4>>*/ var
@@ -32189,11 +32202,11 @@
       /*<<filename.ml:155:14>>*/ r =
         /*<<filename.ml:155:14>>*/ caml_call3
         (Stdlib_String[15], filename, len_f - len_s | 0, len_s),
-      /*<<filename.ml:156:36>>*/ _R_ =
+      /*<<filename.ml:156:36>>*/ _Q_ =
         /*<<filename.ml:156:36>>*/ caml_call1(Stdlib_String[26], suffix);
      /*<<filename.ml:156:9>>*/ return  /*<<filename.ml:156:9>>*/ caml_string_equal
              ( /*<<filename.ml:156:9>>*/ caml_call1(Stdlib_String[26], r),
-              _R_)
+              _Q_)
             ? [0,
                /*<<filename.ml:157:13>>*/ caml_call3
                (Stdlib_String[15], filename, 0, len_f - len_s | 0)]
@@ -32205,8 +32218,8 @@
         /*<<filename.ml:165:8>>*/ caml_sys_getenv("TEMP"),
      temp_dir_name$0 = _j_;
    }
-   catch(_Q_){
-    var _b_ = caml_wrap_exception(_Q_);
+   catch(_P_){
+    var _b_ = caml_wrap_exception(_P_);
     if(_b_ !== Stdlib[8]) throw caml_maybe_attach_backtrace(_b_, 0);
     var temp_dir_name$0 = cst$5;
    }
@@ -32223,17 +32236,17 @@
       if(i$0 === l){
         /*<<filename.ml:171:20>>*/  /*<<filename.ml:171:20>>*/ caml_call2
         (Stdlib_Buffer[12], b, 34);
-        /*<<filename.ml:171:20>>*/ return _l_;
+        /*<<filename.ml:171:20>>*/ return sentinal;
       }
        /*<<filename.ml:172:12>>*/  /*<<filename.ml:172:12>>*/ var
        c =  /*<<filename.ml:172:12>>*/ caml_string_get(s, i$0);
       if(34 === c){
         /*<<filename.ml:173:16>>*/ loop_bs(0, i$0);
-        /*<<filename.ml:173:16>>*/ return _l_;
+        /*<<filename.ml:173:16>>*/ return sentinal;
       }
       if(92 === c){
         /*<<filename.ml:174:16>>*/ loop_bs(0, i$0);
-        /*<<filename.ml:174:16>>*/ return _l_;
+        /*<<filename.ml:174:16>>*/ return sentinal;
       }
        /*<<filename.ml:175:16>>*/  /*<<filename.ml:175:16>>*/ caml_call2
        (Stdlib_Buffer[12], b, c);
@@ -32249,7 +32262,7 @@
         /*<<filename.ml:178:8>>*/  /*<<filename.ml:178:8>>*/ caml_call2
         (Stdlib_Buffer[12], b, 34);
         /*<<filename.ml:178:8>>*/ add_bs(n$0);
-        /*<<filename.ml:178:8>>*/ return _l_;
+        /*<<filename.ml:178:8>>*/ return sentinal;
       }
        /*<<filename.ml:181:14>>*/  /*<<filename.ml:181:14>>*/ var
        match =  /*<<filename.ml:181:14>>*/ caml_string_get(s, i$0);
@@ -32258,12 +32271,12 @@
         /*<<filename.ml:182:34>>*/  /*<<filename.ml:182:34>>*/ caml_call2
         (Stdlib_Buffer[12], b, 34);
         /*<<filename.ml:182:34>>*/ loop(i$0 + 1 | 0);
-        /*<<filename.ml:182:34>>*/ return _l_;
+        /*<<filename.ml:182:34>>*/ return sentinal;
       }
       if(92 !== match){
         /*<<filename.ml:184:18>>*/ add_bs(n$0);
         /*<<filename.ml:184:18>>*/ loop(i$0);
-        /*<<filename.ml:184:18>>*/ return _l_;
+        /*<<filename.ml:184:18>>*/ return sentinal;
       }
        /*<<filename.ml:183:18>>*/ var
         /*<<filename.ml:183:18>>*/ i$1 = i$0 + 1 | 0,
@@ -32273,19 +32286,19 @@
      }
      /*<<filename.ml:185:9>>*/ }
     function add_bs(n){
-      /*<<filename.ml:186:19>>*/  /*<<filename.ml:186:19>>*/ var _O_ = 1;
+      /*<<filename.ml:186:19>>*/  /*<<filename.ml:186:19>>*/ var _N_ = 1;
      if(n >= 1){
-      var j = _O_;
+      var j = _N_;
       for(;;){
         /*<<filename.ml:186:38>>*/  /*<<filename.ml:186:38>>*/ caml_call2
         (Stdlib_Buffer[12], b, 92);
         /*<<filename.ml:186:38>>*/  /*<<filename.ml:186:38>>*/ var
-        _P_ = j + 1 | 0;
+        _O_ = j + 1 | 0;
        if(n === j) break;
-       var j = _P_;
+       var j = _O_;
       }
      }
-     return _l_;
+     return sentinal;
      /*<<filename.ml:186:66>>*/ }
      /*<<filename.ml:188:4>>*/ loop(0);
      /*<<filename.ml:188:4>>*/ return  /*<<filename.ml:188:4>>*/ caml_call1
@@ -32300,62 +32313,62 @@
       (!  /*<<filename.ml:224:12>>*/ caml_call2(Stdlib_String[14], f, 32))
        /*<<filename.ml:227:6>>*/ return f;
       /*<<filename.ml:225:13>>*/  /*<<filename.ml:225:13>>*/ var
-      _N_ =  /*<<filename.ml:225:13>>*/ caml_call2(Stdlib[28], f, cst$6);
+      _M_ =  /*<<filename.ml:225:13>>*/ caml_call2(Stdlib[28], f, cst$6);
       /*<<filename.ml:225:13>>*/ return  /*<<filename.ml:225:13>>*/ caml_call2
-             (Stdlib[28], cst$7, _N_);
+             (Stdlib[28], cst$7, _M_);
     }
      /*<<filename.ml:223:15>>*/  /*<<filename.ml:223:15>>*/ var
-     _M_ =
+     _L_ =
         /*<<filename.ml:223:15>>*/ caml_call2
         (Stdlib[28], cst_Filename_quote_command_bad, f);
      /*<<filename.ml:223:15>>*/ return  /*<<filename.ml:223:15>>*/ caml_call1
-            (Stdlib[2], _M_);
+            (Stdlib[2], _L_);
     /*<<filename.ml:227:7>>*/ }
    function quote_command$0(cmd, stdin, stdout, stderr, args){
      /*<<filename.ml:232:4>>*/ if(stderr){
      var f = stderr[1];
       /*<<filename.ml:240:43>>*/ if
       ( /*<<filename.ml:240:43>>*/ caml_equal(stderr, stdout))
-      var _y_ = cst_2_1$0;
+      var _x_ = cst_2_1$0;
      else
        /*<<filename.ml:242:53>>*/ var
-        /*<<filename.ml:242:53>>*/ _K_ = quote_cmd_filename(f),
-       _y_ =  /*<<filename.ml:242:45>>*/ caml_call2(Stdlib[28], cst_2$0, _K_);
-     var _z_ = _y_;
+        /*<<filename.ml:242:53>>*/ _J_ = quote_cmd_filename(f),
+       _x_ =  /*<<filename.ml:242:45>>*/ caml_call2(Stdlib[28], cst_2$0, _J_);
+     var _y_ = _x_;
     }
     else
-     var _z_ = cst$16;
-    var _A_ = [0, _z_, _c_];
+     var _y_ = cst$16;
+    var _z_ = [0, _y_, _c_];
     if(stdout)
       /*<<filename.ml:238:55>>*/ var
       f$0 = stdout[1],
-       /*<<filename.ml:238:55>>*/ _B_ = quote_cmd_filename(f$0),
-      _C_ =  /*<<filename.ml:238:48>>*/ caml_call2(Stdlib[28], cst$8, _B_);
+       /*<<filename.ml:238:55>>*/ _A_ = quote_cmd_filename(f$0),
+      _B_ =  /*<<filename.ml:238:48>>*/ caml_call2(Stdlib[28], cst$8, _A_);
     else
-     var _C_ = cst$15;
-    var _D_ = [0, _C_, _A_];
+     var _B_ = cst$15;
+    var _C_ = [0, _B_, _z_];
     if(stdin)
       /*<<filename.ml:237:55>>*/ var
       f$1 = stdin[1],
-       /*<<filename.ml:237:55>>*/ _E_ = quote_cmd_filename(f$1),
-      _F_ =  /*<<filename.ml:237:48>>*/ caml_call2(Stdlib[28], cst$9, _E_);
+       /*<<filename.ml:237:55>>*/ _D_ = quote_cmd_filename(f$1),
+      _E_ =  /*<<filename.ml:237:48>>*/ caml_call2(Stdlib[28], cst$9, _D_);
     else
-     var _F_ = cst$14;
+     var _E_ = cst$14;
      /*<<filename.ml:236:35>>*/ var
-      /*<<filename.ml:236:35>>*/ _H_ =
+      /*<<filename.ml:236:35>>*/ _G_ =
         /*<<filename.ml:236:35>>*/ caml_call2(Stdlib_List[19], quote$0, args),
       /*<<filename.ml:236:16>>*/ s =
-        /*<<filename.ml:236:16>>*/ caml_call2(Stdlib_String[6], cst$10, _H_),
+        /*<<filename.ml:236:16>>*/ caml_call2(Stdlib_String[6], cst$10, _G_),
       /*<<filename.ml:211:12>>*/ b =
         /*<<filename.ml:211:12>>*/ caml_call1
         (Stdlib_Buffer[1], caml_ml_string_length(s) + 20 | 0),
-     _G_ = [0, _F_, _D_];
-    function _x_(c){
+     _F_ = [0, _E_, _C_];
+    function _w_(c){
       /*<<filename.ml:214:8>>*/ a:
      {
       if(62 <= c){
-       var _L_ = c - 63 | 0;
-       if(60 < _L_ >>> 0){if(62 <= _L_) break a;} else if(31 !== _L_) break a;
+       var _K_ = c - 63 | 0;
+       if(60 < _K_ >>> 0){if(62 <= _K_) break a;} else if(31 !== _K_) break a;
       }
       else
        if(42 <= c){
@@ -32375,21 +32388,21 @@
              (Stdlib_Buffer[12], b, c);
      /*<<filename.ml:218:31>>*/ }
      /*<<filename.ml:212:4>>*/  /*<<filename.ml:212:4>>*/ caml_call2
-     (Stdlib_String[29], _x_, s);
+     (Stdlib_String[29], _w_, s);
      /*<<filename.ml:232:21>>*/ var
-     _I_ =
+     _H_ =
        [0,
         cst$11,
-        [0,  /*<<filename.ml:212:4>>*/ caml_call1(Stdlib_Buffer[2], b), _G_]],
-      /*<<filename.ml:232:21>>*/ _J_ =
-       [0, cst$12, [0, quote_cmd_filename(cmd), _I_]];
+        [0,  /*<<filename.ml:212:4>>*/ caml_call1(Stdlib_Buffer[2], b), _F_]],
+      /*<<filename.ml:232:21>>*/ _I_ =
+       [0, cst$12, [0, quote_cmd_filename(cmd), _H_]];
      /*<<filename.ml:232:21>>*/ return  /*<<filename.ml:232:21>>*/ caml_call2
-            (Stdlib_String[6], cst$13, _J_);
+            (Stdlib_String[6], cst$13, _I_);
     /*<<filename.ml:244:5>>*/ }
    function drive_and_path(s){
      /*<<filename.ml:252:4>>*/ var
-     _t_ = 2 <=  /*<<filename.ml:250:4>>*/ caml_ml_string_length(s) ? 1 : 0;
-    if(_t_){
+     _s_ = 2 <=  /*<<filename.ml:250:4>>*/ caml_ml_string_length(s) ? 1 : 0;
+    if(_s_){
       /*<<filename.ml:250:38>>*/  /*<<filename.ml:250:38>>*/ var
       param =  /*<<filename.ml:250:38>>*/ caml_string_get(s, 0);
      a:
@@ -32400,28 +32413,28 @@
         if(25 < param - 97 >>> 0) break b;
        }
        else if(65 > param) break b;
-       var _u_ = 1;
+       var _t_ = 1;
        break a;
       }
-      var _u_ = 0;
+      var _t_ = 0;
      }
       /*<<filename.ml:250:28>>*/  /*<<filename.ml:250:28>>*/ var
-      _v_ =
-        _u_
+      _u_ =
+        _t_
          ? 58 ===  /*<<filename.ml:250:47>>*/ caml_string_get(s, 1) ? 1 : 0
-         : _u_;
+         : _t_;
     }
     else
-     var _v_ = _t_;
-     /*<<filename.ml:252:7>>*/ if(! _v_)
+     var _u_ = _s_;
+     /*<<filename.ml:252:7>>*/ if(! _u_)
       /*<<filename.ml:254:9>>*/ return [0, cst$17, s];
      /*<<filename.ml:253:28>>*/  /*<<filename.ml:253:28>>*/ var
-     _w_ =
+     _v_ =
         /*<<filename.ml:253:28>>*/ caml_call3
         (Stdlib_String[15], s, 2, caml_ml_string_length(s) - 2 | 0);
      /*<<filename.ml:253:9>>*/ return [0,
              /*<<filename.ml:253:10>>*/ caml_call3(Stdlib_String[15], s, 0, 2),
-            _w_];
+            _v_];
     /*<<filename.ml:254:16>>*/ }
    function dirname$0(s){
      /*<<filename.ml:256:4>>*/ var
@@ -32455,11 +32468,11 @@
        quote_command$0,
        basename$0,
        dirname$0];
-    /*<<filename.ml:277:17>>*/ function basename$1(_s_){
-     /*<<?>>*/ return generic_basename(is_dir_sep$0, current_dir_name$1, _s_);
+    /*<<filename.ml:277:17>>*/ function basename$1(_r_){
+     /*<<?>>*/ return generic_basename(is_dir_sep$0, current_dir_name$1, _r_);
    }
-    /*<<filename.ml:278:16>>*/ function dirname$1(_r_){
-     /*<<?>>*/ return generic_dirname(is_dir_sep$0, current_dir_name$1, _r_);
+    /*<<filename.ml:278:16>>*/ function dirname$1(_q_){
+     /*<<?>>*/ return generic_dirname(is_dir_sep$0, current_dir_name$1, _q_);
    }
     /*<<filename.ml:264:26>>*/ var
      /*<<filename.ml:264:26>>*/ Cygwin =
@@ -32502,11 +32515,11 @@
      /*<<filename.ml:291:14>>*/ if
      (0 !== l && ! is_dir_sep$1(dirname, l - 1 | 0)){
       /*<<filename.ml:293:17>>*/  /*<<filename.ml:293:17>>*/ var
-      _q_ =
+      _p_ =
          /*<<filename.ml:293:17>>*/ caml_call2
          (Stdlib[28], dir_sep$2, filename);
       /*<<filename.ml:293:17>>*/ return  /*<<filename.ml:293:17>>*/ caml_call2
-             (Stdlib[28], dirname, _q_);
+             (Stdlib[28], dirname, _p_);
     }
      /*<<filename.ml:292:7>>*/ return  /*<<filename.ml:292:7>>*/ caml_call2
             (Stdlib[28], dirname, filename);
@@ -32609,7 +32622,7 @@
     /*<<filename.ml:338:71>>*/ }
     /*<<filename.ml:338:40>>*/ var
      /*<<filename.ml:338:40>>*/ _g_ =
-      [0, function(_p_){ /*<<?>>*/ return _p_;}],
+      [0, function(_o_){ /*<<?>>*/ return _o_;}],
      /*<<filename.ml:338:2>>*/ current_temp_dir_name =
        /*<<filename.ml:338:2>>*/ caml_call2(Stdlib_Domain[10][1], _g_, _f_);
    function set_temp_dir_name(s){
@@ -32649,17 +32662,17 @@
      }
     }
     /*<<filename.ml:351:15>>*/ }
-   function open_temp_file(opt, _n_, _m_, prefix, suffix){
+   function open_temp_file(opt, _m_, _l_, prefix, suffix){
      /*<<filename.ml:356:2>>*/ if(opt)
      var sth = opt[1], mode = sth;
     else
      var mode = _i_;
-     /*<<filename.ml:356:2>>*/ if(_n_)
-     var sth$0 = _n_[1], perms = sth$0;
+     /*<<filename.ml:356:2>>*/ if(_m_)
+     var sth$0 = _m_[1], perms = sth$0;
     else
      var perms = 384;
-     /*<<filename.ml:356:2>>*/ if(_m_)
-     var sth$1 = _m_[1], temp_dir = sth$1;
+     /*<<filename.ml:356:2>>*/ if(_l_)
+     var sth$1 = _l_[1], temp_dir = sth$1;
     else
      var
       temp_dir =
@@ -32671,12 +32684,12 @@
       name = temp_file_name(temp_dir, prefix, suffix);
       /*<<filename.ml:358:4>>*/ try{
        /*<<filename.ml:359:6>>*/  /*<<filename.ml:359:6>>*/ var
-       _o_ =
+       _n_ =
          [0,
           name,
            /*<<filename.ml:360:7>>*/ caml_call3
            (Stdlib[62], [0, 1, [0, 3, [0, 5, mode]]], perms, name)];
-       /*<<filename.ml:359:6>>*/ return _o_;
+       /*<<filename.ml:359:6>>*/ return _n_;
      }
      catch(e$0){
       var e = caml_wrap_exception(e$0);

From d61469b05b0989ef8171501cfb34ada6bf58269f Mon Sep 17 00:00:00 2001
From: Micah Cantor <micahcantor01@gmail.com>
Date: Tue, 22 Aug 2023 20:19:07 -0400
Subject: [PATCH 057/112] change code printing when pretty

---
 compiler/lib/code.ml | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/compiler/lib/code.ml b/compiler/lib/code.ml
index 36c7e75d93..8b5fc7803f 100644
--- a/compiler/lib/code.ml
+++ b/compiler/lib/code.ml
@@ -152,9 +152,10 @@ end = struct
 
   let to_string ?origin i = Var_printer.to_string printer ?origin i
 
-  let print f x = Format.fprintf f "v%d" x
-
-  (* Format.fprintf f "%s" (to_string x) *)
+  let print f x =
+    if Config.Flag.pretty ()
+    then Format.fprintf f "%s" (to_string x)
+    else Format.fprintf f "v%d" x
 
   let name i nm = Var_printer.name printer i nm
 

From d55396c285ed3b1e72a3c0c6e918d54e1b5b824b Mon Sep 17 00:00:00 2001
From: Micah Cantor <micahcantor01@gmail.com>
Date: Thu, 24 Aug 2023 20:25:28 -0500
Subject: [PATCH 058/112] Revert "change code printing when pretty"

This reverts commit d61469b05b0989ef8171501cfb34ada6bf58269f.
---
 compiler/lib/code.ml | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/compiler/lib/code.ml b/compiler/lib/code.ml
index 8b5fc7803f..36c7e75d93 100644
--- a/compiler/lib/code.ml
+++ b/compiler/lib/code.ml
@@ -152,10 +152,9 @@ end = struct
 
   let to_string ?origin i = Var_printer.to_string printer ?origin i
 
-  let print f x =
-    if Config.Flag.pretty ()
-    then Format.fprintf f "%s" (to_string x)
-    else Format.fprintf f "v%d" x
+  let print f x = Format.fprintf f "v%d" x
+
+  (* Format.fprintf f "%s" (to_string x) *)
 
   let name i nm = Var_printer.name printer i nm
 

From e35e594368fe692878c0c84231fb091630d5ba9d Mon Sep 17 00:00:00 2001
From: Micah Cantor <micahcantor01@gmail.com>
Date: Thu, 24 Aug 2023 20:25:33 -0500
Subject: [PATCH 059/112] Revert "promote stdlib changes"

This reverts commit 2f60c4ec9dbcb822f52ff28a235792fc0bd99705.
---
 compiler/tests-full/stdlib.cma.expected.js | 4557 ++++++++++----------
 1 file changed, 2272 insertions(+), 2285 deletions(-)

diff --git a/compiler/tests-full/stdlib.cma.expected.js b/compiler/tests-full/stdlib.cma.expected.js
index 8249793bfe..7e201668fd 100644
--- a/compiler/tests-full/stdlib.cma.expected.js
+++ b/compiler/tests-full/stdlib.cma.expected.js
@@ -1248,11 +1248,11 @@
             : runtime.caml_call_gen(f, [a0]);
    }
    var
-    sentinal = undefined,
     global_data = runtime.caml_get_global_data(),
     Stdlib = global_data.Stdlib,
     Assert_failure = global_data.Assert_failure,
     Stdlib_Sys = global_data.Stdlib__Sys,
+    _b_ = undefined,
     cst_Obj_Ephemeron_blit_key = "Obj.Ephemeron.blit_key",
     cst_Obj_Ephemeron_check_key = "Obj.Ephemeron.check_key",
     cst_Obj_Ephemeron_unset_key = "Obj.Ephemeron.unset_key",
@@ -1330,9 +1330,9 @@
     max_ephe_length = Stdlib_Sys[13] - 2 | 0;
    function create(l){
      /*<<obj.ml:135:4>>*/ var
-     _g_ = 0 <= l ? 1 : 0,
-     _h_ = _g_ ? l <= max_ephe_length ? 1 : 0 : _g_;
-    if(1 - _h_)
+     _h_ = 0 <= l ? 1 : 0,
+     _i_ = _h_ ? l <= max_ephe_length ? 1 : 0 : _h_;
+    if(1 - _i_)
       /*<<obj.ml:136:6>>*/  /*<<obj.ml:136:6>>*/ caml_call1
       (Stdlib[1], cst_Obj_Ephemeron_create);
      /*<<obj.ml:137:4>>*/ return  /*<<obj.ml:137:4>>*/ runtime.caml_ephe_create
@@ -1343,12 +1343,10 @@
     /*<<obj.ml:139:49>>*/ }
    function raise_if_invalid_offset(e, o, msg){
      /*<<obj.ml:142:4>>*/ var
-     _d_ = 0 <= o ? 1 : 0,
-     _e_ = _d_ ? o < length(e) ? 1 : 0 : _d_,
-     _f_ = 1 - _e_;
-    return _f_
-            ? ( /*<<obj.ml:143:6>>*/ caml_call1(Stdlib[1], msg), sentinal)
-            : _f_;
+     _e_ = 0 <= o ? 1 : 0,
+     _f_ = _e_ ? o < length(e) ? 1 : 0 : _e_,
+     _g_ = 1 - _f_;
+    return _g_ ? ( /*<<obj.ml:143:6>>*/ caml_call1(Stdlib[1], msg), _b_) : _g_;
     /*<<obj.ml:143:21>>*/ }
    function get_key(e, o){
      /*<<obj.ml:147:4>>*/ raise_if_invalid_offset
@@ -1387,13 +1385,13 @@
        0 <= o1
        && (length(e1) - l | 0) >= o1 && 0 <= o2 && (length(e2) - l | 0) >= o2){
      var
-      _b_ = 0 !== l ? 1 : 0,
-      _c_ =
-        _b_
+      _c_ = 0 !== l ? 1 : 0,
+      _d_ =
+        _c_
          ?  /*<<obj.ml:177:24>>*/ runtime.caml_ephe_blit_key
            (e1, o1, e2, o2, l)
-         : _b_;
-      /*<<obj.ml:177:24>>*/ return _c_;
+         : _c_;
+      /*<<obj.ml:177:24>>*/ return _d_;
     }
      /*<<obj.ml:176:9>>*/ return  /*<<obj.ml:176:9>>*/ caml_call1
             (Stdlib[1], cst_Obj_Ephemeron_blit_key);
@@ -4551,7 +4549,7 @@
             : runtime.caml_call_gen(f, [a0, a1]);
    }
    var
-    sentinal = undefined,
+    _g_ = undefined,
     global_data = runtime.caml_get_global_data(),
     Stdlib = global_data.Stdlib,
     Stdlib_Uchar = global_data.Stdlib__Uchar,
@@ -4596,15 +4594,15 @@
    function init(n, f){
      /*<<bytes.ml:47:2>>*/ var
       /*<<bytes.ml:47:10>>*/ s =  /*<<bytes.ml:47:10>>*/ caml_create_bytes(n),
-      /*<<bytes.ml:48:2>>*/ _aq_ = n - 1 | 0,
-      /*<<bytes.ml:47:10>>*/ _ap_ = 0;
-    if(_aq_ >= 0){
-     var i = _ap_;
+      /*<<bytes.ml:48:2>>*/ _ar_ = n - 1 | 0,
+      /*<<bytes.ml:47:10>>*/ _aq_ = 0;
+    if(_ar_ >= 0){
+     var i = _aq_;
      for(;;){
       caml_bytes_unsafe_set(s, i,  /*<<bytes.ml:49:19>>*/ caml_call1(f, i));
-       /*<<bytes.ml:48:2>>*/  /*<<bytes.ml:48:2>>*/ var _ar_ = i + 1 | 0;
-      if(_aq_ === i) break;
-      var i = _ar_;
+       /*<<bytes.ml:48:2>>*/  /*<<bytes.ml:48:2>>*/ var _as_ = i + 1 | 0;
+      if(_ar_ === i) break;
+      var i = _as_;
      }
     }
      /*<<bytes.ml:51:2>>*/ return s;
@@ -4646,11 +4644,11 @@
    function symbol(a, b){
      /*<<bytes.ml:77:2>>*/ var
      c = a + b | 0,
-     _ao_ = b < 0 ? 1 : 0,
+     _ap_ = b < 0 ? 1 : 0,
      match = c < 0 ? 1 : 0;
     a:
     {
-     if(a < 0){if(_ao_ && ! match) break a;} else if(! _ao_ && match) break a;
+     if(a < 0){if(_ap_ && ! match) break a;} else if(! _ap_ && match) break a;
       /*<<bytes.ml:81:9>>*/ return c;
     }
      /*<<bytes.ml:80:27>>*/ return  /*<<bytes.ml:80:27>>*/ caml_call1
@@ -4713,32 +4711,32 @@
     /*<<bytes.ml:106:45>>*/ }
    function iter(f, a){
      /*<<bytes.ml:110:2>>*/ var
-     _am_ = caml_ml_bytes_length(a) - 1 | 0,
-      /*<<bytes.ml:110:2>>*/ _al_ = 0;
-    if(_am_ >= 0){
-     var i = _al_;
+     _an_ = caml_ml_bytes_length(a) - 1 | 0,
+      /*<<bytes.ml:110:2>>*/ _am_ = 0;
+    if(_an_ >= 0){
+     var i = _am_;
      for(;;){
        /*<<bytes.ml:110:31>>*/  /*<<bytes.ml:110:31>>*/ caml_call1
        (f, caml_bytes_unsafe_get(a, i));
-       /*<<bytes.ml:110:31>>*/  /*<<bytes.ml:110:31>>*/ var _an_ = i + 1 | 0;
-      if(_am_ === i) break;
-      var i = _an_;
+       /*<<bytes.ml:110:31>>*/  /*<<bytes.ml:110:31>>*/ var _ao_ = i + 1 | 0;
+      if(_an_ === i) break;
+      var i = _ao_;
      }
     }
     return 0;
     /*<<bytes.ml:110:53>>*/ }
    function iteri(f, a){
      /*<<bytes.ml:114:2>>*/ var
-     _aj_ = caml_ml_bytes_length(a) - 1 | 0,
-      /*<<bytes.ml:114:2>>*/ _ai_ = 0;
-    if(_aj_ >= 0){
-     var i = _ai_;
+     _ak_ = caml_ml_bytes_length(a) - 1 | 0,
+      /*<<bytes.ml:114:2>>*/ _aj_ = 0;
+    if(_ak_ >= 0){
+     var i = _aj_;
      for(;;){
        /*<<bytes.ml:114:31>>*/  /*<<bytes.ml:114:31>>*/ caml_call2
        (f, i, caml_bytes_unsafe_get(a, i));
-       /*<<bytes.ml:114:31>>*/  /*<<bytes.ml:114:31>>*/ var _ak_ = i + 1 | 0;
-      if(_aj_ === i) break;
-      var i = _ak_;
+       /*<<bytes.ml:114:31>>*/  /*<<bytes.ml:114:31>>*/ var _al_ = i + 1 | 0;
+      if(_ak_ === i) break;
+      var i = _al_;
      }
     }
     return 0;
@@ -4761,13 +4759,13 @@
         param = tl;
        continue;
       }
-      var _ah_ = caml_ml_bytes_length(hd) + acc | 0;
+      var _ai_ = caml_ml_bytes_length(hd) + acc | 0;
      }
      else
-      var _ah_ = acc;
+      var _ai_ = acc;
       /*<<bytes.ml:136:12>>*/ var
        /*<<bytes.ml:136:12>>*/ dst =
-         /*<<bytes.ml:136:12>>*/ caml_create_bytes(_ah_),
+         /*<<bytes.ml:136:12>>*/ caml_create_bytes(_ai_),
       pos = pos$1,
       param$0 = l;
      for(;;){
@@ -4805,10 +4803,10 @@
     /*<<bytes.ml:145:3>>*/ }
    function is_space(param){
      /*<<bytes.ml:151:15>>*/  /*<<bytes.ml:151:15>>*/ var
-     _ag_ = param - 9 | 0;
+     _ah_ = param - 9 | 0;
     a:
     {
-     if(4 < _ag_ >>> 0){if(23 !== _ag_) break a;} else if(2 === _ag_) break a;
+     if(4 < _ah_ >>> 0){if(23 !== _ah_) break a;} else if(2 === _ah_) break a;
       /*<<bytes.ml:152:41>>*/ return 1;
     }
      /*<<bytes.ml:153:9>>*/ return 0;
@@ -4832,10 +4830,10 @@
    function unsafe_escape(s){
      /*<<bytes.ml:184:2>>*/ var
       /*<<bytes.ml:184:10>>*/ n = [0, 0],
-     _$_ = caml_ml_bytes_length(s) - 1 | 0,
-      /*<<bytes.ml:184:10>>*/ ___ = 0;
-    if(_$_ >= 0){
-     var i$0 = ___;
+     _aa_ = caml_ml_bytes_length(s) - 1 | 0,
+      /*<<bytes.ml:184:10>>*/ _$_ = 0;
+    if(_aa_ >= 0){
+     var i$0 = _$_;
      for(;;){
       var match = caml_bytes_unsafe_get(s, i$0);
       a:
@@ -4845,12 +4843,12 @@
         c:
         {
          if(32 <= match){
-          var _ad_ = match - 34 | 0;
-          if(58 < _ad_ >>> 0){
-           if(93 <= _ad_) break c;
+          var _ae_ = match - 34 | 0;
+          if(58 < _ae_ >>> 0){
+           if(93 <= _ae_) break c;
           }
-          else if(56 < _ad_ - 1 >>> 0) break b;
-          var _ae_ = 1;
+          else if(56 < _ae_ - 1 >>> 0) break b;
+          var _af_ = 1;
           break a;
          }
          if(11 <= match){
@@ -4858,15 +4856,15 @@
          }
          else if(8 <= match) break b;
         }
-        var _ae_ = 4;
+        var _af_ = 4;
         break a;
        }
-       var _ae_ = 2;
+       var _af_ = 2;
       }
-      n[1] = n[1] + _ae_ | 0;
-       /*<<bytes.ml:185:2>>*/  /*<<bytes.ml:185:2>>*/ var _af_ = i$0 + 1 | 0;
-      if(_$_ === i$0) break;
-      var i$0 = _af_;
+      n[1] = n[1] + _af_ | 0;
+       /*<<bytes.ml:185:2>>*/  /*<<bytes.ml:185:2>>*/ var _ag_ = i$0 + 1 | 0;
+      if(_aa_ === i$0) break;
+      var i$0 = _ag_;
      }
     }
     if(n[1] === caml_ml_bytes_length(s))  /*<<bytes.ml:192:24>>*/ return s;
@@ -4874,10 +4872,10 @@
      s$0 =  /*<<bytes.ml:194:13>>*/ caml_create_bytes(n[1]);
     n[1] = 0;
      /*<<bytes.ml:196:4>>*/ var
-     _ab_ = caml_ml_bytes_length(s) - 1 | 0,
-      /*<<bytes.ml:196:4>>*/ _aa_ = 0;
-    if(_ab_ >= 0){
-     var i = _aa_;
+     _ac_ = caml_ml_bytes_length(s) - 1 | 0,
+      /*<<bytes.ml:196:4>>*/ _ab_ = 0;
+    if(_ac_ >= 0){
+     var i = _ab_;
      for(;;){
       var c = caml_bytes_unsafe_get(s, i);
       a:
@@ -4935,9 +4933,9 @@
        caml_bytes_unsafe_set(s$0, n[1], c);
       }
       n[1]++;
-       /*<<bytes.ml:196:4>>*/  /*<<bytes.ml:196:4>>*/ var _ac_ = i + 1 | 0;
-      if(_ab_ === i) break;
-      var i = _ac_;
+       /*<<bytes.ml:196:4>>*/  /*<<bytes.ml:196:4>>*/ var _ad_ = i + 1 | 0;
+      if(_ac_ === i) break;
+      var i = _ad_;
      }
     }
      /*<<bytes.ml:221:4>>*/ return s$0;
@@ -4952,18 +4950,18 @@
      /*<<bytes.ml:233:12>>*/ var
       /*<<bytes.ml:233:12>>*/ r =
         /*<<bytes.ml:233:12>>*/ caml_create_bytes(l),
-      /*<<bytes.ml:234:4>>*/ _Y_ = l - 1 | 0,
-      /*<<bytes.ml:233:12>>*/ _X_ = 0;
-    if(_Y_ >= 0){
-     var i = _X_;
+      /*<<bytes.ml:234:4>>*/ _Z_ = l - 1 | 0,
+      /*<<bytes.ml:233:12>>*/ _Y_ = 0;
+    if(_Z_ >= 0){
+     var i = _Y_;
      for(;;){
       caml_bytes_unsafe_set
        (r,
         i,
          /*<<bytes.ml:234:41>>*/ caml_call1(f, caml_bytes_unsafe_get(s, i)));
-       /*<<bytes.ml:234:4>>*/  /*<<bytes.ml:234:4>>*/ var _Z_ = i + 1 | 0;
-      if(_Y_ === i) break;
-      var i = _Z_;
+       /*<<bytes.ml:234:4>>*/  /*<<bytes.ml:234:4>>*/ var ___ = i + 1 | 0;
+      if(_Z_ === i) break;
+      var i = ___;
      }
     }
      /*<<bytes.ml:235:4>>*/ return r;
@@ -4974,18 +4972,18 @@
      /*<<bytes.ml:241:12>>*/ var
       /*<<bytes.ml:241:12>>*/ r =
         /*<<bytes.ml:241:12>>*/ caml_create_bytes(l),
-      /*<<bytes.ml:242:4>>*/ _V_ = l - 1 | 0,
-      /*<<bytes.ml:241:12>>*/ _U_ = 0;
-    if(_V_ >= 0){
-     var i = _U_;
+      /*<<bytes.ml:242:4>>*/ _W_ = l - 1 | 0,
+      /*<<bytes.ml:241:12>>*/ _V_ = 0;
+    if(_W_ >= 0){
+     var i = _V_;
      for(;;){
       caml_bytes_unsafe_set
        (r,
         i,
          /*<<bytes.ml:242:41>>*/ caml_call2(f, i, caml_bytes_unsafe_get(s, i)));
-       /*<<bytes.ml:242:4>>*/  /*<<bytes.ml:242:4>>*/ var _W_ = i + 1 | 0;
-      if(_V_ === i) break;
-      var i = _W_;
+       /*<<bytes.ml:242:4>>*/  /*<<bytes.ml:242:4>>*/ var _X_ = i + 1 | 0;
+      if(_W_ === i) break;
+      var i = _X_;
      }
     }
      /*<<bytes.ml:243:4>>*/ return r;
@@ -4993,17 +4991,17 @@
    function fold_left(f, x, a){
      /*<<bytes.ml:247:2>>*/ var
       /*<<bytes.ml:247:10>>*/ r = [0, x],
-     _S_ = caml_ml_bytes_length(a) - 1 | 0,
-      /*<<bytes.ml:247:10>>*/ _R_ = 0;
-    if(_S_ >= 0){
-     var i = _R_;
+     _T_ = caml_ml_bytes_length(a) - 1 | 0,
+      /*<<bytes.ml:247:10>>*/ _S_ = 0;
+    if(_T_ >= 0){
+     var i = _S_;
      for(;;){
       r[1] =
         /*<<bytes.ml:249:9>>*/ caml_call2
         (f, r[1], caml_bytes_unsafe_get(a, i));
-       /*<<bytes.ml:248:2>>*/  /*<<bytes.ml:248:2>>*/ var _T_ = i + 1 | 0;
-      if(_S_ === i) break;
-      var i = _T_;
+       /*<<bytes.ml:248:2>>*/  /*<<bytes.ml:248:2>>*/ var _U_ = i + 1 | 0;
+      if(_T_ === i) break;
+      var i = _U_;
      }
     }
     return r[1];
@@ -5011,17 +5009,17 @@
    function fold_right(f, a, x){
      /*<<bytes.ml:254:2>>*/ var
       /*<<bytes.ml:254:10>>*/ r = [0, x],
-      /*<<bytes.ml:255:2>>*/ _P_ =
+      /*<<bytes.ml:255:2>>*/ _Q_ =
         /*<<bytes.ml:255:2>>*/ caml_ml_bytes_length(a) - 1 | 0;
-    if(_P_ >= 0){
-     var i = _P_;
+    if(_Q_ >= 0){
+     var i = _Q_;
      for(;;){
       r[1] =
         /*<<bytes.ml:256:9>>*/ caml_call2
         (f, caml_bytes_unsafe_get(a, i), r[1]);
-       /*<<bytes.ml:255:2>>*/  /*<<bytes.ml:255:2>>*/ var _Q_ = i - 1 | 0;
+       /*<<bytes.ml:255:2>>*/  /*<<bytes.ml:255:2>>*/ var _R_ = i - 1 | 0;
       if(0 === i) break;
-      var i = _Q_;
+      var i = _R_;
      }
     }
     return r[1];
@@ -5076,8 +5074,8 @@
      /*<<bytes.ml:291:2>>*/ var
      len_s = caml_ml_bytes_length(s),
      len_pre = caml_ml_bytes_length(prefix),
-     _O_ = len_pre <= len_s ? 1 : 0;
-    if(! _O_) return _O_;
+     _P_ = len_pre <= len_s ? 1 : 0;
+    if(! _P_) return _P_;
     var i = 0;
      /*<<bytes.ml:294:4>>*/ for(;;){
      if(i === len_pre)  /*<<bytes.ml:294:24>>*/ return 1;
@@ -5093,8 +5091,8 @@
      len_s = caml_ml_bytes_length(s),
      len_suf = caml_ml_bytes_length(suffix),
      diff = len_s - len_suf | 0,
-     _N_ = 0 <= diff ? 1 : 0;
-    if(! _N_) return _N_;
+     _O_ = 0 <= diff ? 1 : 0;
+    if(! _O_) return _O_;
     var i = 0;
      /*<<bytes.ml:305:4>>*/ for(;;){
      if(i === len_suf)  /*<<bytes.ml:305:24>>*/ return 1;
@@ -5193,13 +5191,13 @@
     if(0 <= i && l >= i)
       /*<<bytes.ml:377:4>>*/ try{
        /*<<bytes.ml:377:15>>*/ index_rec(s, l, i, c);
-       /*<<bytes.ml:377:36>>*/  /*<<bytes.ml:377:36>>*/ var _L_ = 1;
-       /*<<bytes.ml:377:36>>*/ return _L_;
+       /*<<bytes.ml:377:36>>*/  /*<<bytes.ml:377:36>>*/ var _M_ = 1;
+       /*<<bytes.ml:377:36>>*/ return _M_;
      }
-     catch(_M_){
-      var _K_ = caml_wrap_exception(_M_);
-      if(_K_ === Stdlib[8])  /*<<bytes.ml:377:59>>*/ return 0;
-      throw caml_maybe_attach_backtrace(_K_, 0);
+     catch(_N_){
+      var _L_ = caml_wrap_exception(_N_);
+      if(_L_ === Stdlib[8])  /*<<bytes.ml:377:59>>*/ return 0;
+      throw caml_maybe_attach_backtrace(_L_, 0);
      }
      /*<<bytes.ml:375:4>>*/ return  /*<<bytes.ml:375:4>>*/ caml_call1
             (Stdlib[1], cst_String_contains_from_Bytes);
@@ -5211,13 +5209,13 @@
      /*<<bytes.ml:385:2>>*/ if(0 <= i && caml_ml_bytes_length(s) > i)
       /*<<bytes.ml:388:4>>*/ try{
        /*<<bytes.ml:388:15>>*/ rindex_rec(s, i, c);
-       /*<<bytes.ml:388:35>>*/  /*<<bytes.ml:388:35>>*/ var _I_ = 1;
-       /*<<bytes.ml:388:35>>*/ return _I_;
+       /*<<bytes.ml:388:35>>*/  /*<<bytes.ml:388:35>>*/ var _J_ = 1;
+       /*<<bytes.ml:388:35>>*/ return _J_;
      }
-     catch(_J_){
-      var _H_ = caml_wrap_exception(_J_);
-      if(_H_ === Stdlib[8])  /*<<bytes.ml:388:58>>*/ return 0;
-      throw caml_maybe_attach_backtrace(_H_, 0);
+     catch(_K_){
+      var _I_ = caml_wrap_exception(_K_);
+      if(_I_ === Stdlib[8])  /*<<bytes.ml:388:58>>*/ return 0;
+      throw caml_maybe_attach_backtrace(_I_, 0);
      }
      /*<<bytes.ml:386:4>>*/ return  /*<<bytes.ml:386:4>>*/ caml_call1
             (Stdlib[1], cst_String_rcontains_from_Byte);
@@ -5228,23 +5226,23 @@
       /*<<bytes.ml:398:10>>*/ r = [0, 0],
       /*<<bytes.ml:399:10>>*/ j =
        [0,  /*<<bytes.ml:399:2>>*/ caml_ml_bytes_length(s)],
-      /*<<bytes.ml:400:2>>*/ _D_ =
+      /*<<bytes.ml:400:2>>*/ _E_ =
         /*<<bytes.ml:400:2>>*/ caml_ml_bytes_length(s) - 1 | 0;
-    if(_D_ >= 0){
-     var i = _D_;
+    if(_E_ >= 0){
+     var i = _E_;
      for(;;){
       if(caml_bytes_unsafe_get(s, i) === sep){
-       var _F_ = r[1];
-       r[1] = [0, sub(s, i + 1 | 0, (j[1] - i | 0) - 1 | 0), _F_];
+       var _G_ = r[1];
+       r[1] = [0, sub(s, i + 1 | 0, (j[1] - i | 0) - 1 | 0), _G_];
        j[1] = i;
       }
-       /*<<bytes.ml:400:2>>*/  /*<<bytes.ml:400:2>>*/ var _G_ = i - 1 | 0;
+       /*<<bytes.ml:400:2>>*/  /*<<bytes.ml:400:2>>*/ var _H_ = i - 1 | 0;
       if(0 === i) break;
-      var i = _G_;
+      var i = _H_;
      }
     }
-    var _E_ = r[1];
-     /*<<bytes.ml:406:2>>*/ return [0, sub(s, 0, j[1]), _E_];
+    var _F_ = r[1];
+     /*<<bytes.ml:406:2>>*/ return [0, sub(s, 0, j[1]), _F_];
     /*<<bytes.ml:406:18>>*/ }
    function to_seq(s){
     function aux(i, param){
@@ -5253,14 +5251,14 @@
       /*<<bytes.ml:414:14>>*/ var
        /*<<bytes.ml:414:14>>*/ x =
          /*<<bytes.ml:414:14>>*/ caml_bytes_get(s, i),
-       /*<<bytes.ml:414:14>>*/ _B_ = i + 1 | 0;
+       /*<<bytes.ml:414:14>>*/ _C_ = i + 1 | 0;
       /*<<bytes.ml:415:6>>*/ return [0,
              x,
-             function(_C_){ /*<<?>>*/ return aux(_B_, _C_);}];
+             function(_D_){ /*<<?>>*/ return aux(_C_, _D_);}];
      /*<<bytes.ml:415:29>>*/ }
-     /*<<bytes.ml:417:2>>*/  /*<<bytes.ml:417:2>>*/ var _z_ = 0;
-     /*<<bytes.ml:417:2>>*/ return function(_A_){
-      /*<<?>>*/ return aux(_z_, _A_);};
+     /*<<bytes.ml:417:2>>*/  /*<<bytes.ml:417:2>>*/ var _A_ = 0;
+     /*<<bytes.ml:417:2>>*/ return function(_B_){
+      /*<<?>>*/ return aux(_A_, _B_);};
     /*<<bytes.ml:417:7>>*/ }
    function to_seqi(s){
     function aux(i, param){
@@ -5269,20 +5267,20 @@
       /*<<bytes.ml:423:14>>*/ var
        /*<<bytes.ml:423:14>>*/ x =
          /*<<bytes.ml:423:14>>*/ caml_bytes_get(s, i),
-       /*<<bytes.ml:423:14>>*/ _x_ = i + 1 | 0;
+       /*<<bytes.ml:423:14>>*/ _y_ = i + 1 | 0;
       /*<<bytes.ml:424:6>>*/ return [0,
              [0, i, x],
-             function(_y_){ /*<<?>>*/ return aux(_x_, _y_);}];
+             function(_z_){ /*<<?>>*/ return aux(_y_, _z_);}];
      /*<<bytes.ml:424:33>>*/ }
-     /*<<bytes.ml:426:2>>*/  /*<<bytes.ml:426:2>>*/ var _v_ = 0;
-     /*<<bytes.ml:426:2>>*/ return function(_w_){
-      /*<<?>>*/ return aux(_v_, _w_);};
+     /*<<bytes.ml:426:2>>*/  /*<<bytes.ml:426:2>>*/ var _w_ = 0;
+     /*<<bytes.ml:426:2>>*/ return function(_x_){
+      /*<<?>>*/ return aux(_w_, _x_);};
     /*<<bytes.ml:426:7>>*/ }
    function of_seq(i){
      /*<<bytes.ml:429:2>>*/ var
       /*<<bytes.ml:429:10>>*/ n = [0, 0],
       /*<<bytes.ml:430:12>>*/ buf = [0, make(256, 0)];
-    function _u_(c){
+    function _v_(c){
       /*<<bytes.ml:441:7>>*/ if(n[1] === caml_ml_bytes_length(buf[1])){
        /*<<bytes.ml:433:18>>*/  /*<<bytes.ml:433:18>>*/ var
        new_len =
@@ -5304,7 +5302,7 @@
      return 0;
      /*<<bytes.ml:443:13>>*/ }
      /*<<bytes.ml:439:2>>*/  /*<<bytes.ml:439:2>>*/ caml_call2
-     (Stdlib_Seq[4], _u_, i);
+     (Stdlib_Seq[4], _v_, i);
     return sub(buf[1], 0, n[1]);
     /*<<bytes.ml:445:15>>*/ }
    function unsafe_get_uint16_le(b, i){
@@ -5321,9 +5319,9 @@
     /*<<bytes.ml:477:40>>*/ }
    function get_int8(b, i){
      /*<<bytes.ml:480:2>>*/ var
-      /*<<bytes.ml:480:2>>*/ _s_ = Stdlib_Sys[10] - 8 | 0,
-     _t_ = Stdlib_Sys[10] - 8 | 0;
-    return  /*<<bytes.ml:480:3>>*/ caml_bytes_get(b, i) << _t_ >> _s_;
+      /*<<bytes.ml:480:2>>*/ _t_ = Stdlib_Sys[10] - 8 | 0,
+     _u_ = Stdlib_Sys[10] - 8 | 0;
+    return  /*<<bytes.ml:480:3>>*/ caml_bytes_get(b, i) << _u_ >> _t_;
     /*<<bytes.ml:480:65>>*/ }
    function get_uint16_le(b, i){
      /*<<bytes.ml:483:2>>*/ return Stdlib_Sys[11]
@@ -5339,21 +5337,21 @@
     /*<<bytes.ml:488:24>>*/ }
    function get_int16_ne(b, i){
      /*<<bytes.ml:491:2>>*/ var
-      /*<<bytes.ml:491:2>>*/ _q_ = Stdlib_Sys[10] - 16 | 0,
-     _r_ = Stdlib_Sys[10] - 16 | 0;
-    return  /*<<bytes.ml:491:3>>*/ caml_bytes_get16(b, i) << _r_ >> _q_;
+      /*<<bytes.ml:491:2>>*/ _r_ = Stdlib_Sys[10] - 16 | 0,
+     _s_ = Stdlib_Sys[10] - 16 | 0;
+    return  /*<<bytes.ml:491:3>>*/ caml_bytes_get16(b, i) << _s_ >> _r_;
     /*<<bytes.ml:491:71>>*/ }
    function get_int16_le(b, i){
      /*<<bytes.ml:494:2>>*/ var
-      /*<<bytes.ml:494:2>>*/ _o_ = Stdlib_Sys[10] - 16 | 0,
-     _p_ = Stdlib_Sys[10] - 16 | 0;
-    return get_uint16_le(b, i) << _p_ >> _o_;
+      /*<<bytes.ml:494:2>>*/ _p_ = Stdlib_Sys[10] - 16 | 0,
+     _q_ = Stdlib_Sys[10] - 16 | 0;
+    return get_uint16_le(b, i) << _q_ >> _p_;
     /*<<bytes.ml:494:71>>*/ }
    function get_int16_be(b, i){
      /*<<bytes.ml:497:2>>*/ var
-      /*<<bytes.ml:497:2>>*/ _m_ = Stdlib_Sys[10] - 16 | 0,
-     _n_ = Stdlib_Sys[10] - 16 | 0;
-    return get_uint16_be(b, i) << _n_ >> _m_;
+      /*<<bytes.ml:497:2>>*/ _n_ = Stdlib_Sys[10] - 16 | 0,
+     _o_ = Stdlib_Sys[10] - 16 | 0;
+    return get_uint16_be(b, i) << _o_ >> _n_;
     /*<<bytes.ml:497:71>>*/ }
    function get_int32_le(b, i){
      /*<<bytes.ml:500:2>>*/ return Stdlib_Sys[11]
@@ -5383,15 +5381,15 @@
      /*<<bytes.ml:516:2>>*/ return Stdlib_Sys[11]
             ? ( /*<<bytes.ml:517:7>>*/ caml_bytes_set16
                (b, i, caml_bswap16(x)),
-              sentinal)
-            : ( /*<<bytes.ml:518:7>>*/ caml_bytes_set16(b, i, x), sentinal);
+              _g_)
+            : ( /*<<bytes.ml:518:7>>*/ caml_bytes_set16(b, i, x), _g_);
     /*<<bytes.ml:518:33>>*/ }
    function unsafe_set_uint16_be(b, i, x){
      /*<<bytes.ml:521:2>>*/ return Stdlib_Sys[11]
-            ? ( /*<<bytes.ml:522:7>>*/ caml_bytes_set16(b, i, x), sentinal)
+            ? ( /*<<bytes.ml:522:7>>*/ caml_bytes_set16(b, i, x), _g_)
             : ( /*<<bytes.ml:523:2>>*/ caml_bytes_set16
                (b, i, caml_bswap16(x)),
-              sentinal);
+              _g_);
     /*<<bytes.ml:523:37>>*/ }
    function set_int16_le(b, i, x){
      /*<<bytes.ml:526:2>>*/ return Stdlib_Sys[11]
@@ -5433,9 +5431,9 @@
     dec_invalid = Stdlib_Uchar[22];
    function dec_ret(n, u){
      /*<<bytes.ml:557:27>>*/  /*<<bytes.ml:557:46>>*/ var
-     _l_ =  /*<<bytes.ml:557:46>>*/ caml_call1(Stdlib_Uchar[9], u);
+     _m_ =  /*<<bytes.ml:557:46>>*/ caml_call1(Stdlib_Uchar[9], u);
      /*<<bytes.ml:557:46>>*/ return  /*<<bytes.ml:557:46>>*/ caml_call2
-            (Stdlib_Uchar[21], n, _l_);
+            (Stdlib_Uchar[21], n, _m_);
     /*<<bytes.ml:557:69>>*/ }
    function not_in_x80_to_xBF(b){
      /*<<bytes.ml:575:35>>*/ return 2 !== (b >>> 6 | 0) ? 1 : 0;
@@ -5448,9 +5446,9 @@
     /*<<bytes.ml:577:51>>*/ }
    function not_in_x90_to_xBF(b){
      /*<<bytes.ml:578:35>>*/ var
-     _j_ = b < 144 ? 1 : 0,
-     _k_ = _j_ || (191 < b ? 1 : 0);
-    return _k_;
+     _k_ = b < 144 ? 1 : 0,
+     _l_ = _k_ || (191 < b ? 1 : 0);
+    return _l_;
     /*<<bytes.ml:578:55>>*/ }
    function not_in_x80_to_x8F(b){
      /*<<bytes.ml:579:35>>*/ return 8 !== (b >>> 4 | 0) ? 1 : 0;
@@ -5647,9 +5645,9 @@
             (dec_invalid, 1);
     /*<<bytes.ml:648:22>>*/ }
    function set_utf_8_uchar(b, i, u){
-     /*<<bytes.ml:651:2>>*/ function set(_i_, _h_, _g_){
-      /*<<?>>*/ caml_bytes_unsafe_set(_i_, _h_, _g_);
-     return sentinal;
+     /*<<bytes.ml:651:2>>*/ function set(_j_, _i_, _h_){
+      /*<<?>>*/ caml_bytes_unsafe_set(_j_, _i_, _h_);
+     return _g_;
     }
      /*<<bytes.ml:652:2>>*/ var
       /*<<bytes.ml:652:2>>*/ max =
@@ -6863,7 +6861,7 @@
             : runtime.caml_call_gen(f, [a0, a1, a2]);
    }
     /*<<array.ml:37:20>>*/ var
-    sentinal = undefined,
+    _b_ = undefined,
     global_data = runtime.caml_get_global_data(),
     Stdlib_Seq = global_data.Stdlib__Seq,
     Assert_failure = global_data.Assert_failure,
@@ -6891,16 +6889,16 @@
       /*<<array.ml:53:13>>*/ res =
         /*<<array.ml:53:13>>*/ caml_make_vect
         (l,  /*<<array.ml:53:22>>*/ caml_call1(f, 0)),
-      /*<<array.ml:54:3>>*/ _as_ = l - 1 | 0,
-      /*<<array.ml:53:13>>*/ _ar_ = 1;
-    if(_as_ >= 1){
-     var i = _ar_;
+      /*<<array.ml:54:3>>*/ _at_ = l - 1 | 0,
+      /*<<array.ml:53:13>>*/ _as_ = 1;
+    if(_at_ >= 1){
+     var i = _as_;
      for(;;){
        /*<<array.ml:55:5>>*/ res[1 + i] =
         /*<<array.ml:55:22>>*/ caml_call1(f, i);
-       /*<<array.ml:55:5>>*/  /*<<array.ml:55:5>>*/ var _at_ = i + 1 | 0;
-      if(_as_ === i) break;
-      var i = _at_;
+       /*<<array.ml:55:5>>*/  /*<<array.ml:55:5>>*/ var _au_ = i + 1 | 0;
+      if(_at_ === i) break;
+      var i = _au_;
      }
     }
      /*<<array.ml:57:3>>*/ return res;
@@ -6909,15 +6907,15 @@
      /*<<array.ml:60:2>>*/ var
       /*<<array.ml:60:12>>*/ res =
         /*<<array.ml:60:12>>*/ caml_make_vect(sx, [0]),
-      /*<<array.ml:61:2>>*/ _ap_ = sx - 1 | 0,
-      /*<<array.ml:60:12>>*/ _ao_ = 0;
-    if(_ap_ >= 0){
-     var x = _ao_;
+      /*<<array.ml:61:2>>*/ _aq_ = sx - 1 | 0,
+      /*<<array.ml:60:12>>*/ _ap_ = 0;
+    if(_aq_ >= 0){
+     var x = _ap_;
      for(;;){
       res[1 + x] =  /*<<array.ml:62:21>>*/ caml_make_vect(sy, init);
-       /*<<array.ml:61:2>>*/  /*<<array.ml:61:2>>*/ var _aq_ = x + 1 | 0;
-      if(_ap_ === x) break;
-      var x = _aq_;
+       /*<<array.ml:61:2>>*/  /*<<array.ml:61:2>>*/ var _ar_ = x + 1 | 0;
+      if(_aq_ === x) break;
+      var x = _ar_;
      }
     }
      /*<<array.ml:64:2>>*/ return res;
@@ -6968,15 +6966,15 @@
     /*<<array.ml:89:38>>*/ }
    function iter(f, a){
      /*<<array.ml:92:2>>*/ var
-     _am_ = a.length - 1 - 1 | 0,
-      /*<<array.ml:92:2>>*/ _al_ = 0;
-    if(_am_ >= 0){
-     var i = _al_;
+     _an_ = a.length - 1 - 1 | 0,
+      /*<<array.ml:92:2>>*/ _am_ = 0;
+    if(_an_ >= 0){
+     var i = _am_;
      for(;;){
        /*<<array.ml:92:31>>*/  /*<<array.ml:92:31>>*/ caml_call1(f, a[1 + i]);
-       /*<<array.ml:92:31>>*/  /*<<array.ml:92:31>>*/ var _an_ = i + 1 | 0;
-      if(_am_ === i) break;
-      var i = _an_;
+       /*<<array.ml:92:31>>*/  /*<<array.ml:92:31>>*/ var _ao_ = i + 1 | 0;
+      if(_an_ === i) break;
+      var i = _ao_;
      }
     }
     return 0;
@@ -6986,16 +6984,16 @@
       /*<<array.ml:96:4>>*/ return  /*<<array.ml:96:4>>*/ caml_call1
              (Stdlib[1], cst_Array_iter2_arrays_must_ha);
      /*<<array.ml:98:4>>*/ var
-     _aj_ = a.length - 1 - 1 | 0,
-      /*<<array.ml:98:4>>*/ _ai_ = 0;
-    if(_aj_ >= 0){
-     var i = _ai_;
+     _ak_ = a.length - 1 - 1 | 0,
+      /*<<array.ml:98:4>>*/ _aj_ = 0;
+    if(_ak_ >= 0){
+     var i = _aj_;
      for(;;){
        /*<<array.ml:98:33>>*/  /*<<array.ml:98:33>>*/ caml_call2
        (f, a[1 + i], b[1 + i]);
-       /*<<array.ml:98:33>>*/  /*<<array.ml:98:33>>*/ var _ak_ = i + 1 | 0;
-      if(_aj_ === i) break;
-      var i = _ak_;
+       /*<<array.ml:98:33>>*/  /*<<array.ml:98:33>>*/ var _al_ = i + 1 | 0;
+      if(_ak_ === i) break;
+      var i = _al_;
      }
     }
     return 0;
@@ -7007,16 +7005,16 @@
       /*<<array.ml:103:12>>*/ r =
         /*<<array.ml:103:12>>*/ caml_make_vect
         (l,  /*<<array.ml:103:21>>*/ caml_call1(f, a[1])),
-      /*<<array.ml:104:4>>*/ _ag_ = l - 1 | 0,
-      /*<<array.ml:103:12>>*/ _af_ = 1;
-    if(_ag_ >= 1){
-     var i = _af_;
+      /*<<array.ml:104:4>>*/ _ah_ = l - 1 | 0,
+      /*<<array.ml:103:12>>*/ _ag_ = 1;
+    if(_ah_ >= 1){
+     var i = _ag_;
      for(;;){
        /*<<array.ml:105:6>>*/ r[1 + i] =
         /*<<array.ml:105:21>>*/ caml_call1(f, a[1 + i]);
-       /*<<array.ml:105:6>>*/  /*<<array.ml:105:6>>*/ var _ah_ = i + 1 | 0;
-      if(_ag_ === i) break;
-      var i = _ah_;
+       /*<<array.ml:105:6>>*/  /*<<array.ml:105:6>>*/ var _ai_ = i + 1 | 0;
+      if(_ah_ === i) break;
+      var i = _ai_;
      }
     }
      /*<<array.ml:107:4>>*/ return r;
@@ -7033,32 +7031,32 @@
       /*<<array.ml:117:14>>*/ r =
         /*<<array.ml:117:14>>*/ caml_make_vect
         (la,  /*<<array.ml:117:24>>*/ caml_call2(f, a[1], b[1])),
-      /*<<array.ml:118:6>>*/ _ad_ = la - 1 | 0,
-      /*<<array.ml:117:14>>*/ _ac_ = 1;
-    if(_ad_ >= 1){
-     var i = _ac_;
+      /*<<array.ml:118:6>>*/ _ae_ = la - 1 | 0,
+      /*<<array.ml:117:14>>*/ _ad_ = 1;
+    if(_ae_ >= 1){
+     var i = _ad_;
      for(;;){
        /*<<array.ml:119:8>>*/ r[1 + i] =
         /*<<array.ml:119:23>>*/ caml_call2(f, a[1 + i], b[1 + i]);
-       /*<<array.ml:119:8>>*/  /*<<array.ml:119:8>>*/ var _ae_ = i + 1 | 0;
-      if(_ad_ === i) break;
-      var i = _ae_;
+       /*<<array.ml:119:8>>*/  /*<<array.ml:119:8>>*/ var _af_ = i + 1 | 0;
+      if(_ae_ === i) break;
+      var i = _af_;
      }
     }
      /*<<array.ml:121:6>>*/ return r;
     /*<<array.ml:123:5>>*/ }
    function iteri(f, a){
      /*<<array.ml:126:2>>*/ var
-     _aa_ = a.length - 1 - 1 | 0,
-      /*<<array.ml:126:2>>*/ _$_ = 0;
-    if(_aa_ >= 0){
-     var i = _$_;
+     _ab_ = a.length - 1 - 1 | 0,
+      /*<<array.ml:126:2>>*/ _aa_ = 0;
+    if(_ab_ >= 0){
+     var i = _aa_;
      for(;;){
        /*<<array.ml:126:31>>*/  /*<<array.ml:126:31>>*/ caml_call2
        (f, i, a[1 + i]);
-       /*<<array.ml:126:31>>*/  /*<<array.ml:126:31>>*/ var _ab_ = i + 1 | 0;
-      if(_aa_ === i) break;
-      var i = _ab_;
+       /*<<array.ml:126:31>>*/  /*<<array.ml:126:31>>*/ var _ac_ = i + 1 | 0;
+      if(_ab_ === i) break;
+      var i = _ac_;
      }
     }
     return 0;
@@ -7070,16 +7068,16 @@
       /*<<array.ml:131:12>>*/ r =
         /*<<array.ml:131:12>>*/ caml_make_vect
         (l,  /*<<array.ml:131:21>>*/ caml_call2(f, 0, a[1])),
-      /*<<array.ml:132:4>>*/ _Z_ = l - 1 | 0,
-      /*<<array.ml:131:12>>*/ _Y_ = 1;
-    if(_Z_ >= 1){
-     var i = _Y_;
+      /*<<array.ml:132:4>>*/ ___ = l - 1 | 0,
+      /*<<array.ml:131:12>>*/ _Z_ = 1;
+    if(___ >= 1){
+     var i = _Z_;
      for(;;){
        /*<<array.ml:133:6>>*/ r[1 + i] =
         /*<<array.ml:133:21>>*/ caml_call2(f, i, a[1 + i]);
-       /*<<array.ml:133:6>>*/  /*<<array.ml:133:6>>*/ var ___ = i + 1 | 0;
-      if(_Z_ === i) break;
-      var i = ___;
+       /*<<array.ml:133:6>>*/  /*<<array.ml:133:6>>*/ var _$_ = i + 1 | 0;
+      if(___ === i) break;
+      var i = _$_;
      }
     }
      /*<<array.ml:135:4>>*/ return r;
@@ -7128,15 +7126,15 @@
    function fold_left(f, x, a){
      /*<<array.ml:158:2>>*/ var
       /*<<array.ml:158:10>>*/ r = [0, x],
-     _W_ = a.length - 1 - 1 | 0,
-      /*<<array.ml:158:10>>*/ _V_ = 0;
-    if(_W_ >= 0){
-     var i = _V_;
+     _X_ = a.length - 1 - 1 | 0,
+      /*<<array.ml:158:10>>*/ _W_ = 0;
+    if(_X_ >= 0){
+     var i = _W_;
      for(;;){
       r[1] =  /*<<array.ml:160:9>>*/ caml_call2(f, r[1], a[1 + i]);
-       /*<<array.ml:159:2>>*/  /*<<array.ml:159:2>>*/ var _X_ = i + 1 | 0;
-      if(_W_ === i) break;
-      var i = _X_;
+       /*<<array.ml:159:2>>*/  /*<<array.ml:159:2>>*/ var _Y_ = i + 1 | 0;
+      if(_X_ === i) break;
+      var i = _Y_;
      }
     }
     return r[1];
@@ -7153,10 +7151,10 @@
       /*<<array.ml:168:23>>*/ output_array =
         /*<<array.ml:168:23>>*/ caml_make_vect(len, elt),
       /*<<array.ml:169:14>>*/ acc$1 = [0, acc$0],
-      /*<<array.ml:170:4>>*/ _T_ = len - 1 | 0,
-      /*<<array.ml:169:14>>*/ _S_ = 1;
-    if(_T_ >= 1){
-     var i = _S_;
+      /*<<array.ml:170:4>>*/ _U_ = len - 1 | 0,
+      /*<<array.ml:169:14>>*/ _T_ = 1;
+    if(_U_ >= 1){
+     var i = _T_;
      for(;;){
        /*<<array.ml:171:22>>*/ var
         /*<<array.ml:171:22>>*/ match$0 =
@@ -7165,9 +7163,9 @@
        acc$2 = match$0[1];
       acc$1[1] = acc$2;
        /*<<array.ml:173:6>>*/ output_array[1 + i] = elt$0;
-       /*<<array.ml:170:4>>*/  /*<<array.ml:170:4>>*/ var _U_ = i + 1 | 0;
-      if(_T_ === i) break;
-      var i = _U_;
+       /*<<array.ml:170:4>>*/  /*<<array.ml:170:4>>*/ var _V_ = i + 1 | 0;
+      if(_U_ === i) break;
+      var i = _V_;
      }
     }
      /*<<array.ml:175:4>>*/ return [0, acc$1[1], output_array];
@@ -7175,14 +7173,14 @@
    function fold_right(f, a, x){
      /*<<array.ml:179:2>>*/ var
       /*<<array.ml:179:10>>*/ r = [0, x],
-      /*<<array.ml:180:2>>*/ _Q_ = a.length - 1 - 1 | 0;
-    if(_Q_ >= 0){
-     var i = _Q_;
+      /*<<array.ml:180:2>>*/ _R_ = a.length - 1 - 1 | 0;
+    if(_R_ >= 0){
+     var i = _R_;
      for(;;){
       r[1] =  /*<<array.ml:181:9>>*/ caml_call2(f, a[1 + i], r[1]);
-       /*<<array.ml:180:2>>*/  /*<<array.ml:180:2>>*/ var _R_ = i - 1 | 0;
+       /*<<array.ml:180:2>>*/  /*<<array.ml:180:2>>*/ var _S_ = i - 1 | 0;
       if(0 === i) break;
-      var i = _R_;
+      var i = _S_;
      }
     }
     return r[1];
@@ -7302,17 +7300,17 @@
         /*<<array.ml:264:12>>*/ caml_make_vect(n, a0),
       /*<<array.ml:265:12>>*/ b =
         /*<<array.ml:265:12>>*/ caml_make_vect(n, b0),
-      /*<<array.ml:266:4>>*/ _O_ = n - 1 | 0,
-      /*<<array.ml:265:12>>*/ _N_ = 1;
-    if(_O_ >= 1){
-     var i = _N_;
+      /*<<array.ml:266:4>>*/ _P_ = n - 1 | 0,
+      /*<<array.ml:265:12>>*/ _O_ = 1;
+    if(_P_ >= 1){
+     var i = _O_;
      for(;;){
       var match$0 = x[1 + i], bi = match$0[2], ai = match$0[1];
        /*<<array.ml:268:6>>*/ a[1 + i] = ai;
        /*<<array.ml:269:6>>*/ b[1 + i] = bi;
-       /*<<array.ml:266:4>>*/  /*<<array.ml:266:4>>*/ var _P_ = i + 1 | 0;
-      if(_O_ === i) break;
-      var i = _P_;
+       /*<<array.ml:266:4>>*/  /*<<array.ml:266:4>>*/ var _Q_ = i + 1 | 0;
+      if(_P_ === i) break;
+      var i = _Q_;
      }
     }
      /*<<array.ml:271:4>>*/ return [0, a, b];
@@ -7328,15 +7326,15 @@
      /*<<array.ml:280:12>>*/ var
       /*<<array.ml:280:12>>*/ x =
         /*<<array.ml:280:12>>*/ caml_make_vect(na, [0, a[1], b[1]]),
-      /*<<array.ml:281:4>>*/ _L_ = na - 1 | 0,
-      /*<<array.ml:280:12>>*/ _K_ = 1;
-    if(_L_ >= 1){
-     var i = _K_;
+      /*<<array.ml:281:4>>*/ _M_ = na - 1 | 0,
+      /*<<array.ml:280:12>>*/ _L_ = 1;
+    if(_M_ >= 1){
+     var i = _L_;
      for(;;){
       x[1 + i] = [0, a[1 + i], b[1 + i]];
-       /*<<array.ml:281:4>>*/  /*<<array.ml:281:4>>*/ var _M_ = i + 1 | 0;
-      if(_L_ === i) break;
-      var i = _M_;
+       /*<<array.ml:281:4>>*/  /*<<array.ml:281:4>>*/ var _N_ = i + 1 | 0;
+      if(_M_ === i) break;
+      var i = _N_;
      }
     }
      /*<<array.ml:284:4>>*/ return x;
@@ -7350,42 +7348,42 @@
        /*<<array.ml:291:12>>*/ x = [0, i31];
      if((i31 + 2 | 0) < l){
        /*<<array.ml:292:22>>*/ var
-        /*<<array.ml:292:22>>*/ _D_ = i31 + 1 | 0,
-        /*<<array.ml:293:25>>*/ _E_ = caml_check_bound(a, _D_)[1 + _D_];
+        /*<<array.ml:292:22>>*/ _E_ = i31 + 1 | 0,
+        /*<<array.ml:293:25>>*/ _F_ = caml_check_bound(a, _E_)[1 + _E_];
       if
        ( /*<<array.ml:293:9>>*/ caml_call2
-         (cmp, caml_check_bound(a, i31)[1 + i31], _E_)
+         (cmp, caml_check_bound(a, i31)[1 + i31], _F_)
         < 0)
        x[1] = i31 + 1 | 0;
        /*<<array.ml:294:6>>*/ var
-        /*<<array.ml:294:6>>*/ _F_ = i31 + 2 | 0,
-        /*<<array.ml:294:24>>*/ _G_ = caml_check_bound(a, _F_)[1 + _F_],
-       _H_ = x[1];
+        /*<<array.ml:294:6>>*/ _G_ = i31 + 2 | 0,
+        /*<<array.ml:294:24>>*/ _H_ = caml_check_bound(a, _G_)[1 + _G_],
+       _I_ = x[1];
       if
        ( /*<<array.ml:294:9>>*/ caml_call2
-         (cmp, caml_check_bound(a, _H_)[1 + _H_], _G_)
+         (cmp, caml_check_bound(a, _I_)[1 + _I_], _H_)
         < 0)
        x[1] = i31 + 2 | 0;
       return x[1];
      }
      if((i31 + 1 | 0) < l){
        /*<<array.ml:297:38>>*/ var
-       _I_ = i31 + 1 | 0,
-        /*<<array.ml:297:38>>*/ _J_ = caml_check_bound(a, _I_)[1 + _I_];
+       _J_ = i31 + 1 | 0,
+        /*<<array.ml:297:38>>*/ _K_ = caml_check_bound(a, _J_)[1 + _J_];
        /*<<array.ml:297:22>>*/ if
        (0
         >
           /*<<array.ml:297:22>>*/ caml_call2
-          (cmp, caml_check_bound(a, i31)[1 + i31], _J_))
+          (cmp, caml_check_bound(a, i31)[1 + i31], _K_))
         /*<<array.ml:298:11>>*/ return i31 + 1 | 0;
      }
      if(i31 < l)  /*<<array.ml:299:27>>*/ return i31;
       /*<<array.ml:299:36>>*/ throw  /*<<array.ml:299:36>>*/ caml_maybe_attach_backtrace
             ([0, Bottom, i], 1);
      /*<<array.ml:299:52>>*/ }
-    var l = a.length - 1, _x_ = ((l + 1 | 0) / 3 | 0) - 1 | 0;
-    if(_x_ >= 0){
-     var i$6 = _x_;
+    var l = a.length - 1, _y_ = ((l + 1 | 0) / 3 | 0) - 1 | 0;
+    if(_y_ >= 0){
+     var i$6 = _y_;
      for(;;){
        /*<<array.ml:328:50>>*/  /*<<array.ml:328:50>>*/ var
        e$1 = caml_check_bound(a, i$6)[1 + i$6];
@@ -7403,8 +7401,8 @@
          break;
         }
          /*<<array.ml:304:14>>*/  /*<<array.ml:304:14>>*/ var
-         _u_ = caml_check_bound(a, j)[1 + j];
-         /*<<array.ml:304:6>>*/ caml_check_bound(a, i)[1 + i] = _u_;
+         _v_ = caml_check_bound(a, j)[1 + j];
+         /*<<array.ml:304:6>>*/ caml_check_bound(a, i)[1 + i] = _v_;
         var i = j;
        }
       }
@@ -7414,14 +7412,14 @@
        var i$0 = exn[2];
         /*<<array.ml:310:61>>*/ caml_check_bound(a, i$0)[1 + i$0] = e$1;
       }
-       /*<<array.ml:328:38>>*/  /*<<array.ml:328:38>>*/ var _C_ = i$6 - 1 | 0;
+       /*<<array.ml:328:38>>*/  /*<<array.ml:328:38>>*/ var _D_ = i$6 - 1 | 0;
       if(0 === i$6) break;
-      var i$6 = _C_;
+      var i$6 = _D_;
      }
     }
-     /*<<array.ml:329:2>>*/  /*<<array.ml:329:2>>*/ var _y_ = l - 1 | 0;
-    if(_y_ >= 2){
-     var i$4 = _y_;
+     /*<<array.ml:329:2>>*/  /*<<array.ml:329:2>>*/ var _z_ = l - 1 | 0;
+    if(_z_ >= 2){
+     var i$4 = _z_;
      a:
      for(;;){
        /*<<array.ml:330:12>>*/  /*<<array.ml:330:12>>*/ var
@@ -7433,8 +7431,8 @@
         /*<<array.ml:312:4>>*/ for(;;){
          /*<<array.ml:312:12>>*/ var
           /*<<array.ml:312:12>>*/ j$0 = maxson(i$4, i$1),
-          /*<<array.ml:313:12>>*/ _v_ = caml_check_bound(a, j$0)[1 + j$0];
-         /*<<array.ml:313:4>>*/ caml_check_bound(a, i$1)[1 + i$1] = _v_;
+          /*<<array.ml:313:12>>*/ _w_ = caml_check_bound(a, j$0)[1 + j$0];
+         /*<<array.ml:313:4>>*/ caml_check_bound(a, i$1)[1 + i$1] = _w_;
         var i$1 = j$0;
        }
       }
@@ -7455,30 +7453,30 @@
           /*<<array.ml:323:13>>*/ caml_check_bound(a, i$3)[1 + i$3] = e$0;
         else{
           /*<<array.ml:321:14>>*/  /*<<array.ml:321:14>>*/ var
-          _w_ = caml_check_bound(a, father)[1 + father];
-          /*<<array.ml:321:6>>*/ caml_check_bound(a, i$3)[1 + i$3] = _w_;
+          _x_ = caml_check_bound(a, father)[1 + father];
+          /*<<array.ml:321:6>>*/ caml_check_bound(a, i$3)[1 + i$3] = _x_;
          if(0 < father){var i$3 = father; continue;}
           /*<<array.ml:322:49>>*/ caml_check_bound(a, 0)[1] = e$0;
         }
-         /*<<array.ml:329:2>>*/  /*<<array.ml:329:2>>*/ var _B_ = i$4 - 1 | 0;
+         /*<<array.ml:329:2>>*/  /*<<array.ml:329:2>>*/ var _C_ = i$4 - 1 | 0;
         if(2 === i$4) break a;
-        var i$4 = _B_;
+        var i$4 = _C_;
         break;
        }
       }
      }
     }
-    var _z_ = 1 < l ? 1 : 0;
-    if(_z_){
+    var _A_ = 1 < l ? 1 : 0;
+    if(_A_){
       /*<<array.ml:334:25>>*/  /*<<array.ml:334:25>>*/ var
       e = caml_check_bound(a, 1)[2];
       /*<<array.ml:334:38>>*/ a[2] = caml_check_bound(a, 0)[1];
       /*<<array.ml:334:57>>*/ a[1] = e;
-     var _A_ = 0;
+     var _B_ = 0;
     }
     else
-     var _A_ = _z_;
-     /*<<array.ml:334:57>>*/ return _A_;
+     var _B_ = _A_;
+     /*<<array.ml:334:57>>*/ return _B_;
     /*<<array.ml:334:67>>*/ }
    function stable_sort(cmp, a){
     function merge(src1ofs, src1len, src2, src2ofs, src2len, dst, dstofs){
@@ -7522,38 +7520,38 @@
      /*<<array.ml:357:70>>*/ }
     function isortto(srcofs, dst, dstofs, len){
       /*<<array.ml:360:4>>*/ var
-      _m_ = len - 1 | 0,
-       /*<<array.ml:360:4>>*/ _l_ = 0;
-     if(_m_ >= 0){
-      var i = _l_;
+      _n_ = len - 1 | 0,
+       /*<<array.ml:360:4>>*/ _m_ = 0;
+     if(_n_ >= 0){
+      var i = _m_;
       a:
       for(;;){
         /*<<array.ml:361:14>>*/ var
-        _n_ = srcofs + i | 0,
-         /*<<array.ml:361:14>>*/ e = caml_check_bound(a, _n_)[1 + _n_],
+        _o_ = srcofs + i | 0,
+         /*<<array.ml:361:14>>*/ e = caml_check_bound(a, _o_)[1 + _o_],
          /*<<array.ml:362:14>>*/ j = [0, (dstofs + i | 0) - 1 | 0];
        for(;;){
         if(dstofs <= j[1]){
-         var _o_ = j[1];
+         var _p_ = j[1];
           /*<<array.ml:363:29>>*/ if
           (0
            <
              /*<<array.ml:363:29>>*/ caml_call2
-             (cmp, caml_check_bound(dst, _o_)[1 + _o_], e)){
+             (cmp, caml_check_bound(dst, _p_)[1 + _p_], e)){
            /*<<array.ml:364:25>>*/ var
-           _p_ = j[1],
-            /*<<array.ml:364:25>>*/ _q_ = caml_check_bound(dst, _p_)[1 + _p_],
-           _r_ = j[1] + 1 | 0;
-           /*<<array.ml:364:8>>*/ caml_check_bound(dst, _r_)[1 + _r_] = _q_;
+           _q_ = j[1],
+            /*<<array.ml:364:25>>*/ _r_ = caml_check_bound(dst, _q_)[1 + _q_],
+           _s_ = j[1] + 1 | 0;
+           /*<<array.ml:364:8>>*/ caml_check_bound(dst, _s_)[1 + _s_] = _r_;
           j[1] += -1;
           continue;
          }
         }
-        var _s_ = j[1] + 1 | 0;
-         /*<<array.ml:367:6>>*/ caml_check_bound(dst, _s_)[1 + _s_] = e;
-         /*<<array.ml:360:4>>*/  /*<<array.ml:360:4>>*/ var _t_ = i + 1 | 0;
-        if(_m_ === i) break a;
-        var i = _t_;
+        var _t_ = j[1] + 1 | 0;
+         /*<<array.ml:367:6>>*/ caml_check_bound(dst, _t_)[1 + _t_] = e;
+         /*<<array.ml:360:4>>*/  /*<<array.ml:360:4>>*/ var _u_ = i + 1 | 0;
+        if(_n_ === i) break a;
+        var i = _u_;
         break;
        }
       }
@@ -7563,14 +7561,14 @@
     function sortto(srcofs, dst, dstofs, len){
       /*<<array.ml:371:4>>*/ if(len <= 5){
        /*<<array.ml:371:26>>*/ isortto(srcofs, dst, dstofs, len);
-       /*<<array.ml:371:26>>*/ return sentinal;
+       /*<<array.ml:371:26>>*/ return _b_;
      }
      var l1 = len / 2 | 0, l2 = len - l1 | 0;
       /*<<array.ml:374:6>>*/ sortto(srcofs + l1 | 0, dst, dstofs + l1 | 0, l2);
       /*<<array.ml:375:6>>*/ sortto(srcofs, a, srcofs + l2 | 0, l1);
       /*<<array.ml:375:6>>*/ merge
       (srcofs + l2 | 0, l1, dst, dstofs + l1 | 0, l2, dst, dstofs);
-      /*<<array.ml:375:6>>*/ return sentinal;
+      /*<<array.ml:375:6>>*/ return _b_;
      /*<<array.ml:377:7>>*/ }
     var l = a.length - 1;
     if(l <= 5)  /*<<array.ml:380:22>>*/ return isortto(0, a, 0, l);
@@ -7589,14 +7587,14 @@
        /*<<array.ml:400:9>>*/ return 0;
       /*<<array.ml:398:14>>*/ var
        /*<<array.ml:398:14>>*/ x = a[1 + i],
-       /*<<array.ml:398:14>>*/ _j_ = i + 1 | 0;
+       /*<<array.ml:398:14>>*/ _k_ = i + 1 | 0;
       /*<<array.ml:399:6>>*/ return [0,
              x,
-             function(_k_){ /*<<?>>*/ return aux(_j_, _k_);}];
+             function(_l_){ /*<<?>>*/ return aux(_k_, _l_);}];
      /*<<array.ml:400:16>>*/ }
-     /*<<array.ml:402:2>>*/  /*<<array.ml:402:2>>*/ var _h_ = 0;
-     /*<<array.ml:402:2>>*/ return function(_i_){
-      /*<<?>>*/ return aux(_h_, _i_);};
+     /*<<array.ml:402:2>>*/  /*<<array.ml:402:2>>*/ var _i_ = 0;
+     /*<<array.ml:402:2>>*/ return function(_j_){
+      /*<<?>>*/ return aux(_i_, _j_);};
     /*<<array.ml:402:7>>*/ }
    function to_seqi(a){
     function aux(i, param){
@@ -7604,22 +7602,22 @@
        /*<<array.ml:410:9>>*/ return 0;
       /*<<array.ml:408:14>>*/ var
        /*<<array.ml:408:14>>*/ x = a[1 + i],
-       /*<<array.ml:408:14>>*/ _f_ = i + 1 | 0;
+       /*<<array.ml:408:14>>*/ _g_ = i + 1 | 0;
       /*<<array.ml:409:6>>*/ return [0,
              [0, i, x],
-             function(_g_){ /*<<?>>*/ return aux(_f_, _g_);}];
+             function(_h_){ /*<<?>>*/ return aux(_g_, _h_);}];
      /*<<array.ml:410:16>>*/ }
-     /*<<array.ml:412:2>>*/  /*<<array.ml:412:2>>*/ var _d_ = 0;
-     /*<<array.ml:412:2>>*/ return function(_e_){
-      /*<<?>>*/ return aux(_d_, _e_);};
+     /*<<array.ml:412:2>>*/  /*<<array.ml:412:2>>*/ var _e_ = 0;
+     /*<<array.ml:412:2>>*/ return function(_f_){
+      /*<<?>>*/ return aux(_e_, _f_);};
     /*<<array.ml:412:7>>*/ }
    function of_seq(i$2){
-     /*<<array.ml:426:2>>*/ var _b_ = 0;
-    function _c_(acc, x){
+     /*<<array.ml:426:2>>*/ var _c_ = 0;
+    function _d_(acc, x){
       /*<<array.ml:426:38>>*/ return [0, x, acc];
      /*<<array.ml:426:44>>*/ }
      /*<<array.ml:426:10>>*/  /*<<array.ml:426:10>>*/ var
-     l =  /*<<array.ml:426:10>>*/ caml_call3(Stdlib_Seq[5], _c_, _b_, i$2);
+     l =  /*<<array.ml:426:10>>*/ caml_call3(Stdlib_Seq[5], _d_, _c_, i$2);
     if(! l)  /*<<array.ml:415:10>>*/ return [0];
      /*<<array.ml:417:16>>*/ var
      tl = l[2],
@@ -7718,7 +7716,7 @@
             : runtime.caml_call_gen(f, [a0, a1, a2]);
    }
    var
-    sentinal = undefined,
+    _j_ = undefined,
     global_data = runtime.caml_get_global_data(),
     Stdlib_Seq = global_data.Stdlib__Seq,
     Stdlib_List = global_data.Stdlib__List,
@@ -7761,8 +7759,8 @@
     pi = 3.141592653589793;
    function is_integer(x){
      /*<<float.ml:111:19>>*/ var
-     _aq_ = x ==  /*<<float.ml:111:23>>*/ runtime.caml_trunc_float(x) ? 1 : 0;
-    return _aq_ ? is_finite(x) : _aq_;
+     _ar_ = x ==  /*<<float.ml:111:23>>*/ runtime.caml_trunc_float(x) ? 1 : 0;
+    return _ar_ ? is_finite(x) : _ar_;
     /*<<float.ml:111:45>>*/ }
    function succ(x){
      /*<<float.ml:116:13>>*/ return  /*<<float.ml:116:13>>*/ caml_nextafter_float
@@ -7859,34 +7857,34 @@
             (10, 100, 0, x);
     /*<<float.ml:164:41>>*/ }
    function unsafe_fill(a, ofs, len, v){
-     /*<<float.ml:178:4>>*/ var _ao_ = (ofs + len | 0) - 1 | 0;
-    if(_ao_ >= ofs){
+     /*<<float.ml:178:4>>*/ var _ap_ = (ofs + len | 0) - 1 | 0;
+    if(_ap_ >= ofs){
      var i = ofs;
      for(;;){
        /*<<float.ml:178:36>>*/ a[1 + i] = v;
-       /*<<float.ml:178:36>>*/  /*<<float.ml:178:36>>*/ var _ap_ = i + 1 | 0;
-      if(_ao_ === i) break;
-      var i = _ap_;
+       /*<<float.ml:178:36>>*/  /*<<float.ml:178:36>>*/ var _aq_ = i + 1 | 0;
+      if(_ap_ === i) break;
+      var i = _aq_;
      }
     }
     return 0;
     /*<<float.ml:178:57>>*/ }
    function check(a, ofs, len, msg){
-     /*<<float.ml:184:4>>*/ var _ak_ = ofs < 0 ? 1 : 0;
-    if(_ak_)
-     var _al_ = _ak_;
+     /*<<float.ml:184:4>>*/ var _al_ = ofs < 0 ? 1 : 0;
+    if(_al_)
+     var _am_ = _al_;
     else{
-     var _am_ = len < 0 ? 1 : 0;
-     if(_am_)
-      var _al_ = _am_;
+     var _an_ = len < 0 ? 1 : 0;
+     if(_an_)
+      var _am_ = _an_;
      else
       var
-       _an_ = (ofs + len | 0) < 0 ? 1 : 0,
-       _al_ = _an_ || (a.length - 1 < (ofs + len | 0) ? 1 : 0);
+       _ao_ = (ofs + len | 0) < 0 ? 1 : 0,
+       _am_ = _ao_ || (a.length - 1 < (ofs + len | 0) ? 1 : 0);
     }
-    return _al_
-            ? ( /*<<float.ml:185:6>>*/ caml_call1(Stdlib[1], msg), sentinal)
-            : _al_;
+    return _am_
+            ? ( /*<<float.ml:185:6>>*/ caml_call1(Stdlib[1], msg), _j_)
+            : _am_;
     /*<<float.ml:185:21>>*/ }
    function make(n, v){
      /*<<float.ml:188:4>>*/  /*<<float.ml:188:17>>*/ var
@@ -7901,16 +7899,16 @@
      /*<<float.ml:195:16>>*/ var
       /*<<float.ml:195:16>>*/ res =
         /*<<float.ml:195:16>>*/ caml_floatarray_create(l),
-      /*<<float.ml:196:6>>*/ _ai_ = l - 1 | 0,
-      /*<<float.ml:195:16>>*/ _ah_ = 0;
-    if(_ai_ >= 0){
-     var i = _ah_;
+      /*<<float.ml:196:6>>*/ _aj_ = l - 1 | 0,
+      /*<<float.ml:195:16>>*/ _ai_ = 0;
+    if(_aj_ >= 0){
+     var i = _ai_;
      for(;;){
        /*<<float.ml:197:8>>*/ res[1 + i] =
         /*<<float.ml:197:25>>*/ caml_call1(f, i);
-       /*<<float.ml:197:8>>*/  /*<<float.ml:197:8>>*/ var _aj_ = i + 1 | 0;
-      if(_ai_ === i) break;
-      var i = _aj_;
+       /*<<float.ml:197:8>>*/  /*<<float.ml:197:8>>*/ var _ak_ = i + 1 | 0;
+      if(_aj_ === i) break;
+      var i = _ak_;
      }
     }
      /*<<float.ml:199:6>>*/ return res;
@@ -7992,11 +7990,11 @@
             (src, sofs, dst, dofs, len);
     /*<<float.ml:250:37>>*/ }
    function to_list(a){
-     /*<<float.ml:253:25>>*/ function _af_(_ag_){
-      /*<<?>>*/ return a[1 + _ag_];
+     /*<<float.ml:253:25>>*/ function _ag_(_ah_){
+      /*<<?>>*/ return a[1 + _ah_];
     }
      /*<<float.ml:253:25>>*/ return  /*<<float.ml:253:25>>*/ caml_call2
-            (Stdlib_List[10], a.length - 1, _af_);
+            (Stdlib_List[10], a.length - 1, _ag_);
     /*<<float.ml:253:39>>*/ }
    function of_list(l){
      /*<<float.ml:256:4>>*/ var
@@ -8017,16 +8015,16 @@
     /*<<float.ml:262:12>>*/ }
    function iter(f, a){
      /*<<float.ml:266:4>>*/ var
-     _ad_ = a.length - 1 - 1 | 0,
-      /*<<float.ml:266:4>>*/ _ac_ = 0;
-    if(_ad_ >= 0){
-     var i = _ac_;
+     _ae_ = a.length - 1 - 1 | 0,
+      /*<<float.ml:266:4>>*/ _ad_ = 0;
+    if(_ae_ >= 0){
+     var i = _ad_;
      for(;;){
        /*<<float.ml:266:33>>*/  /*<<float.ml:266:33>>*/ caml_call1
        (f, a[1 + i]);
-       /*<<float.ml:266:33>>*/  /*<<float.ml:266:33>>*/ var _ae_ = i + 1 | 0;
-      if(_ad_ === i) break;
-      var i = _ae_;
+       /*<<float.ml:266:33>>*/  /*<<float.ml:266:33>>*/ var _af_ = i + 1 | 0;
+      if(_ae_ === i) break;
+      var i = _af_;
      }
     }
     return 0;
@@ -8036,16 +8034,16 @@
       /*<<float.ml:271:6>>*/ return  /*<<float.ml:271:6>>*/ caml_call1
              (Stdlib[1], cst_Float_Array_iter2_arrays_m);
      /*<<float.ml:273:6>>*/ var
-     _aa_ = a.length - 1 - 1 | 0,
-      /*<<float.ml:273:6>>*/ _$_ = 0;
-    if(_aa_ >= 0){
-     var i = _$_;
+     _ab_ = a.length - 1 - 1 | 0,
+      /*<<float.ml:273:6>>*/ _aa_ = 0;
+    if(_ab_ >= 0){
+     var i = _aa_;
      for(;;){
        /*<<float.ml:273:35>>*/  /*<<float.ml:273:35>>*/ caml_call2
        (f, a[1 + i], b[1 + i]);
-       /*<<float.ml:273:35>>*/  /*<<float.ml:273:35>>*/ var _ab_ = i + 1 | 0;
-      if(_aa_ === i) break;
-      var i = _ab_;
+       /*<<float.ml:273:35>>*/  /*<<float.ml:273:35>>*/ var _ac_ = i + 1 | 0;
+      if(_ab_ === i) break;
+      var i = _ac_;
      }
     }
     return 0;
@@ -8055,16 +8053,16 @@
      l = a.length - 1,
       /*<<float.ml:277:12>>*/ r =
         /*<<float.ml:277:12>>*/ caml_floatarray_create(l),
-      /*<<float.ml:278:4>>*/ _Z_ = l - 1 | 0,
-      /*<<float.ml:277:12>>*/ _Y_ = 0;
-    if(_Z_ >= 0){
-     var i = _Y_;
+      /*<<float.ml:278:4>>*/ ___ = l - 1 | 0,
+      /*<<float.ml:277:12>>*/ _Z_ = 0;
+    if(___ >= 0){
+     var i = _Z_;
      for(;;){
        /*<<float.ml:279:6>>*/ r[1 + i] =
         /*<<float.ml:279:21>>*/ caml_call1(f, a[1 + i]);
-       /*<<float.ml:279:6>>*/  /*<<float.ml:279:6>>*/ var ___ = i + 1 | 0;
-      if(_Z_ === i) break;
-      var i = ___;
+       /*<<float.ml:279:6>>*/  /*<<float.ml:279:6>>*/ var _$_ = i + 1 | 0;
+      if(___ === i) break;
+      var i = _$_;
      }
     }
      /*<<float.ml:281:4>>*/ return r;
@@ -8079,32 +8077,32 @@
      /*<<float.ml:289:14>>*/ var
       /*<<float.ml:289:14>>*/ r =
         /*<<float.ml:289:14>>*/ caml_floatarray_create(la),
-      /*<<float.ml:290:6>>*/ _W_ = la - 1 | 0,
-      /*<<float.ml:289:14>>*/ _V_ = 0;
-    if(_W_ >= 0){
-     var i = _V_;
+      /*<<float.ml:290:6>>*/ _X_ = la - 1 | 0,
+      /*<<float.ml:289:14>>*/ _W_ = 0;
+    if(_X_ >= 0){
+     var i = _W_;
      for(;;){
        /*<<float.ml:291:8>>*/ r[1 + i] =
         /*<<float.ml:291:23>>*/ caml_call2(f, a[1 + i], b[1 + i]);
-       /*<<float.ml:291:8>>*/  /*<<float.ml:291:8>>*/ var _X_ = i + 1 | 0;
-      if(_W_ === i) break;
-      var i = _X_;
+       /*<<float.ml:291:8>>*/  /*<<float.ml:291:8>>*/ var _Y_ = i + 1 | 0;
+      if(_X_ === i) break;
+      var i = _Y_;
      }
     }
      /*<<float.ml:293:6>>*/ return r;
     /*<<float.ml:294:7>>*/ }
    function iteri(f, a){
      /*<<float.ml:298:4>>*/ var
-     _T_ = a.length - 1 - 1 | 0,
-      /*<<float.ml:298:4>>*/ _S_ = 0;
-    if(_T_ >= 0){
-     var i = _S_;
+     _U_ = a.length - 1 - 1 | 0,
+      /*<<float.ml:298:4>>*/ _T_ = 0;
+    if(_U_ >= 0){
+     var i = _T_;
      for(;;){
        /*<<float.ml:298:33>>*/  /*<<float.ml:298:33>>*/ caml_call2
        (f, i, a[1 + i]);
-       /*<<float.ml:298:33>>*/  /*<<float.ml:298:33>>*/ var _U_ = i + 1 | 0;
-      if(_T_ === i) break;
-      var i = _U_;
+       /*<<float.ml:298:33>>*/  /*<<float.ml:298:33>>*/ var _V_ = i + 1 | 0;
+      if(_U_ === i) break;
+      var i = _V_;
      }
     }
     return 0;
@@ -8114,16 +8112,16 @@
      l = a.length - 1,
       /*<<float.ml:302:12>>*/ r =
         /*<<float.ml:302:12>>*/ caml_floatarray_create(l),
-      /*<<float.ml:303:4>>*/ _Q_ = l - 1 | 0,
-      /*<<float.ml:302:12>>*/ _P_ = 0;
-    if(_Q_ >= 0){
-     var i = _P_;
+      /*<<float.ml:303:4>>*/ _R_ = l - 1 | 0,
+      /*<<float.ml:302:12>>*/ _Q_ = 0;
+    if(_R_ >= 0){
+     var i = _Q_;
      for(;;){
        /*<<float.ml:304:6>>*/ r[1 + i] =
         /*<<float.ml:304:21>>*/ caml_call2(f, i, a[1 + i]);
-       /*<<float.ml:304:6>>*/  /*<<float.ml:304:6>>*/ var _R_ = i + 1 | 0;
-      if(_Q_ === i) break;
-      var i = _R_;
+       /*<<float.ml:304:6>>*/  /*<<float.ml:304:6>>*/ var _S_ = i + 1 | 0;
+      if(_R_ === i) break;
+      var i = _S_;
      }
     }
      /*<<float.ml:306:4>>*/ return r;
@@ -8131,15 +8129,15 @@
    function fold_left(f, x, a){
      /*<<float.ml:310:4>>*/ var
       /*<<float.ml:310:12>>*/ r = [0, x],
-     _N_ = a.length - 1 - 1 | 0,
-      /*<<float.ml:310:12>>*/ _M_ = 0;
-    if(_N_ >= 0){
-     var i = _M_;
+     _O_ = a.length - 1 - 1 | 0,
+      /*<<float.ml:310:12>>*/ _N_ = 0;
+    if(_O_ >= 0){
+     var i = _N_;
      for(;;){
       r[1] =  /*<<float.ml:312:11>>*/ caml_call2(f, r[1], a[1 + i]);
-       /*<<float.ml:311:4>>*/  /*<<float.ml:311:4>>*/ var _O_ = i + 1 | 0;
-      if(_N_ === i) break;
-      var i = _O_;
+       /*<<float.ml:311:4>>*/  /*<<float.ml:311:4>>*/ var _P_ = i + 1 | 0;
+      if(_O_ === i) break;
+      var i = _P_;
      }
     }
     return r[1];
@@ -8147,14 +8145,14 @@
    function fold_right(f, a, x){
      /*<<float.ml:318:4>>*/ var
       /*<<float.ml:318:12>>*/ r = [0, x],
-      /*<<float.ml:319:4>>*/ _K_ = a.length - 1 - 1 | 0;
-    if(_K_ >= 0){
-     var i = _K_;
+      /*<<float.ml:319:4>>*/ _L_ = a.length - 1 - 1 | 0;
+    if(_L_ >= 0){
+     var i = _L_;
      for(;;){
       r[1] =  /*<<float.ml:320:11>>*/ caml_call2(f, a[1 + i], r[1]);
-       /*<<float.ml:319:4>>*/  /*<<float.ml:319:4>>*/ var _L_ = i - 1 | 0;
+       /*<<float.ml:319:4>>*/  /*<<float.ml:319:4>>*/ var _M_ = i - 1 | 0;
       if(0 === i) break;
-      var i = _L_;
+      var i = _M_;
      }
     }
     return r[1];
@@ -8242,9 +8240,9 @@
       /*<<float.ml:375:38>>*/ throw  /*<<float.ml:375:38>>*/ caml_maybe_attach_backtrace
             ([0, Bottom, i], 1);
      /*<<float.ml:375:54>>*/ }
-    var l = a.length - 1, _E_ = ((l + 1 | 0) / 3 | 0) - 1 | 0;
-    if(_E_ >= 0){
-     var i$6 = _E_;
+    var l = a.length - 1, _F_ = ((l + 1 | 0) / 3 | 0) - 1 | 0;
+    if(_F_ >= 0){
+     var i$6 = _F_;
      for(;;){
        /*<<float.ml:404:52>>*/  /*<<float.ml:404:52>>*/ var
        e$1 =  /*<<float.ml:404:52>>*/ caml_array_get(a, i$6);
@@ -8274,14 +8272,14 @@
         /*<<float.ml:386:63>>*/  /*<<float.ml:386:63>>*/ caml_array_set
         (a, i$0, e$1);
       }
-       /*<<float.ml:404:40>>*/  /*<<float.ml:404:40>>*/ var _J_ = i$6 - 1 | 0;
+       /*<<float.ml:404:40>>*/  /*<<float.ml:404:40>>*/ var _K_ = i$6 - 1 | 0;
       if(0 === i$6) break;
-      var i$6 = _J_;
+      var i$6 = _K_;
      }
     }
-     /*<<float.ml:405:4>>*/  /*<<float.ml:405:4>>*/ var _F_ = l - 1 | 0;
-    if(_F_ >= 2){
-     var i$4 = _F_;
+     /*<<float.ml:405:4>>*/  /*<<float.ml:405:4>>*/ var _G_ = l - 1 | 0;
+    if(_G_ >= 2){
+     var i$4 = _G_;
      a:
      for(;;){
        /*<<float.ml:406:14>>*/  /*<<float.ml:406:14>>*/ var
@@ -8322,25 +8320,25 @@
           /*<<float.ml:398:51>>*/  /*<<float.ml:398:51>>*/ caml_array_set
           (a, 0, e$0);
         }
-         /*<<float.ml:405:4>>*/  /*<<float.ml:405:4>>*/ var _I_ = i$4 - 1 | 0;
+         /*<<float.ml:405:4>>*/  /*<<float.ml:405:4>>*/ var _J_ = i$4 - 1 | 0;
         if(2 === i$4) break a;
-        var i$4 = _I_;
+        var i$4 = _J_;
         break;
        }
       }
      }
     }
-    var _G_ = 1 < l ? 1 : 0;
-    if(_G_){
+    var _H_ = 1 < l ? 1 : 0;
+    if(_H_){
       /*<<float.ml:410:27>>*/  /*<<float.ml:410:27>>*/ var
       e =  /*<<float.ml:410:27>>*/ caml_array_get(a, 1);
       /*<<float.ml:410:40>>*/  /*<<float.ml:410:40>>*/ caml_array_set
       (a, 1,  /*<<float.ml:410:48>>*/ caml_array_get(a, 0));
-     var _H_ =  /*<<float.ml:410:59>>*/ caml_array_set(a, 0, e);
+     var _I_ =  /*<<float.ml:410:59>>*/ caml_array_set(a, 0, e);
     }
     else
-     var _H_ = _G_;
-     /*<<float.ml:410:59>>*/ return _H_;
+     var _I_ = _H_;
+     /*<<float.ml:410:59>>*/ return _I_;
     /*<<float.ml:410:69>>*/ }
    function stable_sort(cmp, a){
     function merge(src1ofs, src1len, src2, src2ofs, src2len, dst, dstofs){
@@ -8390,10 +8388,10 @@
      /*<<float.ml:433:72>>*/ }
     function isortto(srcofs, dst, dstofs, len){
       /*<<float.ml:436:6>>*/ var
-      _C_ = len - 1 | 0,
-       /*<<float.ml:436:6>>*/ _B_ = 0;
-     if(_C_ >= 0){
-      var i = _B_;
+      _D_ = len - 1 | 0,
+       /*<<float.ml:436:6>>*/ _C_ = 0;
+     if(_D_ >= 0){
+      var i = _C_;
       a:
       for(;;){
         /*<<float.ml:437:16>>*/ var
@@ -8417,9 +8415,9 @@
         }
          /*<<float.ml:443:8>>*/  /*<<float.ml:443:8>>*/ caml_array_set
          (dst, j[1] + 1 | 0, e);
-         /*<<float.ml:436:6>>*/  /*<<float.ml:436:6>>*/ var _D_ = i + 1 | 0;
-        if(_C_ === i) break a;
-        var i = _D_;
+         /*<<float.ml:436:6>>*/  /*<<float.ml:436:6>>*/ var _E_ = i + 1 | 0;
+        if(_D_ === i) break a;
+        var i = _E_;
         break;
        }
       }
@@ -8429,14 +8427,14 @@
     function sortto(srcofs, dst, dstofs, len){
       /*<<float.ml:447:6>>*/ if(len <= 5){
        /*<<float.ml:447:28>>*/ isortto(srcofs, dst, dstofs, len);
-       /*<<float.ml:447:28>>*/ return sentinal;
+       /*<<float.ml:447:28>>*/ return _j_;
      }
      var l1 = len / 2 | 0, l2 = len - l1 | 0;
       /*<<float.ml:450:8>>*/ sortto(srcofs + l1 | 0, dst, dstofs + l1 | 0, l2);
       /*<<float.ml:451:8>>*/ sortto(srcofs, a, srcofs + l2 | 0, l1);
       /*<<float.ml:451:8>>*/ merge
       (srcofs + l2 | 0, l1, dst, dstofs + l1 | 0, l2, dst, dstofs);
-      /*<<float.ml:451:8>>*/ return sentinal;
+      /*<<float.ml:451:8>>*/ return _j_;
      /*<<float.ml:453:9>>*/ }
     var l = a.length - 1;
     if(l <= 5)  /*<<float.ml:456:24>>*/ return isortto(0, a, 0, l);
@@ -8455,14 +8453,14 @@
        /*<<float.ml:474:11>>*/ return 0;
       /*<<float.ml:472:16>>*/ var
        /*<<float.ml:472:16>>*/ x = a[1 + i],
-       /*<<float.ml:472:16>>*/ _z_ = i + 1 | 0;
+       /*<<float.ml:472:16>>*/ _A_ = i + 1 | 0;
       /*<<float.ml:473:8>>*/ return [0,
              x,
-             function(_A_){ /*<<?>>*/ return aux(_z_, _A_);}];
+             function(_B_){ /*<<?>>*/ return aux(_A_, _B_);}];
      /*<<float.ml:474:18>>*/ }
-     /*<<float.ml:476:4>>*/  /*<<float.ml:476:4>>*/ var _x_ = 0;
-     /*<<float.ml:476:4>>*/ return function(_y_){
-      /*<<?>>*/ return aux(_x_, _y_);};
+     /*<<float.ml:476:4>>*/  /*<<float.ml:476:4>>*/ var _y_ = 0;
+     /*<<float.ml:476:4>>*/ return function(_z_){
+      /*<<?>>*/ return aux(_y_, _z_);};
     /*<<float.ml:476:9>>*/ }
    function to_seqi(a){
     function aux(i, param){
@@ -8470,23 +8468,23 @@
        /*<<float.ml:485:11>>*/ return 0;
       /*<<float.ml:483:16>>*/ var
        /*<<float.ml:483:16>>*/ x = a[1 + i],
-       /*<<float.ml:483:16>>*/ _v_ = i + 1 | 0;
+       /*<<float.ml:483:16>>*/ _w_ = i + 1 | 0;
       /*<<float.ml:484:8>>*/ return [0,
              [0, i, x],
-             function(_w_){ /*<<?>>*/ return aux(_v_, _w_);}];
+             function(_x_){ /*<<?>>*/ return aux(_w_, _x_);}];
      /*<<float.ml:485:18>>*/ }
-     /*<<float.ml:487:4>>*/  /*<<float.ml:487:4>>*/ var _t_ = 0;
-     /*<<float.ml:487:4>>*/ return function(_u_){
-      /*<<?>>*/ return aux(_t_, _u_);};
+     /*<<float.ml:487:4>>*/  /*<<float.ml:487:4>>*/ var _u_ = 0;
+     /*<<float.ml:487:4>>*/ return function(_v_){
+      /*<<?>>*/ return aux(_u_, _v_);};
     /*<<float.ml:487:9>>*/ }
    function of_seq(i$2){
-     /*<<float.ml:501:4>>*/ var _r_ = 0;
-    function _s_(acc, x){
+     /*<<float.ml:501:4>>*/ var _s_ = 0;
+    function _t_(acc, x){
       /*<<float.ml:501:40>>*/ return [0, x, acc];
      /*<<float.ml:501:46>>*/ }
      /*<<float.ml:501:12>>*/ var
       /*<<float.ml:501:12>>*/ l =
-        /*<<float.ml:501:12>>*/ caml_call3(Stdlib_Seq[5], _s_, _r_, i$2),
+        /*<<float.ml:501:12>>*/ caml_call3(Stdlib_Seq[5], _t_, _s_, i$2),
       /*<<float.ml:491:14>>*/ len =
         /*<<float.ml:491:14>>*/ caml_call1(Stdlib_List[1], l),
       /*<<float.ml:492:12>>*/ a =
@@ -8511,16 +8509,16 @@
       /*<<float.ml:508:14>>*/ r =
         /*<<float.ml:508:14>>*/ runtime.caml_make_vect
         (l,  /*<<float.ml:508:27>>*/ caml_call1(f, a[1])),
-      /*<<float.ml:509:6>>*/ _p_ = l - 1 | 0,
-      /*<<float.ml:508:14>>*/ _o_ = 1;
-    if(_p_ >= 1){
-     var i = _o_;
+      /*<<float.ml:509:6>>*/ _q_ = l - 1 | 0,
+      /*<<float.ml:508:14>>*/ _p_ = 1;
+    if(_q_ >= 1){
+     var i = _p_;
      for(;;){
        /*<<float.ml:510:8>>*/ r[1 + i] =
         /*<<float.ml:510:29>>*/ caml_call1(f, a[1 + i]);
-       /*<<float.ml:510:8>>*/  /*<<float.ml:510:8>>*/ var _q_ = i + 1 | 0;
-      if(_p_ === i) break;
-      var i = _q_;
+       /*<<float.ml:510:8>>*/  /*<<float.ml:510:8>>*/ var _r_ = i + 1 | 0;
+      if(_q_ === i) break;
+      var i = _r_;
      }
     }
      /*<<float.ml:512:6>>*/ return r;
@@ -8530,16 +8528,16 @@
      l = a.length - 1,
       /*<<float.ml:517:12>>*/ r =
         /*<<float.ml:517:12>>*/ caml_floatarray_create(l),
-      /*<<float.ml:518:4>>*/ _m_ = l - 1 | 0,
-      /*<<float.ml:517:12>>*/ _l_ = 0;
-    if(_m_ >= 0){
-     var i = _l_;
+      /*<<float.ml:518:4>>*/ _n_ = l - 1 | 0,
+      /*<<float.ml:517:12>>*/ _m_ = 0;
+    if(_n_ >= 0){
+     var i = _m_;
      for(;;){
        /*<<float.ml:519:6>>*/ r[1 + i] =
         /*<<float.ml:519:21>>*/ caml_call1(f, a[1 + i]);
-       /*<<float.ml:519:6>>*/  /*<<float.ml:519:6>>*/ var _n_ = i + 1 | 0;
-      if(_m_ === i) break;
-      var i = _n_;
+       /*<<float.ml:519:6>>*/  /*<<float.ml:519:6>>*/ var _o_ = i + 1 | 0;
+      if(_n_ === i) break;
+      var i = _o_;
      }
     }
      /*<<float.ml:521:4>>*/ return r;
@@ -8550,7 +8548,7 @@
     _e_ = caml_array_get,
     _f_ =
       [0,
-       function(_k_){ /*<<?>>*/ return _k_.length - 1;},
+       function(_l_){ /*<<?>>*/ return _l_.length - 1;},
        _e_,
        _d_,
        make,
@@ -8617,7 +8615,7 @@
        min_max_num,
        hash,
        [0,
-        function(_j_){ /*<<?>>*/ return _j_.length - 1;},
+        function(_k_){ /*<<?>>*/ return _k_.length - 1;},
         _i_,
         _h_,
         make,
@@ -9416,7 +9414,6 @@
             : runtime.caml_call_gen(f, [a0, a1, a2, a3, a4]);
    }
     /*<<parsing.ml:59:0>>*/ var
-    sentinal = undefined,
     global_data = runtime.caml_get_global_data(),
     Stdlib_Obj = global_data.Stdlib__Obj,
     Stdlib_Array = global_data.Stdlib__Array,
@@ -9443,6 +9440,7 @@
        0,
        0,
        0],
+    _a_ = undefined,
     cst_syntax_error = "syntax error";
    function grow_stacks(param){
      /*<<parsing.ml:108:2>>*/ var
@@ -9469,7 +9467,7 @@
      (Stdlib_Array[8], env[4], 0, new_end, 0, oldsize);
     env[4] = new_end;
     env[5] = newsize;
-    return sentinal;
+    return _a_;
     /*<<parsing.ml:122:28>>*/ }
    function clear_parser(param){
      /*<<parsing.ml:125:2>>*/  /*<<parsing.ml:125:2>>*/ caml_call4
@@ -9522,17 +9520,17 @@
         case 4:
          try{
            /*<<parsing.ml:143:39>>*/ var
-           _i_ = env[13],
-            /*<<parsing.ml:143:39>>*/ _j_ =
+           _j_ = env[13],
+            /*<<parsing.ml:143:39>>*/ _k_ =
               /*<<parsing.ml:143:39>>*/ caml_call1
-              (caml_check_bound(tables[1], _i_)[1 + _i_], env),
-            /*<<parsing.ml:143:39>>*/ _k_ = 4,
-           value = _j_,
-           action = _k_;
+              (caml_check_bound(tables[1], _j_)[1 + _j_], env),
+            /*<<parsing.ml:143:39>>*/ _l_ = 4,
+           value = _k_,
+           action = _l_;
          }
-         catch(_m_){
-          var _h_ = caml_wrap_exception(_m_);
-          if(_h_ !== Parse_error) throw caml_maybe_attach_backtrace(_h_, 0);
+         catch(_n_){
+          var _i_ = caml_wrap_exception(_n_);
+          if(_i_ !== Parse_error) throw caml_maybe_attach_backtrace(_i_, 0);
           var value = 0, action = 5;
          }
          var cmd = action, arg = value;
@@ -9568,9 +9566,9 @@
                 ? 1
                 : 0;
         /*<<parsing.ml:182:38>>*/  /*<<parsing.ml:182:38>>*/ var
-        _l_ =  /*<<parsing.ml:182:38>>*/ runtime.caml_obj_tag(tok);
-        /*<<parsing.ml:182:17>>*/ return caml_check_bound(tables[3], _l_)
-                [1 + _l_]
+        _m_ =  /*<<parsing.ml:182:38>>*/ runtime.caml_obj_tag(tok);
+        /*<<parsing.ml:182:17>>*/ return caml_check_bound(tables[3], _m_)
+                [1 + _m_]
                === curr_char
                ? 1
                : 0;
@@ -9580,21 +9578,21 @@
     }
     /*<<parsing.ml:184:17>>*/ }
    function peek_val(env, n){
-     /*<<parsing.ml:187:2>>*/ var _g_ = env[11] - n | 0;
-     /*<<parsing.ml:187:12>>*/ return caml_check_bound(env[2], _g_)[1 + _g_];
+     /*<<parsing.ml:187:2>>*/ var _h_ = env[11] - n | 0;
+     /*<<parsing.ml:187:12>>*/ return caml_check_bound(env[2], _h_)[1 + _h_];
     /*<<parsing.ml:187:37>>*/ }
    function symbol_start_pos(param){
      /*<<parsing.ml:190:2>>*/ var i$1 = env[12], i = i$1;
      /*<<parsing.ml:191:4>>*/ for(;;){
      if(0 >= i){
-      var _f_ = env[11];
-       /*<<parsing.ml:191:19>>*/ return caml_check_bound(env[4], _f_)[1 + _f_];
+      var _g_ = env[11];
+       /*<<parsing.ml:191:19>>*/ return caml_check_bound(env[4], _g_)[1 + _g_];
      }
       /*<<parsing.ml:193:15>>*/ var
-      _d_ = (env[11] - i | 0) + 1 | 0,
-       /*<<parsing.ml:193:15>>*/ st = caml_check_bound(env[3], _d_)[1 + _d_],
       _e_ = (env[11] - i | 0) + 1 | 0,
-       /*<<parsing.ml:194:15>>*/ en = caml_check_bound(env[4], _e_)[1 + _e_];
+       /*<<parsing.ml:193:15>>*/ st = caml_check_bound(env[3], _e_)[1 + _e_],
+      _f_ = (env[11] - i | 0) + 1 | 0,
+       /*<<parsing.ml:194:15>>*/ en = caml_check_bound(env[4], _f_)[1 + _f_];
       /*<<parsing.ml:195:9>>*/ if
       ( /*<<parsing.ml:195:9>>*/ runtime.caml_notequal(st, en))
        /*<<parsing.ml:195:23>>*/ return st;
@@ -9604,16 +9602,16 @@
     }
     /*<<parsing.ml:198:19>>*/ }
    function symbol_end_pos(param){
-     /*<<parsing.ml:200:24>>*/ var _c_ = env[11];
-     /*<<parsing.ml:200:24>>*/ return caml_check_bound(env[4], _c_)[1 + _c_];
+     /*<<parsing.ml:200:24>>*/ var _d_ = env[11];
+     /*<<parsing.ml:200:24>>*/ return caml_check_bound(env[4], _d_)[1 + _d_];
     /*<<parsing.ml:200:52>>*/ }
    function rhs_start_pos(n){
-     /*<<parsing.ml:201:22>>*/ var _b_ = env[11] - (env[12] - n | 0) | 0;
-     /*<<parsing.ml:201:22>>*/ return caml_check_bound(env[3], _b_)[1 + _b_];
+     /*<<parsing.ml:201:22>>*/ var _c_ = env[11] - (env[12] - n | 0) | 0;
+     /*<<parsing.ml:201:22>>*/ return caml_check_bound(env[3], _c_)[1 + _c_];
     /*<<parsing.ml:201:73>>*/ }
    function rhs_end_pos(n){
-     /*<<parsing.ml:202:20>>*/ var _a_ = env[11] - (env[12] - n | 0) | 0;
-     /*<<parsing.ml:202:20>>*/ return caml_check_bound(env[4], _a_)[1 + _a_];
+     /*<<parsing.ml:202:20>>*/ var _b_ = env[11] - (env[12] - n | 0) | 0;
+     /*<<parsing.ml:202:20>>*/ return caml_check_bound(env[4], _b_)[1 + _b_];
     /*<<parsing.ml:202:69>>*/ }
    function symbol_start(param){
      /*<<parsing.ml:204:22>>*/ return symbol_start_pos(0)[4];
@@ -12008,7 +12006,6 @@
             : runtime.caml_call_gen(f, [a0, a1, a2, a3, a4]);
    }
    var
-    sentinal = undefined,
     global_data = runtime.caml_get_global_data(),
     Stdlib_Bytes = global_data.Stdlib__Bytes,
     Stdlib_Sys = global_data.Stdlib__Sys,
@@ -12016,6 +12013,7 @@
     Stdlib = global_data.Stdlib,
     Stdlib_String = global_data.Stdlib__String,
     Assert_failure = global_data.Assert_failure,
+    _b_ = undefined,
     cst_Buffer_truncate = "Buffer.truncate",
     _a_ = [0, "buffer.ml", 220, 9],
     cst_Buffer_add_channel = "Buffer.add_channel",
@@ -12104,7 +12102,7 @@
        /*<<buffer.ml:99:2>>*/  /*<<buffer.ml:99:2>>*/ caml_call5
        (Stdlib_Bytes[11], b[1][1], 0, new_buffer, 0, b[2]);
       b[1] = [0, new_buffer, new_len[1]];
-      return sentinal;
+      return _b_;
      }
      new_len[1] = 2 * new_len[1] | 0;
     }
@@ -12166,14 +12164,14 @@
     }
     /*<<buffer.ml:147:30>>*/ }
    function add_substring(b, s, offset, len){
-     /*<<buffer.ml:150:2>>*/ var _r_ = offset < 0 ? 1 : 0;
-    if(_r_)
-     var _s_ = _r_;
+     /*<<buffer.ml:150:2>>*/ var _s_ = offset < 0 ? 1 : 0;
+    if(_s_)
+     var _t_ = _s_;
     else
      var
-      _t_ = len < 0 ? 1 : 0,
-      _s_ = _t_ || ((caml_ml_string_length(s) - len | 0) < offset ? 1 : 0);
-    if(_s_)
+      _u_ = len < 0 ? 1 : 0,
+      _t_ = _u_ || ((caml_ml_string_length(s) - len | 0) < offset ? 1 : 0);
+    if(_t_)
       /*<<buffer.ml:151:7>>*/  /*<<buffer.ml:151:7>>*/ caml_call1
       (Stdlib[1], cst_Buffer_add_substring_add_s);
      /*<<buffer.ml:153:2>>*/ var
@@ -12228,9 +12226,9 @@
     /*<<buffer.ml:180:46>>*/ }
    function add_channel(b, ic, to_read$1){
      /*<<buffer.ml:206:2>>*/ var
-     _p_ = to_read$1 < 0 ? 1 : 0,
-     _q_ = _p_ || (Stdlib_Sys[12] < to_read$1 ? 1 : 0);
-    if(_q_)
+     _q_ = to_read$1 < 0 ? 1 : 0,
+     _r_ = _q_ || (Stdlib_Sys[12] < to_read$1 ? 1 : 0);
+    if(_r_)
       /*<<buffer.ml:207:4>>*/  /*<<buffer.ml:207:4>>*/ caml_call1
       (Stdlib[1], cst_Buffer_add_channel);
     if(b[1][2] < (b[2] + to_read$1 | 0))
@@ -12276,8 +12274,8 @@
      i$4 = 0;
      /*<<buffer.ml:262:4>>*/ for(;;){
      if(i$4 >= lim$1){
-      var _o_ = 92 === previous ? 1 : 0;
-      return _o_ ? add_char(b, previous) : _o_;
+      var _p_ = 92 === previous ? 1 : 0;
+      return _p_ ? add_char(b, previous) : _p_;
      }
       /*<<buffer.ml:263:12>>*/  /*<<buffer.ml:263:12>>*/ var
       previous$0 =  /*<<buffer.ml:263:12>>*/ caml_string_get(s, i$4);
@@ -12417,14 +12415,14 @@
       /*<<buffer.ml:298:14>>*/ var
        /*<<buffer.ml:298:14>>*/ x =
          /*<<buffer.ml:298:14>>*/ caml_bytes_get(b[1][1], i),
-       /*<<buffer.ml:298:14>>*/ _m_ = i + 1 | 0;
+       /*<<buffer.ml:298:14>>*/ _n_ = i + 1 | 0;
       /*<<buffer.ml:299:6>>*/ return [0,
              x,
-             function(_n_){ /*<<?>>*/ return aux(_m_, _n_);}];
+             function(_o_){ /*<<?>>*/ return aux(_n_, _o_);}];
      /*<<buffer.ml:299:29>>*/ }
-     /*<<buffer.ml:301:2>>*/  /*<<buffer.ml:301:2>>*/ var _k_ = 0;
-     /*<<buffer.ml:301:2>>*/ return function(_l_){
-      /*<<?>>*/ return aux(_k_, _l_);};
+     /*<<buffer.ml:301:2>>*/  /*<<buffer.ml:301:2>>*/ var _l_ = 0;
+     /*<<buffer.ml:301:2>>*/ return function(_m_){
+      /*<<?>>*/ return aux(_l_, _m_);};
     /*<<buffer.ml:301:7>>*/ }
    function to_seqi(b){
     function aux(i, param){
@@ -12433,21 +12431,21 @@
       /*<<buffer.ml:308:14>>*/ var
        /*<<buffer.ml:308:14>>*/ x =
          /*<<buffer.ml:308:14>>*/ caml_bytes_get(b[1][1], i),
-       /*<<buffer.ml:308:14>>*/ _i_ = i + 1 | 0;
+       /*<<buffer.ml:308:14>>*/ _j_ = i + 1 | 0;
       /*<<buffer.ml:309:6>>*/ return [0,
              [0, i, x],
-             function(_j_){ /*<<?>>*/ return aux(_i_, _j_);}];
+             function(_k_){ /*<<?>>*/ return aux(_j_, _k_);}];
      /*<<buffer.ml:309:33>>*/ }
-     /*<<buffer.ml:311:2>>*/  /*<<buffer.ml:311:2>>*/ var _g_ = 0;
-     /*<<buffer.ml:311:2>>*/ return function(_h_){
-      /*<<?>>*/ return aux(_g_, _h_);};
+     /*<<buffer.ml:311:2>>*/  /*<<buffer.ml:311:2>>*/ var _h_ = 0;
+     /*<<buffer.ml:311:2>>*/ return function(_i_){
+      /*<<?>>*/ return aux(_h_, _i_);};
     /*<<buffer.ml:311:7>>*/ }
    function add_seq(b, seq){
-     /*<<buffer.ml:313:29>>*/ function _e_(_f_){
-      /*<<?>>*/ return add_char(b, _f_);
+     /*<<buffer.ml:313:29>>*/ function _f_(_g_){
+      /*<<?>>*/ return add_char(b, _g_);
     }
      /*<<buffer.ml:313:20>>*/ return  /*<<buffer.ml:313:20>>*/ caml_call2
-            (Stdlib_Seq[4], _e_, seq);
+            (Stdlib_Seq[4], _f_, seq);
     /*<<buffer.ml:313:45>>*/ }
    function of_seq(i){
      /*<<buffer.ml:316:2>>*/  /*<<buffer.ml:316:10>>*/ var b = create(32);
@@ -12526,8 +12524,8 @@
     return 0;
     /*<<buffer.ml:378:28>>*/ }
    function add_int16_le(b, x){
-     /*<<buffer.ml:381:2>>*/ var _d_ = Stdlib_Sys[11] ? caml_bswap16(x) : x;
-    return add_int16_ne(b, _d_);
+     /*<<buffer.ml:381:2>>*/ var _e_ = Stdlib_Sys[11] ? caml_bswap16(x) : x;
+    return add_int16_ne(b, _e_);
     /*<<buffer.ml:381:57>>*/ }
    function add_int16_be(b, x){
      /*<<buffer.ml:384:2>>*/ var x$0 = Stdlib_Sys[11] ? x : caml_bswap16(x);
@@ -12535,8 +12533,8 @@
     /*<<buffer.ml:384:57>>*/ }
    function add_int32_le(b, x){
      /*<<buffer.ml:387:2>>*/ var
-     _c_ = Stdlib_Sys[11] ?  /*<<buffer.ml:387:41>>*/ caml_int32_bswap(x) : x;
-     /*<<buffer.ml:387:41>>*/ return add_int32_ne(b, _c_);
+     _d_ = Stdlib_Sys[11] ?  /*<<buffer.ml:387:41>>*/ caml_int32_bswap(x) : x;
+     /*<<buffer.ml:387:41>>*/ return add_int32_ne(b, _d_);
     /*<<buffer.ml:387:57>>*/ }
    function add_int32_be(b, x){
      /*<<buffer.ml:390:2>>*/ var
@@ -12545,8 +12543,8 @@
     /*<<buffer.ml:390:57>>*/ }
    function add_int64_le(b, x){
      /*<<buffer.ml:393:2>>*/ var
-     _b_ = Stdlib_Sys[11] ?  /*<<buffer.ml:393:41>>*/ caml_int64_bswap(x) : x;
-     /*<<buffer.ml:393:41>>*/ return add_int64_ne(b, _b_);
+     _c_ = Stdlib_Sys[11] ?  /*<<buffer.ml:393:41>>*/ caml_int64_bswap(x) : x;
+     /*<<buffer.ml:393:41>>*/ return add_int64_ne(b, _c_);
     /*<<buffer.ml:393:57>>*/ }
    function add_int64_be(b, x){
      /*<<buffer.ml:396:2>>*/ var
@@ -12787,7 +12785,7 @@
             : runtime.caml_call_gen(f, [a0, a1, a2, a3, a4]);
    }
    var
-    sentinal = undefined,
+    _a_ = undefined,
     global_data = runtime.caml_get_global_data(),
     Stdlib_Mutex = global_data.Stdlib__Mutex,
     Stdlib_Condition = global_data.Stdlib__Condition,
@@ -12807,7 +12805,7 @@
      /*<<domain.ml:59:4>>*/  /*<<domain.ml:59:13>>*/ var
      st =  /*<<domain.ml:59:13>>*/ caml_make_vect(8, unique_value);
      /*<<domain.ml:60:4>>*/  /*<<domain.ml:60:4>>*/ caml_domain_dls_set(st);
-     /*<<domain.ml:60:4>>*/ return sentinal;
+     /*<<domain.ml:60:4>>*/ return _a_;
     /*<<domain.ml:60:20>>*/ }
     /*<<domain.ml:62:10>>*/ create_dls(0);
     /*<<domain.ml:66:20>>*/ var
@@ -12896,7 +12894,7 @@
      /*<<domain.ml:147:27>>*/ first_spawn_function =
       [0,
        function(param){
-         /*<<domain.ml:147:42>>*/ return sentinal;
+         /*<<domain.ml:147:42>>*/ return _a_;
         /*<<domain.ml:147:44>>*/ }];
    function before_first_spawn(f){
      /*<<domain.ml:150:2>>*/ if
@@ -12917,7 +12915,7 @@
     at_exit_key =
       new_key
        (0,
-        function(param, _e_){
+        function(param, _f_){
           /*<<domain.ml:166:52>>*/ return 0;
          /*<<domain.ml:166:54>>*/ });
    function at_exit(f){
@@ -12952,8 +12950,8 @@
        /*<<domain.ml:163:41>>*/ };
     }
      /*<<domain.ml:124:6>>*/  /*<<domain.ml:124:6>>*/ var
-     _a_ =  /*<<domain.ml:124:6>>*/ caml_call1(Stdlib_Atomic[2], parent_keys);
-    function _b_(param){
+     _b_ =  /*<<domain.ml:124:6>>*/ caml_call1(Stdlib_Atomic[2], parent_keys);
+    function _c_(param){
       /*<<domain.ml:122:6>>*/ var split = param[2], k = param[1], idx = k[1];
       /*<<domain.ml:123:11>>*/ return [0,
              idx,
@@ -12961,7 +12959,7 @@
      /*<<domain.ml:123:43>>*/ }
      /*<<domain.ml:124:6>>*/ var
       /*<<domain.ml:124:6>>*/ pk =
-        /*<<domain.ml:124:6>>*/ caml_call2(Stdlib_List[19], _b_, _a_),
+        /*<<domain.ml:124:6>>*/ caml_call2(Stdlib_List[19], _c_, _b_),
       /*<<domain.ml:193:19>>*/ term_mutex =
         /*<<domain.ml:193:19>>*/ caml_call1(Stdlib_Mutex[1], 0),
       /*<<domain.ml:194:23>>*/ term_condition =
@@ -12973,7 +12971,7 @@
        /*<<domain.ml:198:4>>*/ try{
         /*<<domain.ml:200:8>>*/ create_dls(0);
        var
-        _c_ =
+        _d_ =
           function(param){
             /*<<domain.ml:128:6>>*/ var
             v = param[2],
@@ -12983,7 +12981,7 @@
             /*<<domain.ml:129:35>>*/ return 0;
            /*<<domain.ml:129:49>>*/ };
         /*<<domain.ml:127:4>>*/  /*<<domain.ml:127:4>>*/ caml_call2
-        (Stdlib_List[17], _c_, pk);
+        (Stdlib_List[17], _d_, pk);
         /*<<domain.ml:202:18>>*/  /*<<domain.ml:202:18>>*/ var
         res =  /*<<domain.ml:202:18>>*/ caml_call1(f, 0);
       }
@@ -13000,8 +12998,8 @@
      catch(ex){
        /*<<domain.ml:215:10>>*/ var
        ex$0 = caml_wrap_exception(ex),
-        /*<<domain.ml:215:10>>*/ _d_ = 0 === result[0] ? [1, ex$0] : result,
-       result$0 = _d_;
+        /*<<domain.ml:215:10>>*/ _e_ = 0 === result[0] ? [1, ex$0] : result,
+       result$0 = _e_;
      }
       /*<<domain.ml:230:4>>*/  /*<<domain.ml:230:4>>*/ caml_call1
       (Stdlib_Mutex[2], term_mutex);
@@ -13132,7 +13130,7 @@
             : runtime.caml_call_gen(f, [a0, a1, a2, a3, a4]);
    }
    var
-    sentinal = undefined,
+    _$_ = undefined,
     global_data = runtime.caml_get_global_data(),
     cst$9 = "%{",
     cst$10 = "%}",
@@ -13459,14 +13457,14 @@
      /*<<camlinternalFormat.ml:28:2>>*/ var
      str_ind = c >>> 3 | 0,
      mask = 1 << (c & 7),
-      /*<<camlinternalFormat.ml:31:30>>*/ _dS_ =
+      /*<<camlinternalFormat.ml:31:30>>*/ _dT_ =
         /*<<camlinternalFormat.ml:31:30>>*/ runtime.caml_bytes_get
         (char_set, str_ind)
        | mask;
      /*<<camlinternalFormat.ml:30:2>>*/ return  /*<<camlinternalFormat.ml:30:2>>*/ caml_bytes_set
             (char_set,
              str_ind,
-              /*<<camlinternalFormat.ml:31:4>>*/ caml_call1(Stdlib[29], _dS_));
+              /*<<camlinternalFormat.ml:31:4>>*/ caml_call1(Stdlib[29], _dT_));
     /*<<camlinternalFormat.ml:31:69>>*/ }
    function freeze_char_set(char_set){
      /*<<camlinternalFormat.ml:34:2>>*/ return  /*<<camlinternalFormat.ml:34:2>>*/ caml_call1
@@ -13478,19 +13476,19 @@
      i = 0;
     for(;;){
       /*<<camlinternalFormat.ml:41:32>>*/  /*<<camlinternalFormat.ml:41:32>>*/ var
-      _dQ_ =
+      _dR_ =
          /*<<camlinternalFormat.ml:41:32>>*/ caml_string_get(char_set, i)
         ^ 255;
       /*<<camlinternalFormat.ml:40:4>>*/  /*<<camlinternalFormat.ml:40:4>>*/ caml_bytes_set
       (char_set$0,
        i,
-        /*<<camlinternalFormat.ml:41:6>>*/ caml_call1(Stdlib[29], _dQ_));
+        /*<<camlinternalFormat.ml:41:6>>*/ caml_call1(Stdlib[29], _dR_));
       /*<<camlinternalFormat.ml:40:4>>*/  /*<<camlinternalFormat.ml:40:4>>*/ var
-      _dR_ = i + 1 | 0;
+      _dS_ = i + 1 | 0;
      if(31 === i)
        /*<<camlinternalFormat.ml:43:2>>*/ return  /*<<camlinternalFormat.ml:43:2>>*/ caml_call1
               (Stdlib_Bytes[44], char_set$0);
-     var i = _dR_;
+     var i = _dS_;
     }
     /*<<camlinternalFormat.ml:43:34>>*/ }
    function is_in_char_set(char_set, c){
@@ -13550,11 +13548,11 @@
       case 6:
        var prec_opt = ign[2], pad_opt$5 = ign[1];
        if(prec_opt)
-        var ndec = prec_opt[1], _dP_ = [0, ndec];
+        var ndec = prec_opt[1], _dQ_ = [0, ndec];
        else
-        var _dP_ = 0;
+        var _dQ_ = 0;
         /*<<camlinternalFormat.ml:97:4>>*/ return [0,
-               [8, _a_, pad_of_pad_opt(pad_opt$5), _dP_, fmt]];
+               [8, _a_, pad_of_pad_opt(pad_opt$5), _dQ_, fmt]];
       case 7:
        var pad_opt$6 = ign[1];
         /*<<camlinternalFormat.ml:101:4>>*/ return [0,
@@ -13599,14 +13597,14 @@
       (Stdlib_Bytes[11], buf[2], 0, new_str, 0, len);
      buf[2] = new_str;
     }
-    return sentinal;
+    return _$_;
     /*<<camlinternalFormat.ml:267:3>>*/ }
    function buffer_add_char(buf, c){
      /*<<camlinternalFormat.ml:271:2>>*/ buffer_check_size(buf, 1);
      /*<<camlinternalFormat.ml:272:2>>*/  /*<<camlinternalFormat.ml:272:2>>*/ caml_bytes_set
      (buf[2], buf[1], c);
     buf[1] = buf[1] + 1 | 0;
-    return sentinal;
+    return _$_;
     /*<<camlinternalFormat.ml:273:24>>*/ }
    function buffer_add_string(buf, s){
      /*<<camlinternalFormat.ml:277:2>>*/ var
@@ -13615,7 +13613,7 @@
      /*<<camlinternalFormat.ml:279:2>>*/  /*<<camlinternalFormat.ml:279:2>>*/ caml_call5
      (Stdlib_String[48], s, 0, buf[2], buf[1], str_len);
     buf[1] = buf[1] + str_len | 0;
-    return sentinal;
+    return _$_;
     /*<<camlinternalFormat.ml:280:30>>*/ }
    function buffer_contents(buf){
      /*<<camlinternalFormat.ml:284:2>>*/ return caml_call3
@@ -13672,64 +13670,64 @@
      /*<<camlinternalFormat.ml:374:29>>*/ switch(padty){
       case 0:
         /*<<camlinternalFormat.ml:375:13>>*/ buffer_add_char(buf, 45);
-        /*<<camlinternalFormat.ml:375:13>>*/ return sentinal;
+        /*<<camlinternalFormat.ml:375:13>>*/ return _$_;
       case 1:
-        /*<<camlinternalFormat.ml:376:13>>*/ return sentinal;
+        /*<<camlinternalFormat.ml:376:13>>*/ return _$_;
       default:
         /*<<camlinternalFormat.ml:377:13>>*/ buffer_add_char(buf, 48);
-        /*<<camlinternalFormat.ml:377:13>>*/ return sentinal;
+        /*<<camlinternalFormat.ml:377:13>>*/ return _$_;
     }
     /*<<camlinternalFormat.ml:377:36>>*/ }
    function bprint_ignored_flag(buf, ign_flag){
      /*<<camlinternalFormat.ml:381:2>>*/ return ign_flag
-            ? (buffer_add_char(buf, 95), sentinal)
+            ? (buffer_add_char(buf, 95), _$_)
             : ign_flag;
     /*<<camlinternalFormat.ml:381:42>>*/ }
    function bprint_pad_opt(buf, pad_opt){
      /*<<camlinternalFormat.ml:385:33>>*/ if(! pad_opt)
-      /*<<camlinternalFormat.ml:386:12>>*/ return sentinal;
+      /*<<camlinternalFormat.ml:386:12>>*/ return _$_;
     var width = pad_opt[1];
      /*<<camlinternalFormat.ml:387:40>>*/ buffer_add_string
      (buf,
        /*<<camlinternalFormat.ml:387:40>>*/ caml_call1(Stdlib_Int[12], width));
-     /*<<camlinternalFormat.ml:387:40>>*/ return sentinal;
+     /*<<camlinternalFormat.ml:387:40>>*/ return _$_;
     /*<<camlinternalFormat.ml:387:61>>*/ }
    function bprint_padding(buf, pad){
      /*<<camlinternalFormat.ml:393:15>>*/ if(typeof pad === "number")
-      /*<<camlinternalFormat.ml:394:18>>*/ return sentinal;
+      /*<<camlinternalFormat.ml:394:18>>*/ return _$_;
     if(0 === pad[0]){
      var n = pad[2], padty = pad[1];
       /*<<camlinternalFormat.ml:396:4>>*/ bprint_padty(buf, padty);
       /*<<camlinternalFormat.ml:397:26>>*/ buffer_add_string
       (buf,
         /*<<camlinternalFormat.ml:397:26>>*/ caml_call1(Stdlib_Int[12], n));
-      /*<<camlinternalFormat.ml:397:26>>*/ return sentinal;
+      /*<<camlinternalFormat.ml:397:26>>*/ return _$_;
     }
     var padty$0 = pad[1];
      /*<<camlinternalFormat.ml:399:4>>*/ bprint_padty(buf, padty$0);
      /*<<camlinternalFormat.ml:399:4>>*/ buffer_add_char(buf, 42);
-     /*<<camlinternalFormat.ml:399:4>>*/ return sentinal;
+     /*<<camlinternalFormat.ml:399:4>>*/ return _$_;
     /*<<camlinternalFormat.ml:400:27>>*/ }
    function bprint_precision(buf, prec){
      /*<<camlinternalFormat.ml:404:18>>*/ if(typeof prec === "number")
-     return prec ? (buffer_add_string(buf, cst), sentinal) : sentinal;
+     return prec ? (buffer_add_string(buf, cst), _$_) : _$_;
     var n = prec[1];
      /*<<camlinternalFormat.ml:407:4>>*/ buffer_add_char(buf, 46);
      /*<<camlinternalFormat.ml:408:26>>*/ buffer_add_string
      (buf,
        /*<<camlinternalFormat.ml:408:26>>*/ caml_call1(Stdlib_Int[12], n));
-     /*<<camlinternalFormat.ml:408:26>>*/ return sentinal;
+     /*<<camlinternalFormat.ml:408:26>>*/ return _$_;
     /*<<camlinternalFormat.ml:410:30>>*/ }
    function bprint_iconv_flag(buf, iconv){
      /*<<camlinternalFormat.ml:415:34>>*/ switch(iconv){
       case 1:
       case 4:
         /*<<camlinternalFormat.ml:416:23>>*/ buffer_add_char(buf, 43);
-        /*<<camlinternalFormat.ml:416:23>>*/ return sentinal;
+        /*<<camlinternalFormat.ml:416:23>>*/ return _$_;
       case 2:
       case 5:
         /*<<camlinternalFormat.ml:417:23>>*/ buffer_add_char(buf, 32);
-        /*<<camlinternalFormat.ml:417:23>>*/ return sentinal;
+        /*<<camlinternalFormat.ml:417:23>>*/ return _$_;
       case 7:
       case 9:
       case 11:
@@ -13737,8 +13735,8 @@
       case 14:
       case 15:
         /*<<camlinternalFormat.ml:419:6>>*/ buffer_add_char(buf, 35);
-        /*<<camlinternalFormat.ml:419:6>>*/ return sentinal;
-      default:  /*<<camlinternalFormat.ml:420:53>>*/ return sentinal;
+        /*<<camlinternalFormat.ml:419:6>>*/ return _$_;
+      default:  /*<<camlinternalFormat.ml:420:53>>*/ return _$_;
     }
     /*<<camlinternalFormat.ml:420:55>>*/ }
    function bprint_altint_fmt(buf, ign_flag, iconv, pad, prec, c){
@@ -13750,7 +13748,7 @@
      /*<<camlinternalFormat.ml:438:2>>*/ buffer_add_char(buf, c);
      /*<<camlinternalFormat.ml:439:22>>*/ buffer_add_char
      (buf, char_of_iconv(iconv));
-     /*<<camlinternalFormat.ml:439:22>>*/ return sentinal;
+     /*<<camlinternalFormat.ml:439:22>>*/ return _$_;
     /*<<camlinternalFormat.ml:439:43>>*/ }
    function bprint_fconv_flag(buf, fconv){
      /*<<camlinternalFormat.ml:445:2>>*/ switch(fconv[1]){
@@ -13759,7 +13757,7 @@
         /*<<camlinternalFormat.ml:446:20>>*/ buffer_add_char(buf, 43); break;
       default:  /*<<camlinternalFormat.ml:447:20>>*/ buffer_add_char(buf, 32);
     }
-    return 8 <= fconv[2] ? (buffer_add_char(buf, 35), sentinal) : sentinal;
+    return 8 <= fconv[2] ? (buffer_add_char(buf, 35), _$_) : _$_;
     /*<<camlinternalFormat.ml:452:37>>*/ }
    function string_of_formatting_lit(formatting_lit){
      /*<<camlinternalFormat.ml:465:46>>*/ if
@@ -13789,40 +13787,40 @@
       default:
         /*<<camlinternalFormat.ml:475:26>>*/ var
         c = formatting_lit[1],
-         /*<<camlinternalFormat.ml:475:26>>*/ _dO_ =
+         /*<<camlinternalFormat.ml:475:26>>*/ _dP_ =
            /*<<camlinternalFormat.ml:475:26>>*/ caml_call2
            (Stdlib_String[1], 1, c);
         /*<<camlinternalFormat.ml:475:26>>*/ return  /*<<camlinternalFormat.ml:475:26>>*/ caml_call2
-               (Stdlib[28], cst$7, _dO_);
+               (Stdlib[28], cst$7, _dP_);
     }
     /*<<camlinternalFormat.ml:475:43>>*/ }
    function bprint_char_literal(buf, chr){
      /*<<camlinternalFormat.ml:480:34>>*/ return 37 === chr
-            ? (buffer_add_string(buf, cst$8), sentinal)
-            : (buffer_add_char(buf, chr), sentinal);
+            ? (buffer_add_string(buf, cst$8), _$_)
+            : (buffer_add_char(buf, chr), _$_);
     /*<<camlinternalFormat.ml:482:32>>*/ }
    function bprint_string_literal(buf, str){
      /*<<camlinternalFormat.ml:486:2>>*/ var
-     _dM_ = caml_ml_string_length(str) - 1 | 0,
-      /*<<camlinternalFormat.ml:486:2>>*/ _dL_ = 0;
-    if(_dM_ >= 0){
-     var i = _dL_;
+     _dN_ = caml_ml_string_length(str) - 1 | 0,
+      /*<<camlinternalFormat.ml:486:2>>*/ _dM_ = 0;
+    if(_dN_ >= 0){
+     var i = _dM_;
      for(;;){
        /*<<camlinternalFormat.ml:487:4>>*/ bprint_char_literal
        (buf,  /*<<camlinternalFormat.ml:487:28>>*/ caml_string_get(str, i));
        /*<<camlinternalFormat.ml:487:4>>*/  /*<<camlinternalFormat.ml:487:4>>*/ var
-       _dN_ = i + 1 | 0;
-      if(_dM_ === i) break;
-      var i = _dN_;
+       _dO_ = i + 1 | 0;
+      if(_dN_ === i) break;
+      var i = _dO_;
      }
     }
-    return sentinal;
+    return _$_;
     /*<<camlinternalFormat.ml:488:6>>*/ }
    function bprint_fmtty(buf, fmtty){
      /*<<camlinternalFormat.ml:496:17>>*/ var fmtty$0 = fmtty;
      /*<<camlinternalFormat.ml:496:17>>*/ for(;;){
      if(typeof fmtty$0 === "number")
-       /*<<camlinternalFormat.ml:521:20>>*/ return sentinal;
+       /*<<camlinternalFormat.ml:521:20>>*/ return _$_;
      switch(fmtty$0[0]){
        case 0:
         var fmtty$1 = fmtty$0[1];
@@ -13920,7 +13918,7 @@
       ign_flag$0 = ign_flag;
       /*<<camlinternalFormat.ml:535:22>>*/ for(;;){
       if(typeof fmt$0 === "number")
-        /*<<camlinternalFormat.ml:636:23>>*/ return sentinal;
+        /*<<camlinternalFormat.ml:636:23>>*/ return _$_;
       switch(fmt$0[0]){
         case 0:
          var rest = fmt$0[1];
@@ -14124,17 +14122,11 @@
                  /*<<camlinternalFormat.ml:358:31>>*/ caml_call1
                  (Stdlib[29], i);
              return 37 === c
-                     ? (buffer_add_char
-                        (buf, 37),
-                       buffer_add_char(buf, 37),
-                       sentinal)
+                     ? (buffer_add_char(buf, 37), buffer_add_char(buf, 37), _$_)
                      : 64
                        === c
-                       ? (buffer_add_char
-                          (buf, 37),
-                         buffer_add_char(buf, 64),
-                         sentinal)
-                       : (buffer_add_char(buf, c), sentinal);
+                       ? (buffer_add_char(buf, 37), buffer_add_char(buf, 64), _$_)
+                       : (buffer_add_char(buf, c), _$_);
              /*<<camlinternalFormat.ml:361:35>>*/ };
           /*<<camlinternalFormat.ml:363:2>>*/ buffer_add_char(buf, 91);
           /*<<camlinternalFormat.ml:365:7>>*/ var
@@ -14152,18 +14144,18 @@
                 /*<<camlinternalFormat.ml:316:32>>*/ before =
                   /*<<camlinternalFormat.ml:316:32>>*/ caml_call1
                   (Stdlib_Char[1], c - 1 | 0),
-                /*<<camlinternalFormat.ml:317:6>>*/ _dH_ =
+                /*<<camlinternalFormat.ml:317:6>>*/ _dI_ =
                  is_in_char_set(set, c);
-               /*<<camlinternalFormat.ml:317:6>>*/ if(_dH_)
+               /*<<camlinternalFormat.ml:317:6>>*/ if(_dI_)
                 /*<<camlinternalFormat.ml:318:14>>*/ var
-                 /*<<camlinternalFormat.ml:318:14>>*/ _dI_ =
-                  is_in_char_set(set, before),
                  /*<<camlinternalFormat.ml:318:14>>*/ _dJ_ =
-                  _dI_ ? is_in_char_set(set, after) : _dI_,
-                _dK_ = 1 - _dJ_;
+                  is_in_char_set(set, before),
+                 /*<<camlinternalFormat.ml:318:14>>*/ _dK_ =
+                  _dJ_ ? is_in_char_set(set, after) : _dJ_,
+                _dL_ = 1 - _dK_;
               else
-               var _dK_ = _dH_;
-               /*<<camlinternalFormat.ml:318:43>>*/ return _dK_;
+               var _dL_ = _dI_;
+               /*<<camlinternalFormat.ml:318:43>>*/ return _dL_;
               /*<<camlinternalFormat.ml:318:68>>*/ }
              return is_alone;
             },
@@ -14297,12 +14289,12 @@
           (buf, ign_flag$0);
          switch(counter){
            case 0:
-            var _dD_ = 108; break;
+            var _dE_ = 108; break;
            case 1:
-            var _dD_ = 110; break;
-           default: var _dD_ = 78;
+            var _dE_ = 110; break;
+           default: var _dE_ = 78;
          }
-          /*<<camlinternalFormat.ml:614:6>>*/ buffer_add_char(buf, _dD_);
+          /*<<camlinternalFormat.ml:614:6>>*/ buffer_add_char(buf, _dE_);
          var fmt$0 = rest$20, ign_flag$0 = 0;
          break;
         case 22:
@@ -14326,20 +14318,20 @@
           /*<<camlinternalFormat.ml:578:20>>*/ var
           rest$23 = fmt$0[3],
           arity = fmt$0[1],
-           /*<<camlinternalFormat.ml:578:20>>*/ _dF_ =
+           /*<<camlinternalFormat.ml:578:20>>*/ _dG_ =
             int_of_custom_arity(arity),
-          _dE_ = 1;
-         if(_dF_ >= 1){
-          var i$8 = _dE_;
+          _dF_ = 1;
+         if(_dG_ >= 1){
+          var i$8 = _dF_;
           for(;;){
             /*<<camlinternalFormat.ml:579:8>>*/ buffer_add_char(buf, 37);
             /*<<camlinternalFormat.ml:579:33>>*/ bprint_ignored_flag
             (buf, ign_flag$0);
             /*<<camlinternalFormat.ml:580:8>>*/ buffer_add_char(buf, 63);
             /*<<camlinternalFormat.ml:580:8>>*/  /*<<camlinternalFormat.ml:580:8>>*/ var
-            _dG_ = i$8 + 1 | 0;
-           if(_dF_ === i$8) break;
-           var i$8 = _dG_;
+            _dH_ = i$8 + 1 | 0;
+           if(_dG_ === i$8) break;
+           var i$8 = _dH_;
           }
          }
          var fmt$0 = rest$23, ign_flag$0 = 0;
@@ -14411,17 +14403,17 @@
          ed = match[3],
          af = match[2],
          fa = match[1],
-         _di_ =
+         _dj_ =
            function(param){
              /*<<camlinternalFormat.ml:698:17>>*/ af(0);
-             /*<<camlinternalFormat.ml:698:39>>*/ return sentinal;
+             /*<<camlinternalFormat.ml:698:39>>*/ return _$_;
             /*<<camlinternalFormat.ml:698:43>>*/ };
          /*<<camlinternalFormat.ml:697:4>>*/ return [0,
                 function(param){
                   /*<<camlinternalFormat.ml:697:17>>*/ fa(0);
-                  /*<<camlinternalFormat.ml:697:39>>*/ return sentinal;
+                  /*<<camlinternalFormat.ml:697:39>>*/ return _$_;
                  /*<<camlinternalFormat.ml:697:43>>*/ },
-                _di_,
+                _dj_,
                 ed,
                 de];
        case 1:
@@ -14432,17 +14424,17 @@
          ed$0 = match$0[3],
          af$0 = match$0[2],
          fa$0 = match$0[1],
-         _dj_ =
+         _dk_ =
            function(param){
              /*<<camlinternalFormat.ml:703:17>>*/ af$0(0);
-             /*<<camlinternalFormat.ml:703:39>>*/ return sentinal;
+             /*<<camlinternalFormat.ml:703:39>>*/ return _$_;
             /*<<camlinternalFormat.ml:703:43>>*/ };
          /*<<camlinternalFormat.ml:702:4>>*/ return [0,
                 function(param){
                   /*<<camlinternalFormat.ml:702:17>>*/ fa$0(0);
-                  /*<<camlinternalFormat.ml:702:39>>*/ return sentinal;
+                  /*<<camlinternalFormat.ml:702:39>>*/ return _$_;
                  /*<<camlinternalFormat.ml:702:43>>*/ },
-                _dj_,
+                _dk_,
                 ed$0,
                 de$0];
        case 2:
@@ -14453,17 +14445,17 @@
          ed$1 = match$1[3],
          af$1 = match$1[2],
          fa$1 = match$1[1],
-         _dk_ =
+         _dl_ =
            function(param){
              /*<<camlinternalFormat.ml:708:17>>*/ af$1(0);
-             /*<<camlinternalFormat.ml:708:39>>*/ return sentinal;
+             /*<<camlinternalFormat.ml:708:39>>*/ return _$_;
             /*<<camlinternalFormat.ml:708:43>>*/ };
          /*<<camlinternalFormat.ml:707:4>>*/ return [0,
                 function(param){
                   /*<<camlinternalFormat.ml:707:17>>*/ fa$1(0);
-                  /*<<camlinternalFormat.ml:707:39>>*/ return sentinal;
+                  /*<<camlinternalFormat.ml:707:39>>*/ return _$_;
                  /*<<camlinternalFormat.ml:707:43>>*/ },
-                _dk_,
+                _dl_,
                 ed$1,
                 de$1];
        case 3:
@@ -14474,17 +14466,17 @@
          ed$2 = match$2[3],
          af$2 = match$2[2],
          fa$2 = match$2[1],
-         _dl_ =
+         _dm_ =
            function(param){
              /*<<camlinternalFormat.ml:713:17>>*/ af$2(0);
-             /*<<camlinternalFormat.ml:713:39>>*/ return sentinal;
+             /*<<camlinternalFormat.ml:713:39>>*/ return _$_;
             /*<<camlinternalFormat.ml:713:43>>*/ };
          /*<<camlinternalFormat.ml:712:4>>*/ return [0,
                 function(param){
                   /*<<camlinternalFormat.ml:712:17>>*/ fa$2(0);
-                  /*<<camlinternalFormat.ml:712:39>>*/ return sentinal;
+                  /*<<camlinternalFormat.ml:712:39>>*/ return _$_;
                  /*<<camlinternalFormat.ml:712:43>>*/ },
-                _dl_,
+                _dm_,
                 ed$2,
                 de$2];
        case 4:
@@ -14495,17 +14487,17 @@
          ed$3 = match$3[3],
          af$3 = match$3[2],
          fa$3 = match$3[1],
-         _dm_ =
+         _dn_ =
            function(param){
              /*<<camlinternalFormat.ml:723:17>>*/ af$3(0);
-             /*<<camlinternalFormat.ml:723:39>>*/ return sentinal;
+             /*<<camlinternalFormat.ml:723:39>>*/ return _$_;
             /*<<camlinternalFormat.ml:723:43>>*/ };
          /*<<camlinternalFormat.ml:722:4>>*/ return [0,
                 function(param){
                   /*<<camlinternalFormat.ml:722:17>>*/ fa$3(0);
-                  /*<<camlinternalFormat.ml:722:39>>*/ return sentinal;
+                  /*<<camlinternalFormat.ml:722:39>>*/ return _$_;
                  /*<<camlinternalFormat.ml:722:43>>*/ },
-                _dm_,
+                _dn_,
                 ed$3,
                 de$3];
        case 5:
@@ -14516,17 +14508,17 @@
          ed$4 = match$4[3],
          af$4 = match$4[2],
          fa$4 = match$4[1],
-         _dn_ =
+         _do_ =
            function(param){
              /*<<camlinternalFormat.ml:718:17>>*/ af$4(0);
-             /*<<camlinternalFormat.ml:718:39>>*/ return sentinal;
+             /*<<camlinternalFormat.ml:718:39>>*/ return _$_;
             /*<<camlinternalFormat.ml:718:43>>*/ };
          /*<<camlinternalFormat.ml:717:4>>*/ return [0,
                 function(param){
                   /*<<camlinternalFormat.ml:717:17>>*/ fa$4(0);
-                  /*<<camlinternalFormat.ml:717:39>>*/ return sentinal;
+                  /*<<camlinternalFormat.ml:717:39>>*/ return _$_;
                  /*<<camlinternalFormat.ml:717:43>>*/ },
-                _dn_,
+                _do_,
                 ed$4,
                 de$4];
        case 6:
@@ -14537,17 +14529,17 @@
          ed$5 = match$5[3],
          af$5 = match$5[2],
          fa$5 = match$5[1],
-         _do_ =
+         _dp_ =
            function(param){
              /*<<camlinternalFormat.ml:728:17>>*/ af$5(0);
-             /*<<camlinternalFormat.ml:728:39>>*/ return sentinal;
+             /*<<camlinternalFormat.ml:728:39>>*/ return _$_;
             /*<<camlinternalFormat.ml:728:43>>*/ };
          /*<<camlinternalFormat.ml:727:4>>*/ return [0,
                 function(param){
                   /*<<camlinternalFormat.ml:727:17>>*/ fa$5(0);
-                  /*<<camlinternalFormat.ml:727:39>>*/ return sentinal;
+                  /*<<camlinternalFormat.ml:727:39>>*/ return _$_;
                  /*<<camlinternalFormat.ml:727:43>>*/ },
-                _do_,
+                _dp_,
                 ed$5,
                 de$5];
        case 7:
@@ -14558,17 +14550,17 @@
          ed$6 = match$6[3],
          af$6 = match$6[2],
          fa$6 = match$6[1],
-         _dp_ =
+         _dq_ =
            function(param){
              /*<<camlinternalFormat.ml:733:17>>*/ af$6(0);
-             /*<<camlinternalFormat.ml:733:39>>*/ return sentinal;
+             /*<<camlinternalFormat.ml:733:39>>*/ return _$_;
             /*<<camlinternalFormat.ml:733:43>>*/ };
          /*<<camlinternalFormat.ml:732:4>>*/ return [0,
                 function(param){
                   /*<<camlinternalFormat.ml:732:17>>*/ fa$6(0);
-                  /*<<camlinternalFormat.ml:732:39>>*/ return sentinal;
+                  /*<<camlinternalFormat.ml:732:39>>*/ return _$_;
                  /*<<camlinternalFormat.ml:732:43>>*/ },
-                _dp_,
+                _dq_,
                 ed$6,
                 de$6];
        case 8:
@@ -14579,17 +14571,17 @@
          ed$7 = match$7[3],
          af$7 = match$7[2],
          fa$7 = match$7[1],
-         _dq_ =
+         _dr_ =
            function(param){
              /*<<camlinternalFormat.ml:766:17>>*/ af$7(0);
-             /*<<camlinternalFormat.ml:766:39>>*/ return sentinal;
+             /*<<camlinternalFormat.ml:766:39>>*/ return _$_;
             /*<<camlinternalFormat.ml:766:43>>*/ };
          /*<<camlinternalFormat.ml:765:4>>*/ return [0,
                 function(param){
                   /*<<camlinternalFormat.ml:765:17>>*/ fa$7(0);
-                  /*<<camlinternalFormat.ml:765:39>>*/ return sentinal;
+                  /*<<camlinternalFormat.ml:765:39>>*/ return _$_;
                  /*<<camlinternalFormat.ml:765:43>>*/ },
-                _dq_,
+                _dr_,
                 ed$7,
                 de$7];
        case 9:
@@ -14608,33 +14600,33 @@
          dj = match$9[3],
          ga = match$9[2],
          ag = match$9[1],
-         _dr_ =
+         _ds_ =
            function(param){
              /*<<camlinternalFormat.ml:775:17>>*/ jd(0);
              /*<<camlinternalFormat.ml:775:50>>*/ de$8(0);
-             /*<<camlinternalFormat.ml:775:61>>*/ return sentinal;
+             /*<<camlinternalFormat.ml:775:61>>*/ return _$_;
             /*<<camlinternalFormat.ml:775:65>>*/ },
-         _ds_ =
+         _dt_ =
            function(param){
              /*<<camlinternalFormat.ml:774:17>>*/ ed$8(0);
              /*<<camlinternalFormat.ml:774:50>>*/ dj(0);
-             /*<<camlinternalFormat.ml:774:61>>*/ return sentinal;
+             /*<<camlinternalFormat.ml:774:61>>*/ return _$_;
             /*<<camlinternalFormat.ml:774:65>>*/ },
-         _dt_ =
+         _du_ =
            function(param){
              /*<<camlinternalFormat.ml:773:17>>*/ ga(0);
              /*<<camlinternalFormat.ml:773:50>>*/ af$8(0);
-             /*<<camlinternalFormat.ml:773:61>>*/ return sentinal;
+             /*<<camlinternalFormat.ml:773:61>>*/ return _$_;
             /*<<camlinternalFormat.ml:773:65>>*/ };
          /*<<camlinternalFormat.ml:772:4>>*/ return [0,
                 function(param){
                   /*<<camlinternalFormat.ml:772:17>>*/ fa$8(0);
                   /*<<camlinternalFormat.ml:772:50>>*/ ag(0);
-                  /*<<camlinternalFormat.ml:772:61>>*/ return sentinal;
+                  /*<<camlinternalFormat.ml:772:61>>*/ return _$_;
                  /*<<camlinternalFormat.ml:772:65>>*/ },
+                _du_,
                 _dt_,
-                _ds_,
-                _dr_];
+                _ds_];
        case 10:
          /*<<camlinternalFormat.ml:742:25>>*/ var
          rest$9 = param[1],
@@ -14644,17 +14636,17 @@
          ed$9 = match$10[3],
          af$9 = match$10[2],
          fa$9 = match$10[1],
-         _du_ =
+         _dv_ =
            function(param){
              /*<<camlinternalFormat.ml:744:17>>*/ af$9(0);
-             /*<<camlinternalFormat.ml:744:39>>*/ return sentinal;
+             /*<<camlinternalFormat.ml:744:39>>*/ return _$_;
             /*<<camlinternalFormat.ml:744:43>>*/ };
          /*<<camlinternalFormat.ml:743:4>>*/ return [0,
                 function(param){
                   /*<<camlinternalFormat.ml:743:17>>*/ fa$9(0);
-                  /*<<camlinternalFormat.ml:743:39>>*/ return sentinal;
+                  /*<<camlinternalFormat.ml:743:39>>*/ return _$_;
                  /*<<camlinternalFormat.ml:743:43>>*/ },
-                _du_,
+                _dv_,
                 ed$9,
                 de$9];
        case 11:
@@ -14666,17 +14658,17 @@
          ed$10 = match$11[3],
          af$10 = match$11[2],
          fa$10 = match$11[1],
-         _dv_ =
+         _dw_ =
            function(param){
              /*<<camlinternalFormat.ml:739:17>>*/ af$10(0);
-             /*<<camlinternalFormat.ml:739:39>>*/ return sentinal;
+             /*<<camlinternalFormat.ml:739:39>>*/ return _$_;
             /*<<camlinternalFormat.ml:739:43>>*/ };
          /*<<camlinternalFormat.ml:738:4>>*/ return [0,
                 function(param){
                   /*<<camlinternalFormat.ml:738:17>>*/ fa$10(0);
-                  /*<<camlinternalFormat.ml:738:39>>*/ return sentinal;
+                  /*<<camlinternalFormat.ml:738:39>>*/ return _$_;
                  /*<<camlinternalFormat.ml:738:43>>*/ },
-                _dv_,
+                _dw_,
                 ed$10,
                 de$10];
        case 12:
@@ -14688,17 +14680,17 @@
          ed$11 = match$12[3],
          af$11 = match$12[2],
          fa$11 = match$12[1],
-         _dw_ =
+         _dx_ =
            function(param){
              /*<<camlinternalFormat.ml:749:17>>*/ af$11(0);
-             /*<<camlinternalFormat.ml:749:39>>*/ return sentinal;
+             /*<<camlinternalFormat.ml:749:39>>*/ return _$_;
             /*<<camlinternalFormat.ml:749:43>>*/ };
          /*<<camlinternalFormat.ml:748:4>>*/ return [0,
                 function(param){
                   /*<<camlinternalFormat.ml:748:17>>*/ fa$11(0);
-                  /*<<camlinternalFormat.ml:748:39>>*/ return sentinal;
+                  /*<<camlinternalFormat.ml:748:39>>*/ return _$_;
                  /*<<camlinternalFormat.ml:748:43>>*/ },
-                _dw_,
+                _dx_,
                 ed$11,
                 de$11];
        case 13:
@@ -14710,29 +14702,29 @@
          ed$12 = match$13[3],
          af$12 = match$13[2],
          fa$12 = match$13[1],
-          /*<<camlinternalFormat.ml:753:4>>*/ _dx_ =
+          /*<<camlinternalFormat.ml:753:4>>*/ _dy_ =
            function(param){
              /*<<camlinternalFormat.ml:756:17>>*/ de$12(0);
-             /*<<camlinternalFormat.ml:756:39>>*/ return sentinal;
+             /*<<camlinternalFormat.ml:756:39>>*/ return _$_;
             /*<<camlinternalFormat.ml:756:43>>*/ },
-         _dy_ =
+         _dz_ =
            function(param){
              /*<<camlinternalFormat.ml:755:17>>*/ ed$12(0);
-             /*<<camlinternalFormat.ml:755:39>>*/ return sentinal;
+             /*<<camlinternalFormat.ml:755:39>>*/ return _$_;
             /*<<camlinternalFormat.ml:755:43>>*/ },
-         _dz_ =
+         _dA_ =
            function(param){
              /*<<camlinternalFormat.ml:754:17>>*/ af$12(0);
-             /*<<camlinternalFormat.ml:754:39>>*/ return sentinal;
+             /*<<camlinternalFormat.ml:754:39>>*/ return _$_;
             /*<<camlinternalFormat.ml:754:43>>*/ };
          /*<<camlinternalFormat.ml:753:4>>*/ return [0,
                 function(param){
                   /*<<camlinternalFormat.ml:753:17>>*/ fa$12(0);
-                  /*<<camlinternalFormat.ml:753:39>>*/ return sentinal;
+                  /*<<camlinternalFormat.ml:753:39>>*/ return _$_;
                  /*<<camlinternalFormat.ml:753:43>>*/ },
+                _dA_,
                 _dz_,
-                _dy_,
-                _dx_];
+                _dy_];
        default:
          /*<<camlinternalFormat.ml:758:25>>*/ var
          rest$13 = param[1],
@@ -14742,46 +14734,46 @@
          ed$13 = match$14[3],
          af$13 = match$14[2],
          fa$13 = match$14[1],
-          /*<<camlinternalFormat.ml:759:4>>*/ _dA_ =
+          /*<<camlinternalFormat.ml:759:4>>*/ _dB_ =
            function(param){
              /*<<camlinternalFormat.ml:762:17>>*/ de$13(0);
-             /*<<camlinternalFormat.ml:762:39>>*/ return sentinal;
+             /*<<camlinternalFormat.ml:762:39>>*/ return _$_;
             /*<<camlinternalFormat.ml:762:43>>*/ },
-         _dB_ =
+         _dC_ =
            function(param){
              /*<<camlinternalFormat.ml:761:17>>*/ ed$13(0);
-             /*<<camlinternalFormat.ml:761:39>>*/ return sentinal;
+             /*<<camlinternalFormat.ml:761:39>>*/ return _$_;
             /*<<camlinternalFormat.ml:761:43>>*/ },
-         _dC_ =
+         _dD_ =
            function(param){
              /*<<camlinternalFormat.ml:760:17>>*/ af$13(0);
-             /*<<camlinternalFormat.ml:760:39>>*/ return sentinal;
+             /*<<camlinternalFormat.ml:760:39>>*/ return _$_;
             /*<<camlinternalFormat.ml:760:43>>*/ };
          /*<<camlinternalFormat.ml:759:4>>*/ return [0,
                 function(param){
                   /*<<camlinternalFormat.ml:759:17>>*/ fa$13(0);
-                  /*<<camlinternalFormat.ml:759:39>>*/ return sentinal;
+                  /*<<camlinternalFormat.ml:759:39>>*/ return _$_;
                  /*<<camlinternalFormat.ml:759:43>>*/ },
+                _dD_,
                 _dC_,
-                _dB_,
-                _dA_];
+                _dB_];
      }
-     /*<<camlinternalFormat.ml:691:4>>*/ function _df_(param){
-      /*<<camlinternalFormat.ml:694:17>>*/ return sentinal;
+     /*<<camlinternalFormat.ml:691:4>>*/ function _dg_(param){
+      /*<<camlinternalFormat.ml:694:17>>*/ return _$_;
      /*<<camlinternalFormat.ml:694:21>>*/ }
-    function _dg_(param){
-      /*<<camlinternalFormat.ml:693:17>>*/ return sentinal;
-     /*<<camlinternalFormat.ml:693:21>>*/ }
     function _dh_(param){
-      /*<<camlinternalFormat.ml:692:17>>*/ return sentinal;
+      /*<<camlinternalFormat.ml:693:17>>*/ return _$_;
+     /*<<camlinternalFormat.ml:693:21>>*/ }
+    function _di_(param){
+      /*<<camlinternalFormat.ml:692:17>>*/ return _$_;
      /*<<camlinternalFormat.ml:692:21>>*/ }
      /*<<camlinternalFormat.ml:691:4>>*/ return [0,
             function(param){
-              /*<<camlinternalFormat.ml:691:17>>*/ return sentinal;
+              /*<<camlinternalFormat.ml:691:17>>*/ return _$_;
              /*<<camlinternalFormat.ml:691:21>>*/ },
+            _di_,
             _dh_,
-            _dg_,
-            _df_];
+            _dg_];
     /*<<camlinternalFormat.ml:775:66>>*/ }
    function trans(ty1, ty2){
      /*<<camlinternalFormat.ml:803:17>>*/ a:
@@ -15000,11 +14992,11 @@
                     /*<<camlinternalFormat.ml:835:34>>*/ var
                     rest2$7 = ty2[2],
                     ty2$0 = ty2[1],
-                     /*<<camlinternalFormat.ml:835:34>>*/ _de_ =
+                     /*<<camlinternalFormat.ml:835:34>>*/ _df_ =
                       trans(rest1$7, rest2$7);
                     /*<<camlinternalFormat.ml:835:4>>*/ return [8,
                            trans(ty1$0, ty2$0),
-                           _de_];
+                           _df_];
                   case 10:
                    break a;
                   case 11:
@@ -15294,13 +15286,13 @@
          /*<<camlinternalFormat.ml:914:54>>*/ var
          rest$13 = fmtty$0[2],
          formatting_gen = fmtty$0[1],
-          /*<<camlinternalFormat.ml:914:54>>*/ _db_ = fmtty_of_fmt(rest$13);
+          /*<<camlinternalFormat.ml:914:54>>*/ _dc_ = fmtty_of_fmt(rest$13);
         if(0 === formatting_gen[0])
-         var fmt = formatting_gen[1][1], _dc_ = fmtty_of_fmt(fmt);
+         var fmt = formatting_gen[1][1], _dd_ = fmtty_of_fmt(fmt);
         else
-         var fmt$0 = formatting_gen[1][1], _dc_ = fmtty_of_fmt(fmt$0);
+         var fmt$0 = formatting_gen[1][1], _dd_ = fmtty_of_fmt(fmt$0);
          /*<<camlinternalFormat.ml:914:54>>*/ return  /*<<camlinternalFormat.ml:914:54>>*/ caml_call2
-                (CamlinternalFormatBasics[1], _dc_, _db_);
+                (CamlinternalFormatBasics[1], _dd_, _dc_);
        case 19:
         var rest$14 = fmtty$0[1];
          /*<<camlinternalFormat.ml:897:34>>*/ return [13,
@@ -15353,10 +15345,10 @@
            case 9:
              /*<<camlinternalFormat.ml:943:58>>*/ var
              fmtty$6 = ign[2],
-              /*<<camlinternalFormat.ml:943:58>>*/ _dd_ =
+              /*<<camlinternalFormat.ml:943:58>>*/ _de_ =
                fmtty_of_fmt(fmtty$5);
              /*<<camlinternalFormat.ml:943:58>>*/ return  /*<<camlinternalFormat.ml:943:58>>*/ caml_call2
-                    (CamlinternalFormatBasics[1], fmtty$6, _dd_);
+                    (CamlinternalFormatBasics[1], fmtty$6, _de_);
            case 10:
             var fmtty$0 = fmtty$5; break;
            default: var fmtty$0 = fmtty$5;
@@ -15412,11 +15404,11 @@
     /*<<camlinternalFormat.ml:996:54>>*/ }
    function type_format(fmt, fmtty){
      /*<<camlinternalFormat.ml:1008:19>>*/  /*<<camlinternalFormat.ml:1008:25>>*/ var
-     _da_ = type_format_gen(fmt, fmtty);
-    if(typeof _da_[2] !== "number")
+     _db_ = type_format_gen(fmt, fmtty);
+    if(typeof _db_[2] !== "number")
       /*<<camlinternalFormat.ml:1010:9>>*/ throw  /*<<camlinternalFormat.ml:1010:9>>*/ caml_maybe_attach_backtrace
             (Type_mismatch, 1);
-    var fmt$0 = _da_[1];
+    var fmt$0 = _db_[1];
      /*<<camlinternalFormat.ml:1009:42>>*/ return fmt$0;
     /*<<camlinternalFormat.ml:1010:28>>*/ }
    function type_ignored_param_one(ign, fmt, fmtty){
@@ -15701,7 +15693,7 @@
          fmt_rest$13 = fmt[3],
          sub_fmtty$1 = fmt[2],
          pad_opt$0 = fmt[1],
-          /*<<camlinternalFormat.ml:1099:42>>*/ _c__ =
+          /*<<camlinternalFormat.ml:1099:42>>*/ _c$_ =
            [0,
              /*<<camlinternalFormat.ml:1099:52>>*/ caml_call1
              (CamlinternalFormatBasics[2], sub_fmtty1)];
@@ -15710,7 +15702,7 @@
            ([0,
               /*<<camlinternalFormat.ml:1099:17>>*/ caml_call1
               (CamlinternalFormatBasics[2], sub_fmtty$1)],
-            _c__))
+            _c$_))
           /*<<camlinternalFormat.ml:1100:6>>*/ throw  /*<<camlinternalFormat.ml:1100:6>>*/ caml_maybe_attach_backtrace
                 (Type_mismatch, 1);
          /*<<camlinternalFormat.ml:1102:6>>*/ var
@@ -15880,12 +15872,12 @@
             /*<<camlinternalFormat.ml:1176:6>>*/ var
             sub_fmtty$3 = ign[2],
             pad_opt$2 = ign[1],
-             /*<<camlinternalFormat.ml:1176:6>>*/ _c$_ =
+             /*<<camlinternalFormat.ml:1176:6>>*/ _da_ =
               type_ignored_format_substituti(sub_fmtty$3, rest, fmtty0),
-            match$43 = _c$_[2],
+            match$43 = _da_[2],
             fmtty$21 = match$43[2],
             fmt$22 = match$43[1],
-            sub_fmtty$4 = _c$_[1];
+            sub_fmtty$4 = _da_[1];
             /*<<camlinternalFormat.ml:1177:4>>*/ return [0,
                    [23, [9, pad_opt$2, sub_fmtty$4], fmt$22],
                    fmtty$21];
@@ -16077,7 +16069,7 @@
          sub_fmtty_rest$17 = sub_fmtty[3],
          sub2_fmtty$2 = sub_fmtty[2],
          sub1_fmtty$0 = sub_fmtty[1],
-          /*<<camlinternalFormat.ml:1261:43>>*/ _c8_ =
+          /*<<camlinternalFormat.ml:1261:43>>*/ _c9_ =
            [0,
              /*<<camlinternalFormat.ml:1261:53>>*/ caml_call1
              (CamlinternalFormatBasics[2], sub1_fmtty)];
@@ -16086,11 +16078,11 @@
            ([0,
               /*<<camlinternalFormat.ml:1261:17>>*/ caml_call1
               (CamlinternalFormatBasics[2], sub1_fmtty$0)],
-            _c8_))
+            _c9_))
           /*<<camlinternalFormat.ml:1262:9>>*/ throw  /*<<camlinternalFormat.ml:1262:9>>*/ caml_maybe_attach_backtrace
                 (Type_mismatch, 1);
          /*<<camlinternalFormat.ml:1263:43>>*/  /*<<camlinternalFormat.ml:1263:43>>*/ var
-         _c9_ =
+         _c__ =
            [0,
              /*<<camlinternalFormat.ml:1263:53>>*/ caml_call1
              (CamlinternalFormatBasics[2], sub2_fmtty$1)];
@@ -16099,7 +16091,7 @@
            ([0,
               /*<<camlinternalFormat.ml:1263:17>>*/ caml_call1
               (CamlinternalFormatBasics[2], sub2_fmtty$2)],
-            _c9_))
+            _c__))
           /*<<camlinternalFormat.ml:1264:9>>*/ throw  /*<<camlinternalFormat.ml:1264:9>>*/ caml_maybe_attach_backtrace
                 (Type_mismatch, 1);
          /*<<camlinternalFormat.ml:1265:21>>*/ var
@@ -16191,11 +16183,11 @@
     /*<<camlinternalFormat.ml:1277:28>>*/ }
    function recast(fmt, fmtty){
      /*<<camlinternalFormat.ml:1312:2>>*/  /*<<camlinternalFormat.ml:1312:29>>*/ var
-     _c7_ = symm(fmtty);
+     _c8_ = symm(fmtty);
      /*<<camlinternalFormat.ml:1312:18>>*/ return type_format
             (fmt,
               /*<<camlinternalFormat.ml:1312:18>>*/ caml_call1
-              (CamlinternalFormatBasics[2], _c7_));
+              (CamlinternalFormatBasics[2], _c8_));
     /*<<camlinternalFormat.ml:1312:42>>*/ }
    function fix_padding(padty, width, str){
      /*<<camlinternalFormat.ml:1319:2>>*/ var
@@ -16205,10 +16197,10 @@
         /*<<camlinternalFormat.ml:1321:4>>*/ caml_call1(Stdlib[18], width);
     if(width$0 <= len)  /*<<camlinternalFormat.ml:1332:23>>*/ return str;
      /*<<camlinternalFormat.ml:1333:14>>*/ var
-     _c6_ = 2 === padty$0 ? 48 : 32,
+     _c7_ = 2 === padty$0 ? 48 : 32,
       /*<<camlinternalFormat.ml:1333:14>>*/ res =
         /*<<camlinternalFormat.ml:1333:14>>*/ caml_call2
-        (Stdlib_Bytes[1], width$0, _c6_);
+        (Stdlib_Bytes[1], width$0, _c7_);
      /*<<camlinternalFormat.ml:1334:4>>*/ switch(padty$0){
       case 0:
         /*<<camlinternalFormat.ml:1335:15>>*/  /*<<camlinternalFormat.ml:1335:15>>*/ caml_call5
@@ -16400,16 +16392,16 @@
       /*<<camlinternalFormat.ml:1447:9>>*/ return s;
      /*<<camlinternalFormat.ml:1428:14>>*/ var
       /*<<camlinternalFormat.ml:1428:14>>*/ n = [0, 0],
-     _c1_ = caml_ml_string_length(s) - 1 | 0,
-      /*<<camlinternalFormat.ml:1428:14>>*/ _c0_ = 0;
-    if(_c1_ >= 0){
-     var i$0 = _c0_;
+     _c2_ = caml_ml_string_length(s) - 1 | 0,
+      /*<<camlinternalFormat.ml:1428:14>>*/ _c1_ = 0;
+    if(_c2_ >= 0){
+     var i$0 = _c1_;
      for(;;){
       if(9 >= caml_string_unsafe_get(s, i$0) - 48 >>> 0) n[1]++;
        /*<<camlinternalFormat.ml:1429:6>>*/  /*<<camlinternalFormat.ml:1429:6>>*/ var
-       _c5_ = i$0 + 1 | 0;
-      if(_c1_ === i$0) break;
-      var i$0 = _c5_;
+       _c6_ = i$0 + 1 | 0;
+      if(_c2_ === i$0) break;
+      var i$0 = _c6_;
      }
     }
      /*<<camlinternalFormat.ml:1436:14>>*/ var
@@ -16422,15 +16414,15 @@
       /*<<camlinternalFormat.ml:1438:16>>*/  /*<<camlinternalFormat.ml:1438:16>>*/ caml_bytes_set
       (buf, pos[1], c);
      pos[1]++;
-     return sentinal;
+     return _$_;
      /*<<camlinternalFormat.ml:1438:46>>*/ }
      /*<<camlinternalFormat.ml:1439:15>>*/ var
       /*<<camlinternalFormat.ml:1439:15>>*/ left =
        [0, ((digits - 1 | 0) % 3 | 0) + 1 | 0],
-     _c3_ = caml_ml_string_length(s) - 1 | 0,
-      /*<<camlinternalFormat.ml:1439:15>>*/ _c2_ = 0;
-    if(_c3_ >= 0){
-     var i = _c2_;
+     _c4_ = caml_ml_string_length(s) - 1 | 0,
+      /*<<camlinternalFormat.ml:1439:15>>*/ _c3_ = 0;
+    if(_c4_ >= 0){
+     var i = _c3_;
      for(;;){
       var c = caml_string_unsafe_get(s, i);
       if(9 < c - 48 >>> 0)
@@ -16444,9 +16436,9 @@
         /*<<camlinternalFormat.ml:1443:61>>*/ put(c);
       }
        /*<<camlinternalFormat.ml:1440:4>>*/  /*<<camlinternalFormat.ml:1440:4>>*/ var
-       _c4_ = i + 1 | 0;
-      if(_c3_ === i) break;
-      var i = _c4_;
+       _c5_ = i + 1 | 0;
+      if(_c4_ === i) break;
+      var i = _c5_;
      }
     }
      /*<<camlinternalFormat.ml:1446:4>>*/ return  /*<<camlinternalFormat.ml:1446:4>>*/ caml_call1
@@ -16455,139 +16447,139 @@
    function convert_int(iconv, n){
      /*<<camlinternalFormat.ml:1451:2>>*/ switch(iconv){
       case 1:
-       var _cZ_ = cst_d$0; break;
+       var _c0_ = cst_d$0; break;
       case 2:
-       var _cZ_ = cst_d$1; break;
+       var _c0_ = cst_d$1; break;
       case 4:
-       var _cZ_ = cst_i$1; break;
+       var _c0_ = cst_i$1; break;
       case 5:
-       var _cZ_ = cst_i$2; break;
+       var _c0_ = cst_i$2; break;
       case 6:
-       var _cZ_ = cst_x; break;
+       var _c0_ = cst_x; break;
       case 7:
-       var _cZ_ = cst_x$0; break;
+       var _c0_ = cst_x$0; break;
       case 8:
-       var _cZ_ = cst_X; break;
+       var _c0_ = cst_X; break;
       case 9:
-       var _cZ_ = cst_X$0; break;
+       var _c0_ = cst_X$0; break;
       case 10:
-       var _cZ_ = cst_o; break;
+       var _c0_ = cst_o; break;
       case 11:
-       var _cZ_ = cst_o$0; break;
+       var _c0_ = cst_o$0; break;
       case 0:
       case 13:
-       var _cZ_ = cst_d; break;
+       var _c0_ = cst_d; break;
       case 3:
       case 14:
-       var _cZ_ = cst_i$0; break;
-      default: var _cZ_ = cst_u;
+       var _c0_ = cst_i$0; break;
+      default: var _c0_ = cst_u;
     }
      /*<<camlinternalFormat.ml:1451:26>>*/ return transform_int_alt
             (iconv,
-              /*<<camlinternalFormat.ml:1451:26>>*/ caml_format_int(_cZ_, n));
+              /*<<camlinternalFormat.ml:1451:26>>*/ caml_format_int(_c0_, n));
     /*<<camlinternalFormat.ml:1451:64>>*/ }
    function convert_int32(iconv, n){
      /*<<camlinternalFormat.ml:1453:2>>*/ switch(iconv){
       case 1:
-       var _cY_ = cst_ld$0; break;
+       var _cZ_ = cst_ld$0; break;
       case 2:
-       var _cY_ = cst_ld$1; break;
+       var _cZ_ = cst_ld$1; break;
       case 4:
-       var _cY_ = cst_li$1; break;
+       var _cZ_ = cst_li$1; break;
       case 5:
-       var _cY_ = cst_li$2; break;
+       var _cZ_ = cst_li$2; break;
       case 6:
-       var _cY_ = cst_lx; break;
+       var _cZ_ = cst_lx; break;
       case 7:
-       var _cY_ = cst_lx$0; break;
+       var _cZ_ = cst_lx$0; break;
       case 8:
-       var _cY_ = cst_lX; break;
+       var _cZ_ = cst_lX; break;
       case 9:
-       var _cY_ = cst_lX$0; break;
+       var _cZ_ = cst_lX$0; break;
       case 10:
-       var _cY_ = cst_lo; break;
+       var _cZ_ = cst_lo; break;
       case 11:
-       var _cY_ = cst_lo$0; break;
+       var _cZ_ = cst_lo$0; break;
       case 0:
       case 13:
-       var _cY_ = cst_ld; break;
+       var _cZ_ = cst_ld; break;
       case 3:
       case 14:
-       var _cY_ = cst_li$0; break;
-      default: var _cY_ = cst_lu;
+       var _cZ_ = cst_li$0; break;
+      default: var _cZ_ = cst_lu;
     }
      /*<<camlinternalFormat.ml:1453:26>>*/ return transform_int_alt
             (iconv,
-              /*<<camlinternalFormat.ml:1453:26>>*/ caml_format_int(_cY_, n));
+              /*<<camlinternalFormat.ml:1453:26>>*/ caml_format_int(_cZ_, n));
     /*<<camlinternalFormat.ml:1453:67>>*/ }
    function convert_nativeint(iconv, n){
      /*<<camlinternalFormat.ml:1455:2>>*/ switch(iconv){
       case 1:
-       var _cX_ = cst_nd$0; break;
+       var _cY_ = cst_nd$0; break;
       case 2:
-       var _cX_ = cst_nd$1; break;
+       var _cY_ = cst_nd$1; break;
       case 4:
-       var _cX_ = cst_ni$1; break;
+       var _cY_ = cst_ni$1; break;
       case 5:
-       var _cX_ = cst_ni$2; break;
+       var _cY_ = cst_ni$2; break;
       case 6:
-       var _cX_ = cst_nx; break;
+       var _cY_ = cst_nx; break;
       case 7:
-       var _cX_ = cst_nx$0; break;
+       var _cY_ = cst_nx$0; break;
       case 8:
-       var _cX_ = cst_nX; break;
+       var _cY_ = cst_nX; break;
       case 9:
-       var _cX_ = cst_nX$0; break;
+       var _cY_ = cst_nX$0; break;
       case 10:
-       var _cX_ = cst_no; break;
+       var _cY_ = cst_no; break;
       case 11:
-       var _cX_ = cst_no$0; break;
+       var _cY_ = cst_no$0; break;
       case 0:
       case 13:
-       var _cX_ = cst_nd; break;
+       var _cY_ = cst_nd; break;
       case 3:
       case 14:
-       var _cX_ = cst_ni$0; break;
-      default: var _cX_ = cst_nu;
+       var _cY_ = cst_ni$0; break;
+      default: var _cY_ = cst_nu;
     }
      /*<<camlinternalFormat.ml:1455:26>>*/ return transform_int_alt
             (iconv,
-              /*<<camlinternalFormat.ml:1455:26>>*/ caml_format_int(_cX_, n));
+              /*<<camlinternalFormat.ml:1455:26>>*/ caml_format_int(_cY_, n));
     /*<<camlinternalFormat.ml:1455:71>>*/ }
    function convert_int64(iconv, n){
      /*<<camlinternalFormat.ml:1457:2>>*/ switch(iconv){
       case 1:
-       var _cW_ = cst_Ld$0; break;
+       var _cX_ = cst_Ld$0; break;
       case 2:
-       var _cW_ = cst_Ld$1; break;
+       var _cX_ = cst_Ld$1; break;
       case 4:
-       var _cW_ = cst_Li$1; break;
+       var _cX_ = cst_Li$1; break;
       case 5:
-       var _cW_ = cst_Li$2; break;
+       var _cX_ = cst_Li$2; break;
       case 6:
-       var _cW_ = cst_Lx; break;
+       var _cX_ = cst_Lx; break;
       case 7:
-       var _cW_ = cst_Lx$0; break;
+       var _cX_ = cst_Lx$0; break;
       case 8:
-       var _cW_ = cst_LX; break;
+       var _cX_ = cst_LX; break;
       case 9:
-       var _cW_ = cst_LX$0; break;
+       var _cX_ = cst_LX$0; break;
       case 10:
-       var _cW_ = cst_Lo; break;
+       var _cX_ = cst_Lo; break;
       case 11:
-       var _cW_ = cst_Lo$0; break;
+       var _cX_ = cst_Lo$0; break;
       case 0:
       case 13:
-       var _cW_ = cst_Ld; break;
+       var _cX_ = cst_Ld; break;
       case 3:
       case 14:
-       var _cW_ = cst_Li$0; break;
-      default: var _cW_ = cst_Lu;
+       var _cX_ = cst_Li$0; break;
+      default: var _cX_ = cst_Lu;
     }
      /*<<camlinternalFormat.ml:1457:26>>*/ return transform_int_alt
             (iconv,
               /*<<camlinternalFormat.ml:1457:26>>*/ runtime.caml_int64_format
-              (_cW_, n));
+              (_cX_, n));
     /*<<camlinternalFormat.ml:1457:67>>*/ }
    function convert_float(fconv, prec, x){
     function hex(param){
@@ -16619,41 +16611,41 @@
         i = 0;
         /*<<camlinternalFormat.ml:1472:6>>*/ for(;;){
         if(i === len)
-         var _cT_ = 0;
+         var _cU_ = 0;
         else{
           /*<<camlinternalFormat.ml:1473:14>>*/  /*<<camlinternalFormat.ml:1473:14>>*/ var
-          _cS_ =
+          _cT_ =
              /*<<camlinternalFormat.ml:1473:14>>*/ caml_string_get(str, i)
             - 46
             | 0;
          a:
          {
-          if(23 < _cS_ >>> 0){
-           if(55 === _cS_) break a;
+          if(23 < _cT_ >>> 0){
+           if(55 === _cT_) break a;
           }
-          else if(21 < _cS_ - 1 >>> 0) break a;
+          else if(21 < _cT_ - 1 >>> 0) break a;
            /*<<camlinternalFormat.ml:1475:15>>*/ var
             /*<<camlinternalFormat.ml:1475:15>>*/ i$0 = i + 1 | 0,
            i = i$0;
           continue;
          }
-         var _cT_ = 1;
+         var _cU_ = 1;
         }
          /*<<camlinternalFormat.ml:1476:7>>*/  /*<<camlinternalFormat.ml:1476:7>>*/ var
-         _cU_ =
-           _cT_
+         _cV_ =
+           _cU_
             ? str
             :  /*<<camlinternalFormat.ml:1476:32>>*/ caml_call2
               (Stdlib[28], str, cst$17);
-         /*<<camlinternalFormat.ml:1487:21>>*/ return caml_special_val(_cU_);
+         /*<<camlinternalFormat.ml:1487:21>>*/ return caml_special_val(_cV_);
        }
       case 6:
         /*<<camlinternalFormat.ml:1482:15>>*/ return hex(0);
       case 7:
         /*<<camlinternalFormat.ml:1483:38>>*/  /*<<camlinternalFormat.ml:1483:38>>*/ var
-        _cV_ = hex(0);
+        _cW_ = hex(0);
         /*<<camlinternalFormat.ml:1483:38>>*/ return  /*<<camlinternalFormat.ml:1483:38>>*/ caml_call1
-               (Stdlib_String[25], _cV_);
+               (Stdlib_String[25], _cW_);
       case 8:
         /*<<camlinternalFormat.ml:1484:33>>*/ return caml_special_val(hex(0));
       default:
@@ -17038,12 +17030,12 @@
          /*<<camlinternalFormat.ml:1573:4>>*/ return function(param){
           /*<<camlinternalFormat.ml:1573:4>>*/ var
           fmt = param[1],
-           /*<<camlinternalFormat.ml:1574:18>>*/ _cR_ = recast(fmt, fmtty);
+           /*<<camlinternalFormat.ml:1574:18>>*/ _cS_ = recast(fmt, fmtty);
           /*<<camlinternalFormat.ml:1574:6>>*/ return make_printf
                  (k$0,
                   acc$0,
                    /*<<camlinternalFormat.ml:1574:6>>*/ caml_call2
-                   (CamlinternalFormatBasics[3], _cR_, rest$13)); /*<<camlinternalFormat.ml:1574:42>>*/ };
+                   (CamlinternalFormatBasics[3], _cS_, rest$13)); /*<<camlinternalFormat.ml:1574:42>>*/ };
        case 15:
         var rest$14 = fmt$0[1];
          /*<<camlinternalFormat.ml:1544:4>>*/ return function(f, x){
@@ -17070,11 +17062,11 @@
          fmt$0 = rest$16;
         break;
        case 18:
-        var _cP_ = fmt$0[1];
-        if(0 === _cP_[0])
+        var _cQ_ = fmt$0[1];
+        if(0 === _cQ_[0])
          var
           rest$17 = fmt$0[2],
-          fmt$1 = _cP_[1][1],
+          fmt$1 = _cQ_[1][1],
           k$3 =
             function(acc, k, rest){
              function k$0(kacc){
@@ -17090,7 +17082,7 @@
         else
          var
           rest$18 = fmt$0[2],
-          fmt$2 = _cP_[1][1],
+          fmt$2 = _cQ_[1][1],
           k$4 =
             function(acc, k, rest){
              function k$0(kacc){
@@ -17146,14 +17138,14 @@
          rest$23 = fmt$0[3],
          f = fmt$0[2],
          arity = fmt$0[1],
-          /*<<camlinternalFormat.ml:1548:33>>*/ _cQ_ =
+          /*<<camlinternalFormat.ml:1548:33>>*/ _cR_ =
             /*<<camlinternalFormat.ml:1548:33>>*/ caml_call1(f, 0);
          /*<<camlinternalFormat.ml:1548:33>>*/ if(counter >= 50)
           /*<<camlinternalFormat.ml:1548:33>>*/ return  /*<<camlinternalFormat.ml:1548:33>>*/ caml_trampoline_return
-                 (make_custom$0, [0, k$0, acc$0, rest$23, arity, _cQ_]);
+                 (make_custom$0, [0, k$0, acc$0, rest$23, arity, _cR_]);
         var counter$0 = counter + 1 | 0;
          /*<<camlinternalFormat.ml:1548:33>>*/ return make_custom$0
-                (counter$0, k$0, acc$0, rest$23, arity, _cQ_);
+                (counter$0, k$0, acc$0, rest$23, arity, _cR_);
      }
     }
     /*<<camlinternalFormat.ml:1605:9>>*/ }
@@ -17336,7 +17328,7 @@
                   fmt); /*<<camlinternalFormat.ml:1655:61>>*/ };
        case 10:
         var rest$9 = fmtty[1];
-         /*<<camlinternalFormat.ml:1646:31>>*/ return function(param, _cO_){
+         /*<<camlinternalFormat.ml:1646:31>>*/ return function(param, _cP_){
           /*<<camlinternalFormat.ml:1646:42>>*/ return make_from_fmtty
                  (k, acc, rest$9, fmt); /*<<camlinternalFormat.ml:1646:72>>*/ };
        case 11:
@@ -17365,13 +17357,13 @@
     /*<<camlinternalFormat.ml:1655:61>>*/ }
    function make_invalid_arg(counter, k, acc, fmt){
      /*<<camlinternalFormat.ml:1663:2>>*/  /*<<camlinternalFormat.ml:1663:16>>*/ var
-     _cN_ = [8, acc, cst_Printf_bad_conversion$0];
+     _cO_ = [8, acc, cst_Printf_bad_conversion$0];
      /*<<camlinternalFormat.ml:1663:2>>*/ if(counter >= 50)
       /*<<camlinternalFormat.ml:1663:2>>*/ return  /*<<camlinternalFormat.ml:1663:2>>*/ caml_trampoline_return
-             (make_printf$0, [0, k, _cN_, fmt]);
+             (make_printf$0, [0, k, _cO_, fmt]);
     var counter$0 = counter + 1 | 0;
      /*<<camlinternalFormat.ml:1663:2>>*/ return make_printf$0
-            (counter$0, k, _cN_, fmt);
+            (counter$0, k, _cO_, fmt);
     /*<<camlinternalFormat.ml:1663:72>>*/ }
    function make_custom$0(counter, k, acc, rest, arity, f){
      /*<<camlinternalFormat.ml:1778:28>>*/ if(arity){
@@ -17385,13 +17377,13 @@
                 /*<<camlinternalFormat.ml:1782:35>>*/ caml_call1(f, x)); /*<<camlinternalFormat.ml:1782:40>>*/ };
     }
      /*<<camlinternalFormat.ml:1779:33>>*/  /*<<camlinternalFormat.ml:1779:33>>*/ var
-     _cM_ = [4, acc, f];
+     _cN_ = [4, acc, f];
      /*<<camlinternalFormat.ml:1779:19>>*/ if(counter >= 50)
       /*<<camlinternalFormat.ml:1779:19>>*/ return  /*<<camlinternalFormat.ml:1779:19>>*/ caml_trampoline_return
-             (make_printf$0, [0, k, _cM_, rest]);
+             (make_printf$0, [0, k, _cN_, rest]);
     var counter$0 = counter + 1 | 0;
      /*<<camlinternalFormat.ml:1779:19>>*/ return make_printf$0
-            (counter$0, k, _cM_, rest);
+            (counter$0, k, _cN_, rest);
     /*<<camlinternalFormat.ml:1782:40>>*/ }
    function make_printf(k, acc, fmt){
      /*<<?>>*/ return caml_trampoline(make_printf$0(0, k, acc, fmt));
@@ -17412,68 +17404,68 @@
      /*<<camlinternalFormat.ml:1863:26>>*/ if(typeof pad === "number"){
      if(typeof prec !== "number"){
        /*<<camlinternalFormat.ml:1867:14>>*/  /*<<camlinternalFormat.ml:1867:14>>*/ var
-       _cl_ = make_iprintf(k, o, fmt);
-       /*<<camlinternalFormat.ml:1867:14>>*/ return function(_cL_){
-        /*<<?>>*/ return _cl_;};
+       _cm_ = make_iprintf(k, o, fmt);
+       /*<<camlinternalFormat.ml:1867:14>>*/ return function(_cM_){
+        /*<<?>>*/ return _cm_;};
      }
      if(prec){
        /*<<camlinternalFormat.ml:1869:21>>*/ var
-        /*<<camlinternalFormat.ml:1869:21>>*/ _ci_ = make_iprintf(k, o, fmt),
-        /*<<camlinternalFormat.ml:1869:14>>*/ _cj_ =
-         function(_cK_){ /*<<?>>*/ return _ci_;};
-       /*<<camlinternalFormat.ml:1869:14>>*/ return function(_cJ_){
-        /*<<?>>*/ return _cj_;};
+        /*<<camlinternalFormat.ml:1869:21>>*/ _cj_ = make_iprintf(k, o, fmt),
+        /*<<camlinternalFormat.ml:1869:14>>*/ _ck_ =
+         function(_cL_){ /*<<?>>*/ return _cj_;};
+       /*<<camlinternalFormat.ml:1869:14>>*/ return function(_cK_){
+        /*<<?>>*/ return _ck_;};
      }
       /*<<camlinternalFormat.ml:1865:14>>*/  /*<<camlinternalFormat.ml:1865:14>>*/ var
-      _ck_ = make_iprintf(k, o, fmt);
-      /*<<camlinternalFormat.ml:1865:14>>*/ return function(_cI_){
-       /*<<?>>*/ return _ck_;};
+      _cl_ = make_iprintf(k, o, fmt);
+      /*<<camlinternalFormat.ml:1865:14>>*/ return function(_cJ_){
+       /*<<?>>*/ return _cl_;};
     }
     if(0 === pad[0]){
      if(typeof prec !== "number"){
        /*<<camlinternalFormat.ml:1873:14>>*/  /*<<camlinternalFormat.ml:1873:14>>*/ var
-       _cp_ = make_iprintf(k, o, fmt);
-       /*<<camlinternalFormat.ml:1873:14>>*/ return function(_cH_){
-        /*<<?>>*/ return _cp_;};
+       _cq_ = make_iprintf(k, o, fmt);
+       /*<<camlinternalFormat.ml:1873:14>>*/ return function(_cI_){
+        /*<<?>>*/ return _cq_;};
      }
      if(prec){
        /*<<camlinternalFormat.ml:1875:21>>*/ var
-        /*<<camlinternalFormat.ml:1875:21>>*/ _cm_ = make_iprintf(k, o, fmt),
-        /*<<camlinternalFormat.ml:1875:14>>*/ _cn_ =
-         function(_cG_){ /*<<?>>*/ return _cm_;};
-       /*<<camlinternalFormat.ml:1875:14>>*/ return function(_cF_){
-        /*<<?>>*/ return _cn_;};
+        /*<<camlinternalFormat.ml:1875:21>>*/ _cn_ = make_iprintf(k, o, fmt),
+        /*<<camlinternalFormat.ml:1875:14>>*/ _co_ =
+         function(_cH_){ /*<<?>>*/ return _cn_;};
+       /*<<camlinternalFormat.ml:1875:14>>*/ return function(_cG_){
+        /*<<?>>*/ return _co_;};
      }
       /*<<camlinternalFormat.ml:1871:14>>*/  /*<<camlinternalFormat.ml:1871:14>>*/ var
-      _co_ = make_iprintf(k, o, fmt);
-      /*<<camlinternalFormat.ml:1871:14>>*/ return function(_cE_){
-       /*<<?>>*/ return _co_;};
+      _cp_ = make_iprintf(k, o, fmt);
+      /*<<camlinternalFormat.ml:1871:14>>*/ return function(_cF_){
+       /*<<?>>*/ return _cp_;};
     }
     if(typeof prec !== "number"){
       /*<<camlinternalFormat.ml:1879:21>>*/ var
-       /*<<camlinternalFormat.ml:1879:21>>*/ _cv_ = make_iprintf(k, o, fmt),
-       /*<<camlinternalFormat.ml:1879:14>>*/ _cw_ =
-        function(_cD_){ /*<<?>>*/ return _cv_;};
-      /*<<camlinternalFormat.ml:1879:14>>*/ return function(_cC_){
-       /*<<?>>*/ return _cw_;};
+       /*<<camlinternalFormat.ml:1879:21>>*/ _cw_ = make_iprintf(k, o, fmt),
+       /*<<camlinternalFormat.ml:1879:14>>*/ _cx_ =
+        function(_cE_){ /*<<?>>*/ return _cw_;};
+      /*<<camlinternalFormat.ml:1879:14>>*/ return function(_cD_){
+       /*<<?>>*/ return _cx_;};
     }
     if(prec){
       /*<<camlinternalFormat.ml:1881:28>>*/ var
-       /*<<camlinternalFormat.ml:1881:28>>*/ _cq_ = make_iprintf(k, o, fmt),
-       /*<<camlinternalFormat.ml:1881:21>>*/ _cr_ =
-        function(_cB_){ /*<<?>>*/ return _cq_;},
-       /*<<camlinternalFormat.ml:1881:14>>*/ _cs_ =
-        function(_cA_){ /*<<?>>*/ return _cr_;};
-      /*<<camlinternalFormat.ml:1881:14>>*/ return function(_cz_){
-       /*<<?>>*/ return _cs_;};
+       /*<<camlinternalFormat.ml:1881:28>>*/ _cr_ = make_iprintf(k, o, fmt),
+       /*<<camlinternalFormat.ml:1881:21>>*/ _cs_ =
+        function(_cC_){ /*<<?>>*/ return _cr_;},
+       /*<<camlinternalFormat.ml:1881:14>>*/ _ct_ =
+        function(_cB_){ /*<<?>>*/ return _cs_;};
+      /*<<camlinternalFormat.ml:1881:14>>*/ return function(_cA_){
+       /*<<?>>*/ return _ct_;};
     }
      /*<<camlinternalFormat.ml:1877:21>>*/  /*<<camlinternalFormat.ml:1877:21>>*/ var
-     _ct_ = make_iprintf(k, o, fmt);
-     /*<<camlinternalFormat.ml:1877:14>>*/ function _cu_(_cy_){
-      /*<<?>>*/ return _ct_;
+     _cu_ = make_iprintf(k, o, fmt);
+     /*<<camlinternalFormat.ml:1877:14>>*/ function _cv_(_cz_){
+      /*<<?>>*/ return _cu_;
     }
-     /*<<camlinternalFormat.ml:1877:14>>*/ return function(_cx_){
-      /*<<?>>*/ return _cu_;};
+     /*<<camlinternalFormat.ml:1877:14>>*/ return function(_cy_){
+      /*<<?>>*/ return _cv_;};
     /*<<camlinternalFormat.ml:1881:52>>*/ }
    function make_iprintf$0(counter, k, o, fmt){
      /*<<camlinternalFormat.ml:1788:17>>*/ var k$0 = k, fmt$0 = fmt;
@@ -17485,69 +17477,69 @@
        case 0:
          /*<<camlinternalFormat.ml:1790:14>>*/ var
          rest = fmt$0[1],
-          /*<<camlinternalFormat.ml:1790:14>>*/ _by_ =
+          /*<<camlinternalFormat.ml:1790:14>>*/ _bz_ =
            make_iprintf(k$0, o, rest);
-         /*<<camlinternalFormat.ml:1790:14>>*/ return function(_ch_){
-          /*<<?>>*/ return _by_;};
+         /*<<camlinternalFormat.ml:1790:14>>*/ return function(_ci_){
+          /*<<?>>*/ return _bz_;};
        case 1:
          /*<<camlinternalFormat.ml:1792:14>>*/ var
          rest$0 = fmt$0[1],
-          /*<<camlinternalFormat.ml:1792:14>>*/ _bz_ =
+          /*<<camlinternalFormat.ml:1792:14>>*/ _bA_ =
            make_iprintf(k$0, o, rest$0);
-         /*<<camlinternalFormat.ml:1792:14>>*/ return function(_cg_){
-          /*<<?>>*/ return _bz_;};
+         /*<<camlinternalFormat.ml:1792:14>>*/ return function(_ch_){
+          /*<<?>>*/ return _bA_;};
        case 2:
-        var _bA_ = fmt$0[1];
-        if(typeof _bA_ === "number"){
+        var _bB_ = fmt$0[1];
+        if(typeof _bB_ === "number"){
           /*<<camlinternalFormat.ml:1794:14>>*/ var
           rest$1 = fmt$0[2],
-           /*<<camlinternalFormat.ml:1794:14>>*/ _bB_ =
+           /*<<camlinternalFormat.ml:1794:14>>*/ _bC_ =
             make_iprintf(k$0, o, rest$1);
-          /*<<camlinternalFormat.ml:1794:14>>*/ return function(_cf_){
-           /*<<?>>*/ return _bB_;};
+          /*<<camlinternalFormat.ml:1794:14>>*/ return function(_cg_){
+           /*<<?>>*/ return _bC_;};
         }
-        if(0 === _bA_[0]){
+        if(0 === _bB_[0]){
           /*<<camlinternalFormat.ml:1796:14>>*/ var
           rest$2 = fmt$0[2],
-           /*<<camlinternalFormat.ml:1796:14>>*/ _bC_ =
+           /*<<camlinternalFormat.ml:1796:14>>*/ _bD_ =
             make_iprintf(k$0, o, rest$2);
-          /*<<camlinternalFormat.ml:1796:14>>*/ return function(_ce_){
-           /*<<?>>*/ return _bC_;};
+          /*<<camlinternalFormat.ml:1796:14>>*/ return function(_cf_){
+           /*<<?>>*/ return _bD_;};
         }
          /*<<camlinternalFormat.ml:1798:21>>*/ var
          rest$3 = fmt$0[2],
-          /*<<camlinternalFormat.ml:1798:21>>*/ _bD_ =
+          /*<<camlinternalFormat.ml:1798:21>>*/ _bE_ =
            make_iprintf(k$0, o, rest$3),
-          /*<<camlinternalFormat.ml:1798:14>>*/ _bE_ =
-           function(_cd_){ /*<<?>>*/ return _bD_;};
-         /*<<camlinternalFormat.ml:1798:14>>*/ return function(_cc_){
-          /*<<?>>*/ return _bE_;};
+          /*<<camlinternalFormat.ml:1798:14>>*/ _bF_ =
+           function(_ce_){ /*<<?>>*/ return _bE_;};
+         /*<<camlinternalFormat.ml:1798:14>>*/ return function(_cd_){
+          /*<<?>>*/ return _bF_;};
        case 3:
-        var _bF_ = fmt$0[1];
-        if(typeof _bF_ === "number"){
+        var _bG_ = fmt$0[1];
+        if(typeof _bG_ === "number"){
           /*<<camlinternalFormat.ml:1800:14>>*/ var
           rest$4 = fmt$0[2],
-           /*<<camlinternalFormat.ml:1800:14>>*/ _bG_ =
+           /*<<camlinternalFormat.ml:1800:14>>*/ _bH_ =
             make_iprintf(k$0, o, rest$4);
-          /*<<camlinternalFormat.ml:1800:14>>*/ return function(_cb_){
-           /*<<?>>*/ return _bG_;};
+          /*<<camlinternalFormat.ml:1800:14>>*/ return function(_cc_){
+           /*<<?>>*/ return _bH_;};
         }
-        if(0 === _bF_[0]){
+        if(0 === _bG_[0]){
           /*<<camlinternalFormat.ml:1802:14>>*/ var
           rest$5 = fmt$0[2],
-           /*<<camlinternalFormat.ml:1802:14>>*/ _bH_ =
+           /*<<camlinternalFormat.ml:1802:14>>*/ _bI_ =
             make_iprintf(k$0, o, rest$5);
-          /*<<camlinternalFormat.ml:1802:14>>*/ return function(_ca_){
-           /*<<?>>*/ return _bH_;};
+          /*<<camlinternalFormat.ml:1802:14>>*/ return function(_cb_){
+           /*<<?>>*/ return _bI_;};
         }
          /*<<camlinternalFormat.ml:1804:21>>*/ var
          rest$6 = fmt$0[2],
-          /*<<camlinternalFormat.ml:1804:21>>*/ _bI_ =
+          /*<<camlinternalFormat.ml:1804:21>>*/ _bJ_ =
            make_iprintf(k$0, o, rest$6),
-          /*<<camlinternalFormat.ml:1804:14>>*/ _bJ_ =
-           function(_b$_){ /*<<?>>*/ return _bI_;};
-         /*<<camlinternalFormat.ml:1804:14>>*/ return function(_b__){
-          /*<<?>>*/ return _bJ_;};
+          /*<<camlinternalFormat.ml:1804:14>>*/ _bK_ =
+           function(_ca_){ /*<<?>>*/ return _bJ_;};
+         /*<<camlinternalFormat.ml:1804:14>>*/ return function(_b$_){
+          /*<<?>>*/ return _bK_;};
        case 4:
         var rest$7 = fmt$0[4], prec = fmt$0[3], pad = fmt$0[2];
          /*<<camlinternalFormat.ml:1806:8>>*/ return fn_of_padding_precision
@@ -17569,31 +17561,31 @@
          /*<<camlinternalFormat.ml:1814:8>>*/ return fn_of_padding_precision
                 (k$0, o, rest$11, pad$3, prec$3);
        case 9:
-        var _bK_ = fmt$0[1];
-        if(typeof _bK_ === "number"){
+        var _bL_ = fmt$0[1];
+        if(typeof _bL_ === "number"){
           /*<<camlinternalFormat.ml:1816:14>>*/ var
           rest$12 = fmt$0[2],
-           /*<<camlinternalFormat.ml:1816:14>>*/ _bL_ =
+           /*<<camlinternalFormat.ml:1816:14>>*/ _bM_ =
             make_iprintf(k$0, o, rest$12);
-          /*<<camlinternalFormat.ml:1816:14>>*/ return function(_b9_){
-           /*<<?>>*/ return _bL_;};
+          /*<<camlinternalFormat.ml:1816:14>>*/ return function(_b__){
+           /*<<?>>*/ return _bM_;};
         }
-        if(0 === _bK_[0]){
+        if(0 === _bL_[0]){
           /*<<camlinternalFormat.ml:1818:14>>*/ var
           rest$13 = fmt$0[2],
-           /*<<camlinternalFormat.ml:1818:14>>*/ _bM_ =
+           /*<<camlinternalFormat.ml:1818:14>>*/ _bN_ =
             make_iprintf(k$0, o, rest$13);
-          /*<<camlinternalFormat.ml:1818:14>>*/ return function(_b8_){
-           /*<<?>>*/ return _bM_;};
+          /*<<camlinternalFormat.ml:1818:14>>*/ return function(_b9_){
+           /*<<?>>*/ return _bN_;};
         }
          /*<<camlinternalFormat.ml:1820:21>>*/ var
          rest$14 = fmt$0[2],
-          /*<<camlinternalFormat.ml:1820:21>>*/ _bN_ =
+          /*<<camlinternalFormat.ml:1820:21>>*/ _bO_ =
            make_iprintf(k$0, o, rest$14),
-          /*<<camlinternalFormat.ml:1820:14>>*/ _bO_ =
-           function(_b7_){ /*<<?>>*/ return _bN_;};
-         /*<<camlinternalFormat.ml:1820:14>>*/ return function(_b6_){
-          /*<<?>>*/ return _bO_;};
+          /*<<camlinternalFormat.ml:1820:14>>*/ _bP_ =
+           function(_b8_){ /*<<?>>*/ return _bO_;};
+         /*<<camlinternalFormat.ml:1820:14>>*/ return function(_b7_){
+          /*<<?>>*/ return _bP_;};
        case 10:
         var rest$15 = fmt$0[1], fmt$0 = rest$15; break;
        case 11:
@@ -17603,45 +17595,45 @@
        case 13:
          /*<<camlinternalFormat.ml:1838:14>>*/ var
          rest$18 = fmt$0[3],
-          /*<<camlinternalFormat.ml:1838:14>>*/ _bP_ =
+          /*<<camlinternalFormat.ml:1838:14>>*/ _bQ_ =
            make_iprintf(k$0, o, rest$18);
-         /*<<camlinternalFormat.ml:1838:14>>*/ return function(_b5_){
-          /*<<?>>*/ return _bP_;};
+         /*<<camlinternalFormat.ml:1838:14>>*/ return function(_b6_){
+          /*<<?>>*/ return _bQ_;};
        case 14:
         var rest$19 = fmt$0[3], fmtty = fmt$0[2];
          /*<<camlinternalFormat.ml:1840:8>>*/ return function(param){
           /*<<camlinternalFormat.ml:1840:8>>*/ var
           fmt = param[1],
-           /*<<camlinternalFormat.ml:1842:24>>*/ _b4_ = recast(fmt, fmtty);
+           /*<<camlinternalFormat.ml:1842:24>>*/ _b5_ = recast(fmt, fmtty);
           /*<<camlinternalFormat.ml:1842:12>>*/ return make_iprintf
                  (k$0,
                   o,
                    /*<<camlinternalFormat.ml:1842:12>>*/ caml_call2
-                   (CamlinternalFormatBasics[3], _b4_, rest$19)); /*<<camlinternalFormat.ml:1842:48>>*/ };
+                   (CamlinternalFormatBasics[3], _b5_, rest$19)); /*<<camlinternalFormat.ml:1842:48>>*/ };
        case 15:
          /*<<camlinternalFormat.ml:1822:21>>*/ var
          rest$20 = fmt$0[1],
-          /*<<camlinternalFormat.ml:1822:21>>*/ _bQ_ =
+          /*<<camlinternalFormat.ml:1822:21>>*/ _bR_ =
            make_iprintf(k$0, o, rest$20),
-          /*<<camlinternalFormat.ml:1822:14>>*/ _bR_ =
-           function(_b3_){ /*<<?>>*/ return _bQ_;};
-         /*<<camlinternalFormat.ml:1822:14>>*/ return function(_b2_){
-          /*<<?>>*/ return _bR_;};
+          /*<<camlinternalFormat.ml:1822:14>>*/ _bS_ =
+           function(_b4_){ /*<<?>>*/ return _bR_;};
+         /*<<camlinternalFormat.ml:1822:14>>*/ return function(_b3_){
+          /*<<?>>*/ return _bS_;};
        case 16:
          /*<<camlinternalFormat.ml:1824:14>>*/ var
          rest$21 = fmt$0[1],
-          /*<<camlinternalFormat.ml:1824:14>>*/ _bS_ =
+          /*<<camlinternalFormat.ml:1824:14>>*/ _bT_ =
            make_iprintf(k$0, o, rest$21);
-         /*<<camlinternalFormat.ml:1824:14>>*/ return function(_b1_){
-          /*<<?>>*/ return _bS_;};
+         /*<<camlinternalFormat.ml:1824:14>>*/ return function(_b2_){
+          /*<<?>>*/ return _bT_;};
        case 17:
         var rest$22 = fmt$0[2], fmt$0 = rest$22; break;
        case 18:
-        var _bT_ = fmt$0[1];
-        if(0 === _bT_[0])
+        var _bU_ = fmt$0[1];
+        if(0 === _bU_[0])
          var
           rest$23 = fmt$0[2],
-          fmt$1 = _bT_[1][1],
+          fmt$1 = _bU_[1][1],
           k$3 =
             function(k, rest){
              function k$0(koc){
@@ -17656,7 +17648,7 @@
         else
          var
           rest$24 = fmt$0[2],
-          fmt$2 = _bT_[1][1],
+          fmt$2 = _bU_[1][1],
           k$4 =
             function(k, rest){
              function k$0(koc){
@@ -17675,32 +17667,32 @@
        case 20:
          /*<<camlinternalFormat.ml:1844:14>>*/ var
          rest$25 = fmt$0[3],
-          /*<<camlinternalFormat.ml:1844:14>>*/ _bU_ =
+          /*<<camlinternalFormat.ml:1844:14>>*/ _bV_ =
            make_iprintf(k$0, o, rest$25);
-         /*<<camlinternalFormat.ml:1844:14>>*/ return function(_b0_){
-          /*<<?>>*/ return _bU_;};
+         /*<<camlinternalFormat.ml:1844:14>>*/ return function(_b1_){
+          /*<<?>>*/ return _bV_;};
        case 21:
          /*<<camlinternalFormat.ml:1846:14>>*/ var
          rest$26 = fmt$0[2],
-          /*<<camlinternalFormat.ml:1846:14>>*/ _bV_ =
+          /*<<camlinternalFormat.ml:1846:14>>*/ _bW_ =
            make_iprintf(k$0, o, rest$26);
-         /*<<camlinternalFormat.ml:1846:14>>*/ return function(_bZ_){
-          /*<<?>>*/ return _bV_;};
+         /*<<camlinternalFormat.ml:1846:14>>*/ return function(_b0_){
+          /*<<?>>*/ return _bW_;};
        case 22:
          /*<<camlinternalFormat.ml:1848:14>>*/ var
          rest$27 = fmt$0[1],
-          /*<<camlinternalFormat.ml:1848:14>>*/ _bW_ =
+          /*<<camlinternalFormat.ml:1848:14>>*/ _bX_ =
            make_iprintf(k$0, o, rest$27);
-         /*<<camlinternalFormat.ml:1848:14>>*/ return function(_bY_){
-          /*<<?>>*/ return _bW_;};
+         /*<<camlinternalFormat.ml:1848:14>>*/ return function(_bZ_){
+          /*<<?>>*/ return _bX_;};
        case 23:
-        var rest$28 = fmt$0[2], ign = fmt$0[1], _bX_ = 0;
+        var rest$28 = fmt$0[2], ign = fmt$0[1], _bY_ = 0;
          /*<<camlinternalFormat.ml:1850:8>>*/ return make_ignored_param
                 (function(param){
                    /*<<camlinternalFormat.ml:1850:37>>*/ return caml_call1
                           (k$0, o);
                   /*<<camlinternalFormat.ml:1850:40>>*/ },
-                 _bX_,
+                 _bY_,
                  ign,
                  rest$28);
        default:
@@ -17718,10 +17710,10 @@
      /*<<camlinternalFormat.ml:1882:4>>*/ if(param){
       /*<<camlinternalFormat.ml:1889:14>>*/ var
       arity = param[1],
-       /*<<camlinternalFormat.ml:1889:14>>*/ _bw_ =
+       /*<<camlinternalFormat.ml:1889:14>>*/ _bx_ =
         fn_of_custom_arity(k, o, fmt, arity);
-      /*<<camlinternalFormat.ml:1889:14>>*/ return function(_bx_){
-       /*<<?>>*/ return _bw_;};
+      /*<<camlinternalFormat.ml:1889:14>>*/ return function(_by_){
+       /*<<?>>*/ return _bx_;};
     }
      /*<<camlinternalFormat.ml:1887:8>>*/ if(counter >= 50)
       /*<<camlinternalFormat.ml:1887:8>>*/ return  /*<<camlinternalFormat.ml:1887:8>>*/ caml_trampoline_return
@@ -17892,9 +17884,9 @@
         var f = acc$0[2], p$3 = acc$0[1];
          /*<<camlinternalFormat.ml:1950:32>>*/ strput_acc(b, p$3);
          /*<<camlinternalFormat.ml:1950:68>>*/  /*<<camlinternalFormat.ml:1950:68>>*/ var
-         _bv_ =  /*<<camlinternalFormat.ml:1950:68>>*/ caml_call1(f, 0);
+         _bw_ =  /*<<camlinternalFormat.ml:1950:68>>*/ caml_call1(f, 0);
          /*<<camlinternalFormat.ml:1950:68>>*/ return  /*<<camlinternalFormat.ml:1950:68>>*/ caml_call2
-                (Stdlib_Buffer[16], b, _bv_);
+                (Stdlib_Buffer[16], b, _bw_);
        case 7:
         var acc$3 = acc$0[1], acc$0 = acc$3; break;
        case 8:
@@ -17925,11 +17917,11 @@
     function k(acc){
       /*<<camlinternalFormat.ml:1961:14>>*/ strput_acc(buf, acc);
       /*<<camlinternalFormat.ml:1961:43>>*/  /*<<camlinternalFormat.ml:1961:43>>*/ var
-      _bu_ =
+      _bv_ =
          /*<<camlinternalFormat.ml:1961:43>>*/ caml_call1
          (Stdlib_Buffer[2], buf);
       /*<<camlinternalFormat.ml:1961:43>>*/ return  /*<<camlinternalFormat.ml:1961:43>>*/ caml_call1
-             (Stdlib[2], _bu_);
+             (Stdlib[2], _bv_);
      /*<<camlinternalFormat.ml:1961:64>>*/ }
      /*<<camlinternalFormat.ml:1962:2>>*/ return make_printf(k, 0, fmt);
    }
@@ -18004,15 +17996,15 @@
       else
         /*<<camlinternalFormat.ml:1994:8>>*/ try{
          /*<<camlinternalFormat.ml:1994:12>>*/ var
-          /*<<camlinternalFormat.ml:1994:12>>*/ _bs_ =
+          /*<<camlinternalFormat.ml:1994:12>>*/ _bt_ =
             /*<<camlinternalFormat.ml:1994:12>>*/ runtime.caml_int_of_string
             ( /*<<camlinternalFormat.ml:1994:26>>*/ caml_call3
               (Stdlib_String[15], str, nstart, nend - nstart | 0)),
-         indent = _bs_;
+         indent = _bt_;
        }
-       catch(_bt_){
-        var _br_ = caml_wrap_exception(_bt_);
-        if(_br_[1] !== Stdlib[7]) throw caml_maybe_attach_backtrace(_br_, 0);
+       catch(_bu_){
+        var _bs_ = caml_wrap_exception(_bu_);
+        if(_bs_[1] !== Stdlib[7]) throw caml_maybe_attach_backtrace(_bs_, 0);
         var indent = invalid_box(0);
        }
        /*<<camlinternalFormat.ml:1996:18>>*/  /*<<camlinternalFormat.ml:1996:18>>*/ var
@@ -18078,7 +18070,7 @@
     (end_ind){
       /*<<camlinternalFormat.ml:2092:4>>*/ invalid_format_message
       (end_ind, cst_unexpected_end_of_format);
-      /*<<camlinternalFormat.ml:2092:4>>*/ return sentinal;
+      /*<<camlinternalFormat.ml:2092:4>>*/ return _$_;
      /*<<camlinternalFormat.ml:2093:32>>*/ }
     function invalid_format_without(str_ind, c, s){
       /*<<camlinternalFormat.ml:2104:4>>*/ return  /*<<camlinternalFormat.ml:2104:4>>*/ caml_call4
@@ -18216,9 +18208,9 @@
              b:
              try{
               var
-               _bg_ = str_ind$3 === end_ind ? 1 : 0,
-               _bh_ =
-                 _bg_
+               _bh_ = str_ind$3 === end_ind ? 1 : 0,
+               _bi_ =
+                 _bh_
                  ||
                   (60
                     !==
@@ -18226,7 +18218,7 @@
                       (str, str_ind$3)
                     ? 1
                     : 0);
-              if(_bh_)
+              if(_bi_)
                 /*<<camlinternalFormat.ml:2666:58>>*/ throw  /*<<camlinternalFormat.ml:2666:58>>*/ caml_maybe_attach_backtrace
                       (Stdlib[8], 1);
                /*<<camlinternalFormat.ml:2667:24>>*/ var
@@ -18265,12 +18257,12 @@
                      str,
                      str_ind$3 - 2 | 0,
                      (str_ind_3 - str_ind$3 | 0) + 3 | 0),
-                  /*<<camlinternalFormat.ml:2675:31>>*/ _bi_ =
-                   [0, s, width, 0],
                   /*<<camlinternalFormat.ml:2675:31>>*/ _bj_ =
+                   [0, s, width, 0],
+                  /*<<camlinternalFormat.ml:2675:31>>*/ _bk_ =
                    str_ind_3 + 1 | 0,
-                 formatting_lit$0 = _bi_,
-                 next_ind = _bj_;
+                 formatting_lit$0 = _bj_,
+                 next_ind = _bk_;
                 break b;
                }
               }
@@ -18296,21 +18288,21 @@
                     str,
                     str_ind$3 - 2 | 0,
                     (str_ind_5 - str_ind$3 | 0) + 3 | 0),
-                 /*<<camlinternalFormat.ml:2681:31>>*/ _bk_ =
-                  [0, s$0, width, offset],
                  /*<<camlinternalFormat.ml:2681:31>>*/ _bl_ =
+                  [0, s$0, width, offset],
+                 /*<<camlinternalFormat.ml:2681:31>>*/ _bm_ =
                   str_ind_5 + 1 | 0,
-                formatting_lit$0 = _bk_,
-                next_ind = _bl_;
+                formatting_lit$0 = _bl_,
+                next_ind = _bm_;
                break b;
               }
                /*<<camlinternalFormat.ml:2682:21>>*/ throw  /*<<camlinternalFormat.ml:2682:21>>*/ caml_maybe_attach_backtrace
                      (Stdlib[8], 1);
              }
-             catch(_bq_){
-              var _bf_ = caml_wrap_exception(_bq_);
-              if(_bf_ !== Stdlib[8] && _bf_[1] !== Stdlib[7])
-               throw caml_maybe_attach_backtrace(_bf_, 0);
+             catch(_br_){
+              var _bg_ = caml_wrap_exception(_br_);
+              if(_bg_ !== Stdlib[8] && _bg_[1] !== Stdlib[7])
+               throw caml_maybe_attach_backtrace(_bg_, 0);
               var formatting_lit$0 = formatting_lit, next_ind = str_ind$3;
              }
              var
@@ -18334,7 +18326,7 @@
                  if(58 > match$6) break c;
                 }
                 else if(45 === match$6) break c;
-                var _bo_ = 0;
+                var _bp_ = 0;
                 break b;
                }
                 /*<<camlinternalFormat.ml:2699:32>>*/ var
@@ -18358,28 +18350,28 @@
                     str,
                     str_ind$4 - 2 | 0,
                     (str_ind_3$0 - str_ind$4 | 0) + 3 | 0),
-                _bo_ = [0, [0, str_ind_3$0 + 1 | 0, [1, s$1, size]]];
+                _bp_ = [0, [0, str_ind_3$0 + 1 | 0, [1, s$1, size]]];
               }
-              var _bn_ = _bo_;
+              var _bo_ = _bp_;
              }
-             catch(_bp_){
-              var _bm_ = caml_wrap_exception(_bp_);
-              if(_bm_ !== Stdlib[8] && _bm_[1] !== Stdlib[7])
-               throw caml_maybe_attach_backtrace(_bm_, 0);
-              var _bn_ = 0;
+             catch(_bq_){
+              var _bn_ = caml_wrap_exception(_bq_);
+              if(_bn_ !== Stdlib[8] && _bn_[1] !== Stdlib[7])
+               throw caml_maybe_attach_backtrace(_bn_, 0);
+              var _bo_ = 0;
              }
-             if(_bn_)
+             if(_bo_)
               var
-               match$5 = _bn_[1],
+               match$5 = _bo_[1],
                formatting_lit$1 = match$5[2],
                next_ind$0 = match$5[1],
                fmt_rest$13 = parse(next_ind$0, end_ind)[1],
-               _be_ = [0, [17, formatting_lit$1, fmt_rest$13]];
+               _bf_ = [0, [17, formatting_lit$1, fmt_rest$13]];
              else
               var
                fmt_rest$14 = parse(str_ind$4, end_ind)[1],
-               _be_ = [0, [17, _Q_, fmt_rest$14]];
-             var match$0 = _be_;
+               _bf_ = [0, [17, _Q_, fmt_rest$14]];
+             var match$0 = _bf_;
              break a;
             case 31:
              var
@@ -18537,29 +18529,29 @@
             /*<<camlinternalFormat.ml:2536:22>>*/ var
              /*<<camlinternalFormat.ml:2536:22>>*/ ignored$2 =
               [9, get_pad_opt(95), sub_fmtty],
-            _aN_ = [0, [23, ignored$2, fmt_rest$7]];
+            _aO_ = [0, [23, ignored$2, fmt_rest$7]];
           else
-           var _aN_ = [0, [14, get_pad_opt(40), sub_fmtty, fmt_rest$7]];
-          var fmt_result = _aN_;
+           var _aO_ = [0, [14, get_pad_opt(40), sub_fmtty, fmt_rest$7]];
+          var fmt_result = _aO_;
           break a;
          case 44:
           var fmt_result = parse(str_ind, end_ind); break a;
          case 67:
            /*<<camlinternalFormat.ml:2397:9>>*/ var
            fmt_rest$10 = parse(str_ind, end_ind)[1],
-            /*<<camlinternalFormat.ml:2397:9>>*/ _aP_ =
+            /*<<camlinternalFormat.ml:2397:9>>*/ _aQ_ =
              get_ign(0) ? [0, [23, 1, fmt_rest$10]] : [0, [1, fmt_rest$10]],
-           fmt_result = _aP_;
+           fmt_result = _aQ_;
           break a;
          case 78:
           var fmt_rest$14 = parse(str_ind, end_ind)[1], counter$0 = 2;
            /*<<camlinternalFormat.ml:2433:9>>*/ if(get_ign(0))
             /*<<camlinternalFormat.ml:2434:22>>*/ var
              /*<<camlinternalFormat.ml:2434:22>>*/ ignored$6 = [11, counter$0],
-            _aV_ = [0, [23, ignored$6, fmt_rest$14]];
+            _aW_ = [0, [23, ignored$6, fmt_rest$14]];
           else
-           var _aV_ = [0, [21, counter$0, fmt_rest$14]];
-          var fmt_result = _aV_;
+           var _aW_ = [0, [21, counter$0, fmt_rest$14]];
+          var fmt_result = _aW_;
           break a;
          case 83:
            /*<<camlinternalFormat.ml:2410:16>>*/ var
@@ -18570,15 +18562,15 @@
             /*<<camlinternalFormat.ml:2413:22>>*/ var
              /*<<camlinternalFormat.ml:2413:22>>*/ ignored$7 =
               [1, get_padprec_opt(95)],
-            _aW_ = [0, [23, ignored$7, fmt_rest$15]];
+            _aX_ = [0, [23, ignored$7, fmt_rest$15]];
           else
             /*<<camlinternalFormat.ml:2417:10>>*/ var
              /*<<camlinternalFormat.ml:2417:10>>*/ match$5 =
               make_padding_fmt_ebb(pad$6, fmt_rest$15),
             fmt_rest$16 = match$5[2],
             pad$7 = match$5[1],
-            _aW_ = [0, [3, pad$7, fmt_rest$16]];
-          var fmt_result = _aW_;
+            _aX_ = [0, [3, pad$7, fmt_rest$16]];
+          var fmt_result = _aX_;
           break a;
          case 91:
           if(str_ind === end_ind)
@@ -18591,7 +18583,7 @@
              function(c){
                /*<<camlinternalFormat.ml:2721:6>>*/ add_in_char_set
                (char_set, c);
-               /*<<camlinternalFormat.ml:2721:6>>*/ return sentinal;
+               /*<<camlinternalFormat.ml:2721:6>>*/ return _$_;
               /*<<camlinternalFormat.ml:2721:32>>*/ },
            add_range =
              function(c$0, c){
@@ -18603,12 +18595,12 @@
                    /*<<camlinternalFormat.ml:2725:33>>*/ caml_call1
                    (Stdlib[29], i));
                  /*<<camlinternalFormat.ml:2725:8>>*/  /*<<camlinternalFormat.ml:2725:8>>*/ var
-                 _bd_ = i + 1 | 0;
+                 _be_ = i + 1 | 0;
                 if(c === i) break;
-                var i = _bd_;
+                var i = _be_;
                }
               }
-              return sentinal;
+              return _$_;
               /*<<camlinternalFormat.ml:2726:10>>*/ },
            fail_single_percent =
              function(str_ind){
@@ -18630,13 +18622,13 @@
                 if(93 === c)
                   /*<<camlinternalFormat.ml:2746:8>>*/ return str_ind$0 + 1
                         | 0;
-                var _bc_ = str_ind$0 + 1 | 0;
+                var _bd_ = str_ind$0 + 1 | 0;
                  /*<<camlinternalFormat.ml:2751:8>>*/ if(counter >= 50)
                   /*<<camlinternalFormat.ml:2751:8>>*/ return  /*<<camlinternalFormat.ml:2751:8>>*/ caml_trampoline_return
-                         (parse_char_set_after_char$0, [0, _bc_, end_ind, c]);
+                         (parse_char_set_after_char$0, [0, _bd_, end_ind, c]);
                 var counter$0 = counter + 1 | 0;
                  /*<<camlinternalFormat.ml:2751:8>>*/ return parse_char_set_after_char$0
-                        (counter$0, _bc_, end_ind, c);
+                        (counter$0, _bd_, end_ind, c);
                }
                 /*<<camlinternalFormat.ml:2748:8>>*/ add_char(45);
                var str_ind$1 = str_ind$0 + 1 | 0, str_ind$0 = str_ind$1;
@@ -18687,13 +18679,13 @@
                     /*<<camlinternalFormat.ml:2787:17>>*/ return fail_single_percent
                            (str_ind$2);
                    /*<<camlinternalFormat.ml:2785:12>>*/ add_range(c$0, c$3);
-                  var _ba_ = str_ind$2 + 2 | 0;
+                  var _bb_ = str_ind$2 + 2 | 0;
                    /*<<camlinternalFormat.ml:2785:12>>*/ if(counter >= 50)
                     /*<<camlinternalFormat.ml:2785:12>>*/ return  /*<<camlinternalFormat.ml:2785:12>>*/ caml_trampoline_return
-                           (parse_char_set_content, [0, _ba_, end_ind]);
+                           (parse_char_set_content, [0, _bb_, end_ind]);
                   var counter$2 = counter + 1 | 0;
                    /*<<camlinternalFormat.ml:2785:12>>*/ return parse_char_set_content
-                          (counter$2, _ba_, end_ind);
+                          (counter$2, _bb_, end_ind);
                  }
                  if(93 === c$2){
                    /*<<camlinternalFormat.ml:2778:8>>*/ add_char(c$0);
@@ -18702,23 +18694,23 @@
                          | 0;
                  }
                   /*<<camlinternalFormat.ml:2790:8>>*/ add_range(c$0, c$2);
-                 var _bb_ = str_ind$2 + 1 | 0;
+                 var _bc_ = str_ind$2 + 1 | 0;
                   /*<<camlinternalFormat.ml:2790:8>>*/ if(counter >= 50)
                    /*<<camlinternalFormat.ml:2790:8>>*/ return  /*<<camlinternalFormat.ml:2790:8>>*/ caml_trampoline_return
-                          (parse_char_set_content, [0, _bb_, end_ind]);
+                          (parse_char_set_content, [0, _bc_, end_ind]);
                  var counter$1 = counter + 1 | 0;
                   /*<<camlinternalFormat.ml:2790:8>>*/ return parse_char_set_content
-                         (counter$1, _bb_, end_ind);
+                         (counter$1, _bc_, end_ind);
                 }
                 if(37 === c$0){
                   /*<<camlinternalFormat.ml:2763:8>>*/ add_char(c$1);
-                 var _a$_ = str_ind$0 + 1 | 0;
+                 var _ba_ = str_ind$0 + 1 | 0;
                   /*<<camlinternalFormat.ml:2763:8>>*/ if(counter >= 50)
                    /*<<camlinternalFormat.ml:2763:8>>*/ return  /*<<camlinternalFormat.ml:2763:8>>*/ caml_trampoline_return
-                          (parse_char_set_content, [0, _a$_, end_ind]);
+                          (parse_char_set_content, [0, _ba_, end_ind]);
                  var counter$0 = counter + 1 | 0;
                   /*<<camlinternalFormat.ml:2763:8>>*/ return parse_char_set_content
-                         (counter$0, _a$_, end_ind);
+                         (counter$0, _ba_, end_ind);
                 }
                }
                if(37 === c$0)
@@ -18768,10 +18760,10 @@
             /*<<camlinternalFormat.ml:2544:22>>*/ var
              /*<<camlinternalFormat.ml:2544:22>>*/ ignored$9 =
               [10, get_pad_opt(95), char_set$1],
-            _a1_ = [0, [23, ignored$9, fmt_rest$19]];
+            _a2_ = [0, [23, ignored$9, fmt_rest$19]];
           else
-           var _a1_ = [0, [20, get_pad_opt(91), char_set$1, fmt_rest$19]];
-          var fmt_result = _a1_;
+           var _a2_ = [0, [20, get_pad_opt(91), char_set$1, fmt_rest$19]];
+          var fmt_result = _a2_;
           break a;
          case 97:
           var
@@ -18791,28 +18783,28 @@
           if(match$7){
            if(0 === match$7[1])
              /*<<camlinternalFormat.ml:2382:11>>*/ var
-              /*<<camlinternalFormat.ml:2382:11>>*/ _a2_ =
+              /*<<camlinternalFormat.ml:2382:11>>*/ _a3_ =
                get_ign(0) ? [0, [23, 3, fmt_rest$21]] : [0, [22, fmt_rest$21]],
-             _a3_ = _a2_;
+             _a4_ = _a3_;
            else
             var
-             _a3_ =
+             _a4_ =
                legacy_behavior$0
                 ? char_format(fmt_rest$21)
                 : invalid_format_message
                   (str_ind, cst_non_zero_widths_are_unsupp);
-           var _a4_ = _a3_;
+           var _a5_ = _a4_;
           }
           else
-           var _a4_ = char_format(fmt_rest$21);
-          var fmt_result = _a4_;
+           var _a5_ = char_format(fmt_rest$21);
+          var fmt_result = _a5_;
           break a;
          case 114:
            /*<<camlinternalFormat.ml:2512:9>>*/ var
            fmt_rest$22 = parse(str_ind, end_ind)[1],
-            /*<<camlinternalFormat.ml:2512:9>>*/ _a5_ =
+            /*<<camlinternalFormat.ml:2512:9>>*/ _a6_ =
              get_ign(0) ? [0, [23, 2, fmt_rest$22]] : [0, [19, fmt_rest$22]],
-           fmt_result = _a5_;
+           fmt_result = _a6_;
           break a;
          case 115:
            /*<<camlinternalFormat.ml:2400:16>>*/ var
@@ -18823,15 +18815,15 @@
             /*<<camlinternalFormat.ml:2403:22>>*/ var
              /*<<camlinternalFormat.ml:2403:22>>*/ ignored$10 =
               [0, get_padprec_opt(95)],
-            _a6_ = [0, [23, ignored$10, fmt_rest$23]];
+            _a7_ = [0, [23, ignored$10, fmt_rest$23]];
           else
             /*<<camlinternalFormat.ml:2407:10>>*/ var
              /*<<camlinternalFormat.ml:2407:10>>*/ match$8 =
               make_padding_fmt_ebb(pad$9, fmt_rest$23),
             fmt_rest$24 = match$8[2],
             pad$10 = match$8[1],
-            _a6_ = [0, [2, pad$10, fmt_rest$24]];
-          var fmt_result = _a6_;
+            _a7_ = [0, [2, pad$10, fmt_rest$24]];
+          var fmt_result = _a7_;
           break a;
          case 116:
           var
@@ -18850,10 +18842,10 @@
             /*<<camlinternalFormat.ml:2526:22>>*/ var
              /*<<camlinternalFormat.ml:2526:22>>*/ ignored$11 =
               [8, get_pad_opt(95), sub_fmtty$0],
-            _a7_ = [0, [23, ignored$11, fmt_rest$26]];
+            _a8_ = [0, [23, ignored$11, fmt_rest$26]];
           else
-           var _a7_ = [0, [13, get_pad_opt(123), sub_fmtty$0, fmt_rest$26]];
-          var fmt_result = _a7_;
+           var _a8_ = [0, [13, get_pad_opt(123), sub_fmtty$0, fmt_rest$26]];
+          var fmt_result = _a8_;
           break a;
          case 66:
          case 98:
@@ -18865,15 +18857,15 @@
             /*<<camlinternalFormat.ml:2498:22>>*/ var
              /*<<camlinternalFormat.ml:2498:22>>*/ ignored$3 =
               [7, get_padprec_opt(95)],
-            _aO_ = [0, [23, ignored$3, fmt_rest$8]];
+            _aP_ = [0, [23, ignored$3, fmt_rest$8]];
           else
             /*<<camlinternalFormat.ml:2502:10>>*/ var
              /*<<camlinternalFormat.ml:2502:10>>*/ match$3 =
               make_padding_fmt_ebb(pad$3, fmt_rest$8),
             fmt_rest$9 = match$3[2],
             pad$4 = match$3[1],
-            _aO_ = [0, [9, pad$4, fmt_rest$9]];
-          var fmt_result = _aO_;
+            _aP_ = [0, [9, pad$4, fmt_rest$9]];
+          var fmt_result = _aP_;
           break a;
          case 37:
          case 64:
@@ -18889,22 +18881,22 @@
              /*<<camlinternalFormat.ml:2438:63>>*/ symb$0 =
                /*<<camlinternalFormat.ml:2438:63>>*/ caml_string_get
                (str, str_ind),
-             /*<<camlinternalFormat.ml:2892:25>>*/ _a8_ = symb$0 - 88 | 0;
+             /*<<camlinternalFormat.ml:2892:25>>*/ _a9_ = symb$0 - 88 | 0;
            b:
            {
-            if(32 >= _a8_ >>> 0)
-             switch(_a8_){
+            if(32 >= _a9_ >>> 0)
+             switch(_a9_){
                case 0:
                case 12:
                case 17:
                case 23:
                case 29:
                case 32:
-                var _aU_ = 1; break b;
+                var _aV_ = 1; break b;
              }
-            var _aU_ = 0;
+            var _aV_ = 0;
            }
-            /*<<camlinternalFormat.ml:2438:50>>*/ if(_aU_) break;
+            /*<<camlinternalFormat.ml:2438:50>>*/ if(_aV_) break;
           }
           var fmt_rest$13 = parse(str_ind, end_ind)[1];
           b:
@@ -18925,10 +18917,10 @@
            /*<<camlinternalFormat.ml:2441:9>>*/ if(get_ign(0))
             /*<<camlinternalFormat.ml:2442:22>>*/ var
              /*<<camlinternalFormat.ml:2442:22>>*/ ignored$5 = [11, counter],
-            _aT_ = [0, [23, ignored$5, fmt_rest$13]];
+            _aU_ = [0, [23, ignored$5, fmt_rest$13]];
           else
-           var _aT_ = [0, [21, counter, fmt_rest$13]];
-          var fmt_result = _aT_;
+           var _aU_ = [0, [21, counter, fmt_rest$13]];
+          var fmt_result = _aU_;
           break a;
          case 32:
          case 35:
@@ -18947,26 +18939,26 @@
          case 117:
          case 120:
            /*<<camlinternalFormat.ml:2421:8>>*/ var
-            /*<<camlinternalFormat.ml:2421:8>>*/ _aX_ = get_space(0),
-            /*<<camlinternalFormat.ml:2420:65>>*/ _aY_ = get_hash(0),
+            /*<<camlinternalFormat.ml:2421:8>>*/ _aY_ = get_space(0),
+            /*<<camlinternalFormat.ml:2420:65>>*/ _aZ_ = get_hash(0),
             /*<<camlinternalFormat.ml:2420:18>>*/ iconv$2 =
-             compute_int_conv(pct_ind, str_ind, get_plus(0), _aY_, _aX_, symb),
+             compute_int_conv(pct_ind, str_ind, get_plus(0), _aZ_, _aY_, symb),
            fmt_rest$17 = parse(str_ind, end_ind)[1];
            /*<<camlinternalFormat.ml:2423:9>>*/ if(get_ign(0))
             /*<<camlinternalFormat.ml:2424:22>>*/ var
              /*<<camlinternalFormat.ml:2424:22>>*/ ignored$8 =
               [2, iconv$2, get_pad_opt(95)],
-            _aZ_ = [0, [23, ignored$8, fmt_rest$17]];
+            _a0_ = [0, [23, ignored$8, fmt_rest$17]];
           else
             /*<<camlinternalFormat.ml:2428:48>>*/ var
-             /*<<camlinternalFormat.ml:2428:48>>*/ _a0_ = get_prec(0),
+             /*<<camlinternalFormat.ml:2428:48>>*/ _a1_ = get_prec(0),
              /*<<camlinternalFormat.ml:2428:10>>*/ match$6 =
-              make_padprec_fmt_ebb(get_int_pad(0), _a0_, fmt_rest$17),
+              make_padprec_fmt_ebb(get_int_pad(0), _a1_, fmt_rest$17),
             fmt_rest$18 = match$6[3],
             prec$4 = match$6[2],
             pad$8 = match$6[1],
-            _aZ_ = [0, [4, iconv$2, pad$8, prec$4, fmt_rest$18]];
-          var fmt_result = _aZ_;
+            _a0_ = [0, [4, iconv$2, pad$8, prec$4, fmt_rest$18]];
+          var fmt_result = _a0_;
           break a;
          case 69:
          case 70:
@@ -18996,28 +18988,28 @@
             if(3 >= switcher >>> 0){
              switch(switcher){
                case 0:
-                var _a9_ = 1; break;
+                var _a__ = 1; break;
                case 1:
-                var _a9_ = 0; break;
+                var _a__ = 0; break;
                case 2:
-                var _a9_ = 3; break;
-               default: var _a9_ = 6;
+                var _a__ = 3; break;
+               default: var _a__ = 6;
              }
-             var kind = _a9_;
+             var kind = _a__;
              break b;
             }
            }
            else if(69 <= symb){
             switch(symb - 69 | 0){
               case 0:
-               var _a__ = 2; break;
+               var _a$_ = 2; break;
               case 1:
                break c;
               case 2:
-               var _a__ = 4; break;
-              default: var _a__ = 7;
+               var _a$_ = 4; break;
+              default: var _a$_ = 7;
             }
-            var kind = _a__;
+            var kind = _a$_;
             break b;
            }
            if(hash$1){
@@ -19035,25 +19027,25 @@
             match = get_prec(0);
            if(typeof match === "number")
             var
-             _aQ_ =
+             _aR_ =
                match ? incompatible_flag(pct_ind, str_ind, 95, cst$26) : 0;
            else
-            var ndec = match[1], _aQ_ = [0, ndec];
+            var ndec = match[1], _aR_ = [0, ndec];
             /*<<camlinternalFormat.ml:2488:22>>*/ var
              /*<<camlinternalFormat.ml:2488:22>>*/ ignored$4 =
-              [6, get_pad_opt(95), _aQ_],
-            _aR_ = [0, [23, ignored$4, fmt_rest$11]];
+              [6, get_pad_opt(95), _aR_],
+            _aS_ = [0, [23, ignored$4, fmt_rest$11]];
           }
           else
             /*<<camlinternalFormat.ml:2492:44>>*/ var
-             /*<<camlinternalFormat.ml:2492:44>>*/ _aS_ = get_prec(0),
+             /*<<camlinternalFormat.ml:2492:44>>*/ _aT_ = get_prec(0),
              /*<<camlinternalFormat.ml:2492:10>>*/ match$4 =
-              make_padprec_fmt_ebb(get_pad(0), _aS_, fmt_rest$11),
+              make_padprec_fmt_ebb(get_pad(0), _aT_, fmt_rest$11),
             fmt_rest$12 = match$4[3],
             prec$3 = match$4[2],
             pad$5 = match$4[1],
-            _aR_ = [0, [8, fconv, pad$5, prec$3, fmt_rest$12]];
-          var fmt_result = _aR_;
+            _aS_ = [0, [8, fconv, pad$5, prec$3, fmt_rest$12]];
+          var fmt_result = _aS_;
           break a;
        }
       b:
@@ -19062,89 +19054,89 @@
         switch(symb - 108 | 0){
           case 0:
             /*<<camlinternalFormat.ml:2449:25>>*/ var
-             /*<<camlinternalFormat.ml:2449:25>>*/ _ax_ =
+             /*<<camlinternalFormat.ml:2449:25>>*/ _ay_ =
                /*<<camlinternalFormat.ml:2449:25>>*/ caml_string_get
                (str, str_ind),
-             /*<<camlinternalFormat.ml:2449:10>>*/ _ay_ = get_space(0),
-             /*<<camlinternalFormat.ml:2448:61>>*/ _az_ = get_hash(0),
+             /*<<camlinternalFormat.ml:2449:10>>*/ _az_ = get_space(0),
+             /*<<camlinternalFormat.ml:2448:61>>*/ _aA_ = get_hash(0),
              /*<<camlinternalFormat.ml:2448:8>>*/ iconv =
               compute_int_conv
-               (pct_ind, str_ind + 1 | 0, get_plus(0), _az_, _ay_, _ax_),
+               (pct_ind, str_ind + 1 | 0, get_plus(0), _aA_, _az_, _ay_),
             fmt_rest = parse(str_ind + 1 | 0, end_ind)[1];
             /*<<camlinternalFormat.ml:2451:9>>*/ if(get_ign(0))
              /*<<camlinternalFormat.ml:2452:22>>*/ var
               /*<<camlinternalFormat.ml:2452:22>>*/ ignored =
                [3, iconv, get_pad_opt(95)],
-             _aA_ = [0, [23, ignored, fmt_rest]];
+             _aB_ = [0, [23, ignored, fmt_rest]];
            else
              /*<<camlinternalFormat.ml:2456:48>>*/ var
-              /*<<camlinternalFormat.ml:2456:48>>*/ _aC_ = get_prec(0),
+              /*<<camlinternalFormat.ml:2456:48>>*/ _aD_ = get_prec(0),
               /*<<camlinternalFormat.ml:2456:10>>*/ match$0 =
-               make_padprec_fmt_ebb(get_int_pad(0), _aC_, fmt_rest),
+               make_padprec_fmt_ebb(get_int_pad(0), _aD_, fmt_rest),
              fmt_rest$0 = match$0[3],
              prec$0 = match$0[2],
              pad$0 = match$0[1],
-             _aA_ = [0, [5, iconv, pad$0, prec$0, fmt_rest$0]];
-           var _aB_ = _aA_;
+             _aB_ = [0, [5, iconv, pad$0, prec$0, fmt_rest$0]];
+           var _aC_ = _aB_;
            break;
           case 1:
            break b;
           default:
             /*<<camlinternalFormat.ml:2461:39>>*/ var
-             /*<<camlinternalFormat.ml:2461:39>>*/ _aD_ =
+             /*<<camlinternalFormat.ml:2461:39>>*/ _aE_ =
                /*<<camlinternalFormat.ml:2461:39>>*/ caml_string_get
                (str, str_ind),
-             /*<<camlinternalFormat.ml:2461:24>>*/ _aE_ = get_space(0),
-             /*<<camlinternalFormat.ml:2461:10>>*/ _aF_ = get_hash(0),
+             /*<<camlinternalFormat.ml:2461:24>>*/ _aF_ = get_space(0),
+             /*<<camlinternalFormat.ml:2461:10>>*/ _aG_ = get_hash(0),
              /*<<camlinternalFormat.ml:2460:8>>*/ iconv$0 =
               compute_int_conv
-               (pct_ind, str_ind + 1 | 0, get_plus(0), _aF_, _aE_, _aD_),
+               (pct_ind, str_ind + 1 | 0, get_plus(0), _aG_, _aF_, _aE_),
             fmt_rest$1 = parse(str_ind + 1 | 0, end_ind)[1];
             /*<<camlinternalFormat.ml:2463:9>>*/ if(get_ign(0))
              /*<<camlinternalFormat.ml:2464:22>>*/ var
               /*<<camlinternalFormat.ml:2464:22>>*/ ignored$0 =
                [4, iconv$0, get_pad_opt(95)],
-             _aG_ = [0, [23, ignored$0, fmt_rest$1]];
+             _aH_ = [0, [23, ignored$0, fmt_rest$1]];
            else
              /*<<camlinternalFormat.ml:2468:48>>*/ var
-              /*<<camlinternalFormat.ml:2468:48>>*/ _aH_ = get_prec(0),
+              /*<<camlinternalFormat.ml:2468:48>>*/ _aI_ = get_prec(0),
               /*<<camlinternalFormat.ml:2468:10>>*/ match$1 =
-               make_padprec_fmt_ebb(get_int_pad(0), _aH_, fmt_rest$1),
+               make_padprec_fmt_ebb(get_int_pad(0), _aI_, fmt_rest$1),
              fmt_rest$2 = match$1[3],
              prec$1 = match$1[2],
              pad$1 = match$1[1],
-             _aG_ = [0, [6, iconv$0, pad$1, prec$1, fmt_rest$2]];
-           var _aB_ = _aG_;
+             _aH_ = [0, [6, iconv$0, pad$1, prec$1, fmt_rest$2]];
+           var _aC_ = _aH_;
         }
-        var fmt_result = _aB_;
+        var fmt_result = _aC_;
         break a;
        }
       }
       else if(76 === symb){
         /*<<camlinternalFormat.ml:2473:25>>*/ var
-         /*<<camlinternalFormat.ml:2473:25>>*/ _aI_ =
+         /*<<camlinternalFormat.ml:2473:25>>*/ _aJ_ =
            /*<<camlinternalFormat.ml:2473:25>>*/ caml_string_get(str, str_ind),
-         /*<<camlinternalFormat.ml:2473:10>>*/ _aJ_ = get_space(0),
-         /*<<camlinternalFormat.ml:2472:61>>*/ _aK_ = get_hash(0),
+         /*<<camlinternalFormat.ml:2473:10>>*/ _aK_ = get_space(0),
+         /*<<camlinternalFormat.ml:2472:61>>*/ _aL_ = get_hash(0),
          /*<<camlinternalFormat.ml:2472:8>>*/ iconv$1 =
           compute_int_conv
-           (pct_ind, str_ind + 1 | 0, get_plus(0), _aK_, _aJ_, _aI_),
+           (pct_ind, str_ind + 1 | 0, get_plus(0), _aL_, _aK_, _aJ_),
         fmt_rest$3 = parse(str_ind + 1 | 0, end_ind)[1];
         /*<<camlinternalFormat.ml:2475:9>>*/ if(get_ign(0))
          /*<<camlinternalFormat.ml:2476:22>>*/ var
           /*<<camlinternalFormat.ml:2476:22>>*/ ignored$1 =
            [5, iconv$1, get_pad_opt(95)],
-         _aL_ = [0, [23, ignored$1, fmt_rest$3]];
+         _aM_ = [0, [23, ignored$1, fmt_rest$3]];
        else
          /*<<camlinternalFormat.ml:2480:48>>*/ var
-          /*<<camlinternalFormat.ml:2480:48>>*/ _aM_ = get_prec(0),
+          /*<<camlinternalFormat.ml:2480:48>>*/ _aN_ = get_prec(0),
           /*<<camlinternalFormat.ml:2480:10>>*/ match$2 =
-           make_padprec_fmt_ebb(get_int_pad(0), _aM_, fmt_rest$3),
+           make_padprec_fmt_ebb(get_int_pad(0), _aN_, fmt_rest$3),
          fmt_rest$4 = match$2[3],
          prec$2 = match$2[2],
          pad$2 = match$2[1],
-         _aL_ = [0, [7, iconv$1, pad$2, prec$2, fmt_rest$4]];
-       var fmt_result = _aL_;
+         _aM_ = [0, [7, iconv$1, pad$2, prec$2, fmt_rest$4]];
+       var fmt_result = _aM_;
        break a;
       }
       var
@@ -19153,46 +19145,46 @@
           (failwith_message(_J_), str, str_ind - 1 | 0, symb);
      }
      if(1 - legacy_behavior$0){
-      var _ao_ = 1 - plus_used[1], plus$0 = _ao_ ? plus : _ao_;
+      var _ap_ = 1 - plus_used[1], plus$0 = _ap_ ? plus : _ap_;
       if(plus$0)
         /*<<camlinternalFormat.ml:2564:6>>*/ incompatible_flag
         (pct_ind, str_ind, symb, cst$27);
-      var _ap_ = 1 - hash_used[1], hash$0 = _ap_ ? hash : _ap_;
+      var _aq_ = 1 - hash_used[1], hash$0 = _aq_ ? hash : _aq_;
       if(hash$0)
         /*<<camlinternalFormat.ml:2566:6>>*/ incompatible_flag
         (pct_ind, str_ind, symb, cst$28);
-      var _aq_ = 1 - space_used[1], space$0 = _aq_ ? space : _aq_;
+      var _ar_ = 1 - space_used[1], space$0 = _ar_ ? space : _ar_;
       if(space$0)
         /*<<camlinternalFormat.ml:2568:6>>*/ incompatible_flag
         (pct_ind, str_ind, symb, cst$29);
       var
-       _ar_ = 1 - pad_used[1],
-       _as_ =
-         _ar_
+       _as_ = 1 - pad_used[1],
+       _at_ =
+         _as_
           ?  /*<<camlinternalFormat.ml:2569:25>>*/ caml_notequal
             ([0, pad], _K_)
-          : _ar_;
-       /*<<camlinternalFormat.ml:2569:25>>*/ if(_as_)
+          : _as_;
+       /*<<camlinternalFormat.ml:2569:25>>*/ if(_at_)
         /*<<camlinternalFormat.ml:2570:6>>*/ incompatible_flag
         (pct_ind, str_ind, symb, cst_padding$0);
       var
-       _at_ = 1 - prec_used[1],
-       _au_ =
-         _at_
+       _au_ = 1 - prec_used[1],
+       _av_ =
+         _au_
           ?  /*<<camlinternalFormat.ml:2571:25>>*/ caml_notequal
             ([0, prec], _L_)
-          : _at_;
-       /*<<camlinternalFormat.ml:2571:25>>*/ if(_au_){
-       var _av_ = ign ? 95 : symb;
+          : _au_;
+       /*<<camlinternalFormat.ml:2571:25>>*/ if(_av_){
+       var _aw_ = ign ? 95 : symb;
         /*<<camlinternalFormat.ml:2572:6>>*/ incompatible_flag
-        (pct_ind, str_ind, _av_, cst_precision$2);
+        (pct_ind, str_ind, _aw_, cst_precision$2);
       }
       var plus$1 = ign ? plus : ign;
       if(plus$1)
         /*<<camlinternalFormat.ml:2574:24>>*/ incompatible_flag
         (pct_ind, str_ind, 95, cst$30);
      }
-     var _aw_ = 1 - ign_used[1], ign$0 = _aw_ ? ign : _aw_;
+     var _ax_ = 1 - ign_used[1], ign$0 = _ax_ ? ign : _ax_;
      a:
      if(ign$0){
       b:
@@ -19309,10 +19301,10 @@
         case 3:
          if(legacy_behavior$0){
            /*<<camlinternalFormat.ml:2249:6>>*/ var
-            /*<<camlinternalFormat.ml:2249:6>>*/ _an_ = str_ind$0 + 1 | 0,
+            /*<<camlinternalFormat.ml:2249:6>>*/ _ao_ = str_ind$0 + 1 | 0,
            minus$0 = minus || (45 === symb$0 ? 1 : 0);
            /*<<camlinternalFormat.ml:2249:6>>*/ return parse_literal
-                  (minus$0, _an_);
+                  (minus$0, _ao_);
          }
          break;
       }
@@ -19339,17 +19331,17 @@
        /*<<camlinternalFormat.ml:2151:15>>*/ hash = [0, 0];
      function set_flag(str_ind, flag){
        /*<<camlinternalFormat.ml:2154:6>>*/ var
-       _ak_ = flag[1],
-       _al_ = _ak_ ? 1 - legacy_behavior$0 : _ak_;
-      if(_al_){
+       _al_ = flag[1],
+       _am_ = _al_ ? 1 - legacy_behavior$0 : _al_;
+      if(_am_){
         /*<<camlinternalFormat.ml:2157:22>>*/  /*<<camlinternalFormat.ml:2157:22>>*/ var
-        _am_ =
+        _an_ =
            /*<<camlinternalFormat.ml:2157:22>>*/ caml_string_get(str, str_ind);
         /*<<camlinternalFormat.ml:2155:8>>*/  /*<<camlinternalFormat.ml:2155:8>>*/ caml_call3
-        (failwith_message(_C_), str, str_ind, _am_);
+        (failwith_message(_C_), str, str_ind, _an_);
       }
       flag[1] = 1;
-      return sentinal;
+      return _$_;
       /*<<camlinternalFormat.ml:2158:19>>*/ }
      var str_ind$0 = str_ind;
       /*<<camlinternalFormat.ml:2161:6>>*/ for(;;){
@@ -19519,13 +19511,13 @@
          [0, sub_fmt, sub_str],
         /*<<camlinternalFormat.ml:2649:8>>*/ formatting$0 =
          is_open_tag ? [0, sub_format$0] : [1, sub_format$0],
-        /*<<camlinternalFormat.ml:2651:8>>*/ _ai_ =
+        /*<<camlinternalFormat.ml:2651:8>>*/ _aj_ =
          [0, [18, formatting$0, fmt_rest$0]];
-       /*<<camlinternalFormat.ml:2651:8>>*/ return _ai_;
+       /*<<camlinternalFormat.ml:2651:8>>*/ return _aj_;
      }
-     catch(_aj_){
-      var _ah_ = caml_wrap_exception(_aj_);
-      if(_ah_ !== Stdlib[8]) throw caml_maybe_attach_backtrace(_ah_, 0);
+     catch(_ak_){
+      var _ai_ = caml_wrap_exception(_ak_);
+      if(_ai_ !== Stdlib[8]) throw caml_maybe_attach_backtrace(_ai_, 0);
        /*<<camlinternalFormat.ml:2657:6>>*/ var
        fmt_rest = parse(str_ind, end_ind)[1],
         /*<<camlinternalFormat.ml:2657:6>>*/ formatting =
@@ -19565,9 +19557,9 @@
       var new_acc = (acc$0 * 10 | 0) + (c - 48 | 0) | 0;
       if(Stdlib_Sys[12] < new_acc){
         /*<<camlinternalFormat.ml:2815:8>>*/  /*<<camlinternalFormat.ml:2815:8>>*/ var
-        _ag_ = Stdlib_Sys[12];
+        _ah_ = Stdlib_Sys[12];
         /*<<camlinternalFormat.ml:2815:8>>*/ return  /*<<camlinternalFormat.ml:2815:8>>*/ caml_call3
-               (failwith_message(_S_), str, new_acc, _ag_);
+               (failwith_message(_S_), str, new_acc, _ah_);
       }
       var
        str_ind$1 = str_ind$0 + 1 | 0,
@@ -19821,16 +19813,16 @@
      fmt = fmt_ebb_of_string(0, str)[1];
      /*<<camlinternalFormat.ml:2978:2>>*/ try{
       /*<<camlinternalFormat.ml:2978:6>>*/  /*<<camlinternalFormat.ml:2978:6>>*/ var
-      _ae_ = [0, type_format(fmt, fmtty), str];
-      /*<<camlinternalFormat.ml:2978:6>>*/ return _ae_;
+      _af_ = [0, type_format(fmt, fmtty), str];
+      /*<<camlinternalFormat.ml:2978:6>>*/ return _af_;
     }
-    catch(_af_){
-     var _ac_ = caml_wrap_exception(_af_);
-     if(_ac_ !== Type_mismatch) throw caml_maybe_attach_backtrace(_ac_, 0);
+    catch(_ag_){
+     var _ad_ = caml_wrap_exception(_ag_);
+     if(_ad_ !== Type_mismatch) throw caml_maybe_attach_backtrace(_ad_, 0);
       /*<<camlinternalFormat.ml:2982:10>>*/  /*<<camlinternalFormat.ml:2982:10>>*/ var
-      _ad_ = string_of_fmtty(fmtty);
+      _ae_ = string_of_fmtty(fmtty);
       /*<<camlinternalFormat.ml:2982:10>>*/ return  /*<<camlinternalFormat.ml:2982:10>>*/ caml_call2
-             (failwith_message(_Z_), str, _ad_);
+             (failwith_message(_Z_), str, _ae_);
     }
     /*<<camlinternalFormat.ml:2982:33>>*/ }
    function format_of_string_format(str, param){
@@ -19840,15 +19832,15 @@
      fmt$0 = fmt_ebb_of_string(0, str)[1];
      /*<<camlinternalFormat.ml:2988:2>>*/ try{
       /*<<camlinternalFormat.ml:2988:6>>*/  /*<<camlinternalFormat.ml:2988:6>>*/ var
-      _aa_ = [0, type_format(fmt$0, fmtty_of_fmt(fmt)), str];
-      /*<<camlinternalFormat.ml:2988:6>>*/ return _aa_;
+      _ab_ = [0, type_format(fmt$0, fmtty_of_fmt(fmt)), str];
+      /*<<camlinternalFormat.ml:2988:6>>*/ return _ab_;
     }
-    catch(_ab_){
-     var _$_ = caml_wrap_exception(_ab_);
-     if(_$_ === Type_mismatch)
+    catch(_ac_){
+     var _aa_ = caml_wrap_exception(_ac_);
+     if(_aa_ === Type_mismatch)
        /*<<camlinternalFormat.ml:2990:4>>*/ return  /*<<camlinternalFormat.ml:2990:4>>*/ caml_call2
               (failwith_message(___), str, str$0);
-     throw caml_maybe_attach_backtrace(_$_, 0);
+     throw caml_maybe_attach_backtrace(_aa_, 0);
     }
    }
    var
@@ -20056,7 +20048,7 @@
             : runtime.caml_call_gen(f, [a0, a1, a2, a3, a4, a5]);
    }
     /*<<arg.ml:50:0>>*/ var
-    sentinal = undefined,
+    _y_ = undefined,
     global_data = runtime.caml_get_global_data(),
     cst$6 = "\n",
     cst$3 = cst$7,
@@ -20147,18 +20139,18 @@
      /*<<arg.ml:79:53>>*/ var
      t = l[2],
      h = l[1],
-      /*<<arg.ml:79:53>>*/ _aD_ =
+      /*<<arg.ml:79:53>>*/ _aE_ =
         /*<<arg.ml:79:53>>*/ caml_call2(Stdlib[28], prefix, h);
-    function _aE_(x, y){
+    function _aF_(x, y){
       /*<<arg.ml:79:40>>*/  /*<<arg.ml:79:44>>*/ var
-      _aG_ =  /*<<arg.ml:79:44>>*/ caml_call2(Stdlib[28], sep, y);
+      _aH_ =  /*<<arg.ml:79:44>>*/ caml_call2(Stdlib[28], sep, y);
       /*<<arg.ml:79:44>>*/ return  /*<<arg.ml:79:44>>*/ caml_call2
-             (Stdlib[28], x, _aG_);
+             (Stdlib[28], x, _aH_);
      /*<<arg.ml:79:51>>*/ }
      /*<<arg.ml:79:12>>*/  /*<<arg.ml:79:12>>*/ var
-     _aF_ =  /*<<arg.ml:79:12>>*/ caml_call3(Stdlib_List[25], _aE_, _aD_, t);
+     _aG_ =  /*<<arg.ml:79:12>>*/ caml_call3(Stdlib_List[25], _aF_, _aE_, t);
      /*<<arg.ml:79:12>>*/ return  /*<<arg.ml:79:12>>*/ caml_call2
-            (Stdlib[28], _aF_, suffix);
+            (Stdlib[28], _aG_, suffix);
     /*<<arg.ml:79:77>>*/ }
    function help_action(param){
      /*<<arg.ml:91:21>>*/ throw  /*<<arg.ml:91:21>>*/ caml_maybe_attach_backtrace
@@ -20167,11 +20159,11 @@
    function add_help(speclist){
      /*<<arg.ml:94:2>>*/ try{
       /*<<arg.ml:95:15>>*/ assoc3(cst_help$2, speclist);
-      /*<<arg.ml:95:42>>*/ var  /*<<arg.ml:95:42>>*/ _aA_ = 0, add1 = _aA_;
+      /*<<arg.ml:95:42>>*/ var  /*<<arg.ml:95:42>>*/ _aB_ = 0, add1 = _aB_;
     }
-    catch(_aC_){
-     var _aw_ = caml_wrap_exception(_aC_);
-     if(_aw_ !== Stdlib[8]) throw caml_maybe_attach_backtrace(_aw_, 0);
+    catch(_aD_){
+     var _ax_ = caml_wrap_exception(_aD_);
+     if(_ax_ !== Stdlib[8]) throw caml_maybe_attach_backtrace(_ax_, 0);
      var
       add1 =
         [0,
@@ -20180,11 +20172,11 @@
     }
     try{
       /*<<arg.ml:99:15>>*/ assoc3(cst_help$1, speclist);
-      /*<<arg.ml:99:43>>*/ var  /*<<arg.ml:99:43>>*/ _az_ = 0, add2 = _az_;
+      /*<<arg.ml:99:43>>*/ var  /*<<arg.ml:99:43>>*/ _aA_ = 0, add2 = _aA_;
     }
-    catch(_aB_){
-     var _ax_ = caml_wrap_exception(_aB_);
-     if(_ax_ !== Stdlib[8]) throw caml_maybe_attach_backtrace(_ax_, 0);
+    catch(_aC_){
+     var _ay_ = caml_wrap_exception(_aC_);
+     if(_ay_ !== Stdlib[8]) throw caml_maybe_attach_backtrace(_ay_, 0);
      var
       add2 =
         [0,
@@ -20192,34 +20184,34 @@
          0];
     }
      /*<<arg.ml:103:13>>*/  /*<<arg.ml:103:13>>*/ var
-     _ay_ =  /*<<arg.ml:103:13>>*/ caml_call2(Stdlib[37], add1, add2);
+     _az_ =  /*<<arg.ml:103:13>>*/ caml_call2(Stdlib[37], add1, add2);
      /*<<arg.ml:103:13>>*/ return  /*<<arg.ml:103:13>>*/ caml_call2
-            (Stdlib[37], speclist, _ay_);
+            (Stdlib[37], speclist, _az_);
     /*<<arg.ml:103:26>>*/ }
    function usage_b(buf, speclist, errmsg){
      /*<<arg.ml:107:2>>*/  /*<<arg.ml:107:2>>*/ caml_call3
      (Stdlib_Printf[5], buf, _d_, errmsg);
      /*<<arg.ml:108:29>>*/  /*<<arg.ml:108:29>>*/ var
-     _as_ = add_help(speclist);
-     /*<<arg.ml:108:12>>*/ function _at_(param){
+     _at_ = add_help(speclist);
+     /*<<arg.ml:108:12>>*/ function _au_(param){
      var
       doc = param[3],
       spec = param[2],
       key = param[1],
-      _au_ = 0 <  /*<<arg.ml:83:2>>*/ caml_ml_string_length(doc) ? 1 : 0;
-     if(! _au_) return _au_;
+      _av_ = 0 <  /*<<arg.ml:83:2>>*/ caml_ml_string_length(doc) ? 1 : 0;
+     if(! _av_) return _av_;
      if(11 !== spec[0])
        /*<<arg.ml:88:8>>*/ return  /*<<arg.ml:88:8>>*/ caml_call4
               (Stdlib_Printf[5], buf, _a_, key, doc);
       /*<<arg.ml:86:38>>*/ var
       l = spec[1],
-       /*<<arg.ml:86:38>>*/ _av_ = make_symlist(cst$1, cst$0, cst, l);
+       /*<<arg.ml:86:38>>*/ _aw_ = make_symlist(cst$1, cst$0, cst, l);
       /*<<arg.ml:86:8>>*/ return  /*<<arg.ml:86:8>>*/ caml_call5
-             (Stdlib_Printf[5], buf, _b_, key, _av_, doc);
+             (Stdlib_Printf[5], buf, _b_, key, _aw_, doc);
     }
      /*<<arg.ml:108:29>>*/  /*<<arg.ml:108:29>>*/ caml_call2
-     (Stdlib_List[17], _at_, _as_);
-     /*<<arg.ml:108:29>>*/ return sentinal;
+     (Stdlib_List[17], _au_, _at_);
+     /*<<arg.ml:108:29>>*/ return _y_;
     /*<<arg.ml:108:48>>*/ }
    function usage_string(speclist, errmsg){
      /*<<arg.ml:112:2>>*/  /*<<arg.ml:112:10>>*/ var
@@ -20230,33 +20222,33 @@
     /*<<arg.ml:114:19>>*/ }
    function usage(speclist, errmsg){
      /*<<arg.ml:118:2>>*/  /*<<arg.ml:118:15>>*/ var
-     _ar_ = usage_string(speclist, errmsg);
+     _as_ = usage_string(speclist, errmsg);
      /*<<arg.ml:118:15>>*/ return  /*<<arg.ml:118:15>>*/ caml_call2
-            (Stdlib_Printf[3], _e_, _ar_);
+            (Stdlib_Printf[3], _e_, _as_);
     /*<<arg.ml:118:45>>*/ }
     /*<<arg.ml:121:14>>*/  /*<<arg.ml:121:14>>*/ var current = [0, 0];
    function int_of_string_opt(x){
      /*<<arg.ml:128:2>>*/ try{
       /*<<arg.ml:128:6>>*/  /*<<arg.ml:128:6>>*/ var
-      _ap_ = [0,  /*<<arg.ml:128:11>>*/ runtime.caml_int_of_string(x)];
-      /*<<arg.ml:128:6>>*/ return _ap_;
+      _aq_ = [0,  /*<<arg.ml:128:11>>*/ runtime.caml_int_of_string(x)];
+      /*<<arg.ml:128:6>>*/ return _aq_;
     }
-    catch(_aq_){
-     var _ao_ = caml_wrap_exception(_aq_);
-     if(_ao_[1] === Stdlib[7])  /*<<arg.ml:129:20>>*/ return 0;
-     throw caml_maybe_attach_backtrace(_ao_, 0);
+    catch(_ar_){
+     var _ap_ = caml_wrap_exception(_ar_);
+     if(_ap_[1] === Stdlib[7])  /*<<arg.ml:129:20>>*/ return 0;
+     throw caml_maybe_attach_backtrace(_ap_, 0);
     }
     /*<<arg.ml:129:24>>*/ }
    function float_of_string_opt(x){
      /*<<arg.ml:132:2>>*/ try{
       /*<<arg.ml:132:6>>*/  /*<<arg.ml:132:6>>*/ var
-      _am_ = [0,  /*<<arg.ml:132:11>>*/ runtime.caml_float_of_string(x)];
-      /*<<arg.ml:132:6>>*/ return _am_;
+      _an_ = [0,  /*<<arg.ml:132:11>>*/ runtime.caml_float_of_string(x)];
+      /*<<arg.ml:132:6>>*/ return _an_;
     }
-    catch(_an_){
-     var _al_ = caml_wrap_exception(_an_);
-     if(_al_[1] === Stdlib[7])  /*<<arg.ml:133:20>>*/ return 0;
-     throw caml_maybe_attach_backtrace(_al_, 0);
+    catch(_ao_){
+     var _am_ = caml_wrap_exception(_ao_);
+     if(_am_[1] === Stdlib[7])  /*<<arg.ml:133:20>>*/ return 0;
+     throw caml_maybe_attach_backtrace(_am_, 0);
     }
     /*<<arg.ml:133:24>>*/ }
    function parse_and_expand_argv_dynamic_
@@ -20311,8 +20303,8 @@
      if(current[1] >= argv[1].length - 1) return 0;
       /*<<arg.ml:166:4>>*/ try{
        /*<<arg.ml:167:14>>*/ var
-       _Y_ = current[1],
-        /*<<arg.ml:167:14>>*/ s = caml_check_bound(argv[1], _Y_)[1 + _Y_];
+       _Z_ = current[1],
+        /*<<arg.ml:167:14>>*/ s = caml_check_bound(argv[1], _Z_)[1 + _Z_];
       a:
       {
         /*<<arg.ml:168:33>>*/ if
@@ -20321,13 +20313,13 @@
         try{
           /*<<arg.ml:170:14>>*/ var
           follow$1 = 0,
-           /*<<arg.ml:170:14>>*/ _aa_ = assoc3(s, speclist[1]),
+           /*<<arg.ml:170:14>>*/ _ab_ = assoc3(s, speclist[1]),
           follow$0 = follow$1,
-          action = _aa_;
+          action = _ab_;
         }
-        catch(_aj_){
-         var _Z_ = caml_wrap_exception(_aj_);
-         if(_Z_ !== Stdlib[8]) throw caml_maybe_attach_backtrace(_Z_, 0);
+        catch(_ak_){
+         var ___ = caml_wrap_exception(_ak_);
+         if(___ !== Stdlib[8]) throw caml_maybe_attach_backtrace(___, 0);
           /*<<arg.ml:172:10>>*/ try{
            /*<<arg.ml:71:10>>*/ var
             /*<<arg.ml:71:10>>*/ i =
@@ -20340,16 +20332,16 @@
             /*<<arg.ml:73:2>>*/ keyword =
               /*<<arg.ml:73:2>>*/ caml_call3(Stdlib_String[15], s, 0, i),
             /*<<arg.ml:174:38>>*/ follow = [0, arg],
-            /*<<arg.ml:174:12>>*/ _$_ = assoc3(keyword, speclist[1]),
+            /*<<arg.ml:174:12>>*/ _aa_ = assoc3(keyword, speclist[1]),
            follow$0 = follow,
-           action = _$_;
+           action = _aa_;
          }
-         catch(_ak_){
-          var ___ = caml_wrap_exception(_ak_);
-          if(___ === Stdlib[8])
+         catch(_al_){
+          var _$_ = caml_wrap_exception(_al_);
+          if(_$_ === Stdlib[8])
             /*<<arg.ml:175:28>>*/ throw  /*<<arg.ml:175:28>>*/ caml_maybe_attach_backtrace
                   ([0, Stop, [0, s]], 1);
-          throw caml_maybe_attach_backtrace(___, 0);
+          throw caml_maybe_attach_backtrace(_$_, 0);
          }
         }
         var
@@ -20357,7 +20349,7 @@
            function(s, follow){
             function no_arg(param){
               /*<<arg.ml:178:10>>*/ if(! follow)
-               /*<<arg.ml:179:20>>*/ return sentinal;
+               /*<<arg.ml:179:20>>*/ return _y_;
              var arg = follow[1];
               /*<<arg.ml:180:24>>*/ throw  /*<<arg.ml:180:24>>*/ caml_maybe_attach_backtrace
                     ([0, Stop, [1, s, arg, cst_no_argument]], 1);
@@ -20375,9 +20367,9 @@
              if((current[1] + 1 | 0) >= argv[1].length - 1)
                /*<<arg.ml:185:19>>*/ throw  /*<<arg.ml:185:19>>*/ caml_maybe_attach_backtrace
                      ([0, Stop, [2, s]], 1);
-             var _ai_ = current[1] + 1 | 0;
-              /*<<arg.ml:184:58>>*/ return caml_check_bound(argv[1], _ai_)
-                     [1 + _ai_];
+             var _aj_ = current[1] + 1 | 0;
+              /*<<arg.ml:184:58>>*/ return caml_check_bound(argv[1], _aj_)
+                     [1 + _aj_];
              /*<<arg.ml:186:27>>*/ }
             return get_arg;
            },
@@ -20405,14 +20397,14 @@
                   /*<<arg.ml:196:22>>*/ arg = get_arg(0);
                  /*<<arg.ml:124:2>>*/ try{
                   /*<<arg.ml:124:6>>*/ var
-                   /*<<arg.ml:124:6>>*/ _ac_ =
+                   /*<<arg.ml:124:6>>*/ _ad_ =
                     [0,  /*<<arg.ml:124:11>>*/ caml_call1(Stdlib[32], arg)],
-                  match = _ac_;
+                  match = _ad_;
                 }
-                catch(_ah_){
-                 var _ab_ = caml_wrap_exception(_ah_);
-                 if(_ab_[1] !== Stdlib[6])
-                  throw caml_maybe_attach_backtrace(_ab_, 0);
+                catch(_ai_){
+                 var _ac_ = caml_wrap_exception(_ai_);
+                 if(_ac_[1] !== Stdlib[6])
+                  throw caml_maybe_attach_backtrace(_ac_, 0);
                  var match = 0;
                 }
                 if(! match)
@@ -20507,7 +20499,7 @@
                   /*<<arg.ml:211:14>>*/ return consume_arg(0);
                 }
                  /*<<arg.ml:215:44>>*/  /*<<arg.ml:215:44>>*/ var
-                 _ad_ = make_symlist(cst$5, cst$4, cst$3, symb);
+                 _ae_ = make_symlist(cst$5, cst$4, cst$3, symb);
                  /*<<arg.ml:213:21>>*/ throw  /*<<arg.ml:213:21>>*/ caml_maybe_attach_backtrace
                        ([0,
                          Stop,
@@ -20515,16 +20507,16 @@
                           s,
                           arg$5,
                            /*<<arg.ml:214:42>>*/ caml_call2
-                           (Stdlib[28], cst_one_of, _ad_)]],
+                           (Stdlib[28], cst_one_of, _ae_)]],
                         1);
                case 12:
                 var f$5 = param[1];
                  /*<<arg.ml:252:12>>*/ no_arg(0);
                  /*<<arg.ml:255:14>>*/ for(;;){
                  if(current[1] >= (argv[1].length - 1 - 1 | 0)) return 0;
-                 var _ae_ = current[1] + 1 | 0;
+                 var _af_ = current[1] + 1 | 0;
                   /*<<arg.ml:254:14>>*/  /*<<arg.ml:254:14>>*/ caml_call1
-                  (f$5, caml_check_bound(argv[1], _ae_)[1 + _ae_]);
+                  (f$5, caml_check_bound(argv[1], _af_)[1 + _af_]);
                   /*<<arg.ml:255:14>>*/ consume_arg(0);
                 }
                 break;
@@ -20538,8 +20530,8 @@
                    /*<<arg.ml:264:14>>*/ return  /*<<arg.ml:264:14>>*/ caml_call1
                           (f$6,
                             /*<<arg.ml:264:14>>*/ caml_call1(Stdlib_List[9], acc[1]));
-                 var _ag_ = current[1] + 1 | 0, _af_ = acc[1];
-                 acc[1] = [0, caml_check_bound(argv[1], _ag_)[1 + _ag_], _af_];
+                 var _ah_ = current[1] + 1 | 0, _ag_ = acc[1];
+                 acc[1] = [0, caml_check_bound(argv[1], _ah_)[1 + _ah_], _ag_];
                   /*<<arg.ml:262:14>>*/ consume_arg(0);
                 }
                 break;
@@ -20617,8 +20609,8 @@
    function parse(l, f, msg){
      /*<<arg.ml:299:2>>*/ try{
       /*<<arg.ml:300:4>>*/  /*<<arg.ml:300:4>>*/ var
-      _X_ = parse_argv(0, caml_sys_argv(0), l, f, msg);
-      /*<<arg.ml:300:4>>*/ return _X_;
+      _Y_ = parse_argv(0, caml_sys_argv(0), l, f, msg);
+      /*<<arg.ml:300:4>>*/ return _Y_;
     }
     catch(exn$0){
      var exn = caml_wrap_exception(exn$0);
@@ -20640,8 +20632,8 @@
    function parse_dynamic(l, f, msg){
      /*<<arg.ml:307:2>>*/ try{
       /*<<arg.ml:308:4>>*/  /*<<arg.ml:308:4>>*/ var
-      _W_ = parse_argv_dynamic(0, caml_sys_argv(0), l, f, msg);
-      /*<<arg.ml:308:4>>*/ return _W_;
+      _X_ = parse_argv_dynamic(0, caml_sys_argv(0), l, f, msg);
+      /*<<arg.ml:308:4>>*/ return _X_;
     }
     catch(exn$0){
      var exn = caml_wrap_exception(exn$0);
@@ -20666,9 +20658,9 @@
        /*<<arg.ml:315:15>>*/ argv = [0, caml_sys_argv(0)],
        /*<<arg.ml:316:15>>*/ spec = [0, l],
        /*<<arg.ml:317:18>>*/ current$0 = [0, current[1]],
-       /*<<arg.ml:318:4>>*/ _V_ =
+       /*<<arg.ml:318:4>>*/ _W_ =
         parse_and_expand_argv_dynamic(current$0, argv, spec, f, msg);
-      /*<<arg.ml:318:4>>*/ return _V_;
+      /*<<arg.ml:318:4>>*/ return _W_;
     }
     catch(exn$0){
      var exn = caml_wrap_exception(exn$0);
@@ -20705,17 +20697,17 @@
       /*<<arg.ml:331:8>>*/  /*<<arg.ml:331:8>>*/ var
       n$0 =  /*<<arg.ml:331:8>>*/ caml_call2(Stdlib_String[35], s, 9);
     }
-    catch(_T_){
-     var _R_ = caml_wrap_exception(_T_);
-     if(_R_ !== Stdlib[8]) throw caml_maybe_attach_backtrace(_R_, 0);
+    catch(_U_){
+     var _S_ = caml_wrap_exception(_U_);
+     if(_S_ !== Stdlib[8]) throw caml_maybe_attach_backtrace(_S_, 0);
       /*<<arg.ml:334:6>>*/ try{
        /*<<arg.ml:334:18>>*/  /*<<arg.ml:334:18>>*/ var
        n =  /*<<arg.ml:334:18>>*/ caml_call2(Stdlib_String[35], s, 32);
      }
-     catch(_U_){
-      var _S_ = caml_wrap_exception(_U_);
-      if(_S_ === Stdlib[8])  /*<<arg.ml:336:31>>*/ return len;
-      throw caml_maybe_attach_backtrace(_S_, 0);
+     catch(_V_){
+      var _T_ = caml_wrap_exception(_V_);
+      if(_T_ === Stdlib[8])  /*<<arg.ml:336:31>>*/ return len;
+      throw caml_maybe_attach_backtrace(_T_, 0);
      }
       /*<<arg.ml:334:18>>*/ return loop(n + 1 | 0);
     }
@@ -20725,12 +20717,12 @@
     var doc = param[3], spec = param[2], kwd = param[1];
      /*<<arg.ml:341:2>>*/ if(11 === spec[0])
      return caml_call2(Stdlib_Int[11], cur, caml_ml_string_length(kwd));
-    var _Q_ = caml_ml_string_length(kwd) + second_word(doc) | 0;
-    return caml_call2(Stdlib_Int[11], cur, _Q_);
+    var _R_ = caml_ml_string_length(kwd) + second_word(doc) | 0;
+    return caml_call2(Stdlib_Int[11], cur, _R_);
    }
    function replace_leading_tab(s){
      /*<<arg.ml:347:2>>*/  /*<<arg.ml:347:13>>*/ var seen = [0, 0];
-    function _P_(c){
+    function _Q_(c){
       /*<<arg.ml:348:13>>*/ if(9 === c && ! seen[1]){
       seen[1] = 1;
        /*<<arg.ml:348:60>>*/ return 32;
@@ -20738,7 +20730,7 @@
       /*<<arg.ml:348:71>>*/ return c;
      /*<<arg.ml:348:73>>*/ }
      /*<<arg.ml:348:2>>*/ return  /*<<arg.ml:348:2>>*/ caml_call2
-            (Stdlib_String[17], _P_, s);
+            (Stdlib_String[17], _Q_, s);
     /*<<arg.ml:348:75>>*/ }
    function align(opt, speclist){
      /*<<arg.ml:374:2>>*/ if(opt)
@@ -20752,7 +20744,7 @@
         (Stdlib_List[25], max_arg_len, 0, completed),
       /*<<arg.ml:376:12>>*/ len$0 =
         /*<<arg.ml:376:12>>*/ caml_call2(Stdlib_Int[10], len, limit);
-     /*<<arg.ml:377:11>>*/ function _J_(ksd){
+     /*<<arg.ml:377:11>>*/ function _K_(ksd){
      var kwd = ksd[1], spec = ksd[2];
      if(! caml_string_notequal(ksd[3], cst$7))
        /*<<arg.ml:355:6>>*/ return ksd;
@@ -20760,20 +20752,20 @@
        /*<<arg.ml:357:19>>*/ var
        msg$0 = ksd[3],
         /*<<arg.ml:357:19>>*/ cutcol$0 = second_word(msg$0),
-        /*<<arg.ml:358:32>>*/ _M_ =
+        /*<<arg.ml:358:32>>*/ _N_ =
           /*<<arg.ml:358:32>>*/ caml_call2
           (Stdlib_Int[11], 0, len$0 - cutcol$0 | 0)
          + 3
          | 0,
         /*<<arg.ml:358:19>>*/ spaces$0 =
-          /*<<arg.ml:358:19>>*/ caml_call2(Stdlib_String[1], _M_, 32),
-        /*<<arg.ml:359:34>>*/ _N_ = replace_leading_tab(msg$0),
-        /*<<arg.ml:359:25>>*/ _O_ =
-          /*<<arg.ml:359:25>>*/ caml_call2(Stdlib[28], spaces$0, _N_);
+          /*<<arg.ml:358:19>>*/ caml_call2(Stdlib_String[1], _N_, 32),
+        /*<<arg.ml:359:34>>*/ _O_ = replace_leading_tab(msg$0),
+        /*<<arg.ml:359:25>>*/ _P_ =
+          /*<<arg.ml:359:25>>*/ caml_call2(Stdlib[28], spaces$0, _O_);
        /*<<arg.ml:359:6>>*/ return [0,
               kwd,
               spec,
-               /*<<arg.ml:359:18>>*/ caml_call2(Stdlib[28], cst$6, _O_)];
+               /*<<arg.ml:359:18>>*/ caml_call2(Stdlib[28], cst$6, _P_)];
      }
       /*<<arg.ml:361:19>>*/ var
       msg = ksd[3],
@@ -20787,24 +20779,24 @@
       /*<<arg.ml:367:21>>*/ var
        /*<<arg.ml:367:21>>*/ spaces =
          /*<<arg.ml:367:21>>*/ caml_call2(Stdlib_String[1], diff, 32),
-       /*<<arg.ml:368:32>>*/ _K_ = replace_leading_tab(msg),
+       /*<<arg.ml:368:32>>*/ _L_ = replace_leading_tab(msg),
        /*<<arg.ml:368:21>>*/ prefix =
-         /*<<arg.ml:368:21>>*/ caml_call3(Stdlib_String[15], _K_, 0, cutcol),
+         /*<<arg.ml:368:21>>*/ caml_call3(Stdlib_String[15], _L_, 0, cutcol),
        /*<<arg.ml:369:21>>*/ suffix =
          /*<<arg.ml:369:21>>*/ caml_call3
          (Stdlib_String[15],
           msg,
           cutcol,
           caml_ml_string_length(msg) - cutcol | 0),
-       /*<<arg.ml:370:29>>*/ _L_ =
+       /*<<arg.ml:370:29>>*/ _M_ =
          /*<<arg.ml:370:29>>*/ caml_call2(Stdlib[28], spaces, suffix);
       /*<<arg.ml:370:8>>*/ return [0,
              kwd,
              spec$0,
-              /*<<arg.ml:370:20>>*/ caml_call2(Stdlib[28], prefix, _L_)];
+              /*<<arg.ml:370:20>>*/ caml_call2(Stdlib[28], prefix, _M_)];
     }
      /*<<arg.ml:377:2>>*/ return  /*<<arg.ml:377:2>>*/ caml_call2
-            (Stdlib_List[19], _J_, completed);
+            (Stdlib_List[19], _K_, completed);
     /*<<arg.ml:377:38>>*/ }
    function read_aux(trim, sep, file){
      /*<<arg.ml:387:2>>*/ var
@@ -20824,21 +20816,21 @@
         (0 < len
          && 13 ===  /*<<arg.ml:381:16>>*/ caml_string_get(word, len - 1 | 0)){
         var
-         _I_ =
+         _J_ =
             /*<<arg.ml:382:4>>*/ caml_call3
             (Stdlib_String[15], word, 0, len - 1 | 0);
         break a;
        }
-       var _I_ = word;
+       var _J_ = word;
       }
-      var word$0 = _I_;
+      var word$0 = _J_;
      }
      else
       var word$0 = word;
      words[1] = [0, word$0, words[1]];
       /*<<arg.ml:390:2>>*/  /*<<arg.ml:390:2>>*/ caml_call1
       (Stdlib_Buffer[8], buf);
-      /*<<arg.ml:390:2>>*/ return sentinal;
+      /*<<arg.ml:390:2>>*/ return _y_;
      /*<<arg.ml:394:20>>*/ }
      /*<<arg.ml:396:2>>*/ try{
      for(;;){
@@ -20851,45 +20843,45 @@
         (Stdlib_Buffer[12], buf, c);
      }
     }
-    catch(_H_){
-     var _F_ = caml_wrap_exception(_H_);
-     if(_F_ !== Stdlib[12]) throw caml_maybe_attach_backtrace(_F_, 0);
+    catch(_I_){
+     var _G_ = caml_wrap_exception(_I_);
+     if(_G_ !== Stdlib[12]) throw caml_maybe_attach_backtrace(_G_, 0);
      if(0 <  /*<<arg.ml:403:5>>*/ caml_call1(Stdlib_Buffer[7], buf))
        /*<<arg.ml:403:32>>*/ stash(0);
       /*<<arg.ml:404:2>>*/  /*<<arg.ml:404:2>>*/ caml_call1(Stdlib[93], ic);
       /*<<arg.ml:405:16>>*/  /*<<arg.ml:405:16>>*/ var
-      _G_ =  /*<<arg.ml:405:16>>*/ caml_call1(Stdlib_List[9], words[1]);
+      _H_ =  /*<<arg.ml:405:16>>*/ caml_call1(Stdlib_List[9], words[1]);
       /*<<arg.ml:405:16>>*/ return  /*<<arg.ml:405:16>>*/ caml_call1
-             (Stdlib_Array[10], _G_);
+             (Stdlib_Array[10], _H_);
     }
     /*<<arg.ml:405:33>>*/ }
    var _r_ = 10, _s_ = 1;
-    /*<<arg.ml:407:15>>*/ function read_arg(_E_){
-     /*<<?>>*/ return read_aux(_s_, _r_, _E_);
+    /*<<arg.ml:407:15>>*/ function read_arg(_F_){
+     /*<<?>>*/ return read_aux(_s_, _r_, _F_);
    }
     /*<<arg.ml:407:15>>*/ var  /*<<arg.ml:407:15>>*/ _t_ = 0, _u_ = 0;
-    /*<<arg.ml:409:16>>*/ function read_arg0(_D_){
-     /*<<?>>*/ return read_aux(_u_, _t_, _D_);
+    /*<<arg.ml:409:16>>*/ function read_arg0(_E_){
+     /*<<?>>*/ return read_aux(_u_, _t_, _E_);
    }
    function write_aux(sep, file, args){
      /*<<arg.ml:412:2>>*/  /*<<arg.ml:412:11>>*/ var
      oc =  /*<<arg.ml:412:11>>*/ caml_call1(Stdlib[61], file);
-    function _C_(s){
+    function _D_(s){
       /*<<arg.ml:413:23>>*/ return caml_call4
              (Stdlib_Printf[1], oc, _v_, s, sep);
      /*<<arg.ml:413:46>>*/ }
      /*<<arg.ml:413:2>>*/  /*<<arg.ml:413:2>>*/ caml_call2
-     (Stdlib_Array[11], _C_, args);
+     (Stdlib_Array[11], _D_, args);
      /*<<arg.ml:413:2>>*/ return  /*<<arg.ml:413:2>>*/ caml_call1
             (Stdlib[76], oc);
     /*<<arg.ml:414:14>>*/ }
    var _w_ = 10;
-    /*<<arg.ml:416:16>>*/ function write_arg(_A_, _B_){
-     /*<<?>>*/ return write_aux(_w_, _A_, _B_);
+    /*<<arg.ml:416:16>>*/ function write_arg(_B_, _C_){
+     /*<<?>>*/ return write_aux(_w_, _B_, _C_);
    }
     /*<<arg.ml:416:16>>*/  /*<<arg.ml:416:16>>*/ var _x_ = 0;
-    /*<<arg.ml:418:17>>*/ function write_arg0(_y_, _z_){
-     /*<<?>>*/ return write_aux(_x_, _y_, _z_);
+    /*<<arg.ml:418:17>>*/ function write_arg0(_z_, _A_){
+     /*<<?>>*/ return write_aux(_x_, _z_, _A_);
    }
    var
     Stdlib_Arg =
@@ -21552,10 +21544,10 @@
             : runtime.caml_call_gen(f, [a0, a1]);
    }
    var
-    sentinal = undefined,
     global_data = runtime.caml_get_global_data(),
     Stdlib_Printexc = global_data.Stdlib__Printexc,
     Stdlib = global_data.Stdlib,
+    _b_ = undefined,
     cst_Fun_Finally_raised = "Fun.Finally_raised: ",
     cst_Stdlib_Fun_Finally_raised = "Stdlib.Fun.Finally_raised";
    function const$0(c, param){
@@ -21575,11 +21567,11 @@
       /*<<fun.ml:25:7>>*/ return 0;
      /*<<fun.ml:24:55>>*/ var
      exn = param[2],
-      /*<<fun.ml:24:55>>*/ _b_ =
+      /*<<fun.ml:24:55>>*/ _c_ =
         /*<<fun.ml:24:55>>*/ caml_call1(Stdlib_Printexc[1], exn);
      /*<<fun.ml:24:24>>*/ return [0,
              /*<<fun.ml:24:29>>*/ caml_call2
-             (Stdlib[28], cst_Fun_Finally_raised, _b_)];
+             (Stdlib[28], cst_Fun_Finally_raised, _c_)];
     /*<<fun.ml:25:11>>*/ }
     /*<<fun.ml:23:9>>*/  /*<<fun.ml:23:9>>*/ caml_call1
     (Stdlib_Printexc[9], _a_);
@@ -21587,7 +21579,7 @@
     function finally_no_exn(param){
       /*<<fun.ml:29:4>>*/ try{
        /*<<fun.ml:29:8>>*/  /*<<fun.ml:29:8>>*/ caml_call1(finally$0, 0);
-       /*<<fun.ml:29:8>>*/ return sentinal;
+       /*<<fun.ml:29:8>>*/ return _b_;
      }
      catch(e$0){
        /*<<fun.ml:30:15>>*/ var
@@ -22045,7 +22037,7 @@
             : runtime.caml_call_gen(f, [a0, a1, a2]);
    }
    var
-    sentinal = undefined,
+    _a_ = undefined,
     global_data = runtime.caml_get_global_data(),
     Stdlib = global_data.Stdlib,
     Stdlib_Array = global_data.Stdlib__Array,
@@ -22107,46 +22099,46 @@
      /*<<bigarray.ml:104:4>>*/ if(col === idx.length - 1){
       /*<<bigarray.ml:104:35>>*/  /*<<bigarray.ml:104:35>>*/ caml_ba_set_generic
       (arr, idx,  /*<<bigarray.ml:104:47>>*/ caml_call1(f, idx));
-      /*<<bigarray.ml:104:35>>*/ return sentinal;
+      /*<<bigarray.ml:104:35>>*/ return _a_;
     }
      /*<<bigarray.ml:105:27>>*/ var
-      /*<<bigarray.ml:105:27>>*/ _am_ =
+      /*<<bigarray.ml:105:27>>*/ _an_ =
        caml_check_bound(max, col)[1 + col] - 1 | 0,
-      /*<<bigarray.ml:105:9>>*/ _al_ = 0;
-    if(_am_ >= 0){
-     var j = _al_;
+      /*<<bigarray.ml:105:9>>*/ _am_ = 0;
+    if(_an_ >= 0){
+     var j = _am_;
      for(;;){
        /*<<bigarray.ml:106:11>>*/ caml_check_bound(idx, col)[1 + col] = j;
        /*<<bigarray.ml:107:11>>*/ cloop(arr, idx, f, col + 1 | 0, max);
        /*<<bigarray.ml:107:11>>*/  /*<<bigarray.ml:107:11>>*/ var
-       _an_ = j + 1 | 0;
-      if(_am_ === j) break;
-      var j = _an_;
+       _ao_ = j + 1 | 0;
+      if(_an_ === j) break;
+      var j = _ao_;
      }
     }
-    return sentinal;
+    return _a_;
     /*<<bigarray.ml:108:13>>*/ }
    function floop(arr, idx, f, col, max){
      /*<<bigarray.ml:110:4>>*/ if(0 > col){
       /*<<bigarray.ml:110:20>>*/  /*<<bigarray.ml:110:20>>*/ caml_ba_set_generic
       (arr, idx,  /*<<bigarray.ml:110:32>>*/ caml_call1(f, idx));
-      /*<<bigarray.ml:110:20>>*/ return sentinal;
+      /*<<bigarray.ml:110:20>>*/ return _a_;
     }
      /*<<bigarray.ml:111:22>>*/ var
-      /*<<bigarray.ml:111:22>>*/ _aj_ = caml_check_bound(max, col)[1 + col],
-      /*<<bigarray.ml:111:9>>*/ _ai_ = 1;
-    if(_aj_ >= 1){
-     var j = _ai_;
+      /*<<bigarray.ml:111:22>>*/ _ak_ = caml_check_bound(max, col)[1 + col],
+      /*<<bigarray.ml:111:9>>*/ _aj_ = 1;
+    if(_ak_ >= 1){
+     var j = _aj_;
      for(;;){
        /*<<bigarray.ml:112:11>>*/ caml_check_bound(idx, col)[1 + col] = j;
        /*<<bigarray.ml:113:11>>*/ floop(arr, idx, f, col - 1 | 0, max);
        /*<<bigarray.ml:113:11>>*/  /*<<bigarray.ml:113:11>>*/ var
-       _ak_ = j + 1 | 0;
-      if(_aj_ === j) break;
-      var j = _ak_;
+       _al_ = j + 1 | 0;
+      if(_ak_ === j) break;
+      var j = _al_;
      }
     }
-    return sentinal;
+    return _a_;
     /*<<bigarray.ml:114:13>>*/ }
    function init(kind, layout, dims, f){
      /*<<bigarray.ml:116:4>>*/ var
@@ -22175,31 +22167,31 @@
         /*<<bigarray.ml:125:12>>*/ caml_ba_num_dims(a),
       /*<<bigarray.ml:126:12>>*/ d =
         /*<<bigarray.ml:126:12>>*/ caml_make_vect(n, 0),
-      /*<<bigarray.ml:127:4>>*/ _af_ = n - 1 | 0,
-      /*<<bigarray.ml:126:12>>*/ _ae_ = 0;
-    if(_af_ >= 0){
-     var i = _ae_;
+      /*<<bigarray.ml:127:4>>*/ _ag_ = n - 1 | 0,
+      /*<<bigarray.ml:126:12>>*/ _af_ = 0;
+    if(_ag_ >= 0){
+     var i = _af_;
      for(;;){
        /*<<bigarray.ml:127:33>>*/  /*<<bigarray.ml:127:33>>*/ var
-       _ag_ =  /*<<bigarray.ml:127:33>>*/ runtime.caml_ba_dim(a, i);
-       /*<<bigarray.ml:127:24>>*/ caml_check_bound(d, i)[1 + i] = _ag_;
+       _ah_ =  /*<<bigarray.ml:127:33>>*/ runtime.caml_ba_dim(a, i);
+       /*<<bigarray.ml:127:24>>*/ caml_check_bound(d, i)[1 + i] = _ah_;
        /*<<bigarray.ml:127:24>>*/  /*<<bigarray.ml:127:24>>*/ var
-       _ah_ = i + 1 | 0;
-      if(_af_ === i) break;
-      var i = _ah_;
+       _ai_ = i + 1 | 0;
+      if(_ag_ === i) break;
+      var i = _ai_;
      }
     }
      /*<<bigarray.ml:128:4>>*/ return d;
     /*<<bigarray.ml:128:5>>*/ }
    function size_in_bytes(arr){
      /*<<bigarray.ml:136:4>>*/ var
-      /*<<bigarray.ml:136:63>>*/ _ac_ = dims(arr),
-      /*<<bigarray.ml:136:38>>*/ _ad_ =
+      /*<<bigarray.ml:136:63>>*/ _ad_ = dims(arr),
+      /*<<bigarray.ml:136:38>>*/ _ae_ =
         /*<<bigarray.ml:136:38>>*/ caml_call3
-        (Stdlib_Array[15], caml_mul, 1, _ac_);
+        (Stdlib_Array[15], caml_mul, 1, _ad_);
      /*<<bigarray.ml:136:4>>*/ return  /*<<bigarray.ml:136:4>>*/ caml_mul
             (kind_size_in_bytes( /*<<bigarray.ml:136:24>>*/ caml_ba_kind(arr)),
-             _ad_);
+             _ae_);
     /*<<bigarray.ml:136:74>>*/ }
    function create(kind, layout){
      /*<<bigarray.ml:157:4>>*/ return  /*<<bigarray.ml:157:4>>*/ caml_ba_create
@@ -22210,9 +22202,9 @@
             (arr, [0]);
     /*<<bigarray.ml:158:37>>*/ }
    function set(arr){
-     /*<<bigarray.ml:159:16>>*/  /*<<bigarray.ml:159:16>>*/ var _aa_ = [0];
-     /*<<bigarray.ml:159:33>>*/ return function(_ab_){
-      /*<<?>>*/ return caml_ba_set_generic(arr, _aa_, _ab_);};
+     /*<<bigarray.ml:159:16>>*/  /*<<bigarray.ml:159:16>>*/ var _ab_ = [0];
+     /*<<bigarray.ml:159:33>>*/ return function(_ac_){
+      /*<<?>>*/ return caml_ba_set_generic(arr, _ab_, _ac_);};
     /*<<bigarray.ml:159:37>>*/ }
    function size_in_bytes$0(arr){
      /*<<bigarray.ml:166:26>>*/ return kind_size_in_bytes
@@ -22230,10 +22222,10 @@
     /*<<bigarray.ml:181:39>>*/ }
    function size_in_bytes$1(arr){
      /*<<bigarray.ml:195:4>>*/  /*<<bigarray.ml:195:38>>*/ var
-     _$_ =  /*<<bigarray.ml:195:38>>*/ caml_ba_dim_1(arr);
+     _aa_ =  /*<<bigarray.ml:195:38>>*/ caml_ba_dim_1(arr);
      /*<<bigarray.ml:195:4>>*/ return  /*<<bigarray.ml:195:4>>*/ caml_mul
             (kind_size_in_bytes( /*<<bigarray.ml:195:24>>*/ caml_ba_kind(arr)),
-             _$_);
+             _aa_);
     /*<<bigarray.ml:195:47>>*/ }
    function slice(a, n){
      /*<<bigarray.ml:199:4>>*/ return  /*<<bigarray.ml:199:10>>*/ runtime.caml_ba_layout
@@ -22245,32 +22237,32 @@
      /*<<bigarray.ml:209:4>>*/  /*<<bigarray.ml:209:14>>*/ var
      arr = create$0(kind, layout, dim);
      /*<<bigarray.ml:210:4>>*/ if(layout){
-      /*<<bigarray.ml:207:4>>*/  /*<<bigarray.ml:207:4>>*/ var _Z_ = 1;
+      /*<<bigarray.ml:207:4>>*/  /*<<bigarray.ml:207:4>>*/ var ___ = 1;
      if(dim >= 1){
-      var i$0 = _Z_;
+      var i$0 = ___;
       for(;;){
         /*<<bigarray.ml:207:24>>*/  /*<<bigarray.ml:207:24>>*/ caml_ba_set_1
         (arr, i$0,  /*<<bigarray.ml:207:41>>*/ caml_call1(f, i$0));
         /*<<bigarray.ml:207:24>>*/  /*<<bigarray.ml:207:24>>*/ var
-        ___ = i$0 + 1 | 0;
+        _$_ = i$0 + 1 | 0;
        if(dim === i$0) break;
-       var i$0 = ___;
+       var i$0 = _$_;
       }
      }
       /*<<bigarray.ml:212:24>>*/ return arr;
     }
      /*<<bigarray.ml:205:4>>*/ var
-     _X_ = dim - 1 | 0,
-      /*<<bigarray.ml:205:4>>*/ _W_ = 0;
-    if(_X_ >= 0){
-     var i = _W_;
+     _Y_ = dim - 1 | 0,
+      /*<<bigarray.ml:205:4>>*/ _X_ = 0;
+    if(_Y_ >= 0){
+     var i = _X_;
      for(;;){
        /*<<bigarray.ml:205:29>>*/  /*<<bigarray.ml:205:29>>*/ caml_ba_set_1
        (arr, i,  /*<<bigarray.ml:205:46>>*/ caml_call1(f, i));
        /*<<bigarray.ml:205:29>>*/  /*<<bigarray.ml:205:29>>*/ var
-       _Y_ = i + 1 | 0;
-      if(_X_ === i) break;
-      var i = _Y_;
+       _Z_ = i + 1 | 0;
+      if(_Y_ === i) break;
+      var i = _Z_;
      }
     }
      /*<<bigarray.ml:211:18>>*/ return arr;
@@ -22279,17 +22271,17 @@
      /*<<bigarray.ml:214:4>>*/ var
       /*<<bigarray.ml:214:13>>*/ ba = create$0(kind, layout, data.length - 1),
       /*<<bigarray.ml:215:4>>*/ ofs = layout ? 1 : 0,
-     _U_ = data.length - 1 - 1 | 0,
-     _T_ = 0;
-    if(_U_ >= 0){
-     var i = _T_;
+     _V_ = data.length - 1 - 1 | 0,
+     _U_ = 0;
+    if(_V_ >= 0){
+     var i = _U_;
      for(;;){
        /*<<bigarray.ml:220:42>>*/  /*<<bigarray.ml:220:42>>*/ caml_ba_set_1
        (ba, i + ofs | 0, caml_check_bound(data, i)[1 + i]);
        /*<<bigarray.ml:220:42>>*/  /*<<bigarray.ml:220:42>>*/ var
-       _V_ = i + 1 | 0;
-      if(_U_ === i) break;
-      var i = _V_;
+       _W_ = i + 1 | 0;
+      if(_V_ === i) break;
+      var i = _W_;
      }
     }
      /*<<bigarray.ml:221:4>>*/ return ba;
@@ -22300,16 +22292,16 @@
     /*<<bigarray.ml:227:46>>*/ }
    function size_in_bytes$2(arr){
      /*<<bigarray.ml:243:4>>*/ var
-      /*<<bigarray.ml:243:51>>*/ _R_ =
+      /*<<bigarray.ml:243:51>>*/ _S_ =
         /*<<bigarray.ml:243:51>>*/ caml_ba_dim_2(arr),
-      /*<<bigarray.ml:243:38>>*/ _S_ =
+      /*<<bigarray.ml:243:38>>*/ _T_ =
         /*<<bigarray.ml:243:38>>*/ caml_ba_dim_1(arr);
     return caml_mul
             ( /*<<bigarray.ml:243:4>>*/ caml_mul
               (kind_size_in_bytes
                 ( /*<<bigarray.ml:243:24>>*/ caml_ba_kind(arr)),
-               _S_),
-             _R_);
+               _T_),
+             _S_);
     /*<<bigarray.ml:243:61>>*/ }
    function slice_left(a, n){
      /*<<bigarray.ml:250:23>>*/ return  /*<<bigarray.ml:250:23>>*/ caml_ba_slice
@@ -22323,54 +22315,54 @@
      /*<<bigarray.ml:267:4>>*/  /*<<bigarray.ml:267:14>>*/ var
      arr = create$1(kind, layout, dim1, dim2);
      /*<<bigarray.ml:268:4>>*/ if(layout){
-      /*<<bigarray.ml:261:4>>*/  /*<<bigarray.ml:261:4>>*/ var _N_ = 1;
+      /*<<bigarray.ml:261:4>>*/  /*<<bigarray.ml:261:4>>*/ var _O_ = 1;
      if(dim2 >= 1){
-      var j$0 = _N_;
+      var j$0 = _O_;
       for(;;){
-        /*<<bigarray.ml:262:6>>*/  /*<<bigarray.ml:262:6>>*/ var _O_ = 1;
+        /*<<bigarray.ml:262:6>>*/  /*<<bigarray.ml:262:6>>*/ var _P_ = 1;
        if(dim1 >= 1){
-        var i$0 = _O_;
+        var i$0 = _P_;
         for(;;){
           /*<<bigarray.ml:263:8>>*/  /*<<bigarray.ml:263:8>>*/ caml_ba_set_2
           (arr, i$0, j$0,  /*<<bigarray.ml:263:27>>*/ caml_call2(f, i$0, j$0));
           /*<<bigarray.ml:263:8>>*/  /*<<bigarray.ml:263:8>>*/ var
-          _Q_ = i$0 + 1 | 0;
+          _R_ = i$0 + 1 | 0;
          if(dim1 === i$0) break;
-         var i$0 = _Q_;
+         var i$0 = _R_;
         }
        }
         /*<<bigarray.ml:261:4>>*/  /*<<bigarray.ml:261:4>>*/ var
-        _P_ = j$0 + 1 | 0;
+        _Q_ = j$0 + 1 | 0;
        if(dim2 === j$0) break;
-       var j$0 = _P_;
+       var j$0 = _Q_;
       }
      }
       /*<<bigarray.ml:270:24>>*/ return arr;
     }
      /*<<bigarray.ml:255:4>>*/ var
-     _I_ = dim1 - 1 | 0,
-      /*<<bigarray.ml:255:4>>*/ _H_ = 0;
-    if(_I_ >= 0){
-     var i = _H_;
+     _J_ = dim1 - 1 | 0,
+      /*<<bigarray.ml:255:4>>*/ _I_ = 0;
+    if(_J_ >= 0){
+     var i = _I_;
      for(;;){
        /*<<bigarray.ml:256:6>>*/ var
-       _K_ = dim2 - 1 | 0,
-        /*<<bigarray.ml:256:6>>*/ _J_ = 0;
-      if(_K_ >= 0){
-       var j = _J_;
+       _L_ = dim2 - 1 | 0,
+        /*<<bigarray.ml:256:6>>*/ _K_ = 0;
+      if(_L_ >= 0){
+       var j = _K_;
        for(;;){
          /*<<bigarray.ml:257:8>>*/  /*<<bigarray.ml:257:8>>*/ caml_ba_set_2
          (arr, i, j,  /*<<bigarray.ml:257:27>>*/ caml_call2(f, i, j));
          /*<<bigarray.ml:257:8>>*/  /*<<bigarray.ml:257:8>>*/ var
-         _M_ = j + 1 | 0;
-        if(_K_ === j) break;
-        var j = _M_;
+         _N_ = j + 1 | 0;
+        if(_L_ === j) break;
+        var j = _N_;
        }
       }
        /*<<bigarray.ml:255:4>>*/  /*<<bigarray.ml:255:4>>*/ var
-       _L_ = i + 1 | 0;
-      if(_I_ === i) break;
-      var i = _L_;
+       _M_ = i + 1 | 0;
+      if(_J_ === i) break;
+      var i = _M_;
      }
     }
      /*<<bigarray.ml:269:18>>*/ return arr;
@@ -22382,10 +22374,10 @@
        0 === dim1 ? 0 : caml_check_bound(data, 0)[1].length - 1,
       /*<<bigarray.ml:274:13>>*/ ba = create$1(kind, layout, dim1, dim2),
       /*<<bigarray.ml:275:4>>*/ ofs = layout ? 1 : 0,
-      /*<<bigarray.ml:280:4>>*/ _C_ = dim1 - 1 | 0,
-     _B_ = 0;
-    if(_C_ >= 0){
-     var i = _B_;
+      /*<<bigarray.ml:280:4>>*/ _D_ = dim1 - 1 | 0,
+     _C_ = 0;
+    if(_D_ >= 0){
+     var i = _C_;
      for(;;){
        /*<<bigarray.ml:281:16>>*/  /*<<bigarray.ml:281:16>>*/ var
        row = caml_check_bound(data, i)[1 + i];
@@ -22393,23 +22385,23 @@
         /*<<bigarray.ml:283:8>>*/  /*<<bigarray.ml:283:8>>*/ caml_call1
         (Stdlib[1], cst_Bigarray_Array2_of_array_n);
        /*<<bigarray.ml:273:32>>*/ var
-        /*<<bigarray.ml:273:32>>*/ _E_ = dim2 - 1 | 0,
-        /*<<bigarray.ml:283:8>>*/ _D_ = 0;
-      if(_E_ >= 0){
-       var j = _D_;
+        /*<<bigarray.ml:273:32>>*/ _F_ = dim2 - 1 | 0,
+        /*<<bigarray.ml:283:8>>*/ _E_ = 0;
+      if(_F_ >= 0){
+       var j = _E_;
        for(;;){
          /*<<bigarray.ml:285:8>>*/  /*<<bigarray.ml:285:8>>*/ caml_ba_set_2
          (ba, i + ofs | 0, j + ofs | 0, caml_check_bound(row, j)[1 + j]);
          /*<<bigarray.ml:285:8>>*/  /*<<bigarray.ml:285:8>>*/ var
-         _G_ = j + 1 | 0;
-        if(_E_ === j) break;
-        var j = _G_;
+         _H_ = j + 1 | 0;
+        if(_F_ === j) break;
+        var j = _H_;
        }
       }
        /*<<bigarray.ml:280:4>>*/  /*<<bigarray.ml:280:4>>*/ var
-       _F_ = i + 1 | 0;
-      if(_C_ === i) break;
-      var i = _F_;
+       _G_ = i + 1 | 0;
+      if(_D_ === i) break;
+      var i = _G_;
      }
     }
      /*<<bigarray.ml:288:4>>*/ return ba;
@@ -22420,20 +22412,20 @@
     /*<<bigarray.ml:294:52>>*/ }
    function size_in_bytes$3(arr){
      /*<<bigarray.ml:312:4>>*/ var
-      /*<<bigarray.ml:312:64>>*/ _y_ =
+      /*<<bigarray.ml:312:64>>*/ _z_ =
         /*<<bigarray.ml:312:64>>*/ runtime.caml_ba_dim_3(arr),
-      /*<<bigarray.ml:312:51>>*/ _z_ =
+      /*<<bigarray.ml:312:51>>*/ _A_ =
         /*<<bigarray.ml:312:51>>*/ caml_ba_dim_2(arr),
-      /*<<bigarray.ml:312:38>>*/ _A_ =
+      /*<<bigarray.ml:312:38>>*/ _B_ =
         /*<<bigarray.ml:312:38>>*/ caml_ba_dim_1(arr);
     return caml_mul
             (caml_mul
               ( /*<<bigarray.ml:312:4>>*/ caml_mul
                 (kind_size_in_bytes
                   ( /*<<bigarray.ml:312:24>>*/ caml_ba_kind(arr)),
-                 _A_),
-               _z_),
-             _y_);
+                 _B_),
+               _A_),
+             _z_);
     /*<<bigarray.ml:312:74>>*/ }
    function slice_left_1(a, n, m){
      /*<<bigarray.ml:319:27>>*/ return  /*<<bigarray.ml:319:27>>*/ caml_ba_slice
@@ -22455,17 +22447,17 @@
      /*<<bigarray.ml:342:4>>*/  /*<<bigarray.ml:342:14>>*/ var
      arr = create$2(kind, layout, dim1, dim2, dim3);
      /*<<bigarray.ml:343:4>>*/ if(layout){
-      /*<<bigarray.ml:334:4>>*/  /*<<bigarray.ml:334:4>>*/ var _s_ = 1;
+      /*<<bigarray.ml:334:4>>*/  /*<<bigarray.ml:334:4>>*/ var _t_ = 1;
      if(dim3 >= 1){
-      var k$0 = _s_;
+      var k$0 = _t_;
       for(;;){
-        /*<<bigarray.ml:335:6>>*/  /*<<bigarray.ml:335:6>>*/ var _t_ = 1;
+        /*<<bigarray.ml:335:6>>*/  /*<<bigarray.ml:335:6>>*/ var _u_ = 1;
        if(dim2 >= 1){
-        var j$0 = _t_;
+        var j$0 = _u_;
         for(;;){
-          /*<<bigarray.ml:336:8>>*/  /*<<bigarray.ml:336:8>>*/ var _v_ = 1;
+          /*<<bigarray.ml:336:8>>*/  /*<<bigarray.ml:336:8>>*/ var _w_ = 1;
          if(dim1 >= 1){
-          var i$0 = _v_;
+          var i$0 = _w_;
           for(;;){
             /*<<bigarray.ml:337:10>>*/  /*<<bigarray.ml:337:10>>*/ caml_ba_set_3
             (arr,
@@ -22474,61 +22466,61 @@
              k$0,
               /*<<bigarray.ml:337:31>>*/ caml_call3(f, i$0, j$0, k$0));
             /*<<bigarray.ml:337:10>>*/  /*<<bigarray.ml:337:10>>*/ var
-            _x_ = i$0 + 1 | 0;
+            _y_ = i$0 + 1 | 0;
            if(dim1 === i$0) break;
-           var i$0 = _x_;
+           var i$0 = _y_;
           }
          }
           /*<<bigarray.ml:335:6>>*/  /*<<bigarray.ml:335:6>>*/ var
-          _w_ = j$0 + 1 | 0;
+          _x_ = j$0 + 1 | 0;
          if(dim2 === j$0) break;
-         var j$0 = _w_;
+         var j$0 = _x_;
         }
        }
         /*<<bigarray.ml:334:4>>*/  /*<<bigarray.ml:334:4>>*/ var
-        _u_ = k$0 + 1 | 0;
+        _v_ = k$0 + 1 | 0;
        if(dim3 === k$0) break;
-       var k$0 = _u_;
+       var k$0 = _v_;
       }
      }
       /*<<bigarray.ml:345:24>>*/ return arr;
     }
      /*<<bigarray.ml:326:4>>*/ var
-     _k_ = dim1 - 1 | 0,
-      /*<<bigarray.ml:326:4>>*/ _j_ = 0;
-    if(_k_ >= 0){
-     var i = _j_;
+     _l_ = dim1 - 1 | 0,
+      /*<<bigarray.ml:326:4>>*/ _k_ = 0;
+    if(_l_ >= 0){
+     var i = _k_;
      for(;;){
        /*<<bigarray.ml:327:6>>*/ var
-       _m_ = dim2 - 1 | 0,
-        /*<<bigarray.ml:327:6>>*/ _l_ = 0;
-      if(_m_ >= 0){
-       var j = _l_;
+       _n_ = dim2 - 1 | 0,
+        /*<<bigarray.ml:327:6>>*/ _m_ = 0;
+      if(_n_ >= 0){
+       var j = _m_;
        for(;;){
          /*<<bigarray.ml:328:8>>*/ var
-         _p_ = dim3 - 1 | 0,
-          /*<<bigarray.ml:328:8>>*/ _o_ = 0;
-        if(_p_ >= 0){
-         var k = _o_;
+         _q_ = dim3 - 1 | 0,
+          /*<<bigarray.ml:328:8>>*/ _p_ = 0;
+        if(_q_ >= 0){
+         var k = _p_;
          for(;;){
            /*<<bigarray.ml:329:10>>*/  /*<<bigarray.ml:329:10>>*/ caml_ba_set_3
            (arr, i, j, k,  /*<<bigarray.ml:329:31>>*/ caml_call3(f, i, j, k));
            /*<<bigarray.ml:329:10>>*/  /*<<bigarray.ml:329:10>>*/ var
-           _r_ = k + 1 | 0;
-          if(_p_ === k) break;
-          var k = _r_;
+           _s_ = k + 1 | 0;
+          if(_q_ === k) break;
+          var k = _s_;
          }
         }
          /*<<bigarray.ml:327:6>>*/  /*<<bigarray.ml:327:6>>*/ var
-         _q_ = j + 1 | 0;
-        if(_m_ === j) break;
-        var j = _q_;
+         _r_ = j + 1 | 0;
+        if(_n_ === j) break;
+        var j = _r_;
        }
       }
        /*<<bigarray.ml:326:4>>*/  /*<<bigarray.ml:326:4>>*/ var
-       _n_ = i + 1 | 0;
-      if(_k_ === i) break;
-      var i = _n_;
+       _o_ = i + 1 | 0;
+      if(_l_ === i) break;
+      var i = _o_;
      }
     }
      /*<<bigarray.ml:344:18>>*/ return arr;
@@ -22544,10 +22536,10 @@
         : caml_check_bound(caml_check_bound(data, 0)[1], 0)[1].length - 1,
       /*<<bigarray.ml:350:13>>*/ ba = create$2(kind, layout, dim1, dim2, dim3),
       /*<<bigarray.ml:351:4>>*/ ofs = layout ? 1 : 0,
-      /*<<bigarray.ml:356:4>>*/ _b_ = dim1 - 1 | 0,
-     _a_ = 0;
-    if(_b_ >= 0){
-     var i = _a_;
+      /*<<bigarray.ml:356:4>>*/ _c_ = dim1 - 1 | 0,
+     _b_ = 0;
+    if(_c_ >= 0){
+     var i = _b_;
      for(;;){
        /*<<bigarray.ml:357:16>>*/  /*<<bigarray.ml:357:16>>*/ var
        row = caml_check_bound(data, i)[1 + i];
@@ -22555,10 +22547,10 @@
         /*<<bigarray.ml:359:8>>*/  /*<<bigarray.ml:359:8>>*/ caml_call1
         (Stdlib[1], cst_Bigarray_Array3_of_array_n);
        /*<<bigarray.ml:348:32>>*/ var
-        /*<<bigarray.ml:348:32>>*/ _d_ = dim2 - 1 | 0,
-        /*<<bigarray.ml:359:8>>*/ _c_ = 0;
-      if(_d_ >= 0){
-       var j = _c_;
+        /*<<bigarray.ml:348:32>>*/ _e_ = dim2 - 1 | 0,
+        /*<<bigarray.ml:359:8>>*/ _d_ = 0;
+      if(_e_ >= 0){
+       var j = _d_;
        for(;;){
          /*<<bigarray.ml:361:18>>*/  /*<<bigarray.ml:361:18>>*/ var
          col = caml_check_bound(row, j)[1 + j];
@@ -22566,10 +22558,10 @@
           /*<<bigarray.ml:363:10>>*/  /*<<bigarray.ml:363:10>>*/ caml_call1
           (Stdlib[1], cst_Bigarray_Array3_of_array_n$0);
          /*<<bigarray.ml:349:32>>*/ var
-          /*<<bigarray.ml:349:32>>*/ _g_ = dim3 - 1 | 0,
-          /*<<bigarray.ml:363:10>>*/ _f_ = 0;
-        if(_g_ >= 0){
-         var k = _f_;
+          /*<<bigarray.ml:349:32>>*/ _h_ = dim3 - 1 | 0,
+          /*<<bigarray.ml:363:10>>*/ _g_ = 0;
+        if(_h_ >= 0){
+         var k = _g_;
          for(;;){
            /*<<bigarray.ml:365:10>>*/  /*<<bigarray.ml:365:10>>*/ caml_ba_set_3
            (ba,
@@ -22578,21 +22570,21 @@
             k + ofs | 0,
             caml_check_bound(col, k)[1 + k]);
            /*<<bigarray.ml:365:10>>*/  /*<<bigarray.ml:365:10>>*/ var
-           _i_ = k + 1 | 0;
-          if(_g_ === k) break;
-          var k = _i_;
+           _j_ = k + 1 | 0;
+          if(_h_ === k) break;
+          var k = _j_;
          }
         }
          /*<<bigarray.ml:359:8>>*/  /*<<bigarray.ml:359:8>>*/ var
-         _h_ = j + 1 | 0;
-        if(_d_ === j) break;
-        var j = _h_;
+         _i_ = j + 1 | 0;
+        if(_e_ === j) break;
+        var j = _i_;
        }
       }
        /*<<bigarray.ml:356:4>>*/  /*<<bigarray.ml:356:4>>*/ var
-       _e_ = i + 1 | 0;
-      if(_b_ === i) break;
-      var i = _e_;
+       _f_ = i + 1 | 0;
+      if(_c_ === i) break;
+      var i = _f_;
      }
     }
      /*<<bigarray.ml:369:4>>*/ return ba;
@@ -24171,13 +24163,13 @@
             : runtime.caml_call_gen(f, [a0, a1, a2, a3, a4]);
    }
    var
-    sentinal = undefined,
     global_data = runtime.caml_get_global_data(),
     Stdlib = global_data.Stdlib,
     Stdlib_Sys = global_data.Stdlib__Sys,
     Stdlib_Int = global_data.Stdlib__Int,
     Stdlib_Array = global_data.Stdlib__Array,
     Stdlib_Obj = global_data.Stdlib__Obj,
+    _a_ = undefined,
     cst_Weak_Make_hash_bucket_cann = "Weak.Make: hash bucket cannot grow more",
     cst_Weak_fill = "Weak.fill",
     cst_Weak_blit = "Weak.blit",
@@ -24188,9 +24180,9 @@
     cst_Weak_create = "Weak.create";
    function create(l){
      /*<<weak.ml:28:2>>*/ var
-     _W_ = 0 <= l ? 1 : 0,
-     _X_ = _W_ ? l <= Stdlib_Obj[24][15] ? 1 : 0 : _W_;
-    if(1 - _X_)
+     _X_ = 0 <= l ? 1 : 0,
+     _Y_ = _X_ ? l <= Stdlib_Obj[24][15] ? 1 : 0 : _X_;
+    if(1 - _Y_)
       /*<<weak.ml:29:4>>*/  /*<<weak.ml:29:4>>*/ caml_call1
       (Stdlib[1], cst_Weak_create);
      /*<<weak.ml:30:2>>*/ return  /*<<weak.ml:30:2>>*/ runtime.caml_weak_create
@@ -24201,12 +24193,10 @@
     /*<<weak.ml:33:55>>*/ }
    function raise_if_invalid_offset(e, o, msg){
      /*<<weak.ml:36:2>>*/ var
-     _T_ = 0 <= o ? 1 : 0,
-     _U_ = _T_ ? o < length(e) ? 1 : 0 : _T_,
-     _V_ = 1 - _U_;
-    return _V_
-            ? ( /*<<weak.ml:37:4>>*/ caml_call1(Stdlib[1], msg), sentinal)
-            : _V_;
+     _U_ = 0 <= o ? 1 : 0,
+     _V_ = _U_ ? o < length(e) ? 1 : 0 : _U_,
+     _W_ = 1 - _V_;
+    return _W_ ? ( /*<<weak.ml:37:4>>*/ caml_call1(Stdlib[1], msg), _a_) : _W_;
     /*<<weak.ml:37:20>>*/ }
    function set(e, o, x){
      /*<<weak.ml:42:2>>*/ raise_if_invalid_offset(e, o, cst_Weak_set);
@@ -24239,13 +24229,13 @@
        0 <= o1
        && (length(e1) - l | 0) >= o1 && 0 <= o2 && (length(e2) - l | 0) >= o2){
      var
-      _R_ = 0 !== l ? 1 : 0,
-      _S_ =
-        _R_
+      _S_ = 0 !== l ? 1 : 0,
+      _T_ =
+        _S_
          ?  /*<<weak.ml:69:22>>*/ runtime.caml_ephe_blit_key
            (e1, o1, e2, o2, l)
-         : _R_;
-      /*<<weak.ml:69:22>>*/ return _S_;
+         : _S_;
+      /*<<weak.ml:69:22>>*/ return _T_;
     }
      /*<<weak.ml:68:7>>*/ return  /*<<weak.ml:68:7>>*/ caml_call1
             (Stdlib[1], cst_Weak_blit);
@@ -24253,14 +24243,14 @@
    function fill(ar, ofs, len, x){
      /*<<weak.ml:72:2>>*/ if
      (0 <= ofs && 0 <= len && (length(ar) - len | 0) >= ofs){
-     var _P_ = (ofs + len | 0) - 1 | 0;
-     if(_P_ >= ofs){
+     var _Q_ = (ofs + len | 0) - 1 | 0;
+     if(_Q_ >= ofs){
       var i = ofs;
       for(;;){
         /*<<weak.ml:76:6>>*/ set(ar, i, x);
-        /*<<weak.ml:76:6>>*/  /*<<weak.ml:76:6>>*/ var _Q_ = i + 1 | 0;
-       if(_P_ === i) break;
-       var i = _Q_;
+        /*<<weak.ml:76:6>>*/  /*<<weak.ml:76:6>>*/ var _R_ = i + 1 | 0;
+       if(_Q_ === i) break;
+       var i = _R_;
       }
      }
      return 0;
@@ -24288,16 +24278,16 @@
      /*<<weak.ml:131:5>>*/ }
     function clear(t){
       /*<<weak.ml:134:4>>*/ var
-      _N_ = t[1].length - 1 - 1 | 0,
-       /*<<weak.ml:134:4>>*/ _M_ = 0;
-     if(_N_ >= 0){
-      var i = _M_;
+      _O_ = t[1].length - 1 - 1 | 0,
+       /*<<weak.ml:134:4>>*/ _N_ = 0;
+     if(_O_ >= 0){
+      var i = _N_;
       for(;;){
         /*<<weak.ml:135:6>>*/ caml_check_bound(t[1], i)[1 + i] = emptybucket;
         /*<<weak.ml:136:6>>*/ caml_check_bound(t[2], i)[1 + i] = [0];
-        /*<<weak.ml:136:6>>*/  /*<<weak.ml:136:6>>*/ var _O_ = i + 1 | 0;
-       if(_N_ === i) break;
-       var i = _O_;
+        /*<<weak.ml:136:6>>*/  /*<<weak.ml:136:6>>*/ var _P_ = i + 1 | 0;
+       if(_O_ === i) break;
+       var i = _P_;
       }
      }
      t[3] = limit;
@@ -24305,8 +24295,8 @@
      return 0;
      /*<<weak.ml:139:19>>*/ }
     function fold(f, t, init){
-      /*<<weak.ml:143:4>>*/ var _K_ = t[1], i = 0;
-      /*<<weak.ml:149:21>>*/ function _L_(b, accu$1){
+      /*<<weak.ml:143:4>>*/ var _L_ = t[1], i = 0;
+      /*<<weak.ml:149:21>>*/ function _M_(b, accu$1){
       var i$0 = i, accu = accu$1;
        /*<<weak.ml:144:6>>*/ for(;;){
        if(length(b) <= i$0)  /*<<weak.ml:144:28>>*/ return accu;
@@ -24325,11 +24315,11 @@
       }
      }
       /*<<weak.ml:149:4>>*/ return  /*<<weak.ml:149:4>>*/ caml_call3
-             (Stdlib_Array[17], _L_, _K_, init);
+             (Stdlib_Array[17], _M_, _L_, init);
      /*<<weak.ml:149:49>>*/ }
     function iter(f, t){
-      /*<<weak.ml:153:4>>*/ var _I_ = t[1], i = 0;
-      /*<<weak.ml:159:15>>*/ function _J_(b){
+      /*<<weak.ml:153:4>>*/ var _J_ = t[1], i = 0;
+      /*<<weak.ml:159:15>>*/ function _K_(b){
       var i$0 = i;
        /*<<weak.ml:154:6>>*/ for(;;){
        if(length(b) <= i$0)  /*<<weak.ml:154:28>>*/ return 0;
@@ -24345,15 +24335,15 @@
       }
      }
       /*<<weak.ml:159:15>>*/ return  /*<<weak.ml:159:15>>*/ caml_call2
-             (Stdlib_Array[11], _J_, _I_);
+             (Stdlib_Array[11], _K_, _J_);
      /*<<weak.ml:159:38>>*/ }
     function count_bucket(i, b, accu){
       /*<<weak.ml:173:4>>*/ var i$0 = i, accu$0 = accu;
       /*<<weak.ml:173:4>>*/ for(;;){
       if(length(b) <= i$0)  /*<<weak.ml:173:26>>*/ return accu$0;
        /*<<weak.ml:174:37>>*/ var
-        /*<<weak.ml:174:37>>*/ _H_ = check(b, i$0) ? 1 : 0,
-       accu$1 = accu$0 + _H_ | 0,
+        /*<<weak.ml:174:37>>*/ _I_ = check(b, i$0) ? 1 : 0,
+       accu$1 = accu$0 + _I_ | 0,
        i$1 = i$0 + 1 | 0,
        i$0 = i$1,
        accu$0 = accu$1;
@@ -24361,14 +24351,14 @@
      /*<<weak.ml:174:62>>*/ }
     function count(t){
       /*<<weak.ml:178:4>>*/ var
-       /*<<weak.ml:178:4>>*/ _B_ = 0,
-      _C_ = t[1],
-      _D_ = 0;
-      /*<<weak.ml:178:21>>*/ function _E_(_F_, _G_){
-       /*<<?>>*/ return count_bucket(_D_, _F_, _G_);
+       /*<<weak.ml:178:4>>*/ _C_ = 0,
+      _D_ = t[1],
+      _E_ = 0;
+      /*<<weak.ml:178:21>>*/ function _F_(_G_, _H_){
+       /*<<?>>*/ return count_bucket(_E_, _G_, _H_);
      }
       /*<<weak.ml:178:4>>*/ return  /*<<weak.ml:178:4>>*/ caml_call3
-             (Stdlib_Array[17], _E_, _C_, _B_);
+             (Stdlib_Array[17], _F_, _D_, _C_);
      /*<<weak.ml:178:47>>*/ }
     function add_aux(t, setter, d, h, index){
       /*<<weak.ml:238:4>>*/ var
@@ -24401,18 +24391,18 @@
         /*<<weak.ml:252:8>>*/ caml_check_bound(newhashes, sz)[1 + sz] = h;
         /*<<weak.ml:253:8>>*/ caml_check_bound(t[1], index)[1 + index] = newbucket$0;
         /*<<weak.ml:254:8>>*/ caml_check_bound(t[2], index)[1 + index] = newhashes;
-       var _x_ = sz <= t[3] ? 1 : 0, _y_ = _x_ ? t[3] < newsz ? 1 : 0 : _x_;
-       if(_y_){
+       var _y_ = sz <= t[3] ? 1 : 0, _z_ = _y_ ? t[3] < newsz ? 1 : 0 : _y_;
+       if(_z_){
         t[4] = t[4] + 1 | 0;
         var i$4 = 0;
         for(;;){
           /*<<weak.ml:185:17>>*/ var
-          _n_ = t[5],
+          _o_ = t[5],
            /*<<weak.ml:185:17>>*/ bucket =
-            caml_check_bound(t[1], _n_)[1 + _n_],
-           /*<<weak.ml:186:4>>*/ _o_ = t[5],
+            caml_check_bound(t[1], _o_)[1 + _o_],
+           /*<<weak.ml:186:4>>*/ _p_ = t[5],
            /*<<weak.ml:186:18>>*/ hbucket =
-            caml_check_bound(t[2], _o_)[1 + _o_],
+            caml_check_bound(t[2], _p_)[1 + _p_],
            /*<<weak.ml:187:14>>*/ len = length(bucket),
           prev_len = (((len - 3 | 0) * 2 | 0) + 2 | 0) / 3 | 0,
            /*<<weak.ml:189:15>>*/ live = count_bucket(0, bucket, 0);
@@ -24424,28 +24414,28 @@
            /*<<weak.ml:192:8>>*/ for(;;){
            if(prev_len > j){
             if(0 === prev_len){
-             var _q_ = t[5];
-              /*<<weak.ml:203:8>>*/ caml_check_bound(t[1], _q_)[1 + _q_] = emptybucket;
              var _r_ = t[5];
-              /*<<weak.ml:204:8>>*/ caml_check_bound(t[2], _r_)[1 + _r_] = [0];
+              /*<<weak.ml:203:8>>*/ caml_check_bound(t[1], _r_)[1 + _r_] = emptybucket;
+             var _s_ = t[5];
+              /*<<weak.ml:204:8>>*/ caml_check_bound(t[2], _s_)[1 + _s_] = [0];
             }
             else{
               /*<<weak.ml:206:24>>*/  /*<<weak.ml:206:24>>*/ var
               newbucket = create(prev_len);
               /*<<weak.ml:207:8>>*/ blit(bucket, 0, newbucket, 0, prev_len);
-             var _u_ = t[5];
-              /*<<weak.ml:208:8>>*/ caml_check_bound(t[1], _u_)[1 + _u_] = newbucket;
+             var _v_ = t[5];
+              /*<<weak.ml:208:8>>*/ caml_check_bound(t[1], _v_)[1 + _v_] = newbucket;
               /*<<weak.ml:209:30>>*/ var
-               /*<<weak.ml:209:30>>*/ _v_ =
+               /*<<weak.ml:209:30>>*/ _w_ =
                  /*<<weak.ml:209:30>>*/ caml_call3
                  (Stdlib_Array[5], hbucket, 0, prev_len),
-              _w_ = t[5];
-              /*<<weak.ml:209:8>>*/ caml_check_bound(t[2], _w_)[1 + _w_] = _v_;
+              _x_ = t[5];
+              /*<<weak.ml:209:8>>*/ caml_check_bound(t[2], _x_)[1 + _x_] = _w_;
             }
             var
-             _s_ = t[3] < len ? 1 : 0,
-             _t_ = _s_ ? prev_len <= t[3] ? 1 : 0 : _s_;
-            if(_t_) t[4] = t[4] - 1 | 0;
+             _t_ = t[3] < len ? 1 : 0,
+             _u_ = _t_ ? prev_len <= t[3] ? 1 : 0 : _t_;
+            if(_u_) t[4] = t[4] - 1 | 0;
             break;
            }
             /*<<weak.ml:193:13>>*/ if(check(bucket, i$0))
@@ -24453,8 +24443,8 @@
            else if(check(bucket, j)){
              /*<<weak.ml:195:12>>*/ blit(bucket, j, bucket, i$0, 1);
              /*<<weak.ml:196:27>>*/  /*<<weak.ml:196:27>>*/ var
-             _p_ = caml_check_bound(hbucket, j)[1 + j];
-             /*<<weak.ml:196:12>>*/ caml_check_bound(hbucket, i$0)[1 + i$0] = _p_;
+             _q_ = caml_check_bound(hbucket, j)[1 + j];
+             /*<<weak.ml:196:12>>*/ caml_check_bound(hbucket, i$0)[1 + i$0] = _q_;
              /*<<weak.ml:196:12>>*/ var
               /*<<weak.ml:196:12>>*/ j$0 = j - 1 | 0,
              i$2 = i$0 + 1 | 0,
@@ -24469,13 +24459,13 @@
          }
          t[5] = caml_mod(t[5] + 1 | 0, t[1].length - 1);
           /*<<weak.ml:257:38>>*/  /*<<weak.ml:257:38>>*/ var
-          _A_ = i$4 + 1 | 0;
+          _B_ = i$4 + 1 | 0;
          if(2 === i$4) break;
-         var i$4 = _A_;
+         var i$4 = _B_;
         }
        }
-       var _z_ = ((t[1].length - 1) / 2 | 0) < t[4] ? 1 : 0;
-       if(! _z_) return _z_;
+       var _A_ = ((t[1].length - 1) / 2 | 0) < t[4] ? 1 : 0;
+       if(! _A_) return _A_;
         /*<<weak.ml:181:18>>*/ var
         oldlen = t[1].length - 1,
          /*<<weak.ml:181:18>>*/ newlen =
@@ -24486,9 +24476,9 @@
        if(oldlen < newlen){
          /*<<weak.ml:220:17>>*/ var
           /*<<weak.ml:220:17>>*/ newt = create$0(newlen),
-         _l_ = t[1],
+         _m_ = t[1],
          i = 0,
-          /*<<weak.ml:169:16>>*/ _m_ =
+          /*<<weak.ml:169:16>>*/ _n_ =
            function(j, ob){
             var oi = i;
              /*<<weak.ml:164:6>>*/ for(;;){
@@ -24514,7 +24504,7 @@
             }
            };
          /*<<weak.ml:169:16>>*/  /*<<weak.ml:169:16>>*/ caml_call2
-         (Stdlib_Array[12], _m_, _l_);
+         (Stdlib_Array[12], _n_, _m_);
         t[1] = newt[1];
         t[2] = newt[2];
         t[3] = newt[3];
@@ -24675,24 +24665,24 @@
      }
      /*<<weak.ml:337:10>>*/ }
     function remove(t, d){
-      /*<<weak.ml:340:19>>*/  /*<<weak.ml:340:19>>*/ var _k_ = 0;
+      /*<<weak.ml:340:19>>*/  /*<<weak.ml:340:19>>*/ var _l_ = 0;
       /*<<weak.ml:340:19>>*/ return find_shadow
              (t,
               d,
               function(w, i){
                 /*<<weak.ml:340:47>>*/ return set(w, i, 0);
                /*<<weak.ml:340:59>>*/ },
-              _k_);
+              _l_);
      /*<<weak.ml:340:63>>*/ }
     function mem(t, d){
-      /*<<weak.ml:343:16>>*/  /*<<weak.ml:343:16>>*/ var _j_ = 0;
+      /*<<weak.ml:343:16>>*/  /*<<weak.ml:343:16>>*/ var _k_ = 0;
       /*<<weak.ml:343:16>>*/ return find_shadow
              (t,
               d,
               function(w, i){
                 /*<<weak.ml:343:46>>*/ return 1;
                /*<<weak.ml:343:50>>*/ },
-              _j_);
+              _k_);
      /*<<weak.ml:343:57>>*/ }
     function find_all(t, d){
       /*<<weak.ml:347:4>>*/ var
@@ -24742,17 +24732,17 @@
          /*<<weak.ml:369:15>>*/ caml_call2(Stdlib_Array[13], length, t[1]);
       /*<<weak.ml:370:4>>*/  /*<<weak.ml:370:4>>*/ caml_call2
       (Stdlib_Array[30], runtime.caml_int_compare, lens);
-     var _a_ = 0;
-     function _b_(_i_, _h_){ /*<<?>>*/ return _i_ + _h_ | 0;}
+     var _b_ = 0;
+     function _c_(_j_, _i_){ /*<<?>>*/ return _j_ + _i_ | 0;}
       /*<<weak.ml:371:17>>*/ var
        /*<<weak.ml:371:17>>*/ totlen =
-         /*<<weak.ml:371:17>>*/ caml_call3(Stdlib_Array[15], _b_, _a_, lens),
-       /*<<weak.ml:371:17>>*/ _c_ = len - 1 | 0,
-      _e_ = len / 2 | 0,
-       /*<<weak.ml:372:51>>*/ _d_ = caml_check_bound(lens, _c_)[1 + _c_],
-       /*<<weak.ml:372:37>>*/ _f_ = caml_check_bound(lens, _e_)[1 + _e_],
-       /*<<weak.ml:372:27>>*/ _g_ = caml_check_bound(lens, 0)[1];
-      /*<<weak.ml:372:4>>*/ return [0, len, count(t), totlen, _g_, _f_, _d_];
+         /*<<weak.ml:371:17>>*/ caml_call3(Stdlib_Array[15], _c_, _b_, lens),
+       /*<<weak.ml:371:17>>*/ _d_ = len - 1 | 0,
+      _f_ = len / 2 | 0,
+       /*<<weak.ml:372:51>>*/ _e_ = caml_check_bound(lens, _d_)[1 + _d_],
+       /*<<weak.ml:372:37>>*/ _g_ = caml_check_bound(lens, _f_)[1 + _f_],
+       /*<<weak.ml:372:27>>*/ _h_ = caml_check_bound(lens, 0)[1];
+      /*<<weak.ml:372:4>>*/ return [0, len, count(t), totlen, _h_, _g_, _e_];
      /*<<weak.ml:372:64>>*/ }
      /*<<weak.ml:101:66>>*/ return [0,
             create$0,
@@ -24809,7 +24799,7 @@
             : runtime.caml_call_gen(f, [a0, a1, a2, a3]);
    }
    var
-    sentinal = undefined,
+    _m_ = undefined,
     global_data = runtime.caml_get_global_data(),
     cst$14 = ".",
     cst$11 = cst$15,
@@ -24859,25 +24849,25 @@
    function pp_output_string(state, s){
      /*<<format.ml:251:31>>*/ caml_call3
      (state[17], s, 0, caml_ml_string_length(s));
-    return sentinal;
+    return _m_;
     /*<<format.ml:251:72>>*/ }
    function pp_output_newline(state){
      /*<<format.ml:252:30>>*/  /*<<format.ml:252:30>>*/ caml_call1
      (state[19], 0);
-     /*<<format.ml:252:30>>*/ return sentinal;
+     /*<<format.ml:252:30>>*/ return _m_;
     /*<<format.ml:252:53>>*/ }
    function format_pp_text(state, size, text){
      /*<<format.ml:258:2>>*/ state[9] = state[9] - size | 0;
      /*<<format.ml:259:2>>*/ pp_output_string(state, text);
     state[11] = 0;
-    return sentinal;
+    return _m_;
     /*<<format.ml:260:31>>*/ }
    function format_string(state, s){
      /*<<format.ml:264:2>>*/  /*<<format.ml:264:5>>*/ var
-     _bN_ =  /*<<format.ml:264:5>>*/ runtime.caml_string_notequal(s, cst$16);
-     /*<<format.ml:264:5>>*/ return _bN_
-            ? (format_pp_text(state, caml_ml_string_length(s), s), sentinal)
-            : _bN_;
+     _bO_ =  /*<<format.ml:264:5>>*/ runtime.caml_string_notequal(s, cst$16);
+     /*<<format.ml:264:5>>*/ return _bO_
+            ? (format_pp_text(state, caml_ml_string_length(s), s), _m_)
+            : _bO_;
     /*<<format.ml:264:58>>*/ }
    function break_new_line(state, param, width){
     var after = param[3], offset = param[2], before = param[1];
@@ -24894,11 +24884,11 @@
      /*<<format.ml:254:31>>*/  /*<<format.ml:254:31>>*/ caml_call1
      (state[21], n);
      /*<<format.ml:276:2>>*/ format_string(state, after);
-     /*<<format.ml:276:2>>*/ return sentinal;
+     /*<<format.ml:276:2>>*/ return _m_;
    }
    function break_line(state, width){
      /*<<format.ml:281:29>>*/ break_new_line(state, _a_, width);
-     /*<<format.ml:281:29>>*/ return sentinal;
+     /*<<format.ml:281:29>>*/ return _m_;
     /*<<format.ml:281:67>>*/ }
    function break_same_line(state, param){
     var after = param[3], width = param[2], before = param[1];
@@ -24907,7 +24897,7 @@
      /*<<format.ml:253:31>>*/  /*<<format.ml:253:31>>*/ caml_call1
      (state[20], width);
      /*<<format.ml:287:2>>*/ format_string(state, after);
-     /*<<format.ml:287:2>>*/ return sentinal;
+     /*<<format.ml:287:2>>*/ return _m_;
    }
    function format_pp_token(state, size$0, param){
      /*<<?>>*/ if(typeof param === "number")
@@ -24916,7 +24906,7 @@
          /*<<format.ml:348:16>>*/  /*<<format.ml:348:16>>*/ var
          match$3 =
             /*<<format.ml:348:16>>*/ caml_call1(Stdlib_Stack[7], state[3]);
-        if(! match$3)  /*<<format.ml:349:14>>*/ return sentinal;
+        if(! match$3)  /*<<format.ml:349:14>>*/ return _m_;
          /*<<format.ml:351:6>>*/ var
          tabs = match$3[1][1],
           /*<<format.ml:351:6>>*/ add_tab =
@@ -24929,15 +24919,15 @@
                     : [0, x, add_tab(n, l)];
            };
         tabs[1] = add_tab(state[6] - state[9] | 0, tabs[1]);
-        return sentinal;
+        return _m_;
        case 1:
          /*<<format.ml:339:4>>*/  /*<<format.ml:339:4>>*/ caml_call1
          (Stdlib_Stack[5], state[2]);
-         /*<<format.ml:339:4>>*/ return sentinal;
+         /*<<format.ml:339:4>>*/ return _m_;
        case 2:
          /*<<format.ml:345:4>>*/  /*<<format.ml:345:4>>*/ caml_call1
          (Stdlib_Stack[5], state[3]);
-         /*<<format.ml:345:4>>*/ return sentinal;
+         /*<<format.ml:345:4>>*/ return _m_;
        case 3:
          /*<<format.ml:378:16>>*/  /*<<format.ml:378:16>>*/ var
          match$4 =
@@ -24945,38 +24935,38 @@
         if(match$4){
          var width$0 = match$4[1][2];
           /*<<format.ml:380:26>>*/ break_line(state, width$0);
-          /*<<format.ml:380:26>>*/ return sentinal;
+          /*<<format.ml:380:26>>*/ return _m_;
         }
          /*<<format.ml:379:14>>*/ pp_output_newline(state);
-         /*<<format.ml:379:14>>*/ return sentinal;
+         /*<<format.ml:379:14>>*/ return _m_;
        case 4:
-        var _bL_ = state[10] !== (state[6] - state[9] | 0) ? 1 : 0;
-        if(! _bL_) return _bL_;
+        var _bM_ = state[10] !== (state[6] - state[9] | 0) ? 1 : 0;
+        if(! _bM_) return _bM_;
          /*<<format.ml:306:8>>*/  /*<<format.ml:306:8>>*/ var
          match$1 =
             /*<<format.ml:306:8>>*/ caml_call1(Stdlib_Queue[6], state[28]);
-        if(! match$1)  /*<<format.ml:307:12>>*/ return sentinal;
+        if(! match$1)  /*<<format.ml:307:12>>*/ return _m_;
         var match$2 = match$1[1], size = match$2[1], length = match$2[3];
         state[12] = state[12] - length | 0;
         state[9] = state[9] + size | 0;
-        return sentinal;
+        return _m_;
        default:
          /*<<format.ml:419:17>>*/  /*<<format.ml:419:17>>*/ var
          match$5 =
             /*<<format.ml:419:17>>*/ caml_call1(Stdlib_Stack[5], state[5]);
-        if(! match$5)  /*<<format.ml:420:15>>*/ return sentinal;
+        if(! match$5)  /*<<format.ml:420:15>>*/ return _m_;
          /*<<format.ml:422:20>>*/ var
          tag_name = match$5[1],
           /*<<format.ml:422:20>>*/ marker =
             /*<<format.ml:422:20>>*/ caml_call1(state[25], tag_name);
          /*<<format.ml:423:7>>*/ pp_output_string(state, marker);
-         /*<<format.ml:423:7>>*/ return sentinal;
+         /*<<format.ml:423:7>>*/ return _m_;
      }
     switch(param[0]){
       case 0:
        var s = param[1];
         /*<<format.ml:323:4>>*/ format_pp_text(state, size$0, s);
-        /*<<format.ml:323:4>>*/ return sentinal;
+        /*<<format.ml:323:4>>*/ return _m_;
       case 1:
         /*<<format.ml:388:4>>*/ var
         breaks = param[2],
@@ -24985,7 +24975,7 @@
         before = breaks[1],
          /*<<format.ml:389:16>>*/ match$6 =
            /*<<format.ml:389:16>>*/ caml_call1(Stdlib_Stack[7], state[2]);
-       if(! match$6)  /*<<format.ml:390:14>>*/ return sentinal;
+       if(! match$6)  /*<<format.ml:390:14>>*/ return _m_;
        var
         match$7 = match$6[1],
         width$1 = match$7[2],
@@ -24993,24 +24983,24 @@
         /*<<format.ml:392:6>>*/ switch(box_type$0){
          case 0:
            /*<<format.ml:409:19>>*/ break_same_line(state, fits);
-           /*<<format.ml:409:19>>*/ return sentinal;
+           /*<<format.ml:409:19>>*/ return _m_;
          case 1:
            /*<<format.ml:408:19>>*/ break_new_line(state, breaks, width$1);
-           /*<<format.ml:408:19>>*/ return sentinal;
+           /*<<format.ml:408:19>>*/ return _m_;
          case 2:
            /*<<format.ml:406:20>>*/ break_new_line(state, breaks, width$1);
-           /*<<format.ml:406:20>>*/ return sentinal;
+           /*<<format.ml:406:20>>*/ return _m_;
          case 3:
           return state[9] < (size$0 + caml_ml_string_length(before) | 0)
-                  ? (break_new_line(state, breaks, width$1), sentinal)
-                  : (break_same_line(state, fits), sentinal);
+                  ? (break_new_line(state, breaks, width$1), _m_)
+                  : (break_same_line(state, fits), _m_);
          case 4:
           return state[11]
-                  ? (break_same_line(state, fits), sentinal)
+                  ? (break_same_line(state, fits), _m_)
                   : state
                      [9]
                     < (size$0 + caml_ml_string_length(before) | 0)
-                    ? (break_new_line(state, breaks, width$1), sentinal)
+                    ? (break_new_line(state, breaks, width$1), _m_)
                     : ((state
                        [6]
                       - width$1
@@ -25018,11 +25008,11 @@
                       + off
                       | 0)
                       < state[10]
-                      ? (break_new_line(state, breaks, width$1), sentinal)
-                      : (break_same_line(state, fits), sentinal);
+                      ? (break_new_line(state, breaks, width$1), _m_)
+                      : (break_same_line(state, fits), _m_);
          default:
            /*<<format.ml:407:19>>*/ break_same_line(state, fits);
-           /*<<format.ml:407:19>>*/ return sentinal;
+           /*<<format.ml:407:19>>*/ return _m_;
        }
       case 2:
         /*<<format.ml:359:16>>*/ var
@@ -25031,7 +25021,7 @@
         insertion_point = state[6] - state[9] | 0,
          /*<<format.ml:359:16>>*/ match$8 =
            /*<<format.ml:359:16>>*/ caml_call1(Stdlib_Stack[7], state[3]);
-       if(! match$8)  /*<<format.ml:360:14>>*/ return sentinal;
+       if(! match$8)  /*<<format.ml:360:14>>*/ return _m_;
         /*<<format.ml:362:6>>*/ var
         tabs$0 = match$8[1][1],
          /*<<format.ml:362:6>>*/ match$9 = tabs$0[1];
@@ -25041,11 +25031,11 @@
          if(param$0){
           var tail = param$0[2], head = param$0[1];
           if(insertion_point > head){var param$0 = tail; continue;}
-          var _bM_ = head;
+          var _bN_ = head;
          }
          else
-          var _bM_ = first;
-         var tab = _bM_;
+          var _bN_ = first;
+         var tab = _bN_;
          break;
         }
        }
@@ -25055,10 +25045,10 @@
         /*<<format.ml:372:6>>*/ return 0 <= offset
                ? (break_same_line
                   (state, [0, cst$0, offset + n | 0, cst]),
-                 sentinal)
+                 _m_)
                : (break_new_line
                   (state, [0, cst$2, tab + off$0 | 0, cst$1], state[6]),
-                 sentinal);
+                 _m_);
       case 3:
        var
         ty = param[2],
@@ -25082,12 +25072,12 @@
           1 === ty ? 1 : state[9] < size$0 ? ty : 5;
         /*<<format.ml:336:4>>*/  /*<<format.ml:336:4>>*/ caml_call2
         (Stdlib_Stack[3], [0, box_type$1, width$2], state[2]);
-        /*<<format.ml:336:4>>*/ return sentinal;
+        /*<<format.ml:336:4>>*/ return _m_;
       case 4:
        var tbox = param[1];
         /*<<format.ml:342:4>>*/  /*<<format.ml:342:4>>*/ caml_call2
         (Stdlib_Stack[3], tbox, state[3]);
-        /*<<format.ml:342:4>>*/ return sentinal;
+        /*<<format.ml:342:4>>*/ return _m_;
       default:
         /*<<format.ml:414:18>>*/ var
         tag_name$0 = param[1],
@@ -25095,7 +25085,7 @@
            /*<<format.ml:414:18>>*/ caml_call1(state[24], tag_name$0);
         /*<<format.ml:415:5>>*/ pp_output_string(state, marker$0);
        caml_call2(Stdlib_Stack[3], tag_name$0, state[5]);
-       return sentinal;
+       return _m_;
     }
    }
    function advance_left(state){
@@ -25109,10 +25099,10 @@
       length = match$0[3],
       token = match$0[2],
       pending_count = state[13] - state[12] | 0,
-       /*<<format.ml:435:7>>*/ _bJ_ = 0 <= size ? 1 : 0,
-       /*<<format.ml:435:7>>*/ _bK_ =
-        _bJ_ || (state[9] <= pending_count ? 1 : 0);
-     if(! _bK_)  /*<<format.ml:435:7>>*/ return _bK_;
+       /*<<format.ml:435:7>>*/ _bK_ = 0 <= size ? 1 : 0,
+       /*<<format.ml:435:7>>*/ _bL_ =
+        _bK_ || (state[9] <= pending_count ? 1 : 0);
+     if(! _bL_)  /*<<format.ml:435:7>>*/ return _bL_;
       /*<<format.ml:436:6>>*/  /*<<format.ml:436:6>>*/ caml_call1
       (Stdlib_Queue[5], state[28]);
       /*<<format.ml:437:20>>*/  /*<<format.ml:437:20>>*/ var
@@ -25136,31 +25126,28 @@
      queue_elem = [0, unknown, _b_, 0];
      /*<<format.ml:464:2>>*/  /*<<format.ml:464:2>>*/ caml_call2
      (Stdlib_Stack[3], [0, -1, queue_elem], stack);
-     /*<<format.ml:464:2>>*/ return sentinal;
+     /*<<format.ml:464:2>>*/ return _m_;
     /*<<format.ml:464:50>>*/ }
    function set_size(state, ty){
      /*<<format.ml:476:2>>*/  /*<<format.ml:476:8>>*/ var
      match =  /*<<format.ml:476:8>>*/ caml_call1(Stdlib_Stack[7], state[1]);
-    if(! match)  /*<<format.ml:477:12>>*/ return sentinal;
+    if(! match)  /*<<format.ml:477:12>>*/ return _m_;
      /*<<format.ml:479:4>>*/ var
      match$0 = match[1],
      queue_elem = match$0[2],
      left_total = match$0[1],
       /*<<format.ml:479:4>>*/ size = queue_elem[1];
-    if(left_total < state[12]){
-     initialize_scan_stack(state[1]);
-     return sentinal;
-    }
-    var _bI_ = queue_elem[2];
-    if(typeof _bI_ !== "number")
-     switch(_bI_[0]){
+    if(left_total < state[12]){initialize_scan_stack(state[1]); return _m_;}
+    var _bJ_ = queue_elem[2];
+    if(typeof _bJ_ !== "number")
+     switch(_bJ_[0]){
        case 3:
         if(1 - ty){
          queue_elem[1] = state[13] + size | 0;
           /*<<format.ml:493:10>>*/  /*<<format.ml:493:10>>*/ caml_call1
           (Stdlib_Stack[5], state[1]);
         }
-         /*<<format.ml:493:10>>*/ return sentinal;
+         /*<<format.ml:493:10>>*/ return _m_;
        case 1:
        case 2:
         if(ty){
@@ -25168,9 +25155,9 @@
           /*<<format.ml:488:10>>*/  /*<<format.ml:488:10>>*/ caml_call1
           (Stdlib_Stack[5], state[1]);
         }
-         /*<<format.ml:488:10>>*/ return sentinal;
+         /*<<format.ml:488:10>>*/ return _m_;
      }
-     /*<<format.ml:497:8>>*/ return sentinal;
+     /*<<format.ml:497:8>>*/ return _m_;
     /*<<format.ml:497:10>>*/ }
    function scan_push(state, b, token){
      /*<<format.ml:503:2>>*/ pp_enqueue(state, token);
@@ -25188,26 +25175,26 @@
        /*<<format.ml:516:15>>*/ elem = [0, size, [3, indent, br_ty], 0];
       /*<<format.ml:517:4>>*/ return scan_push(state, 0, elem);
     }
-    var _bH_ = state[14] === state[15] ? 1 : 0;
-    if(! _bH_) return _bH_;
+    var _bI_ = state[14] === state[15] ? 1 : 0;
+    if(! _bI_) return _bI_;
     var s = state[16];
      /*<<format.ml:454:2>>*/ return enqueue_string_as
             (state, caml_ml_string_length(s), s);
     /*<<format.ml:519:45>>*/ }
    function pp_close_box(state, param){
-     /*<<format.ml:527:2>>*/ var _bF_ = 1 < state[14] ? 1 : 0;
-    if(_bF_){
+     /*<<format.ml:527:2>>*/ var _bG_ = 1 < state[14] ? 1 : 0;
+    if(_bG_){
      if(state[14] < state[15]){
        /*<<format.ml:531:6>>*/ pp_enqueue(state, [0, zero, 1, 0]);
        /*<<format.ml:532:6>>*/ set_size(state, 1);
        /*<<format.ml:532:27>>*/ set_size(state, 0);
      }
      state[14] = state[14] - 1 | 0;
-     var _bG_ = 0;
+     var _bH_ = 0;
     }
     else
-     var _bG_ = _bF_;
-    return _bG_;
+     var _bH_ = _bG_;
+    return _bH_;
     /*<<format.ml:535:5>>*/ }
    function pp_open_stag(state, tag_name){
      /*<<format.ml:540:2>>*/ if(state[22]){
@@ -25216,8 +25203,8 @@
       /*<<format.ml:543:4>>*/  /*<<format.ml:543:4>>*/ caml_call1
       (state[26], tag_name);
     }
-    var _bE_ = state[23];
-    if(! _bE_) return _bE_;
+    var _bF_ = state[23];
+    if(! _bF_) return _bF_;
      /*<<format.ml:546:16>>*/  /*<<format.ml:546:16>>*/ var
      token = [5, tag_name];
      /*<<format.ml:547:21>>*/ return pp_enqueue(state, [0, zero, token, 0]);
@@ -25225,8 +25212,8 @@
    function pp_close_stag(state, param){
      /*<<format.ml:552:2>>*/ if(state[23])
       /*<<format.ml:553:4>>*/ pp_enqueue(state, [0, zero, 5, 0]);
-    var _bC_ = state[22];
-    if(_bC_){
+    var _bD_ = state[22];
+    if(_bD_){
       /*<<format.ml:555:10>>*/  /*<<format.ml:555:10>>*/ var
       match =  /*<<format.ml:555:10>>*/ caml_call1(Stdlib_Stack[5], state[4]);
      if(match){
@@ -25234,11 +25221,11 @@
        /*<<format.ml:558:6>>*/ return  /*<<format.ml:558:6>>*/ caml_call1
               (state[27], tag_name);
      }
-     var _bD_ = 0;
+     var _bE_ = 0;
     }
     else
-     var _bD_ = _bC_;
-     /*<<format.ml:556:14>>*/ return _bD_;
+     var _bE_ = _bD_;
+     /*<<format.ml:556:14>>*/ return _bE_;
     /*<<format.ml:558:39>>*/ }
    function pp_set_print_tags(state, b){
      /*<<format.ml:560:32>>*/ state[22] = b;
@@ -25292,26 +25279,26 @@
      /*<<format.ml:523:28>>*/ return pp_open_box_gen(state, 0, 3);
     /*<<format.ml:600:23>>*/ }
    function pp_flush_queue(state, b){
-     /*<<format.ml:608:2>>*/ var _bA_ = state[4];
-    function _bB_(param){
+     /*<<format.ml:608:2>>*/ var _bB_ = state[4];
+    function _bC_(param){
       /*<<format.ml:603:23>>*/ return pp_close_stag(state, 0);
      /*<<format.ml:603:45>>*/ }
      /*<<format.ml:603:13>>*/  /*<<format.ml:603:13>>*/ caml_call2
-     (Stdlib_Stack[12], _bB_, _bA_);
+     (Stdlib_Stack[12], _bC_, _bB_);
      /*<<format.ml:610:4>>*/ for(;;){
      if(1 >= state[14]){
       state[13] = pp_infinity;
        /*<<format.ml:613:2>>*/ advance_left(state);
       if(b)  /*<<format.ml:614:12>>*/ pp_output_newline(state);
        /*<<format.ml:614:12>>*/ pp_rinit(state);
-       /*<<format.ml:614:12>>*/ return sentinal;
+       /*<<format.ml:614:12>>*/ return _m_;
      }
       /*<<format.ml:610:4>>*/ pp_close_box(state, 0);
     }
     /*<<format.ml:615:16>>*/ }
    function pp_print_as_size(state, size, s){
-     /*<<format.ml:625:2>>*/ var _bz_ = state[14] < state[15] ? 1 : 0;
-    return _bz_ ? enqueue_string_as(state, size, s) : _bz_;
+     /*<<format.ml:625:2>>*/ var _bA_ = state[14] < state[15] ? 1 : 0;
+    return _bA_ ? enqueue_string_as(state, size, s) : _bA_;
     /*<<format.ml:626:37>>*/ }
    function pp_print_as(state, isize, s){
      /*<<format.ml:630:2>>*/ return pp_print_as_size(state, isize, s);
@@ -25370,20 +25357,20 @@
             (state[18], 0);
     /*<<format.ml:673:51>>*/ }
    function pp_force_newline(state, param){
-     /*<<format.ml:678:2>>*/ var _by_ = state[14] < state[15] ? 1 : 0;
-    return _by_ ? enqueue_advance(state, [0, zero, 3, 0]) : _by_;
+     /*<<format.ml:678:2>>*/ var _bz_ = state[14] < state[15] ? 1 : 0;
+    return _bz_ ? enqueue_advance(state, [0, zero, 3, 0]) : _bz_;
     /*<<format.ml:679:78>>*/ }
    function pp_print_if_newline(state, param){
-     /*<<format.ml:684:2>>*/ var _bx_ = state[14] < state[15] ? 1 : 0;
-    return _bx_ ? enqueue_advance(state, [0, zero, 4, 0]) : _bx_;
+     /*<<format.ml:684:2>>*/ var _by_ = state[14] < state[15] ? 1 : 0;
+    return _by_ ? enqueue_advance(state, [0, zero, 4, 0]) : _by_;
     /*<<format.ml:686:61>>*/ }
    function pp_print_custom_break(state, fits, breaks){
      /*<<format.ml:692:2>>*/ var
      after = fits[3],
      width = fits[2],
      before = fits[1],
-     _bw_ = state[14] < state[15] ? 1 : 0;
-    if(! _bw_) return _bw_;
+     _bx_ = state[14] < state[15] ? 1 : 0;
+    if(! _bx_) return _bx_;
      /*<<format.ml:695:25>>*/ var
      size = - state[13] | 0,
       /*<<format.ml:695:25>>*/ token = [1, fits, breaks],
@@ -25406,33 +25393,33 @@
     /*<<format.ml:715:52>>*/ }
    function pp_open_tbox(state, param){
      /*<<format.ml:720:2>>*/ state[14] = state[14] + 1 | 0;
-    var _bv_ = state[14] < state[15] ? 1 : 0;
-    if(! _bv_) return _bv_;
+    var _bw_ = state[14] < state[15] ? 1 : 0;
+    if(! _bw_) return _bw_;
      /*<<format.ml:723:15>>*/  /*<<format.ml:723:15>>*/ var
      elem = [0, zero, [4, [0, [0, 0]]], 0];
      /*<<format.ml:724:4>>*/ return enqueue_advance(state, elem);
     /*<<format.ml:724:30>>*/ }
    function pp_close_tbox(state, param){
-     /*<<format.ml:729:2>>*/ var _bs_ = 1 < state[14] ? 1 : 0;
-    if(_bs_){
-     var _bt_ = state[14] < state[15] ? 1 : 0;
-     if(_bt_){
+     /*<<format.ml:729:2>>*/ var _bt_ = 1 < state[14] ? 1 : 0;
+    if(_bt_){
+     var _bu_ = state[14] < state[15] ? 1 : 0;
+     if(_bu_){
        /*<<format.ml:732:16>>*/  /*<<format.ml:732:16>>*/ var
        elem = [0, zero, 2, 0];
        /*<<format.ml:733:5>>*/ enqueue_advance(state, elem);
       state[14] = state[14] - 1 | 0;
-      var _bu_ = 0;
+      var _bv_ = 0;
      }
      else
-      var _bu_ = _bt_;
+      var _bv_ = _bu_;
     }
     else
-     var _bu_ = _bs_;
-    return _bu_;
+     var _bv_ = _bt_;
+    return _bv_;
     /*<<format.ml:735:5>>*/ }
    function pp_print_tbreak(state, width, offset){
-     /*<<format.ml:740:2>>*/ var _br_ = state[14] < state[15] ? 1 : 0;
-    if(! _br_) return _br_;
+     /*<<format.ml:740:2>>*/ var _bs_ = state[14] < state[15] ? 1 : 0;
+    if(! _bs_) return _bs_;
      /*<<format.ml:742:15>>*/ var
      size = - state[13] | 0,
       /*<<format.ml:742:15>>*/ elem = [0, size, [2, width, offset], width];
@@ -25442,17 +25429,17 @@
      /*<<format.ml:746:28>>*/ return pp_print_tbreak(state, 0, 0);
     /*<<format.ml:746:53>>*/ }
    function pp_set_tab(state, param){
-     /*<<format.ml:749:2>>*/ var _bq_ = state[14] < state[15] ? 1 : 0;
-    if(! _bq_) return _bq_;
+     /*<<format.ml:749:2>>*/ var _br_ = state[14] < state[15] ? 1 : 0;
+    if(! _br_) return _br_;
      /*<<format.ml:750:15>>*/  /*<<format.ml:750:15>>*/ var
      elem = [0, zero, 0, 0];
      /*<<format.ml:751:4>>*/ return enqueue_advance(state, elem);
     /*<<format.ml:751:30>>*/ }
    function pp_set_max_boxes(state, n){
      /*<<format.ml:761:31>>*/ var
-     _bo_ = 1 < n ? 1 : 0,
-     _bp_ = _bo_ ? (state[15] = n, 0) : _bo_;
-    return _bp_;
+     _bp_ = 1 < n ? 1 : 0,
+     _bq_ = _bp_ ? (state[15] = n, 0) : _bp_;
+    return _bq_;
     /*<<format.ml:761:68>>*/ }
    function pp_get_max_boxes(state, param){
      /*<<format.ml:764:32>>*/ return state[15];
@@ -25471,10 +25458,10 @@
      /*<<format.ml:775:2>>*/ return n < 1000000010 ? n : 1000000009;
     /*<<format.ml:775:49>>*/ }
    function pp_set_max_indent(state, n$0){
-     /*<<format.ml:791:2>>*/ var _bn_ = 1 < n$0 ? 1 : 0;
+     /*<<format.ml:791:2>>*/ var _bo_ = 1 < n$0 ? 1 : 0;
+    if(! _bo_) return _bo_;
+    var n$1 = state[6] - n$0 | 0, _bn_ = 1 <= n$1 ? 1 : 0;
     if(! _bn_) return _bn_;
-    var n$1 = state[6] - n$0 | 0, _bm_ = 1 <= n$1 ? 1 : 0;
-    if(! _bm_) return _bm_;
      /*<<format.ml:781:12>>*/  /*<<format.ml:781:12>>*/ var n = pp_limit(n$1);
     state[7] = n;
     state[8] = state[6] - state[7] | 0;
@@ -25484,19 +25471,19 @@
      /*<<format.ml:795:33>>*/ return state[8];
     /*<<format.ml:795:52>>*/ }
    function pp_set_margin(state, n){
-     /*<<format.ml:798:2>>*/ var _bk_ = 1 <= n ? 1 : 0;
-    if(! _bk_) return _bk_;
+     /*<<format.ml:798:2>>*/ var _bl_ = 1 <= n ? 1 : 0;
+    if(! _bl_) return _bl_;
      /*<<format.ml:799:12>>*/  /*<<format.ml:799:12>>*/ var n$0 = pp_limit(n);
     state[6] = n$0;
     if(state[8] <= state[6])
      var new_max_indent = state[8];
     else
       /*<<format.ml:808:15>>*/ var
-       /*<<format.ml:808:15>>*/ _bl_ =
+       /*<<format.ml:808:15>>*/ _bm_ =
          /*<<format.ml:808:15>>*/ caml_call2
          (Stdlib_Int[11], state[6] - state[7] | 0, state[6] / 2 | 0),
       new_max_indent =
-         /*<<format.ml:808:7>>*/ caml_call2(Stdlib_Int[11], _bl_, 1);
+         /*<<format.ml:808:7>>*/ caml_call2(Stdlib_Int[11], _bm_, 1);
      /*<<format.ml:811:4>>*/ return pp_set_max_indent(state, new_max_indent);
     /*<<format.ml:811:42>>*/ }
    function validate_geometry(param){
@@ -25527,11 +25514,11 @@
       /*<<format.ml:842:4>>*/ return pp_set_full_geometry(state, geometry);
      /*<<format.ml:840:28>>*/ var
      msg = match[1],
-      /*<<format.ml:840:28>>*/ _bj_ =
+      /*<<format.ml:840:28>>*/ _bk_ =
         /*<<format.ml:840:28>>*/ caml_call2
         (Stdlib[28], cst_Format_pp_set_geometry, msg);
      /*<<format.ml:840:4>>*/ throw  /*<<format.ml:840:4>>*/ caml_maybe_attach_backtrace
-           ([0, Stdlib[6], _bj_], 1);
+           ([0, Stdlib[6], _bk_], 1);
     /*<<format.ml:842:39>>*/ }
    function pp_safe_set_geometry(state, max_indent, margin){
      /*<<format.ml:845:2>>*/  /*<<format.ml:845:17>>*/ var
@@ -25584,8 +25571,8 @@
    function display_blanks(state, n){
      /*<<format.ml:896:2>>*/ var n$0 = n;
      /*<<format.ml:896:2>>*/ for(;;){
-     var _bi_ = 0 < n$0 ? 1 : 0;
-     if(! _bi_) return _bi_;
+     var _bj_ = 0 < n$0 ? 1 : 0;
+     if(! _bj_) return _bj_;
      if(80 >= n$0)
        /*<<format.ml:897:18>>*/ return  /*<<format.ml:897:18>>*/ caml_call3
               (state[17], blank_line, 0, n$0);
@@ -25605,9 +25592,9 @@
               (Stdlib[63], oc);
       /*<<format.ml:911:43>>*/ };
     state[19] =
-     function(_bh_){ /*<<?>>*/ return display_newline(state, _bh_);};
-    state[20] = function(_bg_){ /*<<?>>*/ return display_blanks(state, _bg_);};
-    state[21] = function(_bf_){ /*<<?>>*/ return display_blanks(state, _bf_);};
+     function(_bi_){ /*<<?>>*/ return display_newline(state, _bi_);};
+    state[20] = function(_bh_){ /*<<?>>*/ return display_blanks(state, _bh_);};
+    state[21] = function(_bg_){ /*<<?>>*/ return display_blanks(state, _bg_);};
     return 0;
     /*<<format.ml:914:45>>*/ }
    function default_pp_mark_open_tag(param){
@@ -25615,23 +25602,23 @@
       /*<<format.ml:924:9>>*/ return cst$10;
      /*<<format.ml:923:26>>*/ var
      s = param[2],
-      /*<<format.ml:923:26>>*/ _be_ =
+      /*<<format.ml:923:26>>*/ _bf_ =
         /*<<format.ml:923:26>>*/ caml_call2(Stdlib[28], s, cst$8);
      /*<<format.ml:923:26>>*/ return  /*<<format.ml:923:26>>*/ caml_call2
-            (Stdlib[28], cst$9, _be_);
+            (Stdlib[28], cst$9, _bf_);
     /*<<format.ml:924:11>>*/ }
    function default_pp_mark_close_tag(param){
      /*<<format.ml:925:32>>*/ if(param[1] !== String_tag)
       /*<<format.ml:927:9>>*/ return cst$13;
      /*<<format.ml:926:27>>*/ var
      s = param[2],
-      /*<<format.ml:926:27>>*/ _bd_ =
+      /*<<format.ml:926:27>>*/ _be_ =
         /*<<format.ml:926:27>>*/ caml_call2(Stdlib[28], s, cst$11);
      /*<<format.ml:926:27>>*/ return  /*<<format.ml:926:27>>*/ caml_call2
-            (Stdlib[28], cst$12, _bd_);
+            (Stdlib[28], cst$12, _be_);
     /*<<format.ml:927:11>>*/ }
-   function default_pp_print_open_tag(_bc_){ /*<<?>>*/ return 0;}
-   function default_pp_print_close_tag(_bb_){ /*<<?>>*/ return 0;}
+   function default_pp_print_open_tag(_bd_){ /*<<?>>*/ return 0;}
+   function default_pp_print_close_tag(_bc_){ /*<<?>>*/ return 0;}
    function pp_make_formatter(f, g, h, i, j){
      /*<<format.ml:936:17>>*/ var
       /*<<format.ml:936:17>>*/ pp_queue =
@@ -25645,19 +25632,19 @@
      /*<<format.ml:942:2>>*/  /*<<format.ml:942:2>>*/ caml_call2
      (Stdlib_Stack[3], [0, 1, sys_tok], scan_stack);
      /*<<format.ml:950:20>>*/ var
-     _a9_ = Stdlib[19],
-      /*<<format.ml:950:20>>*/ _a__ =
+     _a__ = Stdlib[19],
+      /*<<format.ml:950:20>>*/ _a$_ =
         /*<<format.ml:950:20>>*/ caml_call1(Stdlib_Stack[2], 0),
-      /*<<format.ml:949:19>>*/ _a$_ =
+      /*<<format.ml:949:19>>*/ _ba_ =
         /*<<format.ml:949:19>>*/ caml_call1(Stdlib_Stack[2], 0),
-      /*<<format.ml:948:20>>*/ _ba_ =
+      /*<<format.ml:948:20>>*/ _bb_ =
         /*<<format.ml:948:20>>*/ caml_call1(Stdlib_Stack[2], 0);
      /*<<format.ml:945:2>>*/ return [0,
             scan_stack,
              /*<<format.ml:947:22>>*/ caml_call1(Stdlib_Stack[2], 0),
+            _bb_,
             _ba_,
             _a$_,
-            _a__,
             78,
             10,
             68,
@@ -25667,7 +25654,7 @@
             1,
             1,
             1,
-            _a9_,
+            _a__,
             cst$14,
             f,
             g,
@@ -25687,30 +25674,30 @@
             (out_funs[1], out_funs[2], out_funs[3], out_funs[4], out_funs[5]);
     /*<<format.ml:984:23>>*/ }
    function make_formatter(output, flush){
-    function _a1_(_a8_){ /*<<?>>*/ return 0;}
-    function _a2_(_a7_){ /*<<?>>*/ return 0;}
+    function _a2_(_a9_){ /*<<?>>*/ return 0;}
+    function _a3_(_a8_){ /*<<?>>*/ return 0;}
      /*<<format.ml:990:12>>*/  /*<<format.ml:990:12>>*/ var
      ppf =
        pp_make_formatter
-        (output, flush, function(_a6_){ /*<<?>>*/ return 0;}, _a2_, _a1_);
-    ppf[19] = function(_a5_){ /*<<?>>*/ return display_newline(ppf, _a5_);};
-    ppf[20] = function(_a4_){ /*<<?>>*/ return display_blanks(ppf, _a4_);};
-    ppf[21] = function(_a3_){ /*<<?>>*/ return display_blanks(ppf, _a3_);};
+        (output, flush, function(_a7_){ /*<<?>>*/ return 0;}, _a3_, _a2_);
+    ppf[19] = function(_a6_){ /*<<?>>*/ return display_newline(ppf, _a6_);};
+    ppf[20] = function(_a5_){ /*<<?>>*/ return display_blanks(ppf, _a5_);};
+    ppf[21] = function(_a4_){ /*<<?>>*/ return display_blanks(ppf, _a4_);};
      /*<<format.ml:994:2>>*/ return ppf;
     /*<<format.ml:994:5>>*/ }
    function formatter_of_out_channel(oc){
-    function _a0_(param){
+    function _a1_(param){
       /*<<format.ml:999:50>>*/ return  /*<<format.ml:999:2>>*/ caml_call1
              (Stdlib[63], oc);
      /*<<format.ml:999:58>>*/ }
      /*<<format.ml:999:39>>*/ return make_formatter
-            ( /*<<format.ml:999:17>>*/ caml_call1(Stdlib[69], oc), _a0_);
+            ( /*<<format.ml:999:17>>*/ caml_call1(Stdlib[69], oc), _a1_);
     /*<<format.ml:999:59>>*/ }
    function formatter_of_buffer(b){
-     /*<<format.ml:1004:2>>*/ function _aY_(_aZ_){ /*<<?>>*/ return 0;}
+     /*<<format.ml:1004:2>>*/ function _aZ_(_a0_){ /*<<?>>*/ return 0;}
      /*<<format.ml:1004:42>>*/ return make_formatter
             ( /*<<format.ml:1004:17>>*/ caml_call1(Stdlib_Buffer[18], b),
-             _aY_);
+             _aZ_);
     /*<<format.ml:1004:48>>*/ }
    var pp_buffer_size = 512;
    function pp_make_buffer(param){
@@ -25741,9 +25728,9 @@
     (Stdlib_Domain[10][3], str_formatter_key, str_formatter);
     /*<<format.ml:1030:8>>*/ function buffered_out_string(key, str, ofs, len){
      /*<<format.ml:1033:2>>*/  /*<<format.ml:1033:23>>*/ var
-     _aX_ =  /*<<format.ml:1033:23>>*/ caml_call1(Stdlib_Domain[10][2], key);
+     _aY_ =  /*<<format.ml:1033:23>>*/ caml_call1(Stdlib_Domain[10][2], key);
      /*<<format.ml:1033:2>>*/ return  /*<<format.ml:1033:2>>*/ caml_call4
-            (Stdlib_Buffer[18], _aX_, str, ofs, len);
+            (Stdlib_Buffer[18], _aY_, str, ofs, len);
     /*<<format.ml:1033:55>>*/ }
    function buffered_out_flush(oc, key, param){
      /*<<format.ml:1036:2>>*/ var
@@ -25775,31 +25762,31 @@
     err_buf_key =
        /*<<format.ml:1044:18>>*/ caml_call2(Stdlib_Domain[10][1], 0, _i_);
    function _j_(param){
-    function _aG_(_aW_){ /*<<?>>*/ return 0;}
-    function _aH_(_aV_){ /*<<?>>*/ return 0;}
-    function _aI_(_aU_){ /*<<?>>*/ return 0;}
-    var _aJ_ = Stdlib[39];
-     /*<<format.ml:1049:6>>*/ function _aK_(_aT_){
-      /*<<?>>*/ return buffered_out_flush(_aJ_, std_buf_key, _aT_);
+    function _aH_(_aX_){ /*<<?>>*/ return 0;}
+    function _aI_(_aW_){ /*<<?>>*/ return 0;}
+    function _aJ_(_aV_){ /*<<?>>*/ return 0;}
+    var _aK_ = Stdlib[39];
+     /*<<format.ml:1049:6>>*/ function _aL_(_aU_){
+      /*<<?>>*/ return buffered_out_flush(_aK_, std_buf_key, _aU_);
     }
      /*<<format.ml:1048:4>>*/  /*<<format.ml:1048:4>>*/ var
      ppf =
        pp_make_formatter
-        (function(_aQ_, _aR_, _aS_){
-           /*<<?>>*/ return buffered_out_string(std_buf_key, _aQ_, _aR_, _aS_);
+        (function(_aR_, _aS_, _aT_){
+           /*<<?>>*/ return buffered_out_string(std_buf_key, _aR_, _aS_, _aT_);
          },
-         _aK_,
+         _aL_,
+         _aJ_,
          _aI_,
-         _aH_,
-         _aG_);
-    ppf[19] = function(_aP_){ /*<<?>>*/ return display_newline(ppf, _aP_);};
-    ppf[20] = function(_aO_){ /*<<?>>*/ return display_blanks(ppf, _aO_);};
-    ppf[21] = function(_aN_){ /*<<?>>*/ return display_blanks(ppf, _aN_);};
-     /*<<format.ml:1054:17>>*/ function _aL_(_aM_){
-      /*<<?>>*/ return pp_print_flush(ppf, _aM_);
+         _aH_);
+    ppf[19] = function(_aQ_){ /*<<?>>*/ return display_newline(ppf, _aQ_);};
+    ppf[20] = function(_aP_){ /*<<?>>*/ return display_blanks(ppf, _aP_);};
+    ppf[21] = function(_aO_){ /*<<?>>*/ return display_blanks(ppf, _aO_);};
+     /*<<format.ml:1054:17>>*/ function _aM_(_aN_){
+      /*<<?>>*/ return pp_print_flush(ppf, _aN_);
     }
      /*<<format.ml:1054:2>>*/  /*<<format.ml:1054:2>>*/ caml_call1
-     (Stdlib_Domain[6], _aL_);
+     (Stdlib_Domain[6], _aM_);
      /*<<format.ml:1054:2>>*/ return ppf;
     /*<<format.ml:1055:5>>*/ }
     /*<<format.ml:1046:24>>*/  /*<<format.ml:1046:24>>*/ var
@@ -25808,31 +25795,31 @@
     /*<<format.ml:1056:8>>*/  /*<<format.ml:1056:8>>*/ caml_call2
     (Stdlib_Domain[10][3], std_formatter_key, std_formatter);
    function _k_(param){
-    function _ap_(_aF_){ /*<<?>>*/ return 0;}
-    function _aq_(_aE_){ /*<<?>>*/ return 0;}
-    function _ar_(_aD_){ /*<<?>>*/ return 0;}
-    var _as_ = Stdlib[40];
-     /*<<format.ml:1061:6>>*/ function _at_(_aC_){
-      /*<<?>>*/ return buffered_out_flush(_as_, err_buf_key, _aC_);
+    function _aq_(_aG_){ /*<<?>>*/ return 0;}
+    function _ar_(_aF_){ /*<<?>>*/ return 0;}
+    function _as_(_aE_){ /*<<?>>*/ return 0;}
+    var _at_ = Stdlib[40];
+     /*<<format.ml:1061:6>>*/ function _au_(_aD_){
+      /*<<?>>*/ return buffered_out_flush(_at_, err_buf_key, _aD_);
     }
      /*<<format.ml:1060:4>>*/  /*<<format.ml:1060:4>>*/ var
      ppf =
        pp_make_formatter
-        (function(_az_, _aA_, _aB_){
-           /*<<?>>*/ return buffered_out_string(err_buf_key, _az_, _aA_, _aB_);
+        (function(_aA_, _aB_, _aC_){
+           /*<<?>>*/ return buffered_out_string(err_buf_key, _aA_, _aB_, _aC_);
          },
-         _at_,
+         _au_,
+         _as_,
          _ar_,
-         _aq_,
-         _ap_);
-    ppf[19] = function(_ay_){ /*<<?>>*/ return display_newline(ppf, _ay_);};
-    ppf[20] = function(_ax_){ /*<<?>>*/ return display_blanks(ppf, _ax_);};
-    ppf[21] = function(_aw_){ /*<<?>>*/ return display_blanks(ppf, _aw_);};
-     /*<<format.ml:1066:17>>*/ function _au_(_av_){
-      /*<<?>>*/ return pp_print_flush(ppf, _av_);
+         _aq_);
+    ppf[19] = function(_az_){ /*<<?>>*/ return display_newline(ppf, _az_);};
+    ppf[20] = function(_ay_){ /*<<?>>*/ return display_blanks(ppf, _ay_);};
+    ppf[21] = function(_ax_){ /*<<?>>*/ return display_blanks(ppf, _ax_);};
+     /*<<format.ml:1066:17>>*/ function _av_(_aw_){
+      /*<<?>>*/ return pp_print_flush(ppf, _aw_);
     }
      /*<<format.ml:1066:2>>*/  /*<<format.ml:1066:2>>*/ caml_call1
-     (Stdlib_Domain[6], _au_);
+     (Stdlib_Domain[6], _av_);
      /*<<format.ml:1066:2>>*/ return ppf;
     /*<<format.ml:1067:5>>*/ }
     /*<<format.ml:1058:24>>*/  /*<<format.ml:1058:24>>*/ var
@@ -25875,7 +25862,7 @@
             (stdbuf, str_formatter);
     /*<<format.ml:1089:45>>*/ }
    function make_synchronized_formatter(output, flush){
-    function _an_(param){
+    function _ao_(param){
       /*<<format.ml:1093:4>>*/ var
        /*<<format.ml:1093:14>>*/ buf =
          /*<<format.ml:1093:14>>*/ caml_call1
@@ -25884,12 +25871,12 @@
          /*<<format.ml:1094:18>>*/ caml_call1(Stdlib_Buffer[18], buf);
      function flush$0(param){
        /*<<format.ml:1096:6>>*/  /*<<format.ml:1096:37>>*/ var
-       _ao_ =  /*<<format.ml:1096:37>>*/ caml_call1(Stdlib_Buffer[7], buf);
+       _ap_ =  /*<<format.ml:1096:37>>*/ caml_call1(Stdlib_Buffer[7], buf);
        /*<<format.ml:1096:6>>*/  /*<<format.ml:1096:6>>*/ caml_call3
        (output,
          /*<<format.ml:1096:13>>*/ caml_call1(Stdlib_Buffer[2], buf),
         0,
-        _ao_);
+        _ap_);
        /*<<format.ml:1097:6>>*/  /*<<format.ml:1097:6>>*/ caml_call1
        (Stdlib_Buffer[8], buf);
        /*<<format.ml:1097:6>>*/ return  /*<<format.ml:1097:6>>*/ caml_call1
@@ -25898,15 +25885,15 @@
       /*<<format.ml:1100:4>>*/ return make_formatter(output$0, flush$0);
      /*<<format.ml:1100:33>>*/ }
      /*<<format.ml:1092:14>>*/ return  /*<<format.ml:1092:14>>*/ caml_call2
-            (Stdlib_Domain[10][1], 0, _an_);
+            (Stdlib_Domain[10][1], 0, _ao_);
     /*<<format.ml:1100:34>>*/ }
    function synchronized_formatter_of_out_(oc){
-    function _am_(param){
+    function _an_(param){
       /*<<format.ml:1103:63>>*/ return  /*<<format.ml:1103:2>>*/ caml_call1
              (Stdlib[63], oc);
      /*<<format.ml:1103:71>>*/ }
      /*<<format.ml:1103:52>>*/ return make_synchronized_formatter
-            ( /*<<format.ml:1103:30>>*/ caml_call1(Stdlib[69], oc), _am_);
+            ( /*<<format.ml:1103:30>>*/ caml_call1(Stdlib[69], oc), _an_);
     /*<<format.ml:1103:72>>*/ }
    function make_symbolic_output_buffer(param){ /*<<format.ml:1130:2>>*/ return [0, 0];
     /*<<format.ml:1130:35>>*/ }
@@ -25935,10 +25922,10 @@
                 /*<<format.ml:1152:48>>*/ caml_call3
                 (Stdlib_String[15], s, i, n)]);
     }
-     /*<<format.ml:1159:10>>*/ function g(_al_){
+     /*<<format.ml:1159:10>>*/ function g(_am_){
       /*<<format.ml:1148:4>>*/ return add_symbolic_output_item(sob, 0);
     }
-     /*<<format.ml:1160:10>>*/ function h(_ak_){
+     /*<<format.ml:1160:10>>*/ function h(_al_){
       /*<<format.ml:1150:4>>*/ return add_symbolic_output_item(sob, 1);
     }
      /*<<format.ml:1161:10>>*/ function i(n){
@@ -26325,8 +26312,8 @@
      /*<<format.ml:1285:31>>*/ }
     for(;;){
      if(right[1] === len){
-      var _aj_ = left[1] !== len ? 1 : 0;
-      return _aj_ ? flush(0) : _aj_;
+      var _ak_ = left[1] !== len ? 1 : 0;
+      return _ak_ ? flush(0) : _ak_;
      }
       /*<<format.ml:1288:10>>*/  /*<<format.ml:1288:10>>*/ var
       match =  /*<<format.ml:1288:10>>*/ runtime.caml_string_get(s, right[1]);
@@ -26348,7 +26335,7 @@
     else
      var
       none =
-        function(param, _ai_){
+        function(param, _aj_){
           /*<<format.ml:1300:41>>*/ return 0;
          /*<<format.ml:1300:43>>*/ };
      /*<<format.ml:1300:56>>*/ if(! param)
@@ -26447,56 +26434,56 @@
           var acc$1 = match[1];
            /*<<format.ml:1366:4>>*/ output_acc(ppf, p$0);
            /*<<format.ml:1367:43>>*/ var
-            /*<<format.ml:1367:43>>*/ _$_ = compute_tag(output_acc, acc$1),
+            /*<<format.ml:1367:43>>*/ _aa_ = compute_tag(output_acc, acc$1),
             /*<<format.ml:1367:24>>*/ match$0 =
               /*<<format.ml:1367:24>>*/ caml_call1
-              (CamlinternalFormat[20], _$_),
+              (CamlinternalFormat[20], _aa_),
            bty = match$0[2],
            indent = match$0[1];
            /*<<format.ml:1368:4>>*/ return pp_open_box_gen(ppf, indent, bty);
          case 2:
-          var _aa_ = acc[1];
-          if(typeof _aa_ !== "number" && 0 === _aa_[0]){
-           var _ab_ = _aa_[2];
-           if(typeof _ab_ !== "number" && 1 === _ab_[0]){
-            var s$0 = acc[2], size = _ab_[2], p$2 = _aa_[1];
+          var _ab_ = acc[1];
+          if(typeof _ab_ !== "number" && 0 === _ab_[0]){
+           var _ac_ = _ab_[2];
+           if(typeof _ac_ !== "number" && 1 === _ac_[0]){
+            var s$0 = acc[2], size = _ac_[2], p$2 = _ab_[1];
             break b;
            }
           }
-          var s = acc[2], p$1 = _aa_;
+          var s = acc[2], p$1 = _ab_;
           break a;
          case 3:
-          var _ac_ = acc[1];
-          if(typeof _ac_ !== "number" && 0 === _ac_[0]){
-           var _ad_ = _ac_[2];
-           if(typeof _ad_ !== "number" && 1 === _ad_[0]){
-            var c$0 = acc[2], size$0 = _ad_[2], p$4 = _ac_[1];
+          var _ad_ = acc[1];
+          if(typeof _ad_ !== "number" && 0 === _ad_[0]){
+           var _ae_ = _ad_[2];
+           if(typeof _ae_ !== "number" && 1 === _ae_[0]){
+            var c$0 = acc[2], size$0 = _ae_[2], p$4 = _ad_[1];
             break;
            }
           }
-          var c = acc[2], p$3 = _ac_;
+          var c = acc[2], p$3 = _ad_;
           break c;
          case 4:
-          var _ae_ = acc[1];
-          if(typeof _ae_ !== "number" && 0 === _ae_[0]){
-           var _af_ = _ae_[2];
-           if(typeof _af_ !== "number" && 1 === _af_[0]){
-            var s$0 = acc[2], size = _af_[2], p$2 = _ae_[1];
+          var _af_ = acc[1];
+          if(typeof _af_ !== "number" && 0 === _af_[0]){
+           var _ag_ = _af_[2];
+           if(typeof _ag_ !== "number" && 1 === _ag_[0]){
+            var s$0 = acc[2], size = _ag_[2], p$2 = _af_[1];
             break b;
            }
           }
-          var s = acc[2], p$1 = _ae_;
+          var s = acc[2], p$1 = _af_;
           break a;
          case 5:
-          var _ag_ = acc[1];
-          if(typeof _ag_ !== "number" && 0 === _ag_[0]){
-           var _ah_ = _ag_[2];
-           if(typeof _ah_ !== "number" && 1 === _ah_[0]){
-            var c$0 = acc[2], size$0 = _ah_[2], p$4 = _ag_[1];
+          var _ah_ = acc[1];
+          if(typeof _ah_ !== "number" && 0 === _ah_[0]){
+           var _ai_ = _ah_[2];
+           if(typeof _ai_ !== "number" && 1 === _ai_[0]){
+            var c$0 = acc[2], size$0 = _ai_[2], p$4 = _ah_[1];
             break;
            }
           }
-          var c = acc[2], p$3 = _ag_;
+          var c = acc[2], p$3 = _ah_;
           break c;
          case 6:
           var f$0 = acc[2], p$5 = acc[1];
@@ -26554,56 +26541,56 @@
           var acc$1 = match[1];
            /*<<format.ml:1401:4>>*/ strput_acc(ppf, p$0);
            /*<<format.ml:1402:43>>*/ var
-            /*<<format.ml:1402:43>>*/ _S_ = compute_tag(strput_acc, acc$1),
+            /*<<format.ml:1402:43>>*/ _T_ = compute_tag(strput_acc, acc$1),
             /*<<format.ml:1402:24>>*/ match$0 =
               /*<<format.ml:1402:24>>*/ caml_call1
-              (CamlinternalFormat[20], _S_),
+              (CamlinternalFormat[20], _T_),
            bty = match$0[2],
            indent = match$0[1];
            /*<<format.ml:1403:4>>*/ return pp_open_box_gen(ppf, indent, bty);
          case 2:
-          var _T_ = acc[1];
-          if(typeof _T_ !== "number" && 0 === _T_[0]){
-           var _U_ = _T_[2];
-           if(typeof _U_ !== "number" && 1 === _U_[0]){
-            var s$0 = acc[2], size = _U_[2], p$2 = _T_[1];
+          var _U_ = acc[1];
+          if(typeof _U_ !== "number" && 0 === _U_[0]){
+           var _V_ = _U_[2];
+           if(typeof _V_ !== "number" && 1 === _V_[0]){
+            var s$0 = acc[2], size = _V_[2], p$2 = _U_[1];
             break b;
            }
           }
-          var s = acc[2], p$1 = _T_;
+          var s = acc[2], p$1 = _U_;
           break a;
          case 3:
-          var _V_ = acc[1];
-          if(typeof _V_ !== "number" && 0 === _V_[0]){
-           var _W_ = _V_[2];
-           if(typeof _W_ !== "number" && 1 === _W_[0]){
-            var c$0 = acc[2], size$0 = _W_[2], p$4 = _V_[1];
+          var _W_ = acc[1];
+          if(typeof _W_ !== "number" && 0 === _W_[0]){
+           var _X_ = _W_[2];
+           if(typeof _X_ !== "number" && 1 === _X_[0]){
+            var c$0 = acc[2], size$0 = _X_[2], p$4 = _W_[1];
             break;
            }
           }
-          var c = acc[2], p$3 = _V_;
+          var c = acc[2], p$3 = _W_;
           break c;
          case 4:
-          var _X_ = acc[1];
-          if(typeof _X_ !== "number" && 0 === _X_[0]){
-           var _Y_ = _X_[2];
-           if(typeof _Y_ !== "number" && 1 === _Y_[0]){
-            var s$0 = acc[2], size = _Y_[2], p$2 = _X_[1];
+          var _Y_ = acc[1];
+          if(typeof _Y_ !== "number" && 0 === _Y_[0]){
+           var _Z_ = _Y_[2];
+           if(typeof _Z_ !== "number" && 1 === _Z_[0]){
+            var s$0 = acc[2], size = _Z_[2], p$2 = _Y_[1];
             break b;
            }
           }
-          var s = acc[2], p$1 = _X_;
+          var s = acc[2], p$1 = _Y_;
           break a;
          case 5:
-          var _Z_ = acc[1];
-          if(typeof _Z_ !== "number" && 0 === _Z_[0]){
-           var ___ = _Z_[2];
-           if(typeof ___ !== "number" && 1 === ___[0]){
-            var c$0 = acc[2], size$0 = ___[2], p$4 = _Z_[1];
+          var ___ = acc[1];
+          if(typeof ___ !== "number" && 0 === ___[0]){
+           var _$_ = ___[2];
+           if(typeof _$_ !== "number" && 1 === _$_[0]){
+            var c$0 = acc[2], size$0 = _$_[2], p$4 = ___[1];
             break;
            }
           }
-          var c = acc[2], p$3 = _Z_;
+          var c = acc[2], p$3 = ___;
           break c;
          case 6:
           var p$5 = acc[1];
@@ -26649,13 +26636,13 @@
    function kfprintf(k, ppf, param){
      /*<<format.ml:1420:2>>*/ var
      fmt = param[1],
-      /*<<format.ml:1420:2>>*/ _Q_ = 0;
-    function _R_(acc){
+      /*<<format.ml:1420:2>>*/ _R_ = 0;
+    function _S_(acc){
       /*<<format.ml:1421:16>>*/ output_acc(ppf, acc);
      return caml_call1(k, ppf);
      /*<<format.ml:1421:41>>*/ }
      /*<<format.ml:1420:2>>*/ return  /*<<format.ml:1420:2>>*/ caml_call3
-            (CamlinternalFormat[7], _R_, _Q_, fmt);
+            (CamlinternalFormat[7], _S_, _R_, fmt);
    }
    function ikfprintf(k, ppf, param){
     var fmt = param[1];
@@ -26665,47 +26652,47 @@
    function ifprintf(ppf, param){
      /*<<format.ml:1428:2>>*/ var
      fmt = param[1],
-      /*<<format.ml:1428:2>>*/ _N_ = 0;
-    function _O_(_P_){ /*<<?>>*/ return 0;}
+      /*<<format.ml:1428:2>>*/ _O_ = 0;
+    function _P_(_Q_){ /*<<?>>*/ return 0;}
      /*<<format.ml:1428:2>>*/ return  /*<<format.ml:1428:2>>*/ caml_call3
-            (CamlinternalFormat[8], _O_, _N_, fmt);
+            (CamlinternalFormat[8], _P_, _O_, fmt);
    }
    function fprintf(ppf){
-    function _K_(_M_){ /*<<?>>*/ return 0;}
-     /*<<format.ml:1430:18>>*/ return function(_L_){
-      /*<<?>>*/ return kfprintf(_K_, ppf, _L_);};
+    function _L_(_N_){ /*<<?>>*/ return 0;}
+     /*<<format.ml:1430:18>>*/ return function(_M_){
+      /*<<?>>*/ return kfprintf(_L_, ppf, _M_);};
     /*<<format.ml:1430:37>>*/ }
    function printf(param){
      /*<<format.ml:1433:2>>*/ var
      fmt = param[1],
-      /*<<format.ml:1433:2>>*/ _I_ = 0;
-    function _J_(acc){
+      /*<<format.ml:1433:2>>*/ _J_ = 0;
+    function _K_(acc){
       /*<<format.ml:1434:16>>*/ return output_acc
              ( /*<<format.ml:1434:27>>*/ caml_call1
                (Stdlib_Domain[10][2], std_formatter_key),
               acc);
      /*<<format.ml:1434:58>>*/ }
      /*<<format.ml:1433:2>>*/ return  /*<<format.ml:1433:2>>*/ caml_call3
-            (CamlinternalFormat[7], _J_, _I_, fmt);
+            (CamlinternalFormat[7], _K_, _J_, fmt);
    }
    function eprintf(param){
      /*<<format.ml:1438:2>>*/ var
      fmt = param[1],
-      /*<<format.ml:1438:2>>*/ _G_ = 0;
-    function _H_(acc){
+      /*<<format.ml:1438:2>>*/ _H_ = 0;
+    function _I_(acc){
       /*<<format.ml:1439:16>>*/ return output_acc
              ( /*<<format.ml:1439:27>>*/ caml_call1
                (Stdlib_Domain[10][2], err_formatter_key),
               acc);
      /*<<format.ml:1439:58>>*/ }
      /*<<format.ml:1438:2>>*/ return  /*<<format.ml:1438:2>>*/ caml_call3
-            (CamlinternalFormat[7], _H_, _G_, fmt);
+            (CamlinternalFormat[7], _I_, _H_, fmt);
    }
    function kdprintf(k, param){
      /*<<format.ml:1443:2>>*/ var
      fmt = param[1],
-      /*<<format.ml:1443:2>>*/ _E_ = 0;
-    function _F_(acc){
+      /*<<format.ml:1443:2>>*/ _F_ = 0;
+    function _G_(acc){
       /*<<format.ml:1444:16>>*/ return  /*<<format.ml:1444:18>>*/ caml_call1
              (k,
               function(ppf){
@@ -26713,7 +26700,7 @@
                /*<<format.ml:1444:48>>*/ });
      /*<<format.ml:1444:49>>*/ }
      /*<<format.ml:1443:2>>*/ return  /*<<format.ml:1443:2>>*/ caml_call3
-            (CamlinternalFormat[7], _F_, _E_, fmt);
+            (CamlinternalFormat[7], _G_, _F_, fmt);
    }
    function dprintf(fmt){
      /*<<format.ml:1447:18>>*/ return kdprintf
@@ -26771,44 +26758,44 @@
      /*<<format.ml:1481:11>>*/ var
       /*<<format.ml:1481:11>>*/ fs =
        pp_get_formatter_out_functions(std_formatter, 0),
-     _m_ = fs[5],
-     _n_ = fs[4],
-     _o_ = fs[3],
-     _p_ = Stdlib[39];
-     /*<<format.ml:1484:25>>*/ function _q_(_D_){
-      /*<<?>>*/ return buffered_out_flush(_p_, std_buf_key, _D_);
+     _n_ = fs[5],
+     _o_ = fs[4],
+     _p_ = fs[3],
+     _q_ = Stdlib[39];
+     /*<<format.ml:1484:25>>*/ function _r_(_E_){
+      /*<<?>>*/ return buffered_out_flush(_q_, std_buf_key, _E_);
     }
      /*<<format.ml:1482:2>>*/ pp_set_formatter_out_functions
      (std_formatter,
       [0,
-       function(_A_, _B_, _C_){
-         /*<<?>>*/ return buffered_out_string(std_buf_key, _A_, _B_, _C_);
+       function(_B_, _C_, _D_){
+         /*<<?>>*/ return buffered_out_string(std_buf_key, _B_, _C_, _D_);
        },
-       _q_,
+       _r_,
+       _p_,
        _o_,
-       _n_,
-       _m_]);
+       _n_]);
      /*<<format.ml:1486:11>>*/ var
       /*<<format.ml:1486:11>>*/ fs$0 =
        pp_get_formatter_out_functions(err_formatter, 0),
-     _r_ = fs$0[5],
-     _s_ = fs$0[4],
-     _t_ = fs$0[3],
-     _u_ = Stdlib[40];
-     /*<<format.ml:1489:25>>*/ function _v_(_z_){
-      /*<<?>>*/ return buffered_out_flush(_u_, err_buf_key, _z_);
+     _s_ = fs$0[5],
+     _t_ = fs$0[4],
+     _u_ = fs$0[3],
+     _v_ = Stdlib[40];
+     /*<<format.ml:1489:25>>*/ function _w_(_A_){
+      /*<<?>>*/ return buffered_out_flush(_v_, err_buf_key, _A_);
     }
      /*<<format.ml:1488:4>>*/ return pp_set_formatter_out_functions
             (err_formatter,
              [0,
-              function(_w_, _x_, _y_){
+              function(_x_, _y_, _z_){
                 /*<<?>>*/ return buffered_out_string
-                       (err_buf_key, _w_, _x_, _y_);
+                       (err_buf_key, _x_, _y_, _z_);
               },
-              _v_,
+              _w_,
+              _u_,
               _t_,
-              _s_,
-              _r_]);
+              _s_]);
     /*<<format.ml:1489:71>>*/ }
     /*<<format.ml:1479:9>>*/  /*<<format.ml:1479:9>>*/ caml_call1
     (Stdlib_Domain[5], _l_);
@@ -27009,7 +26996,7 @@
             : runtime.caml_call_gen(f, [a0, a1, a2, a3]);
    }
    var
-    sentinal = undefined,
+    _u_ = undefined,
     global_data = runtime.caml_get_global_data(),
     cst$3 = cst$5,
     cst$4 = cst$5,
@@ -27133,9 +27120,9 @@
      if(10 === c) ib[5] = ib[5] + 1 | 0;
       /*<<scanf.ml:171:6>>*/ return c;
     }
-    catch(_bb_){
-     var _ba_ = caml_wrap_exception(_bb_);
-     if(_ba_ !== Stdlib[12]) throw caml_maybe_attach_backtrace(_ba_, 0);
+    catch(_bc_){
+     var _bb_ = caml_wrap_exception(_bc_);
+     if(_bb_ !== Stdlib[12]) throw caml_maybe_attach_backtrace(_bb_, 0);
      ib[2] = null_char;
      ib[3] = 0;
      ib[1] = 1;
@@ -27228,8 +27215,8 @@
      /*<<scanf.ml:271:4>>*/ return create(1, next);
     /*<<scanf.ml:271:27>>*/ }
    var _a_ = 0;
-    /*<<scanf.ml:274:22>>*/ function from_function(_a$_){
-     /*<<?>>*/ return create(_a_, _a$_);
+    /*<<scanf.ml:274:22>>*/ function from_function(_ba_){
+     /*<<?>>*/ return create(_a_, _ba_);
    }
     /*<<scanf.ml:274:22>>*/  /*<<scanf.ml:274:22>>*/ var len = 1024;
    function scan_close_at_end(ic){
@@ -27276,12 +27263,12 @@
     return from_ic(scan_close_at_end, [1, fname, ic], ic);
     /*<<scanf.ml:371:53>>*/ }
    var _b_ = Stdlib[79];
-    /*<<scanf.ml:374:16>>*/ function open_in(_a__){
-     /*<<?>>*/ return open_in_file(_b_, _a__);
+    /*<<scanf.ml:374:16>>*/ function open_in(_a$_){
+     /*<<?>>*/ return open_in_file(_b_, _a$_);
    }
     /*<<scanf.ml:374:16>>*/  /*<<scanf.ml:374:16>>*/ var _c_ = Stdlib[80];
-    /*<<scanf.ml:375:20>>*/ function open_in_bin(_a9_){
-     /*<<?>>*/ return open_in_file(_c_, _a9_);
+    /*<<scanf.ml:375:20>>*/ function open_in_bin(_a__){
+     /*<<?>>*/ return open_in_file(_c_, _a__);
    }
    function from_channel(ic){
      /*<<scanf.ml:381:4>>*/ return from_ic(scan_raise_at_end, [0, ic], ic);
@@ -27344,15 +27331,15 @@
      /*<<scanf.ml:444:2>>*/ for(;;){
       /*<<scanf.ml:444:10>>*/ var
        /*<<scanf.ml:444:10>>*/ c = peek_char(ib),
-       /*<<scanf.ml:445:9>>*/ _a7_ = 1 - ib[1];
-     if(! _a7_)  /*<<scanf.ml:445:9>>*/ return _a7_;
-      /*<<scanf.ml:445:32>>*/  /*<<scanf.ml:445:32>>*/ var _a8_ = c - 9 | 0;
+       /*<<scanf.ml:445:9>>*/ _a8_ = 1 - ib[1];
+     if(! _a8_)  /*<<scanf.ml:445:9>>*/ return _a8_;
+      /*<<scanf.ml:445:32>>*/  /*<<scanf.ml:445:32>>*/ var _a9_ = c - 9 | 0;
      a:
      {
-      if(4 < _a8_ >>> 0){
-       if(23 === _a8_) break a;
+      if(4 < _a9_ >>> 0){
+       if(23 === _a9_) break a;
       }
-      else if(1 < _a8_ - 2 >>> 0) break a;
+      else if(1 < _a9_ - 2 >>> 0) break a;
        /*<<scanf.ml:449:11>>*/ return 0;
      }
       /*<<scanf.ml:448:6>>*/ invalidate_current_char(ib);
@@ -27398,23 +27385,23 @@
      /*<<scanf.ml:523:2>>*/ switch(conv){
       case 0:
         /*<<scanf.ml:529:29>>*/ var
-         /*<<scanf.ml:529:29>>*/ _a3_ = token_string(ib),
-        tok =  /*<<scanf.ml:529:22>>*/ caml_call2(Stdlib[28], cst_0b, _a3_);
+         /*<<scanf.ml:529:29>>*/ _a4_ = token_string(ib),
+        tok =  /*<<scanf.ml:529:22>>*/ caml_call2(Stdlib[28], cst_0b, _a4_);
        break;
       case 3:
         /*<<scanf.ml:527:29>>*/ var
-         /*<<scanf.ml:527:29>>*/ _a4_ = token_string(ib),
-        tok =  /*<<scanf.ml:527:22>>*/ caml_call2(Stdlib[28], cst_0o, _a4_);
+         /*<<scanf.ml:527:29>>*/ _a5_ = token_string(ib),
+        tok =  /*<<scanf.ml:527:22>>*/ caml_call2(Stdlib[28], cst_0o, _a5_);
        break;
       case 4:
         /*<<scanf.ml:526:29>>*/ var
-         /*<<scanf.ml:526:29>>*/ _a5_ = token_string(ib),
-        tok =  /*<<scanf.ml:526:22>>*/ caml_call2(Stdlib[28], cst_0u, _a5_);
+         /*<<scanf.ml:526:29>>*/ _a6_ = token_string(ib),
+        tok =  /*<<scanf.ml:526:22>>*/ caml_call2(Stdlib[28], cst_0u, _a6_);
        break;
       case 5:
         /*<<scanf.ml:528:29>>*/ var
-         /*<<scanf.ml:528:29>>*/ _a6_ = token_string(ib),
-        tok =  /*<<scanf.ml:528:22>>*/ caml_call2(Stdlib[28], cst_0x, _a6_);
+         /*<<scanf.ml:528:29>>*/ _a7_ = token_string(ib),
+        tok =  /*<<scanf.ml:528:22>>*/ caml_call2(Stdlib[28], cst_0x, _a7_);
        break;
       default: var tok = token_string(ib);
     }
@@ -27499,31 +27486,31 @@
    function is_binary_digit(param){
      /*<<scanf.ml:629:22>>*/ return 1 < param - 48 >>> 0 ? 0 : 1;
     /*<<scanf.ml:631:14>>*/ }
-    /*<<scanf.ml:634:22>>*/ function scan_binary_int(_a1_, _a2_){
-     /*<<?>>*/ return scan_digit_plus(cst_binary, is_binary_digit, _a1_, _a2_);
+    /*<<scanf.ml:634:22>>*/ function scan_binary_int(_a2_, _a3_){
+     /*<<?>>*/ return scan_digit_plus(cst_binary, is_binary_digit, _a2_, _a3_);
    }
    function is_octal_digit(param){
      /*<<scanf.ml:636:21>>*/ return 7 < param - 48 >>> 0 ? 0 : 1;
     /*<<scanf.ml:638:14>>*/ }
-    /*<<scanf.ml:641:21>>*/ function scan_octal_int(_aZ_, _a0_){
-     /*<<?>>*/ return scan_digit_plus(cst_octal, is_octal_digit, _aZ_, _a0_);
+    /*<<scanf.ml:641:21>>*/ function scan_octal_int(_a0_, _a1_){
+     /*<<?>>*/ return scan_digit_plus(cst_octal, is_octal_digit, _a0_, _a1_);
    }
    function is_hexa_digit(param){
      /*<<scanf.ml:643:20>>*/  /*<<scanf.ml:643:20>>*/ var
-     _aY_ = param - 48 | 0;
+     _aZ_ = param - 48 | 0;
     a:
     {
-     if(22 < _aY_ >>> 0){
-      if(5 < _aY_ - 49 >>> 0) break a;
+     if(22 < _aZ_ >>> 0){
+      if(5 < _aZ_ - 49 >>> 0) break a;
      }
-     else if(6 >= _aY_ - 10 >>> 0) break a;
+     else if(6 >= _aZ_ - 10 >>> 0) break a;
       /*<<scanf.ml:644:44>>*/ return 1;
     }
      /*<<scanf.ml:645:9>>*/ return 0;
     /*<<scanf.ml:645:14>>*/ }
-    /*<<scanf.ml:648:27>>*/ function scan_hexadecimal_int(_aW_, _aX_){
+    /*<<scanf.ml:648:27>>*/ function scan_hexadecimal_int(_aX_, _aY_){
      /*<<?>>*/ return scan_digit_plus
-            (cst_hexadecimal, is_hexa_digit, _aW_, _aX_);
+            (cst_hexadecimal, is_hexa_digit, _aX_, _aY_);
    }
    function scan_sign(width, ib){
      /*<<scanf.ml:654:2>>*/ var
@@ -27643,38 +27630,38 @@
       /*<<scanf.ml:785:2>>*/ len =
         /*<<scanf.ml:785:2>>*/ caml_ml_string_length(str),
       /*<<scanf.ml:786:14>>*/ width$0 = [0, width],
-      /*<<scanf.ml:787:2>>*/ _aT_ = len - 1 | 0,
-      /*<<scanf.ml:786:14>>*/ _aS_ = 0;
-    if(_aT_ >= 0){
-     var i = _aS_;
+      /*<<scanf.ml:787:2>>*/ _aU_ = len - 1 | 0,
+      /*<<scanf.ml:786:14>>*/ _aT_ = 0;
+    if(_aU_ >= 0){
+     var i = _aT_;
      for(;;){
        /*<<scanf.ml:788:12>>*/ var
         /*<<scanf.ml:788:12>>*/ c = peek_char(ib),
-        /*<<scanf.ml:789:22>>*/ _aU_ =
+        /*<<scanf.ml:789:22>>*/ _aV_ =
          lowercase( /*<<scanf.ml:789:32>>*/ caml_string_get(str, i));
-      if(lowercase(c) !== _aU_)
+      if(lowercase(c) !== _aV_)
         /*<<scanf.ml:789:45>>*/  /*<<scanf.ml:789:45>>*/ caml_call1(error, 0);
       if(0 === width$0[1])
         /*<<scanf.ml:790:23>>*/  /*<<scanf.ml:790:23>>*/ caml_call1(error, 0);
       width$0[1] = store_char(width$0[1], ib, c);
-       /*<<scanf.ml:787:2>>*/  /*<<scanf.ml:787:2>>*/ var _aV_ = i + 1 | 0;
-      if(_aT_ === i) break;
-      var i = _aV_;
+       /*<<scanf.ml:787:2>>*/  /*<<scanf.ml:787:2>>*/ var _aW_ = i + 1 | 0;
+      if(_aU_ === i) break;
+      var i = _aW_;
      }
     }
     return width$0[1];
     /*<<scanf.ml:793:8>>*/ }
    function scan_hex_float(width, precision, ib){
      /*<<scanf.ml:797:2>>*/ var
-     _aF_ = 0 === width ? 1 : 0,
-     _aG_ = _aF_ || end_of_input(ib);
-     /*<<scanf.ml:797:18>>*/ if(_aG_)
+     _aG_ = 0 === width ? 1 : 0,
+     _aH_ = _aG_ || end_of_input(ib);
+     /*<<scanf.ml:797:18>>*/ if(_aH_)
       /*<<scanf.ml:797:48>>*/ bad_hex_float(0);
      /*<<scanf.ml:798:14>>*/ var
       /*<<scanf.ml:798:14>>*/ width$0 = scan_sign(width, ib),
-     _aH_ = 0 === width$0 ? 1 : 0,
-     _aI_ = _aH_ || end_of_input(ib);
-     /*<<scanf.ml:799:18>>*/ if(_aI_)
+     _aI_ = 0 === width$0 ? 1 : 0,
+     _aJ_ = _aI_ || end_of_input(ib);
+     /*<<scanf.ml:799:18>>*/ if(_aJ_)
       /*<<scanf.ml:799:48>>*/ bad_hex_float(0);
      /*<<scanf.ml:800:8>>*/  /*<<scanf.ml:800:8>>*/ var c = peek_char(ib);
     a:
@@ -27686,9 +27673,9 @@
        if(32 <= switcher) break a;
         /*<<scanf.ml:830:16>>*/ var
          /*<<scanf.ml:830:16>>*/ width$1 = store_char(width$0, ib, c),
-        _aJ_ = 0 === width$1 ? 1 : 0,
-        _aK_ = _aJ_ || end_of_input(ib);
-        /*<<scanf.ml:831:20>>*/ if(_aK_)
+        _aK_ = 0 === width$1 ? 1 : 0,
+        _aL_ = _aK_ || end_of_input(ib);
+        /*<<scanf.ml:831:20>>*/ if(_aL_)
          /*<<scanf.ml:831:50>>*/ bad_hex_float(0);
         /*<<scanf.ml:831:50>>*/ return check_case_insensitive_string
                (width$1, ib, bad_hex_float, cst_an);
@@ -27699,24 +27686,24 @@
       if(48 === c){
         /*<<scanf.ml:802:16>>*/ var
          /*<<scanf.ml:802:16>>*/ width$3 = store_char(width$0, ib, c),
-        _aN_ = 0 === width$3 ? 1 : 0,
-        _aO_ = _aN_ || end_of_input(ib);
-        /*<<scanf.ml:803:20>>*/ if(_aO_)
+        _aO_ = 0 === width$3 ? 1 : 0,
+        _aP_ = _aO_ || end_of_input(ib);
+        /*<<scanf.ml:803:20>>*/ if(_aP_)
          /*<<scanf.ml:803:50>>*/ bad_hex_float(0);
         /*<<scanf.ml:804:16>>*/  /*<<scanf.ml:804:16>>*/ var
         width$4 =
           check_case_insensitive_string(width$3, ib, bad_hex_float, cst_x);
         /*<<scanf.ml:805:20>>*/ if(0 !== width$4 && ! end_of_input(ib)){
          /*<<scanf.ml:806:24>>*/  /*<<scanf.ml:806:24>>*/ var
-         _aP_ = peek_char(ib) - 46 | 0;
+         _aQ_ = peek_char(ib) - 46 | 0;
         b:
         {
          c:
          {
-          if(34 < _aP_ >>> 0){
-           if(66 === _aP_) break c;
+          if(34 < _aQ_ >>> 0){
+           if(66 === _aQ_) break c;
           }
-          else if(32 < _aP_ - 1 >>> 0) break c;
+          else if(32 < _aQ_ - 1 >>> 0) break c;
           var width$5 = scan_hexadecimal_int(width$4, ib);
           break b;
          }
@@ -27764,9 +27751,9 @@
             /*<<scanf.ml:827:17>>*/ return width$8;
            /*<<scanf.ml:824:24>>*/ var
             /*<<scanf.ml:824:24>>*/ width$9 = store_char(width$8, ib, c$1),
-           _aQ_ = 0 === width$9 ? 1 : 0,
-           _aR_ = _aQ_ || end_of_input(ib);
-           /*<<scanf.ml:825:28>>*/ if(_aR_)
+           _aR_ = 0 === width$9 ? 1 : 0,
+           _aS_ = _aR_ || end_of_input(ib);
+           /*<<scanf.ml:825:28>>*/ if(_aS_)
             /*<<scanf.ml:825:58>>*/ bad_hex_float(0);
            /*<<scanf.ml:825:58>>*/ return scan_optionally_signed_decimal
                   (width$9, ib);
@@ -27781,9 +27768,9 @@
      }
       /*<<scanf.ml:834:16>>*/ var
        /*<<scanf.ml:834:16>>*/ width$2 = store_char(width$0, ib, c),
-      _aL_ = 0 === width$2 ? 1 : 0,
-      _aM_ = _aL_ || end_of_input(ib);
-      /*<<scanf.ml:835:20>>*/ if(_aM_)
+      _aM_ = 0 === width$2 ? 1 : 0,
+      _aN_ = _aM_ || end_of_input(ib);
+      /*<<scanf.ml:835:20>>*/ if(_aN_)
        /*<<scanf.ml:835:50>>*/ bad_hex_float(0);
       /*<<scanf.ml:835:50>>*/ return check_case_insensitive_string
              (width$2, ib, bad_hex_float, cst_nfinity);
@@ -27792,14 +27779,14 @@
     /*<<scanf.ml:837:25>>*/ }
    function scan_caml_float_rest(width, precision, ib){
      /*<<scanf.ml:841:2>>*/ var
-     _aB_ = 0 === width ? 1 : 0,
-     _aC_ = _aB_ || end_of_input(ib);
-     /*<<scanf.ml:841:18>>*/ if(_aC_)  /*<<scanf.ml:841:48>>*/ bad_float(0);
+     _aC_ = 0 === width ? 1 : 0,
+     _aD_ = _aC_ || end_of_input(ib);
+     /*<<scanf.ml:841:18>>*/ if(_aD_)  /*<<scanf.ml:841:48>>*/ bad_float(0);
      /*<<scanf.ml:842:14>>*/ var
       /*<<scanf.ml:842:14>>*/ width$0 = scan_decimal_digit_star(width, ib),
-     _aD_ = 0 === width$0 ? 1 : 0,
-     _aE_ = _aD_ || end_of_input(ib);
-     /*<<scanf.ml:843:18>>*/ if(_aE_)  /*<<scanf.ml:843:48>>*/ bad_float(0);
+     _aE_ = 0 === width$0 ? 1 : 0,
+     _aF_ = _aE_ || end_of_input(ib);
+     /*<<scanf.ml:843:18>>*/ if(_aF_)  /*<<scanf.ml:843:48>>*/ bad_float(0);
      /*<<scanf.ml:844:10>>*/ var
       /*<<scanf.ml:844:10>>*/ c = peek_char(ib),
       /*<<scanf.ml:844:10>>*/ switcher = c - 69 | 0;
@@ -27823,22 +27810,22 @@
     /*<<scanf.ml:862:21>>*/ }
    function scan_caml_float(width, precision, ib){
      /*<<scanf.ml:866:2>>*/ var
-     _an_ = 0 === width ? 1 : 0,
-     _ao_ = _an_ || end_of_input(ib);
-     /*<<scanf.ml:866:18>>*/ if(_ao_)  /*<<scanf.ml:866:48>>*/ bad_float(0);
+     _ao_ = 0 === width ? 1 : 0,
+     _ap_ = _ao_ || end_of_input(ib);
+     /*<<scanf.ml:866:18>>*/ if(_ap_)  /*<<scanf.ml:866:48>>*/ bad_float(0);
      /*<<scanf.ml:867:14>>*/ var
       /*<<scanf.ml:867:14>>*/ width$0 = scan_sign(width, ib),
-     _ap_ = 0 === width$0 ? 1 : 0,
-     _aq_ = _ap_ || end_of_input(ib);
-     /*<<scanf.ml:868:18>>*/ if(_aq_)  /*<<scanf.ml:868:48>>*/ bad_float(0);
+     _aq_ = 0 === width$0 ? 1 : 0,
+     _ar_ = _aq_ || end_of_input(ib);
+     /*<<scanf.ml:868:18>>*/ if(_ar_)  /*<<scanf.ml:868:48>>*/ bad_float(0);
      /*<<scanf.ml:869:8>>*/  /*<<scanf.ml:869:8>>*/ var c = peek_char(ib);
     if(49 <= c){
      if(58 > c){
        /*<<scanf.ml:903:16>>*/ var
         /*<<scanf.ml:903:16>>*/ width$1 = store_char(width$0, ib, c),
-       _ar_ = 0 === width$1 ? 1 : 0,
-       _as_ = _ar_ || end_of_input(ib);
-       /*<<scanf.ml:904:20>>*/ if(_as_)  /*<<scanf.ml:904:50>>*/ bad_float(0);
+       _as_ = 0 === width$1 ? 1 : 0,
+       _at_ = _as_ || end_of_input(ib);
+       /*<<scanf.ml:904:20>>*/ if(_at_)  /*<<scanf.ml:904:50>>*/ bad_float(0);
        /*<<scanf.ml:904:50>>*/ return scan_caml_float_rest
               (width$1, precision, ib);
      }
@@ -27846,9 +27833,9 @@
     else if(48 <= c){
       /*<<scanf.ml:871:16>>*/ var
        /*<<scanf.ml:871:16>>*/ width$2 = store_char(width$0, ib, c),
-      _at_ = 0 === width$2 ? 1 : 0,
-      _au_ = _at_ || end_of_input(ib);
-      /*<<scanf.ml:872:20>>*/ if(_au_)  /*<<scanf.ml:872:50>>*/ bad_float(0);
+      _au_ = 0 === width$2 ? 1 : 0,
+      _av_ = _au_ || end_of_input(ib);
+      /*<<scanf.ml:872:20>>*/ if(_av_)  /*<<scanf.ml:872:50>>*/ bad_float(0);
       /*<<scanf.ml:873:10>>*/  /*<<scanf.ml:873:10>>*/ var
       c$0 = peek_char(ib);
      if(88 !== c$0 && 120 !== c$0)
@@ -27856,14 +27843,14 @@
               (width$2, precision, ib);
       /*<<scanf.ml:875:18>>*/ var
        /*<<scanf.ml:875:18>>*/ width$3 = store_char(width$2, ib, c$0),
-      _av_ = 0 === width$3 ? 1 : 0,
-      _aw_ = _av_ || end_of_input(ib);
-      /*<<scanf.ml:876:22>>*/ if(_aw_)  /*<<scanf.ml:876:52>>*/ bad_float(0);
+      _aw_ = 0 === width$3 ? 1 : 0,
+      _ax_ = _aw_ || end_of_input(ib);
+      /*<<scanf.ml:876:22>>*/ if(_ax_)  /*<<scanf.ml:876:52>>*/ bad_float(0);
       /*<<scanf.ml:877:18>>*/ var
        /*<<scanf.ml:877:18>>*/ width$4 = scan_hexadecimal_int(width$3, ib),
-      _ax_ = 0 === width$4 ? 1 : 0,
-      _ay_ = _ax_ || end_of_input(ib);
-      /*<<scanf.ml:878:22>>*/ if(_ay_)  /*<<scanf.ml:878:52>>*/ bad_float(0);
+      _ay_ = 0 === width$4 ? 1 : 0,
+      _az_ = _ay_ || end_of_input(ib);
+      /*<<scanf.ml:878:22>>*/ if(_az_)  /*<<scanf.ml:878:52>>*/ bad_float(0);
       /*<<scanf.ml:879:24>>*/ var
        /*<<scanf.ml:879:24>>*/ c$1 = peek_char(ib),
        /*<<scanf.ml:879:24>>*/ switcher = c$1 - 80 | 0;
@@ -27916,9 +27903,9 @@
       if(80 !== c$2 && 112 !== c$2)  /*<<scanf.ml:897:15>>*/ return width$8;
        /*<<scanf.ml:894:22>>*/ var
         /*<<scanf.ml:894:22>>*/ width$9 = store_char(width$8, ib, c$2),
-       _az_ = 0 === width$9 ? 1 : 0,
-       _aA_ = _az_ || end_of_input(ib);
-       /*<<scanf.ml:895:26>>*/ if(_aA_)
+       _aA_ = 0 === width$9 ? 1 : 0,
+       _aB_ = _aA_ || end_of_input(ib);
+       /*<<scanf.ml:895:26>>*/ if(_aB_)
         /*<<scanf.ml:895:56>>*/ bad_hex_float(0);
        /*<<scanf.ml:895:56>>*/ return scan_optionally_signed_decimal
               (width$9, ib);
@@ -27935,13 +27922,13 @@
       /*<<scanf.ml:923:7>>*/ if(ib[1])
        /*<<scanf.ml:923:28>>*/ return width$0;
      if(! stp){
-       /*<<scanf.ml:928:8>>*/  /*<<scanf.ml:928:8>>*/ var _am_ = c - 9 | 0;
+       /*<<scanf.ml:928:8>>*/  /*<<scanf.ml:928:8>>*/ var _an_ = c - 9 | 0;
       a:
       {
-       if(4 < _am_ >>> 0){
-        if(23 === _am_) break a;
+       if(4 < _an_ >>> 0){
+        if(23 === _an_) break a;
        }
-       else if(1 < _am_ - 2 >>> 0) break a;
+       else if(1 < _an_ - 2 >>> 0) break a;
         /*<<scanf.ml:930:20>>*/ var
          /*<<scanf.ml:930:20>>*/ width$2 = store_char(width$0, ib, c),
         width$0 = width$2;
@@ -27971,11 +27958,11 @@
                 (Stdlib_Printf[4], _f_, message))
             : c;
     /*<<scanf.ml:998:3>>*/ }
-    /*<<scanf.ml:1001:31>>*/ function check_next_char_for_char(_ak_, _al_){
-     /*<<?>>*/ return check_next_char(cst_a_Char, _ak_, _al_);
+    /*<<scanf.ml:1001:31>>*/ function check_next_char_for_char(_al_, _am_){
+     /*<<?>>*/ return check_next_char(cst_a_Char, _al_, _am_);
    }
-    /*<<scanf.ml:1002:33>>*/ function check_next_char_for_string(_ai_, _aj_){
-     /*<<?>>*/ return check_next_char(cst_a_String, _ai_, _aj_);
+    /*<<scanf.ml:1002:33>>*/ function check_next_char_for_string(_aj_, _ak_){
+     /*<<?>>*/ return check_next_char(cst_a_String, _aj_, _ak_);
    }
    function scan_backslash_char(width, ib){
      /*<<scanf.ml:1005:2>>*/  /*<<scanf.ml:1005:8>>*/ var
@@ -28001,16 +27988,16 @@
        b:
        {
         if(0 <= c && 255 >= c){
-         var _ag_ =  /*<<scanf.ml:963:2>>*/ caml_call1(Stdlib[29], c);
+         var _ah_ =  /*<<scanf.ml:963:2>>*/ caml_call1(Stdlib[29], c);
          break b;
         }
         var
-         _ag_ =
+         _ah_ =
            bad_input
             ( /*<<scanf.ml:961:6>>*/ caml_call4
               (Stdlib_Printf[4], _l_, c0, c1$0, c2$0));
        }
-        /*<<scanf.ml:1017:39>>*/ return store_char(width - 2 | 0, ib, _ag_);
+        /*<<scanf.ml:1017:39>>*/ return store_char(width - 2 | 0, ib, _ah_);
       }
        /*<<scanf.ml:1005:8>>*/  /*<<scanf.ml:1005:8>>*/ var
        switcher = c0 - 92 | 0;
@@ -28022,34 +28009,34 @@
             function(param){
               /*<<scanf.ml:1020:6>>*/ var
                /*<<scanf.ml:1020:14>>*/ c = next_char(ib),
-               /*<<scanf.ml:1020:14>>*/ _ah_ = c - 48 | 0;
+               /*<<scanf.ml:1020:14>>*/ _ai_ = c - 48 | 0;
              a:
              {
-              if(22 < _ah_ >>> 0){
-               if(5 < _ah_ - 49 >>> 0) break a;
+              if(22 < _ai_ >>> 0){
+               if(5 < _ai_ - 49 >>> 0) break a;
               }
-              else if(6 >= _ah_ - 10 >>> 0) break a;
+              else if(6 >= _ai_ - 10 >>> 0) break a;
                /*<<scanf.ml:1022:53>>*/ return c;
              }
               /*<<scanf.ml:1023:13>>*/ return bad_input_escape(c);
              /*<<scanf.ml:1023:31>>*/ },
            /*<<scanf.ml:1024:13>>*/ c1 = get_digit(0),
            /*<<scanf.ml:1025:13>>*/ c2 = get_digit(0),
-           /*<<scanf.ml:985:9>>*/ _ad_ = hexadecimal_value_of_char(c2),
-          c$0 = (16 * hexadecimal_value_of_char(c1) | 0) + _ad_ | 0;
+           /*<<scanf.ml:985:9>>*/ _ae_ = hexadecimal_value_of_char(c2),
+          c$0 = (16 * hexadecimal_value_of_char(c1) | 0) + _ae_ | 0;
          b:
          {
           if(0 <= c$0 && 255 >= c$0){
-           var _af_ =  /*<<scanf.ml:989:2>>*/ caml_call1(Stdlib[29], c$0);
+           var _ag_ =  /*<<scanf.ml:989:2>>*/ caml_call1(Stdlib[29], c$0);
            break b;
           }
           var
-           _af_ =
+           _ag_ =
              bad_input
               ( /*<<scanf.ml:988:6>>*/ caml_call3
                 (Stdlib_Printf[4], _m_, c1, c2));
          }
-          /*<<scanf.ml:1026:39>>*/ return store_char(width - 2 | 0, ib, _af_);
+          /*<<scanf.ml:1026:39>>*/ return store_char(width - 2 | 0, ib, _ag_);
         case 0:
         case 6:
         case 18:
@@ -28065,17 +28052,17 @@
        if(117 > c0)
         switch(c0 - 110 | 0){
           case 0:
-           var _ae_ = 10; break b;
+           var _af_ = 10; break b;
           case 4:
-           var _ae_ = 13; break b;
+           var _af_ = 13; break b;
           case 6:
-           var _ae_ = 9; break b;
+           var _af_ = 9; break b;
         }
       }
-      else if(98 === c0){var _ae_ = 8; break b;}
-      var _ae_ = c0;
+      else if(98 === c0){var _af_ = 8; break b;}
+      var _af_ = c0;
      }
-      /*<<scanf.ml:1007:33>>*/ return store_char(width, ib, _ae_);
+      /*<<scanf.ml:1007:33>>*/ return store_char(width, ib, _af_);
     }
      /*<<scanf.ml:1028:4>>*/ return bad_input_escape(c0);
     /*<<scanf.ml:1028:22>>*/ }
@@ -28093,24 +28080,24 @@
           check_next_char_for_string(width$1, ib);
        if(10 === match){
          /*<<scanf.ml:1071:26>>*/  /*<<scanf.ml:1071:26>>*/ var
-         _ab_ = ignore_char(width$1, ib);
+         _ac_ = ignore_char(width$1, ib);
          /*<<scanf.ml:1071:26>>*/ if(counter >= 50)
           /*<<scanf.ml:1071:26>>*/ return  /*<<scanf.ml:1071:26>>*/ caml_trampoline_return
-                 (skip_spaces, [0, _ab_]);
+                 (skip_spaces, [0, _ac_]);
         var counter$0 = counter + 1 | 0;
-         /*<<scanf.ml:1071:26>>*/ return skip_spaces(counter$0, _ab_);
+         /*<<scanf.ml:1071:26>>*/ return skip_spaces(counter$0, _ac_);
        }
        if(13 === match){
          /*<<scanf.ml:1070:27>>*/  /*<<scanf.ml:1070:27>>*/ var
          width$3 = ignore_char(width$1, ib);
         if(10 === check_next_char_for_string(width$3, ib)){
           /*<<scanf.ml:1076:26>>*/  /*<<scanf.ml:1076:26>>*/ var
-          _ac_ = ignore_char(width$3, ib);
+          _ad_ = ignore_char(width$3, ib);
           /*<<scanf.ml:1076:26>>*/ if(counter >= 50)
            /*<<scanf.ml:1076:26>>*/ return  /*<<scanf.ml:1076:26>>*/ caml_trampoline_return
-                  (skip_spaces, [0, _ac_]);
+                  (skip_spaces, [0, _ad_]);
          var counter$1 = counter + 1 | 0;
-          /*<<scanf.ml:1076:26>>*/ return skip_spaces(counter$1, _ac_);
+          /*<<scanf.ml:1076:26>>*/ return skip_spaces(counter$1, _ad_);
         }
          /*<<scanf.ml:1077:21>>*/ var
           /*<<scanf.ml:1077:21>>*/ width$5 = store_char(width$3, ib, 13),
@@ -28157,39 +28144,39 @@
       /*<<scanf.ml:1104:4>>*/ for(;;){
        /*<<scanf.ml:1104:12>>*/ var
         /*<<scanf.ml:1104:12>>*/ c = peek_char(ib),
-       _Z_ = 0 < i$0 ? 1 : 0;
-      if(_Z_){
+       ___ = 0 < i$0 ? 1 : 0;
+      if(___){
         /*<<scanf.ml:1105:20>>*/  /*<<scanf.ml:1105:20>>*/ var
-        ___ = 1 - ib[1];
-       if(___)
+        _$_ = 1 - ib[1];
+       if(_$_)
          /*<<scanf.ml:1106:7>>*/ var
-          /*<<scanf.ml:1106:7>>*/ _$_ =
+          /*<<scanf.ml:1106:7>>*/ _aa_ =
             /*<<scanf.ml:1106:7>>*/ caml_call2
             (CamlinternalFormat[1], char_set, c),
-          /*<<scanf.ml:1106:7>>*/ _aa_ = _$_ ? c !== stp ? 1 : 0 : _$_;
+          /*<<scanf.ml:1106:7>>*/ _ab_ = _aa_ ? c !== stp ? 1 : 0 : _aa_;
        else
-        var _aa_ = ___;
+        var _ab_ = _$_;
       }
       else
-       var _aa_ = _Z_;
-      if(! _aa_) return _aa_;
+       var _ab_ = ___;
+      if(! _ab_) return _ab_;
        /*<<scanf.ml:1108:14>>*/ store_char(Stdlib[19], ib, c);
       var i$1 = i$0 - 1 | 0, i$0 = i$1;
      }
      /*<<scanf.ml:1109:28>>*/ }
     if(! scan_indic){
       /*<<scanf.ml:1111:12>>*/ scan_chars(width, -1);
-      /*<<scanf.ml:1111:12>>*/ return sentinal;
+      /*<<scanf.ml:1111:12>>*/ return _u_;
     }
     var c = scan_indic[1];
      /*<<scanf.ml:1113:4>>*/ scan_chars(width, c);
-     /*<<scanf.ml:1114:11>>*/  /*<<scanf.ml:1114:11>>*/ var _Y_ = 1 - ib[1];
-    if(! _Y_)  /*<<scanf.ml:1114:11>>*/ return _Y_;
+     /*<<scanf.ml:1114:11>>*/  /*<<scanf.ml:1114:11>>*/ var _Z_ = 1 - ib[1];
+    if(! _Z_)  /*<<scanf.ml:1114:11>>*/ return _Z_;
      /*<<scanf.ml:1115:15>>*/  /*<<scanf.ml:1115:15>>*/ var
      ci = peek_char(ib);
     return c === ci
-            ? (invalidate_current_char(ib), sentinal)
-            : (character_mismatch(c, ci), sentinal);
+            ? (invalidate_current_char(ib), _u_)
+            : (character_mismatch(c, ci), _u_);
     /*<<scanf.ml:1118:34>>*/ }
    function scanf_bad_input(ib, x){
      /*<<?>>*/ if(x[1] === Scan_failure)
@@ -28266,17 +28253,17 @@
          /*<<scanf.ml:1195:44>>*/ var
          rest$13 = fmt$0[3],
          fmtty = fmt$0[2],
-          /*<<scanf.ml:1195:44>>*/ _V_ =
+          /*<<scanf.ml:1195:44>>*/ _W_ =
             /*<<scanf.ml:1195:44>>*/ caml_call1(CamlinternalFormat[21], fmtty),
-          /*<<scanf.ml:1195:33>>*/ _W_ =
+          /*<<scanf.ml:1195:33>>*/ _X_ =
             /*<<scanf.ml:1195:33>>*/ caml_call1
-            (CamlinternalFormatBasics[2], _V_);
+            (CamlinternalFormatBasics[2], _W_);
          /*<<scanf.ml:1195:5>>*/ if(counter >= 50)
           /*<<scanf.ml:1195:5>>*/ return  /*<<scanf.ml:1195:5>>*/ caml_trampoline_return
-                 (take_fmtty_format_readers$0, [0, k, _W_, rest$13]);
+                 (take_fmtty_format_readers$0, [0, k, _X_, rest$13]);
         var counter$0 = counter + 1 | 0;
          /*<<scanf.ml:1195:5>>*/ return take_fmtty_format_readers$0
-                (counter$0, k, _W_, rest$13);
+                (counter$0, k, _X_, rest$13);
        case 15:
         var rest$14 = fmt$0[1], fmt$0 = rest$14; break;
        case 16:
@@ -28284,11 +28271,11 @@
        case 17:
         var rest$16 = fmt$0[2], fmt$0 = rest$16; break;
        case 18:
-        var _X_ = fmt$0[1];
-        if(0 === _X_[0])
+        var _Y_ = fmt$0[1];
+        if(0 === _Y_[0])
           /*<<scanf.ml:1189:28>>*/ var
           rest$17 = fmt$0[2],
-          fmt$1 = _X_[1][1],
+          fmt$1 = _Y_[1][1],
            /*<<scanf.ml:1189:28>>*/ fmt$2 =
              /*<<scanf.ml:1189:28>>*/ caml_call2
              (CamlinternalFormatBasics[3], fmt$1, rest$17),
@@ -28296,7 +28283,7 @@
         else
           /*<<scanf.ml:1191:28>>*/ var
           rest$18 = fmt$0[2],
-          fmt$3 = _X_[1][1],
+          fmt$3 = _Y_[1][1],
            /*<<scanf.ml:1191:28>>*/ fmt$4 =
              /*<<scanf.ml:1191:28>>*/ caml_call2
              (CamlinternalFormatBasics[3], fmt$3, rest$18),
@@ -28406,11 +28393,11 @@
          rest = fmtty$0[3],
          ty2 = fmtty$0[2],
          ty1 = fmtty$0[1],
-          /*<<scanf.ml:1227:19>>*/ _U_ =
+          /*<<scanf.ml:1227:19>>*/ _V_ =
             /*<<scanf.ml:1227:19>>*/ caml_call1(CamlinternalFormat[21], ty1),
           /*<<scanf.ml:1227:13>>*/ ty =
             /*<<scanf.ml:1227:13>>*/ caml_call2
-            (CamlinternalFormat[22], _U_, ty2),
+            (CamlinternalFormat[22], _V_, ty2),
           /*<<scanf.ml:1228:32>>*/ fmtty$10 =
             /*<<scanf.ml:1228:32>>*/ caml_call2
             (CamlinternalFormatBasics[1], ty, rest),
@@ -28515,8 +28502,8 @@
              /*<<scanf.ml:1047:4>>*/  /*<<scanf.ml:1047:10>>*/ var
              c = check_next_char_for_char(width, ib);
             return 39 === c
-                    ? (ignore_char(width, ib), sentinal)
-                    : (character_mismatch(39, c), sentinal);
+                    ? (ignore_char(width, ib), _u_)
+                    : (character_mismatch(39, c), _u_);
             /*<<scanf.ml:1049:36>>*/ },
           /*<<scanf.ml:1035:10>>*/ c = checked_peek_char(ib);
         if(39 === c){
@@ -28557,11 +28544,11 @@
              /*<<scanf.ml:1280:4>>*/ return pad_prec_scanf
                     (ib, str_rest, readers, pad, 0, scan$0, token_string);
            case 18:
-            var _G_ = match[1];
-            if(0 === _G_[0]){
+            var _H_ = match[1];
+            if(0 === _H_[0]){
               /*<<scanf.ml:1282:4>>*/ var
               rest$3 = match[2],
-              fmt$1 = _G_[1][1],
+              fmt$1 = _H_[1][1],
                /*<<scanf.ml:1282:4>>*/ scan$1 =
                 function(width, param, ib){
                   /*<<scanf.ml:1282:26>>*/ return scan_string(_q_, width, ib);
@@ -28578,7 +28565,7 @@
             }
              /*<<scanf.ml:1286:4>>*/ var
              rest$4 = match[2],
-             fmt$2 = _G_[1][1],
+             fmt$2 = _H_[1][1],
               /*<<scanf.ml:1286:4>>*/ scan$2 =
                function(width, param, ib){
                  /*<<scanf.ml:1286:26>>*/ return scan_string(_r_, width, ib);
@@ -28755,7 +28742,7 @@
          rest$13 = fmt$0[2],
          pad$8 = fmt$0[1],
           /*<<scanf.ml:1320:4>>*/ scan$8 =
-           function(param, _T_, ib){
+           function(param, _U_, ib){
              /*<<scanf.ml:1320:22>>*/ var
               /*<<scanf.ml:1089:10>>*/ c = checked_peek_char(ib),
               /*<<scanf.ml:1090:2>>*/ m =
@@ -28781,10 +28768,10 @@
          /*<<scanf.ml:1341:16>>*/ var
          rest$15 = fmt$0[2],
          str$0 = fmt$0[1],
-          /*<<scanf.ml:1341:16>>*/ _H_ =
-           function(_S_){ /*<<?>>*/ return check_char(ib, _S_);};
+          /*<<scanf.ml:1341:16>>*/ _I_ =
+           function(_T_){ /*<<?>>*/ return check_char(ib, _T_);};
          /*<<scanf.ml:1341:4>>*/  /*<<scanf.ml:1341:4>>*/ caml_call2
-         (Stdlib_String[29], _H_, str$0);
+         (Stdlib_String[29], _I_, str$0);
         var fmt$0 = rest$15;
         break;
        case 12:
@@ -28800,10 +28787,10 @@
          s = token_string(ib);
          /*<<scanf.ml:1350:4>>*/ try{
           /*<<scanf.ml:1351:10>>*/ var
-           /*<<scanf.ml:1351:10>>*/ _I_ =
+           /*<<scanf.ml:1351:10>>*/ _J_ =
              /*<<scanf.ml:1351:10>>*/ caml_call2
              (CamlinternalFormat[14], s, fmtty),
-          fmt$3 = _I_;
+          fmt$3 = _J_;
         }
         catch(exn$0){
          var exn = caml_wrap_exception(exn$0);
@@ -28829,23 +28816,23 @@
              /*<<scanf.ml:1361:27>>*/ caml_call2
               (CamlinternalFormat[13], 0, s$0)
              [1],
-           /*<<scanf.ml:1375:36>>*/ _K_ =
+           /*<<scanf.ml:1375:36>>*/ _L_ =
              /*<<scanf.ml:1375:36>>*/ caml_call1
              (CamlinternalFormat[21], fmtty$0),
-           /*<<scanf.ml:1375:25>>*/ _L_ =
+           /*<<scanf.ml:1375:25>>*/ _M_ =
              /*<<scanf.ml:1375:25>>*/ caml_call1
-             (CamlinternalFormatBasics[2], _K_),
+             (CamlinternalFormatBasics[2], _L_),
            /*<<scanf.ml:1375:8>>*/ fmt$8 =
              /*<<scanf.ml:1375:8>>*/ caml_call2
-             (CamlinternalFormat[12], fmt$7, _L_),
-           /*<<scanf.ml:1374:24>>*/ _M_ =
+             (CamlinternalFormat[12], fmt$7, _M_),
+           /*<<scanf.ml:1374:24>>*/ _N_ =
              /*<<scanf.ml:1374:24>>*/ caml_call1
              (CamlinternalFormatBasics[2], fmtty$0),
-           /*<<scanf.ml:1374:8>>*/ _N_ =
+           /*<<scanf.ml:1374:8>>*/ _O_ =
              /*<<scanf.ml:1374:8>>*/ caml_call2
-             (CamlinternalFormat[12], fmt$6, _M_),
+             (CamlinternalFormat[12], fmt$6, _N_),
           fmt$5 = fmt$8,
-          fmt$4 = _N_;
+          fmt$4 = _O_;
         }
         catch(exn){
          var exn$0 = caml_wrap_exception(exn);
@@ -28853,9 +28840,9 @@
           throw caml_maybe_attach_backtrace(exn$0, 0);
          var
           msg$0 = exn$0[2],
-          _J_ = bad_input(msg$0),
-          fmt$5 = _J_[2],
-          fmt$4 = _J_[1];
+          _K_ = bad_input(msg$0),
+          fmt$5 = _K_[2],
+          fmt$4 = _K_[1];
         }
          /*<<scanf.ml:1378:4>>*/ return [0,
                 [0, fmt$4, s$0],
@@ -28874,19 +28861,19 @@
          /*<<scanf.ml:1401:32>>*/ var
          rest$19 = fmt$0[2],
          formatting_lit = fmt$0[1],
-          /*<<scanf.ml:1401:32>>*/ _O_ =
+          /*<<scanf.ml:1401:32>>*/ _P_ =
             /*<<scanf.ml:1401:32>>*/ caml_call1
             (CamlinternalFormat[17], formatting_lit),
-          /*<<scanf.ml:1401:16>>*/ _P_ =
-           function(_R_){ /*<<?>>*/ return check_char(ib, _R_);};
+          /*<<scanf.ml:1401:16>>*/ _Q_ =
+           function(_S_){ /*<<?>>*/ return check_char(ib, _S_);};
          /*<<scanf.ml:1401:4>>*/  /*<<scanf.ml:1401:4>>*/ caml_call2
-         (Stdlib_String[29], _P_, _O_);
+         (Stdlib_String[29], _Q_, _P_);
         var fmt$0 = rest$19;
         break;
        case 18:
-        var _Q_ = fmt$0[1];
-        if(0 === _Q_[0]){
-         var rest$20 = fmt$0[2], fmt$9 = _Q_[1][1];
+        var _R_ = fmt$0[1];
+        if(0 === _R_[0]){
+         var rest$20 = fmt$0[2], fmt$9 = _R_[1][1];
           /*<<scanf.ml:1404:4>>*/ check_char(ib, 64);
           /*<<scanf.ml:1404:23>>*/ check_char(ib, 123);
           /*<<scanf.ml:1405:18>>*/ var
@@ -28896,7 +28883,7 @@
           fmt$0 = fmt$10;
         }
         else{
-         var rest$21 = fmt$0[2], fmt$11 = _Q_[1][1];
+         var rest$21 = fmt$0[2], fmt$11 = _R_[1][1];
           /*<<scanf.ml:1407:4>>*/ check_char(ib, 64);
           /*<<scanf.ml:1407:23>>*/ check_char(ib, 91);
           /*<<scanf.ml:1408:18>>*/ var
@@ -29005,16 +28992,16 @@
        if(exc[1] !== Stdlib[6]) throw caml_maybe_attach_backtrace(exc, 0);
         /*<<scanf.ml:1470:45>>*/ var
         msg = exc[2],
-         /*<<scanf.ml:1470:45>>*/ _C_ =
-           /*<<scanf.ml:1470:45>>*/ caml_call1(Stdlib_String[24], str),
          /*<<scanf.ml:1470:45>>*/ _D_ =
-           /*<<scanf.ml:1470:45>>*/ caml_call2(Stdlib[28], _C_, cst$0),
-         /*<<scanf.ml:1470:27>>*/ _E_ =
-           /*<<scanf.ml:1470:27>>*/ caml_call2(Stdlib[28], cst_in_format, _D_),
-         /*<<scanf.ml:1470:20>>*/ _F_ =
-           /*<<scanf.ml:1470:20>>*/ caml_call2(Stdlib[28], msg, _E_);
+           /*<<scanf.ml:1470:45>>*/ caml_call1(Stdlib_String[24], str),
+         /*<<scanf.ml:1470:45>>*/ _E_ =
+           /*<<scanf.ml:1470:45>>*/ caml_call2(Stdlib[28], _D_, cst$0),
+         /*<<scanf.ml:1470:27>>*/ _F_ =
+           /*<<scanf.ml:1470:27>>*/ caml_call2(Stdlib[28], cst_in_format, _E_),
+         /*<<scanf.ml:1470:20>>*/ _G_ =
+           /*<<scanf.ml:1470:20>>*/ caml_call2(Stdlib[28], msg, _F_);
         /*<<scanf.ml:1470:20>>*/ return  /*<<scanf.ml:1470:20>>*/ caml_call1
-               (Stdlib[1], _F_);
+               (Stdlib[1], _G_);
       }
        /*<<scanf.ml:1468:8>>*/ return  /*<<scanf.ml:1468:8>>*/ caml_call2
               (ef, ib, exc);
@@ -29045,15 +29032,15 @@
              fmt);
     /*<<scanf.ml:1477:35>>*/ }
    function kscanf_opt(ib, fmt){
-    function _A_(x){
+    function _B_(x){
       /*<<scanf.ml:1480:44>>*/ return [0, x];
      /*<<scanf.ml:1480:50>>*/ }
      /*<<scanf.ml:1480:2>>*/ return kscanf_gen
             (ib,
-             function(param, _B_){
+             function(param, _C_){
                /*<<scanf.ml:1480:28>>*/ return 0;
               /*<<scanf.ml:1480:32>>*/ },
-             _A_,
+             _B_,
              fmt);
     /*<<scanf.ml:1480:55>>*/ }
    function bscanf(ib, fmt){
@@ -29084,10 +29071,10 @@
      str = token_string(ib);
      /*<<scanf.ml:1504:4>>*/ try{
       /*<<scanf.ml:1505:10>>*/ var
-       /*<<scanf.ml:1505:10>>*/ _z_ =
+       /*<<scanf.ml:1505:10>>*/ _A_ =
          /*<<scanf.ml:1505:10>>*/ caml_call2
          (CamlinternalFormat[15], str, format),
-      fmt = _z_;
+      fmt = _A_;
     }
     catch(exn$0){
      var exn = caml_wrap_exception(exn$0);
@@ -29101,30 +29088,30 @@
      /*<<scanf.ml:1513:20>>*/ return bscanf_format(from_string(s), format, f);
     /*<<scanf.ml:1513:67>>*/ }
    function format_from_string(s, fmt){
-     /*<<scanf.ml:1517:2>>*/ function _w_(x){
+     /*<<scanf.ml:1517:2>>*/ function _x_(x){
       /*<<scanf.ml:1517:63>>*/ return x;
      /*<<scanf.ml:1517:64>>*/ }
      /*<<scanf.ml:1517:24>>*/ var
-      /*<<scanf.ml:1517:24>>*/ _x_ =
-        /*<<scanf.ml:1517:24>>*/ caml_call1(Stdlib_String[24], s),
       /*<<scanf.ml:1517:24>>*/ _y_ =
-        /*<<scanf.ml:1517:24>>*/ caml_call2(Stdlib[28], _x_, cst$1);
+        /*<<scanf.ml:1517:24>>*/ caml_call1(Stdlib_String[24], s),
+      /*<<scanf.ml:1517:24>>*/ _z_ =
+        /*<<scanf.ml:1517:24>>*/ caml_call2(Stdlib[28], _y_, cst$1);
      /*<<scanf.ml:1517:53>>*/ return sscanf_format
-            ( /*<<scanf.ml:1517:16>>*/ caml_call2(Stdlib[28], cst$2, _y_),
+            ( /*<<scanf.ml:1517:16>>*/ caml_call2(Stdlib[28], cst$2, _z_),
              fmt,
-             _w_);
+             _x_);
     /*<<scanf.ml:1517:65>>*/ }
    function unescaped(s){
-     /*<<scanf.ml:1521:2>>*/ function _u_(x){
+     /*<<scanf.ml:1521:2>>*/ function _v_(x){
       /*<<scanf.ml:1521:44>>*/ return x;
      /*<<scanf.ml:1521:45>>*/ }
      /*<<scanf.ml:1521:17>>*/  /*<<scanf.ml:1521:17>>*/ var
-     _v_ =  /*<<scanf.ml:1521:17>>*/ caml_call2(Stdlib[28], s, cst$3);
+     _w_ =  /*<<scanf.ml:1521:17>>*/ caml_call2(Stdlib[28], s, cst$3);
      /*<<scanf.ml:1521:34>>*/ return  /*<<scanf.ml:1521:34>>*/ caml_call1
             (sscanf
-              ( /*<<scanf.ml:1521:9>>*/ caml_call2(Stdlib[28], cst$4, _v_),
+              ( /*<<scanf.ml:1521:9>>*/ caml_call2(Stdlib[28], cst$4, _w_),
                _t_),
-             _u_);
+             _v_);
     /*<<scanf.ml:1521:46>>*/ }
    var
     Stdlib_Scanf =
@@ -30489,7 +30476,7 @@
             : runtime.caml_call_gen(f, [a0, a1, a2]);
    }
    var
-    sentinal = undefined,
+    _d_ = undefined,
     global_data = runtime.caml_get_global_data(),
     Stdlib_List = global_data.Stdlib__List,
     Stdlib = global_data.Stdlib,
@@ -30508,7 +30495,7 @@
      /*<<ephemeron.ml:105:20>>*/  /*<<ephemeron.ml:105:20>>*/ var
      prng =
        [246,
-        function(_aM_){ /*<<?>>*/ return caml_call1(Stdlib_Random[15][2], 0);}];
+        function(_aN_){ /*<<?>>*/ return caml_call1(Stdlib_Random[15][2], 0);}];
     function create(opt, initial_size){
       /*<<ephemeron.ml:108:6>>*/ if(opt)
       var sth = opt[1], random = sth;
@@ -30519,17 +30506,17 @@
       /*<<ephemeron.ml:101:6>>*/ for(;;){
       if(initial_size > x && Stdlib_Sys[13] >= (x * 2 | 0)){var x$0 = x * 2 | 0, x = x$0; continue;}
        /*<<ephemeron.ml:109:6>>*/ if(random){
-       var _aK_ = runtime.caml_obj_tag(prng);
+       var _aL_ = runtime.caml_obj_tag(prng);
        a:
-       if(250 === _aK_)
-        var _aL_ = prng[1];
+       if(250 === _aL_)
+        var _aM_ = prng[1];
        else{
-        if(246 !== _aK_ && 244 !== _aK_){var _aL_ = prng; break a;}
-        var _aL_ = caml_call1(CamlinternalLazy[2], prng);
+        if(246 !== _aL_ && 244 !== _aL_){var _aM_ = prng; break a;}
+        var _aM_ = caml_call1(CamlinternalLazy[2], prng);
        }
        var
         seed =
-           /*<<ephemeron.ml:109:32>>*/ caml_call1(Stdlib_Random[15][4], _aL_);
+           /*<<ephemeron.ml:109:32>>*/ caml_call1(Stdlib_Random[15][4], _aM_);
       }
       else
        var seed = 0;
@@ -30544,16 +30531,16 @@
       /*<<ephemeron.ml:113:6>>*/ h[1] = 0;
       /*<<ephemeron.ml:115:6>>*/ var
       len = h[2].length - 1,
-       /*<<ephemeron.ml:115:6>>*/ _aI_ = len - 1 | 0,
-      _aH_ = 0;
-     if(_aI_ >= 0){
-      var i = _aH_;
+       /*<<ephemeron.ml:115:6>>*/ _aJ_ = len - 1 | 0,
+      _aI_ = 0;
+     if(_aJ_ >= 0){
+      var i = _aI_;
       for(;;){
         /*<<ephemeron.ml:116:8>>*/ caml_check_bound(h[2], i)[1 + i] = 0;
         /*<<ephemeron.ml:116:8>>*/  /*<<ephemeron.ml:116:8>>*/ var
-        _aJ_ = i + 1 | 0;
-       if(_aI_ === i) break;
-       var i = _aJ_;
+        _aK_ = i + 1 | 0;
+       if(_aJ_ === i) break;
+       var i = _aK_;
       }
      }
      return 0;
@@ -30570,11 +30557,11 @@
      /*<<ephemeron.ml:126:9>>*/ }
     function copy(h){
       /*<<ephemeron.ml:128:17>>*/ var
-      _aE_ = h[4],
-      _aF_ = h[3],
-       /*<<ephemeron.ml:128:33>>*/ _aG_ =
+      _aF_ = h[4],
+      _aG_ = h[3],
+       /*<<ephemeron.ml:128:33>>*/ _aH_ =
          /*<<ephemeron.ml:128:33>>*/ caml_call1(Stdlib_Array[6], h[2]);
-      /*<<ephemeron.ml:128:17>>*/ return [0, h[1], _aG_, _aF_, _aE_];
+      /*<<ephemeron.ml:128:17>>*/ return [0, h[1], _aH_, _aG_, _aF_];
      /*<<ephemeron.ml:128:52>>*/ }
     function key_index(h, hkey){
       /*<<ephemeron.ml:131:6>>*/ return hkey & (h[2].length - 1 - 1 | 0);
@@ -30594,16 +30581,16 @@
        var param$0 = rest;
       }
       /*<<ephemeron.ml:141:41>>*/ }
-     var d = h[2], _aC_ = d.length - 1 - 1 | 0, _aB_ = 0;
-     if(_aC_ >= 0){
-      var i = _aB_;
+     var d = h[2], _aD_ = d.length - 1 - 1 | 0, _aC_ = 0;
+     if(_aD_ >= 0){
+      var i = _aC_;
       for(;;){
         /*<<ephemeron.ml:145:8>>*/ d[1 + i] =
         do_bucket(caml_check_bound(d, i)[1 + i]);
         /*<<ephemeron.ml:145:8>>*/  /*<<ephemeron.ml:145:8>>*/ var
-        _aD_ = i + 1 | 0;
-       if(_aC_ === i) break;
-       var i = _aD_;
+        _aE_ = i + 1 | 0;
+       if(_aD_ === i) break;
+       var i = _aE_;
       }
      }
      return 0;
@@ -30615,9 +30602,9 @@
       nsize = osize * 2 | 0;
       /*<<ephemeron.ml:172:6>>*/ clean(h);
      var
-      _av_ = nsize < Stdlib_Sys[13] ? 1 : 0,
-      _aw_ = _av_ ? (osize >>> 1 | 0) <= h[1] ? 1 : 0 : _av_;
-     if(_aw_){
+      _aw_ = nsize < Stdlib_Sys[13] ? 1 : 0,
+      _ax_ = _aw_ ? (osize >>> 1 | 0) <= h[1] ? 1 : 0 : _aw_;
+     if(_ax_){
        /*<<ephemeron.ml:174:20>>*/  /*<<ephemeron.ml:174:20>>*/ var
        ndata =  /*<<ephemeron.ml:174:20>>*/ caml_make_vect(nsize, 0);
       h[2] = ndata;
@@ -30625,33 +30612,33 @@
        insert_bucket =
          function(param){
            /*<<ephemeron.ml:176:32>>*/ if(! param)
-            /*<<ephemeron.ml:177:21>>*/ return sentinal;
+            /*<<ephemeron.ml:177:21>>*/ return _d_;
           var rest = param[3], data = param[2], hkey = param[1];
            /*<<ephemeron.ml:179:14>>*/ insert_bucket(rest);
            /*<<ephemeron.ml:180:25>>*/  /*<<ephemeron.ml:180:25>>*/ var
            nidx = key_index(h, hkey);
            /*<<ephemeron.ml:181:14>>*/ ndata[1 + nidx] =
            [0, hkey, data, caml_check_bound(ndata, nidx)[1 + nidx]];
-           /*<<ephemeron.ml:181:14>>*/ return sentinal;
+           /*<<ephemeron.ml:181:14>>*/ return _d_;
           /*<<ephemeron.ml:181:60>>*/ },
-        /*<<ephemeron.ml:170:6>>*/ _ay_ = osize - 1 | 0,
-        /*<<ephemeron.ml:182:8>>*/ _ax_ = 0;
-      if(_ay_ >= 0){
-       var i = _ax_;
+        /*<<ephemeron.ml:170:6>>*/ _az_ = osize - 1 | 0,
+        /*<<ephemeron.ml:182:8>>*/ _ay_ = 0;
+      if(_az_ >= 0){
+       var i = _ay_;
        for(;;){
          /*<<ephemeron.ml:183:10>>*/ insert_bucket
          (caml_check_bound(odata, i)[1 + i]);
          /*<<ephemeron.ml:183:10>>*/  /*<<ephemeron.ml:183:10>>*/ var
-         _aA_ = i + 1 | 0;
-        if(_ay_ === i) break;
-        var i = _aA_;
+         _aB_ = i + 1 | 0;
+        if(_az_ === i) break;
+        var i = _aB_;
        }
       }
-      var _az_ = 0;
+      var _aA_ = 0;
      }
      else
-      var _az_ = _aw_;
-     return _az_;
+      var _aA_ = _ax_;
+     return _aA_;
      /*<<ephemeron.ml:185:9>>*/ }
     function add(h, key, info){
       /*<<ephemeron.ml:188:6>>*/ var
@@ -30664,8 +30651,8 @@
         [0, hkey, container, caml_check_bound(h[2], i)[1 + i]];
       /*<<ephemeron.ml:192:6>>*/ caml_check_bound(h[2], i)[1 + i] = bucket;
      h[1] = h[1] + 1 | 0;
-     var _au_ = h[2].length - 1 << 1 < h[1] ? 1 : 0;
-     return _au_ ? resize(h) : _au_;
+     var _av_ = h[2].length - 1 << 1 < h[1] ? 1 : 0;
+     return _av_ ? resize(h) : _av_;
      /*<<ephemeron.ml:194:57>>*/ }
     function remove(h, key){
       /*<<ephemeron.ml:197:6>>*/  /*<<ephemeron.ml:197:17>>*/ var
@@ -30693,17 +30680,17 @@
       /*<<ephemeron.ml:210:60>>*/ }
       /*<<ephemeron.ml:211:14>>*/ var
        /*<<ephemeron.ml:211:14>>*/ i = key_index(h, hkey),
-       /*<<ephemeron.ml:212:20>>*/ _at_ =
+       /*<<ephemeron.ml:212:20>>*/ _au_ =
         remove_bucket(caml_check_bound(h[2], i)[1 + i]);
-      /*<<ephemeron.ml:212:6>>*/ caml_check_bound(h[2], i)[1 + i] = _at_;
+      /*<<ephemeron.ml:212:6>>*/ caml_check_bound(h[2], i)[1 + i] = _au_;
       /*<<ephemeron.ml:212:6>>*/ return 0;
      /*<<ephemeron.ml:212:44>>*/ }
     function find(h, key){
       /*<<ephemeron.ml:239:6>>*/ var
        /*<<ephemeron.ml:239:17>>*/ hkey =
          /*<<ephemeron.ml:239:17>>*/ caml_call2(H[2], h[3], key),
-       /*<<ephemeron.ml:241:33>>*/ _as_ = key_index(h, hkey),
-      param = caml_check_bound(h[2], _as_)[1 + _as_];
+       /*<<ephemeron.ml:241:33>>*/ _at_ = key_index(h, hkey),
+      param = caml_check_bound(h[2], _at_)[1 + _at_];
      for(;;){
       if(! param)
         /*<<ephemeron.ml:220:10>>*/ throw  /*<<ephemeron.ml:220:10>>*/ caml_maybe_attach_backtrace
@@ -30729,8 +30716,8 @@
       /*<<ephemeron.ml:264:6>>*/ var
        /*<<ephemeron.ml:264:17>>*/ hkey =
          /*<<ephemeron.ml:264:17>>*/ caml_call2(H[2], h[3], key),
-       /*<<ephemeron.ml:266:37>>*/ _ar_ = key_index(h, hkey),
-      param = caml_check_bound(h[2], _ar_)[1 + _ar_];
+       /*<<ephemeron.ml:266:37>>*/ _as_ = key_index(h, hkey),
+      param = caml_check_bound(h[2], _as_)[1 + _as_];
      for(;;){
       if(! param)  /*<<ephemeron.ml:245:10>>*/ return 0;
       var hk = param[1], rest = param[3], c = param[2];
@@ -30778,9 +30765,9 @@
       }
       /*<<ephemeron.ml:284:29>>*/ }
       /*<<ephemeron.ml:285:29>>*/  /*<<ephemeron.ml:285:29>>*/ var
-      _aq_ = key_index(h, hkey);
+      _ar_ = key_index(h, hkey);
       /*<<ephemeron.ml:285:21>>*/ return find_in_bucket
-             (caml_check_bound(h[2], _aq_)[1 + _aq_]);
+             (caml_check_bound(h[2], _ar_)[1 + _ar_]);
      /*<<ephemeron.ml:285:46>>*/ }
     function replace(h, key, info){
       /*<<ephemeron.ml:289:6>>*/ var
@@ -30798,8 +30785,8 @@
        if(hkey === hk){
         if(!  /*<<ephemeron.ml:293:24>>*/ caml_call2(H[3], c, key)){
           /*<<ephemeron.ml:290:6>>*/  /*<<ephemeron.ml:290:6>>*/ var
-          _am_ =  /*<<ephemeron.ml:290:6>>*/ caml_call3(H[5], c, key, info);
-          /*<<ephemeron.ml:302:8>>*/ return _am_;
+          _an_ =  /*<<ephemeron.ml:290:6>>*/ caml_call3(H[5], c, key, info);
+          /*<<ephemeron.ml:302:8>>*/ return _an_;
         }
         var param = next;
        }
@@ -30807,23 +30794,23 @@
         var next$0 = param[3], param = next$0;
       }
      }
-     catch(_ap_){
-      var _an_ = caml_wrap_exception(_ap_);
-      if(_an_ !== Stdlib[8]) throw caml_maybe_attach_backtrace(_an_, 0);
+     catch(_aq_){
+      var _ao_ = caml_wrap_exception(_aq_);
+      if(_ao_ !== Stdlib[8]) throw caml_maybe_attach_backtrace(_ao_, 0);
        /*<<ephemeron.ml:304:24>>*/  /*<<ephemeron.ml:304:24>>*/ var
        container =  /*<<ephemeron.ml:304:24>>*/ caml_call2(H[1], key, info);
        /*<<ephemeron.ml:305:8>>*/ caml_check_bound(h[2], i)[1 + i] = [0, hkey, container, l];
       h[1] = h[1] + 1 | 0;
-      var _ao_ = h[2].length - 1 << 1 < h[1] ? 1 : 0;
-      return _ao_ ? resize(h) : _ao_;
+      var _ap_ = h[2].length - 1 << 1 < h[1] ? 1 : 0;
+      return _ap_ ? resize(h) : _ap_;
      }
      /*<<ephemeron.ml:307:59>>*/ }
     function mem(h, key){
       /*<<ephemeron.ml:310:6>>*/ var
        /*<<ephemeron.ml:310:17>>*/ hkey =
          /*<<ephemeron.ml:310:17>>*/ caml_call2(H[2], h[3], key),
-       /*<<ephemeron.ml:320:28>>*/ _al_ = key_index(h, hkey),
-      param = caml_check_bound(h[2], _al_)[1 + _al_];
+       /*<<ephemeron.ml:320:28>>*/ _am_ = key_index(h, hkey),
+      param = caml_check_bound(h[2], _am_)[1 + _am_];
       /*<<ephemeron.ml:311:30>>*/ for(;;){
       if(! param)  /*<<ephemeron.ml:313:10>>*/ return 0;
       var hk = param[1], rest = param[3], c = param[2];
@@ -30851,21 +30838,21 @@
      }
     }
     function stats(h){
-      /*<<ephemeron.ml:329:6>>*/ var _af_ = h[2], _ag_ = 0;
-     function _ah_(m, b){
+      /*<<ephemeron.ml:329:6>>*/ var _ag_ = h[2], _ah_ = 0;
+     function _ai_(m, b){
        /*<<ephemeron.ml:330:36>>*/  /*<<ephemeron.ml:330:46>>*/ var
-       _ak_ = bucket_length(0, b);
+       _al_ = bucket_length(0, b);
        /*<<ephemeron.ml:330:46>>*/ return  /*<<ephemeron.ml:330:46>>*/ caml_call2
-              (Stdlib_Int[11], m, _ak_);
+              (Stdlib_Int[11], m, _al_);
       /*<<ephemeron.ml:330:65>>*/ }
       /*<<ephemeron.ml:330:8>>*/ var
        /*<<ephemeron.ml:330:8>>*/ mbl =
          /*<<ephemeron.ml:330:8>>*/ caml_call3
-         (Stdlib_Array[15], _ah_, _ag_, _af_),
+         (Stdlib_Array[15], _ai_, _ah_, _ag_),
        /*<<ephemeron.ml:331:18>>*/ histo =
          /*<<ephemeron.ml:331:18>>*/ caml_make_vect(mbl + 1 | 0, 0),
-       /*<<ephemeron.ml:332:6>>*/ _ai_ = h[2];
-     function _aj_(b){
+       /*<<ephemeron.ml:332:6>>*/ _aj_ = h[2];
+     function _ak_(b){
        /*<<ephemeron.ml:334:11>>*/  /*<<ephemeron.ml:334:19>>*/ var
        l = bucket_length(0, b);
        /*<<ephemeron.ml:335:11>>*/ histo[1 + l] =
@@ -30873,7 +30860,7 @@
        /*<<ephemeron.ml:335:11>>*/ return 0;
       /*<<ephemeron.ml:335:37>>*/ }
       /*<<ephemeron.ml:332:6>>*/  /*<<ephemeron.ml:332:6>>*/ caml_call2
-      (Stdlib_Array[11], _aj_, _ai_);
+      (Stdlib_Array[11], _ak_, _aj_);
       /*<<ephemeron.ml:337:6>>*/ return [0, h[1], h[2].length - 1, mbl, histo];
      /*<<ephemeron.ml:340:34>>*/ }
     function bucket_length_alive(accu, param){
@@ -30891,22 +30878,22 @@
     function stats_alive(h){
       /*<<ephemeron.ml:349:6>>*/ var
        /*<<ephemeron.ml:349:17>>*/ size = [0, 0],
-       /*<<ephemeron.ml:350:6>>*/ _$_ = h[2],
-      _aa_ = 0;
-     function _ab_(m, b){
+       /*<<ephemeron.ml:350:6>>*/ _aa_ = h[2],
+      _ab_ = 0;
+     function _ac_(m, b){
        /*<<ephemeron.ml:352:22>>*/  /*<<ephemeron.ml:352:32>>*/ var
-       _ae_ = bucket_length_alive(0, b);
+       _af_ = bucket_length_alive(0, b);
        /*<<ephemeron.ml:352:32>>*/ return  /*<<ephemeron.ml:352:32>>*/ caml_call2
-              (Stdlib_Int[11], m, _ae_);
+              (Stdlib_Int[11], m, _af_);
       /*<<ephemeron.ml:352:57>>*/ }
       /*<<ephemeron.ml:351:8>>*/ var
        /*<<ephemeron.ml:351:8>>*/ mbl =
          /*<<ephemeron.ml:351:8>>*/ caml_call3
-         (Stdlib_Array[15], _ab_, _aa_, _$_),
+         (Stdlib_Array[15], _ac_, _ab_, _aa_),
        /*<<ephemeron.ml:354:18>>*/ histo =
          /*<<ephemeron.ml:354:18>>*/ caml_make_vect(mbl + 1 | 0, 0),
-       /*<<ephemeron.ml:355:6>>*/ _ac_ = h[2];
-     function _ad_(b){
+       /*<<ephemeron.ml:355:6>>*/ _ad_ = h[2];
+     function _ae_(b){
        /*<<ephemeron.ml:357:11>>*/  /*<<ephemeron.ml:357:19>>*/ var
        l = bucket_length_alive(0, b);
       size[1] = size[1] + l | 0;
@@ -30915,7 +30902,7 @@
        /*<<ephemeron.ml:359:11>>*/ return 0;
       /*<<ephemeron.ml:359:37>>*/ }
       /*<<ephemeron.ml:355:6>>*/  /*<<ephemeron.ml:355:6>>*/ caml_call2
-      (Stdlib_Array[11], _ad_, _ac_);
+      (Stdlib_Array[11], _ae_, _ad_);
       /*<<ephemeron.ml:361:6>>*/ return [0,
              size[1],
              h[2].length - 1,
@@ -30923,20 +30910,20 @@
              histo];
      /*<<ephemeron.ml:364:34>>*/ }
     function add_seq(tbl, i){
-     function ___(param){
+     function _$_(param){
        /*<<ephemeron.ml:367:15>>*/ var v = param[2], k = param[1];
        /*<<ephemeron.ml:367:29>>*/ return add(tbl, k, v);
       /*<<ephemeron.ml:367:41>>*/ }
       /*<<ephemeron.ml:367:6>>*/ return  /*<<ephemeron.ml:367:6>>*/ caml_call2
-             (Stdlib_Seq[4], ___, i);
+             (Stdlib_Seq[4], _$_, i);
      /*<<ephemeron.ml:367:43>>*/ }
     function replace_seq(tbl, i){
-     function _Z_(param){
+     function ___(param){
        /*<<ephemeron.ml:370:15>>*/ var v = param[2], k = param[1];
        /*<<ephemeron.ml:370:29>>*/ return replace(tbl, k, v);
       /*<<ephemeron.ml:370:45>>*/ }
       /*<<ephemeron.ml:370:6>>*/ return  /*<<ephemeron.ml:370:6>>*/ caml_call2
-             (Stdlib_Seq[4], _Z_, i);
+             (Stdlib_Seq[4], ___, i);
      /*<<ephemeron.ml:370:47>>*/ }
     function of_seq(i){
       /*<<ephemeron.ml:373:6>>*/  /*<<ephemeron.ml:373:16>>*/ var
@@ -30975,7 +30962,7 @@
    function set_key(t, k){
      /*<<ephemeron.ml:397:44>>*/  /*<<ephemeron.ml:397:44>>*/ caml_call3
      (Stdlib_Obj[24][5], t, 0, k);
-     /*<<ephemeron.ml:397:44>>*/ return sentinal;
+     /*<<ephemeron.ml:397:44>>*/ return _d_;
     /*<<ephemeron.ml:397:75>>*/ }
    function check_key(t){
      /*<<ephemeron.ml:398:39>>*/ return  /*<<ephemeron.ml:398:39>>*/ caml_call2
@@ -31061,10 +31048,10 @@
      replace_seq = include[15],
      clean = include[17],
      stats_alive = include[18],
-     _Y_ = include[1];
+     _Z_ = include[1];
     function create(sz){
       /*<<ephemeron.ml:448:20>>*/ return  /*<<ephemeron.ml:448:20>>*/ caml_call2
-             (_Y_, _a_, sz);
+             (_Z_, _a_, sz);
      /*<<ephemeron.ml:448:43>>*/ }
     function of_seq(i){
       /*<<ephemeron.ml:450:6>>*/  /*<<ephemeron.ml:450:16>>*/ var
@@ -31097,8 +31084,8 @@
      /*<<ephemeron.ml:459:18>>*/ return [0, 0];
     /*<<ephemeron.ml:459:24>>*/ }
    function add(b, k, d){
-     /*<<ephemeron.ml:460:20>>*/ var _X_ = b[1];
-    b[1] = [0, make(k, d), _X_];
+     /*<<ephemeron.ml:460:20>>*/ var _Y_ = b[1];
+    b[1] = [0, make(k, d), _Y_];
     return 0;
     /*<<ephemeron.ml:460:42>>*/ }
    function test_key(k, e){
@@ -31127,13 +31114,13 @@
     }
     /*<<ephemeron.ml:474:16>>*/ }
    function find(b, k){
-     /*<<ephemeron.ml:477:6>>*/ var _U_ = b[1];
-     /*<<ephemeron.ml:477:26>>*/ function _V_(_W_){
-      /*<<?>>*/ return test_key(k, _W_);
+     /*<<ephemeron.ml:477:6>>*/ var _V_ = b[1];
+     /*<<ephemeron.ml:477:26>>*/ function _W_(_X_){
+      /*<<?>>*/ return test_key(k, _X_);
     }
      /*<<ephemeron.ml:477:12>>*/  /*<<ephemeron.ml:477:12>>*/ var
      match =
-        /*<<ephemeron.ml:477:12>>*/ caml_call2(Stdlib_List[39], _V_, _U_);
+        /*<<ephemeron.ml:477:12>>*/ caml_call2(Stdlib_List[39], _W_, _V_);
     if(! match)  /*<<ephemeron.ml:479:16>>*/ return 0;
     var e = match[1];
      /*<<ephemeron.ml:478:18>>*/ return get_data(e);
@@ -31156,7 +31143,7 @@
    function set_key1(t, k){
      /*<<ephemeron.ml:495:4>>*/  /*<<ephemeron.ml:495:4>>*/ caml_call3
      (Stdlib_Obj[24][5], t, 0, k);
-     /*<<ephemeron.ml:495:4>>*/ return sentinal;
+     /*<<ephemeron.ml:495:4>>*/ return _d_;
     /*<<ephemeron.ml:495:35>>*/ }
    function get_key2(t){
      /*<<ephemeron.ml:498:49>>*/ return  /*<<ephemeron.ml:498:57>>*/ caml_call2
@@ -31165,7 +31152,7 @@
    function set_key2(t, k){
      /*<<ephemeron.ml:500:4>>*/  /*<<ephemeron.ml:500:4>>*/ caml_call3
      (Stdlib_Obj[24][5], t, 1, k);
-     /*<<ephemeron.ml:500:4>>*/ return sentinal;
+     /*<<ephemeron.ml:500:4>>*/ return _d_;
     /*<<ephemeron.ml:500:35>>*/ }
    function get_data$0(t){
      /*<<ephemeron.ml:503:48>>*/ return  /*<<ephemeron.ml:503:56>>*/ caml_call1
@@ -31210,11 +31197,11 @@
       /*<<ephemeron.ml:539:33>>*/ var
       k2 = param[2],
       k1 = param[1],
-       /*<<ephemeron.ml:539:33>>*/ _T_ =
+       /*<<ephemeron.ml:539:33>>*/ _U_ =
          /*<<ephemeron.ml:539:33>>*/ caml_call2(H2[2], seed, k2) * 65599 | 0;
       /*<<ephemeron.ml:539:8>>*/ return  /*<<ephemeron.ml:539:8>>*/ caml_call2
              (H1[2], seed, k1)
-            + _T_
+            + _U_
             | 0;
     }
     function equal(c, param){
@@ -31243,11 +31230,11 @@
     }
     function check_key(c){
       /*<<ephemeron.ml:551:24>>*/  /*<<ephemeron.ml:496:45>>*/ var
-      _S_ =  /*<<ephemeron.ml:496:45>>*/ caml_call2(Stdlib_Obj[24][7], c, 0);
-      /*<<ephemeron.ml:551:24>>*/ return _S_
+      _T_ =  /*<<ephemeron.ml:496:45>>*/ caml_call2(Stdlib_Obj[24][7], c, 0);
+      /*<<ephemeron.ml:551:24>>*/ return _T_
              ?  /*<<ephemeron.ml:501:45>>*/ caml_call2
                (Stdlib_Obj[24][7], c, 1)
-             : _S_;
+             : _T_;
      /*<<ephemeron.ml:551:52>>*/ }
      /*<<ephemeron.ml:530:28>>*/ return MakeSeeded
             ([0,
@@ -31266,13 +31253,13 @@
      /*<<ephemeron.ml:566:52>>*/ }
      /*<<ephemeron.ml:563:9>>*/ var
      equal$0 = H1[1],
-      /*<<ephemeron.ml:563:9>>*/ _Q_ = [0, equal, seeded_hash];
+      /*<<ephemeron.ml:563:9>>*/ _R_ = [0, equal, seeded_hash];
     function seeded_hash$0(seed, x){
       /*<<ephemeron.ml:561:43>>*/ return  /*<<ephemeron.ml:561:43>>*/ caml_call1
              (H1[2], x);
      /*<<ephemeron.ml:561:52>>*/ }
     var
-     include = MakeSeeded$1([0, equal$0, seeded_hash$0], _Q_),
+     include = MakeSeeded$1([0, equal$0, seeded_hash$0], _R_),
      clear = include[2],
      reset = include[3],
      copy = include[4],
@@ -31289,10 +31276,10 @@
      replace_seq = include[15],
      clean = include[17],
      stats_alive = include[18],
-     _R_ = include[1];
+     _S_ = include[1];
     function create(sz){
       /*<<ephemeron.ml:568:20>>*/ return  /*<<ephemeron.ml:568:20>>*/ caml_call2
-             (_R_, _b_, sz);
+             (_S_, _b_, sz);
      /*<<ephemeron.ml:568:43>>*/ }
     function of_seq(i){
       /*<<ephemeron.ml:570:6>>*/  /*<<ephemeron.ml:570:16>>*/ var
@@ -31325,8 +31312,8 @@
      /*<<ephemeron.ml:579:18>>*/ return [0, 0];
     /*<<ephemeron.ml:579:24>>*/ }
    function add$0(b, k1, k2, d){
-     /*<<ephemeron.ml:580:24>>*/ var _P_ = b[1];
-    b[1] = [0, make$1(k1, k2, d), _P_];
+     /*<<ephemeron.ml:580:24>>*/ var _Q_ = b[1];
+    b[1] = [0, make$1(k1, k2, d), _Q_];
     return 0;
     /*<<ephemeron.ml:580:50>>*/ }
    function test_keys(k1, k2, e){
@@ -31356,13 +31343,13 @@
     }
     /*<<ephemeron.ml:594:16>>*/ }
    function find$0(b, k1, k2){
-     /*<<ephemeron.ml:597:6>>*/ var _M_ = b[1];
-     /*<<ephemeron.ml:597:26>>*/ function _N_(_O_){
-      /*<<?>>*/ return test_keys(k1, k2, _O_);
+     /*<<ephemeron.ml:597:6>>*/ var _N_ = b[1];
+     /*<<ephemeron.ml:597:26>>*/ function _O_(_P_){
+      /*<<?>>*/ return test_keys(k1, k2, _P_);
     }
      /*<<ephemeron.ml:597:12>>*/  /*<<ephemeron.ml:597:12>>*/ var
      match =
-        /*<<ephemeron.ml:597:12>>*/ caml_call2(Stdlib_List[39], _N_, _M_);
+        /*<<ephemeron.ml:597:12>>*/ caml_call2(Stdlib_List[39], _O_, _N_);
     if(! match)  /*<<ephemeron.ml:599:16>>*/ return 0;
     var e = match[1];
      /*<<ephemeron.ml:598:18>>*/ return get_data$0(e);
@@ -31389,7 +31376,7 @@
    function set_key$0(t, n, k){
      /*<<ephemeron.ml:616:4>>*/  /*<<ephemeron.ml:616:4>>*/ caml_call3
      (Stdlib_Obj[24][5], t, n, k);
-     /*<<ephemeron.ml:616:4>>*/ return sentinal;
+     /*<<ephemeron.ml:616:4>>*/ return _d_;
     /*<<ephemeron.ml:616:35>>*/ }
    function get_data$1(t){
      /*<<ephemeron.ml:619:43>>*/ return  /*<<ephemeron.ml:619:51>>*/ caml_call1
@@ -31405,17 +31392,17 @@
       /*<<ephemeron.ml:625:14>>*/ eph = create$1(l);
      /*<<ephemeron.ml:626:4>>*/ set_data$1(eph, data);
      /*<<ephemeron.ml:626:4>>*/ var
-     _K_ = l - 1 | 0,
-      /*<<ephemeron.ml:626:4>>*/ _J_ = 0;
-    if(_K_ >= 0){
-     var i = _J_;
+     _L_ = l - 1 | 0,
+      /*<<ephemeron.ml:626:4>>*/ _K_ = 0;
+    if(_L_ >= 0){
+     var i = _K_;
      for(;;){
        /*<<ephemeron.ml:627:26>>*/ set_key$0
        (eph, i, caml_check_bound(keys, i)[1 + i]);
        /*<<ephemeron.ml:627:26>>*/  /*<<ephemeron.ml:627:26>>*/ var
-       _L_ = i + 1 | 0;
-      if(_K_ === i) break;
-      var i = _L_;
+       _M_ = i + 1 | 0;
+      if(_L_ === i) break;
+      var i = _M_;
      }
     }
      /*<<ephemeron.ml:628:4>>*/ return eph;
@@ -31428,10 +31415,10 @@
        /*<<ephemeron.ml:633:37>>*/ throw  /*<<ephemeron.ml:633:37>>*/ caml_maybe_attach_backtrace
              (Stdlib[3], 1);
       /*<<ephemeron.ml:631:12>>*/ var
-       /*<<ephemeron.ml:631:12>>*/ _F_ = l - 1 | 0,
-       /*<<ephemeron.ml:634:6>>*/ _E_ = 0;
-     if(_F_ >= 0){
-      var i = _E_;
+       /*<<ephemeron.ml:631:12>>*/ _G_ = l - 1 | 0,
+       /*<<ephemeron.ml:634:6>>*/ _F_ = 0;
+     if(_G_ >= 0){
+      var i = _F_;
       for(;;){
         /*<<ephemeron.ml:635:14>>*/  /*<<ephemeron.ml:635:14>>*/ var
         match = get_key$0(eph, i);
@@ -31443,19 +31430,19 @@
          /*<<ephemeron.ml:638:20>>*/ throw  /*<<ephemeron.ml:638:20>>*/ caml_maybe_attach_backtrace
                (Stdlib[3], 1);
         /*<<ephemeron.ml:634:6>>*/  /*<<ephemeron.ml:634:6>>*/ var
-        _H_ = i + 1 | 0;
-       if(_F_ === i) break;
-       var i = _H_;
+        _I_ = i + 1 | 0;
+       if(_G_ === i) break;
+       var i = _I_;
       }
      }
       /*<<ephemeron.ml:640:6>>*/  /*<<ephemeron.ml:640:6>>*/ var
-      _G_ = get_data$1(eph);
-      /*<<ephemeron.ml:640:6>>*/ return _G_;
+      _H_ = get_data$1(eph);
+      /*<<ephemeron.ml:640:6>>*/ return _H_;
     }
-    catch(_I_){
-     var _D_ = caml_wrap_exception(_I_);
-     if(_D_ === Stdlib[3])  /*<<ephemeron.ml:641:17>>*/ return 0;
-     throw caml_maybe_attach_backtrace(_D_, 0);
+    catch(_J_){
+     var _E_ = caml_wrap_exception(_J_);
+     if(_E_ === Stdlib[3])  /*<<ephemeron.ml:641:17>>*/ return 0;
+     throw caml_maybe_attach_backtrace(_E_, 0);
     }
     /*<<ephemeron.ml:641:21>>*/ }
    function MakeSeeded$2(H){
@@ -31464,17 +31451,17 @@
       c = create$1(k.length - 1);
       /*<<ephemeron.ml:649:8>>*/ set_data$1(c, d);
       /*<<ephemeron.ml:649:8>>*/ var
-      _B_ = k.length - 1 - 1 | 0,
-       /*<<ephemeron.ml:649:8>>*/ _A_ = 0;
-     if(_B_ >= 0){
-      var i = _A_;
+      _C_ = k.length - 1 - 1 | 0,
+       /*<<ephemeron.ml:649:8>>*/ _B_ = 0;
+     if(_C_ >= 0){
+      var i = _B_;
       for(;;){
         /*<<ephemeron.ml:651:10>>*/ set_key$0
         (c, i, caml_check_bound(k, i)[1 + i]);
         /*<<ephemeron.ml:651:10>>*/  /*<<ephemeron.ml:651:10>>*/ var
-        _C_ = i + 1 | 0;
-       if(_B_ === i) break;
-       var i = _C_;
+        _D_ = i + 1 | 0;
+       if(_C_ === i) break;
+       var i = _D_;
       }
      }
       /*<<ephemeron.ml:653:8>>*/ return c;
@@ -31482,22 +31469,22 @@
     function seeded_hash(seed, k){
       /*<<ephemeron.ml:655:8>>*/ var
        /*<<ephemeron.ml:655:16>>*/ h = [0, 0],
-      _w_ = k.length - 1 - 1 | 0,
-       /*<<ephemeron.ml:655:16>>*/ _v_ = 0;
-     if(_w_ >= 0){
-      var i = _v_;
+      _x_ = k.length - 1 - 1 | 0,
+       /*<<ephemeron.ml:655:16>>*/ _w_ = 0;
+     if(_x_ >= 0){
+      var i = _w_;
       for(;;){
         /*<<ephemeron.ml:657:34>>*/ var
-        _x_ = h[1],
-         /*<<ephemeron.ml:657:34>>*/ _y_ = caml_check_bound(k, i)[1 + i];
+        _y_ = h[1],
+         /*<<ephemeron.ml:657:34>>*/ _z_ = caml_check_bound(k, i)[1 + i];
        h[1] =
-        ( /*<<ephemeron.ml:657:15>>*/ caml_call2(H[2], seed, _y_) * 65599 | 0)
-        + _x_
+        ( /*<<ephemeron.ml:657:15>>*/ caml_call2(H[2], seed, _z_) * 65599 | 0)
+        + _y_
         | 0;
         /*<<ephemeron.ml:656:8>>*/  /*<<ephemeron.ml:656:8>>*/ var
-        _z_ = i + 1 | 0;
-       if(_w_ === i) break;
-       var i = _z_;
+        _A_ = i + 1 | 0;
+       if(_x_ === i) break;
+       var i = _A_;
       }
      }
      return h[1];
@@ -31517,9 +31504,9 @@
       if(! match)  /*<<ephemeron.ml:669:24>>*/ return 2;
        /*<<ephemeron.ml:671:29>>*/ var
        ki = match[1],
-        /*<<ephemeron.ml:671:29>>*/ _u_ = caml_check_bound(k, i)[1 + i];
+        /*<<ephemeron.ml:671:29>>*/ _v_ = caml_check_bound(k, i)[1 + i];
        /*<<ephemeron.ml:671:21>>*/ if
-       (!  /*<<ephemeron.ml:671:21>>*/ caml_call2(H[1], _u_, ki))
+       (!  /*<<ephemeron.ml:671:21>>*/ caml_call2(H[1], _v_, ki))
         /*<<ephemeron.ml:673:23>>*/ return 1;
        /*<<ephemeron.ml:672:23>>*/ var
         /*<<ephemeron.ml:672:23>>*/ i$0 = i - 1 | 0,
@@ -31530,17 +31517,17 @@
       /*<<ephemeron.ml:678:8>>*/  /*<<ephemeron.ml:621:40>>*/ caml_call1
       (Stdlib_Obj[24][12], c);
       /*<<ephemeron.ml:678:8>>*/ var
-      _s_ = k.length - 1 - 1 | 0,
-       /*<<ephemeron.ml:678:8>>*/ _r_ = 0;
-     if(_s_ >= 0){
-      var i = _r_;
+      _t_ = k.length - 1 - 1 | 0,
+       /*<<ephemeron.ml:678:8>>*/ _s_ = 0;
+     if(_t_ >= 0){
+      var i = _s_;
       for(;;){
         /*<<ephemeron.ml:680:10>>*/ set_key$0
         (c, i, caml_check_bound(k, i)[1 + i]);
         /*<<ephemeron.ml:680:10>>*/  /*<<ephemeron.ml:680:10>>*/ var
-        _t_ = i + 1 | 0;
-       if(_s_ === i) break;
-       var i = _t_;
+        _u_ = i + 1 | 0;
+       if(_t_ === i) break;
+       var i = _u_;
       }
      }
       /*<<ephemeron.ml:682:8>>*/ return set_data$1(c, d);
@@ -31550,19 +31537,19 @@
        /*<<ephemeron.ml:686:17>>*/ i$1 = length$1(c) - 1 | 0,
       i = i$1;
       /*<<ephemeron.ml:685:10>>*/ for(;;){
-      var _p_ = i < 0 ? 1 : 0;
-      if(_p_)
-       var _q_ = _p_;
+      var _q_ = i < 0 ? 1 : 0;
+      if(_q_)
+       var _r_ = _q_;
       else{
         /*<<ephemeron.ml:617:47>>*/  /*<<ephemeron.ml:617:47>>*/ var
-        _o_ =  /*<<ephemeron.ml:617:47>>*/ caml_call2(Stdlib_Obj[24][7], c, i);
-        /*<<ephemeron.ml:685:20>>*/ if(_o_){
+        _p_ =  /*<<ephemeron.ml:617:47>>*/ caml_call2(Stdlib_Obj[24][7], c, i);
+        /*<<ephemeron.ml:685:20>>*/ if(_p_){
         var i$0 = i - 1 | 0, i = i$0;
         continue;
        }
-       var _q_ = _o_;
+       var _r_ = _p_;
       }
-      return _q_;
+      return _r_;
      }
      /*<<ephemeron.ml:686:30>>*/ }
      /*<<ephemeron.ml:644:28>>*/ return MakeSeeded
@@ -31598,10 +31585,10 @@
      replace_seq = include[15],
      clean = include[17],
      stats_alive = include[18],
-     _n_ = include[1];
+     _o_ = include[1];
     function create(sz){
       /*<<ephemeron.ml:696:20>>*/ return  /*<<ephemeron.ml:696:20>>*/ caml_call2
-             (_n_, _c_, sz);
+             (_o_, _c_, sz);
      /*<<ephemeron.ml:696:43>>*/ }
     function of_seq(i){
       /*<<ephemeron.ml:698:6>>*/  /*<<ephemeron.ml:698:16>>*/ var
@@ -31634,8 +31621,8 @@
      /*<<ephemeron.ml:707:18>>*/ return [0, 0];
     /*<<ephemeron.ml:707:24>>*/ }
    function add$1(b, k, d){
-     /*<<ephemeron.ml:708:20>>*/ var _m_ = b[1];
-    b[1] = [0, make$3(k, d), _m_];
+     /*<<ephemeron.ml:708:20>>*/ var _n_ = b[1];
+    b[1] = [0, make$3(k, d), _n_];
     return 0;
     /*<<ephemeron.ml:708:42>>*/ }
    function test_keys$0(k, e){
@@ -31644,10 +31631,10 @@
        /*<<ephemeron.ml:712:43>>*/ throw  /*<<ephemeron.ml:712:43>>*/ caml_maybe_attach_backtrace
              (Stdlib[3], 1);
       /*<<ephemeron.ml:713:8>>*/ var
-      _i_ = k.length - 1 - 1 | 0,
-       /*<<ephemeron.ml:713:8>>*/ _h_ = 0;
-     if(_i_ >= 0){
-      var i = _h_;
+      _j_ = k.length - 1 - 1 | 0,
+       /*<<ephemeron.ml:713:8>>*/ _i_ = 0;
+     if(_j_ >= 0){
+      var i = _i_;
       for(;;){
         /*<<ephemeron.ml:714:16>>*/  /*<<ephemeron.ml:714:16>>*/ var
         match = get_key$0(e, i);
@@ -31655,9 +31642,9 @@
         var x = match[1];
         if(x === caml_check_bound(k, i)[1 + i]){
           /*<<ephemeron.ml:713:8>>*/  /*<<ephemeron.ml:713:8>>*/ var
-          _k_ = i + 1 | 0;
-         if(_i_ === i) break;
-         var i = _k_;
+          _l_ = i + 1 | 0;
+         if(_j_ === i) break;
+         var i = _l_;
          continue;
         }
        }
@@ -31665,13 +31652,13 @@
               (Stdlib[3], 1);
       }
      }
-      /*<<ephemeron.ml:718:8>>*/  /*<<ephemeron.ml:718:8>>*/ var _j_ = 1;
-      /*<<ephemeron.ml:718:8>>*/ return _j_;
+      /*<<ephemeron.ml:718:8>>*/  /*<<ephemeron.ml:718:8>>*/ var _k_ = 1;
+      /*<<ephemeron.ml:718:8>>*/ return _k_;
     }
-    catch(_l_){
-     var _g_ = caml_wrap_exception(_l_);
-     if(_g_ === Stdlib[3])  /*<<ephemeron.ml:719:19>>*/ return 0;
-     throw caml_maybe_attach_backtrace(_g_, 0);
+    catch(_m_){
+     var _h_ = caml_wrap_exception(_m_);
+     if(_h_ === Stdlib[3])  /*<<ephemeron.ml:719:19>>*/ return 0;
+     throw caml_maybe_attach_backtrace(_h_, 0);
     }
     /*<<ephemeron.ml:719:24>>*/ }
    function remove$1(b, k){
@@ -31691,13 +31678,13 @@
     }
     /*<<ephemeron.ml:728:16>>*/ }
    function find$1(b, k){
-     /*<<ephemeron.ml:731:6>>*/ var _d_ = b[1];
-     /*<<ephemeron.ml:731:26>>*/ function _e_(_f_){
-      /*<<?>>*/ return test_keys$0(k, _f_);
+     /*<<ephemeron.ml:731:6>>*/ var _e_ = b[1];
+     /*<<ephemeron.ml:731:26>>*/ function _f_(_g_){
+      /*<<?>>*/ return test_keys$0(k, _g_);
     }
      /*<<ephemeron.ml:731:12>>*/  /*<<ephemeron.ml:731:12>>*/ var
      match =
-        /*<<ephemeron.ml:731:12>>*/ caml_call2(Stdlib_List[39], _e_, _d_);
+        /*<<ephemeron.ml:731:12>>*/ caml_call2(Stdlib_List[39], _f_, _e_);
     if(! match)  /*<<ephemeron.ml:733:16>>*/ return 0;
     var e = match[1];
      /*<<ephemeron.ml:732:18>>*/ return get_data$1(e);
@@ -31784,7 +31771,7 @@
             : runtime.caml_call_gen(f, [a0, a1, a2, a3]);
    }
    var
-    sentinal = undefined,
+    _l_ = undefined,
     global_data = runtime.caml_get_global_data(),
     cst$18 = cst$19,
     cst$17 = cst$19,
@@ -31920,39 +31907,39 @@
     /*<<filename.ml:96:34>>*/ }
    function is_relative(n){
      /*<<filename.ml:97:22>>*/ var
-     _aH_ = caml_ml_string_length(n) < 1 ? 1 : 0,
-     _aI_ =
-       _aH_
+     _aI_ = caml_ml_string_length(n) < 1 ? 1 : 0,
+     _aJ_ =
+       _aI_
        || (47 !==  /*<<filename.ml:97:45>>*/ caml_string_get(n, 0) ? 1 : 0);
-    return _aI_;
+    return _aJ_;
     /*<<filename.ml:97:57>>*/ }
    function is_implicit(n){
      /*<<filename.ml:99:4>>*/  /*<<filename.ml:99:4>>*/ var
-     _aC_ = is_relative(n);
-     /*<<filename.ml:99:4>>*/ if(_aC_){
+     _aD_ = is_relative(n);
+     /*<<filename.ml:99:4>>*/ if(_aD_){
      var
-      _aD_ = caml_ml_string_length(n) < 2 ? 1 : 0,
-      _aE_ =
-        _aD_
+      _aE_ = caml_ml_string_length(n) < 2 ? 1 : 0,
+      _aF_ =
+        _aE_
         ||
           /*<<filename.ml:100:31>>*/ caml_string_notequal
           ( /*<<filename.ml:100:31>>*/ caml_call3(Stdlib_String[15], n, 0, 2),
            cst$27);
-      /*<<filename.ml:100:31>>*/ if(_aE_)
+      /*<<filename.ml:100:31>>*/ if(_aF_)
       var
-       _aF_ = caml_ml_string_length(n) < 3 ? 1 : 0,
-       _aG_ =
-         _aF_
+       _aG_ = caml_ml_string_length(n) < 3 ? 1 : 0,
+       _aH_ =
+         _aG_
          ||
            /*<<filename.ml:101:31>>*/ caml_string_notequal
            ( /*<<filename.ml:101:31>>*/ caml_call3(Stdlib_String[15], n, 0, 3),
             cst$28);
      else
-      var _aG_ = _aE_;
+      var _aH_ = _aF_;
     }
     else
-     var _aG_ = _aC_;
-     /*<<filename.ml:101:31>>*/ return _aG_;
+     var _aH_ = _aD_;
+     /*<<filename.ml:101:31>>*/ return _aH_;
     /*<<filename.ml:101:57>>*/ }
    function check_suffix(name, suff){
      /*<<filename.ml:103:4>>*/ return  /*<<filename.ml:103:4>>*/ caml_call2
@@ -31980,8 +31967,8 @@
         /*<<filename.ml:117:8>>*/ caml_sys_getenv("TMPDIR"),
      temp_dir_name = _k_;
    }
-   catch(_aB_){
-    var _a_ = caml_wrap_exception(_aB_);
+   catch(_aC_){
+    var _a_ = caml_wrap_exception(_aC_);
     if(_a_ !== Stdlib[8]) throw caml_maybe_attach_backtrace(_a_, 0);
     var temp_dir_name = cst_tmp;
    }
@@ -31993,10 +31980,10 @@
      /*<<filename.ml:19:2>>*/  /*<<filename.ml:19:2>>*/ caml_call2
      (Stdlib_Buffer[12], b, 39);
      /*<<filename.ml:19:2>>*/ var
-     _ay_ = l - 1 | 0,
-      /*<<filename.ml:19:2>>*/ _ax_ = 0;
-    if(_ay_ >= 0){
-     var i = _ax_;
+     _az_ = l - 1 | 0,
+      /*<<filename.ml:19:2>>*/ _ay_ = 0;
+    if(_az_ >= 0){
+     var i = _ay_;
      for(;;){
        /*<<filename.ml:21:7>>*/ if
        (39 ===  /*<<filename.ml:21:7>>*/ caml_string_get(s, i))
@@ -32004,14 +31991,14 @@
         (Stdlib_Buffer[16], b, quotequote);
       else{
         /*<<filename.ml:23:28>>*/  /*<<filename.ml:23:28>>*/ var
-        _aA_ =  /*<<filename.ml:23:28>>*/ caml_string_get(s, i);
+        _aB_ =  /*<<filename.ml:23:28>>*/ caml_string_get(s, i);
         /*<<filename.ml:23:9>>*/  /*<<filename.ml:23:9>>*/ caml_call2
-        (Stdlib_Buffer[12], b, _aA_);
+        (Stdlib_Buffer[12], b, _aB_);
       }
        /*<<filename.ml:23:9>>*/  /*<<filename.ml:23:9>>*/ var
-       _az_ = i + 1 | 0;
-      if(_ay_ === i) break;
-      var i = _az_;
+       _aA_ = i + 1 | 0;
+      if(_az_ === i) break;
+      var i = _aA_;
      }
     }
      /*<<filename.ml:25:2>>*/  /*<<filename.ml:25:2>>*/ caml_call2
@@ -32024,47 +32011,47 @@
      var f = stderr[1];
       /*<<filename.ml:123:51>>*/ if
       ( /*<<filename.ml:123:51>>*/ caml_equal(stderr, stdout))
-      var _am_ = cst_2_1;
+      var _an_ = cst_2_1;
      else
        /*<<filename.ml:125:61>>*/ var
-        /*<<filename.ml:125:61>>*/ _aw_ = quote(f),
-       _am_ =  /*<<filename.ml:125:53>>*/ caml_call2(Stdlib[28], cst_2, _aw_);
-     var _an_ = _am_;
+        /*<<filename.ml:125:61>>*/ _ax_ = quote(f),
+       _an_ =  /*<<filename.ml:125:53>>*/ caml_call2(Stdlib[28], cst_2, _ax_);
+     var _ao_ = _an_;
     }
     else
-     var _an_ = cst$4;
+     var _ao_ = cst$4;
     if(stdout)
       /*<<filename.ml:122:55>>*/ var
       f$0 = stdout[1],
-       /*<<filename.ml:122:55>>*/ _ao_ = quote(f$0),
-      _ap_ =  /*<<filename.ml:122:48>>*/ caml_call2(Stdlib[28], cst, _ao_);
+       /*<<filename.ml:122:55>>*/ _ap_ = quote(f$0),
+      _aq_ =  /*<<filename.ml:122:48>>*/ caml_call2(Stdlib[28], cst, _ap_);
     else
-     var _ap_ = cst$3;
+     var _aq_ = cst$3;
      /*<<filename.ml:122:6>>*/  /*<<filename.ml:122:6>>*/ var
-     _aq_ =  /*<<filename.ml:122:6>>*/ caml_call2(Stdlib[28], _ap_, _an_);
+     _ar_ =  /*<<filename.ml:122:6>>*/ caml_call2(Stdlib[28], _aq_, _ao_);
     if(stdin)
       /*<<filename.ml:121:55>>*/ var
       f$1 = stdin[1],
-       /*<<filename.ml:121:55>>*/ _ar_ = quote(f$1),
-      _as_ =  /*<<filename.ml:121:48>>*/ caml_call2(Stdlib[28], cst$0, _ar_);
+       /*<<filename.ml:121:55>>*/ _as_ = quote(f$1),
+      _at_ =  /*<<filename.ml:121:48>>*/ caml_call2(Stdlib[28], cst$0, _as_);
     else
-     var _as_ = cst$2;
+     var _at_ = cst$2;
      /*<<filename.ml:121:6>>*/ var
-      /*<<filename.ml:121:6>>*/ _at_ =
-        /*<<filename.ml:121:6>>*/ caml_call2(Stdlib[28], _as_, _aq_),
-      /*<<filename.ml:120:22>>*/ _au_ =
+      /*<<filename.ml:121:6>>*/ _au_ =
+        /*<<filename.ml:121:6>>*/ caml_call2(Stdlib[28], _at_, _ar_),
+      /*<<filename.ml:120:22>>*/ _av_ =
         /*<<filename.ml:120:22>>*/ caml_call2
         (Stdlib_List[19], quote, [0, cmd, args]),
-      /*<<filename.ml:120:4>>*/ _av_ =
-        /*<<filename.ml:120:4>>*/ caml_call2(Stdlib_String[6], cst$1, _au_);
+      /*<<filename.ml:120:4>>*/ _aw_ =
+        /*<<filename.ml:120:4>>*/ caml_call2(Stdlib_String[6], cst$1, _av_);
      /*<<filename.ml:121:6>>*/ return  /*<<filename.ml:121:6>>*/ caml_call2
-            (Stdlib[28], _av_, _at_);
+            (Stdlib[28], _aw_, _au_);
     /*<<filename.ml:125:69>>*/ }
-    /*<<filename.ml:126:17>>*/ function basename(_al_){
-     /*<<?>>*/ return generic_basename(is_dir_sep, current_dir_name, _al_);
+    /*<<filename.ml:126:17>>*/ function basename(_am_){
+     /*<<?>>*/ return generic_basename(is_dir_sep, current_dir_name, _am_);
    }
-    /*<<filename.ml:127:16>>*/ function dirname(_ak_){
-     /*<<?>>*/ return generic_dirname(is_dir_sep, current_dir_name, _ak_);
+    /*<<filename.ml:127:16>>*/ function dirname(_al_){
+     /*<<?>>*/ return generic_dirname(is_dir_sep, current_dir_name, _al_);
    }
     /*<<filename.ml:91:24>>*/  /*<<filename.ml:91:24>>*/ var
     Unix =
@@ -32087,96 +32074,96 @@
      /*<<filename.ml:135:23>>*/ var
       /*<<filename.ml:135:31>>*/ c =
         /*<<filename.ml:135:31>>*/ caml_string_get(s, i),
-     _ah_ = 47 === c ? 1 : 0;
-    if(_ah_)
-     var _ai_ = _ah_;
+     _ai_ = 47 === c ? 1 : 0;
+    if(_ai_)
+     var _aj_ = _ai_;
     else
-     var _aj_ = 92 === c ? 1 : 0, _ai_ = _aj_ || (58 === c ? 1 : 0);
-    return _ai_;
+     var _ak_ = 92 === c ? 1 : 0, _aj_ = _ak_ || (58 === c ? 1 : 0);
+    return _aj_;
     /*<<filename.ml:135:70>>*/ }
    function is_relative$0(n){
      /*<<filename.ml:137:4>>*/ var
-     _ab_ = caml_ml_string_length(n) < 1 ? 1 : 0,
-     _ac_ =
-       _ab_
+     _ac_ = caml_ml_string_length(n) < 1 ? 1 : 0,
+     _ad_ =
+       _ac_
        || (47 !==  /*<<filename.ml:137:28>>*/ caml_string_get(n, 0) ? 1 : 0);
-    if(_ac_){
+    if(_ad_){
      var
-      _ad_ = caml_ml_string_length(n) < 1 ? 1 : 0,
-      _ae_ =
-        _ad_
+      _ae_ = caml_ml_string_length(n) < 1 ? 1 : 0,
+      _af_ =
+        _ae_
         || (92 !==  /*<<filename.ml:138:31>>*/ caml_string_get(n, 0) ? 1 : 0);
-     if(_ae_)
+     if(_af_)
       var
-       _af_ = caml_ml_string_length(n) < 2 ? 1 : 0,
-       _ag_ =
-         _af_
+       _ag_ = caml_ml_string_length(n) < 2 ? 1 : 0,
+       _ah_ =
+         _ag_
          || (58 !==  /*<<filename.ml:139:31>>*/ caml_string_get(n, 1) ? 1 : 0);
      else
-      var _ag_ = _ae_;
+      var _ah_ = _af_;
     }
     else
-     var _ag_ = _ac_;
-    return _ag_;
+     var _ah_ = _ad_;
+    return _ah_;
     /*<<filename.ml:139:44>>*/ }
    function is_implicit$0(n){
      /*<<filename.ml:141:4>>*/  /*<<filename.ml:141:4>>*/ var
-     _U_ = is_relative$0(n);
-     /*<<filename.ml:141:4>>*/ if(_U_){
+     _V_ = is_relative$0(n);
+     /*<<filename.ml:141:4>>*/ if(_V_){
      var
-      _V_ = caml_ml_string_length(n) < 2 ? 1 : 0,
-      _W_ =
-        _V_
+      _W_ = caml_ml_string_length(n) < 2 ? 1 : 0,
+      _X_ =
+        _W_
         ||
           /*<<filename.ml:142:31>>*/ caml_string_notequal
           ( /*<<filename.ml:142:31>>*/ caml_call3(Stdlib_String[15], n, 0, 2),
            cst$27);
-      /*<<filename.ml:142:31>>*/ if(_W_){
+      /*<<filename.ml:142:31>>*/ if(_X_){
       var
-       _X_ = caml_ml_string_length(n) < 2 ? 1 : 0,
-       _Y_ =
-         _X_
+       _Y_ = caml_ml_string_length(n) < 2 ? 1 : 0,
+       _Z_ =
+         _Y_
          ||
            /*<<filename.ml:143:31>>*/ caml_string_notequal
            ( /*<<filename.ml:143:31>>*/ caml_call3(Stdlib_String[15], n, 0, 2),
             ".\\");
-       /*<<filename.ml:143:31>>*/ if(_Y_){
+       /*<<filename.ml:143:31>>*/ if(_Z_){
        var
-        _Z_ = caml_ml_string_length(n) < 3 ? 1 : 0,
-        ___ =
-          _Z_
+        ___ = caml_ml_string_length(n) < 3 ? 1 : 0,
+        _$_ =
+          ___
           ||
             /*<<filename.ml:144:31>>*/ caml_string_notequal
             ( /*<<filename.ml:144:31>>*/ caml_call3
               (Stdlib_String[15], n, 0, 3),
              cst$28);
-        /*<<filename.ml:144:31>>*/ if(___)
+        /*<<filename.ml:144:31>>*/ if(_$_)
         var
-         _$_ = caml_ml_string_length(n) < 3 ? 1 : 0,
-         _aa_ =
-           _$_
+         _aa_ = caml_ml_string_length(n) < 3 ? 1 : 0,
+         _ab_ =
+           _aa_
            ||
              /*<<filename.ml:145:31>>*/ caml_string_notequal
              ( /*<<filename.ml:145:31>>*/ caml_call3
                (Stdlib_String[15], n, 0, 3),
               "..\\");
        else
-        var _aa_ = ___;
+        var _ab_ = _$_;
       }
       else
-       var _aa_ = _Y_;
+       var _ab_ = _Z_;
      }
      else
-      var _aa_ = _W_;
+      var _ab_ = _X_;
     }
     else
-     var _aa_ = _U_;
-     /*<<filename.ml:145:31>>*/ return _aa_;
+     var _ab_ = _V_;
+     /*<<filename.ml:145:31>>*/ return _ab_;
     /*<<filename.ml:145:58>>*/ }
    function check_suffix$0(name, suff){
      /*<<filename.ml:147:3>>*/ var
-     _R_ = caml_ml_string_length(suff) <= caml_ml_string_length(name) ? 1 : 0;
-    if(_R_)
+     _S_ = caml_ml_string_length(suff) <= caml_ml_string_length(name) ? 1 : 0;
+    if(_S_)
       /*<<filename.ml:148:12>>*/ var
        /*<<filename.ml:148:12>>*/ s =
          /*<<filename.ml:148:12>>*/ caml_call3
@@ -32184,14 +32171,14 @@
           name,
           caml_ml_string_length(name) - caml_ml_string_length(suff) | 0,
           caml_ml_string_length(suff)),
-       /*<<filename.ml:150:31>>*/ _S_ =
+       /*<<filename.ml:150:31>>*/ _T_ =
          /*<<filename.ml:150:31>>*/ caml_call1(Stdlib_String[26], suff),
-      _T_ =
+      _U_ =
          /*<<filename.ml:150:4>>*/ caml_string_equal
-         ( /*<<filename.ml:150:4>>*/ caml_call1(Stdlib_String[26], s), _S_);
+         ( /*<<filename.ml:150:4>>*/ caml_call1(Stdlib_String[26], s), _T_);
     else
-     var _T_ = _R_;
-     /*<<filename.ml:150:4>>*/ return _T_;
+     var _U_ = _S_;
+     /*<<filename.ml:150:4>>*/ return _U_;
     /*<<filename.ml:150:59>>*/ }
    function chop_suffix_opt$0(suffix, filename){
      /*<<filename.ml:153:4>>*/ var
@@ -32202,11 +32189,11 @@
       /*<<filename.ml:155:14>>*/ r =
         /*<<filename.ml:155:14>>*/ caml_call3
         (Stdlib_String[15], filename, len_f - len_s | 0, len_s),
-      /*<<filename.ml:156:36>>*/ _Q_ =
+      /*<<filename.ml:156:36>>*/ _R_ =
         /*<<filename.ml:156:36>>*/ caml_call1(Stdlib_String[26], suffix);
      /*<<filename.ml:156:9>>*/ return  /*<<filename.ml:156:9>>*/ caml_string_equal
              ( /*<<filename.ml:156:9>>*/ caml_call1(Stdlib_String[26], r),
-              _Q_)
+              _R_)
             ? [0,
                /*<<filename.ml:157:13>>*/ caml_call3
                (Stdlib_String[15], filename, 0, len_f - len_s | 0)]
@@ -32218,8 +32205,8 @@
         /*<<filename.ml:165:8>>*/ caml_sys_getenv("TEMP"),
      temp_dir_name$0 = _j_;
    }
-   catch(_P_){
-    var _b_ = caml_wrap_exception(_P_);
+   catch(_Q_){
+    var _b_ = caml_wrap_exception(_Q_);
     if(_b_ !== Stdlib[8]) throw caml_maybe_attach_backtrace(_b_, 0);
     var temp_dir_name$0 = cst$5;
    }
@@ -32236,17 +32223,17 @@
       if(i$0 === l){
         /*<<filename.ml:171:20>>*/  /*<<filename.ml:171:20>>*/ caml_call2
         (Stdlib_Buffer[12], b, 34);
-        /*<<filename.ml:171:20>>*/ return sentinal;
+        /*<<filename.ml:171:20>>*/ return _l_;
       }
        /*<<filename.ml:172:12>>*/  /*<<filename.ml:172:12>>*/ var
        c =  /*<<filename.ml:172:12>>*/ caml_string_get(s, i$0);
       if(34 === c){
         /*<<filename.ml:173:16>>*/ loop_bs(0, i$0);
-        /*<<filename.ml:173:16>>*/ return sentinal;
+        /*<<filename.ml:173:16>>*/ return _l_;
       }
       if(92 === c){
         /*<<filename.ml:174:16>>*/ loop_bs(0, i$0);
-        /*<<filename.ml:174:16>>*/ return sentinal;
+        /*<<filename.ml:174:16>>*/ return _l_;
       }
        /*<<filename.ml:175:16>>*/  /*<<filename.ml:175:16>>*/ caml_call2
        (Stdlib_Buffer[12], b, c);
@@ -32262,7 +32249,7 @@
         /*<<filename.ml:178:8>>*/  /*<<filename.ml:178:8>>*/ caml_call2
         (Stdlib_Buffer[12], b, 34);
         /*<<filename.ml:178:8>>*/ add_bs(n$0);
-        /*<<filename.ml:178:8>>*/ return sentinal;
+        /*<<filename.ml:178:8>>*/ return _l_;
       }
        /*<<filename.ml:181:14>>*/  /*<<filename.ml:181:14>>*/ var
        match =  /*<<filename.ml:181:14>>*/ caml_string_get(s, i$0);
@@ -32271,12 +32258,12 @@
         /*<<filename.ml:182:34>>*/  /*<<filename.ml:182:34>>*/ caml_call2
         (Stdlib_Buffer[12], b, 34);
         /*<<filename.ml:182:34>>*/ loop(i$0 + 1 | 0);
-        /*<<filename.ml:182:34>>*/ return sentinal;
+        /*<<filename.ml:182:34>>*/ return _l_;
       }
       if(92 !== match){
         /*<<filename.ml:184:18>>*/ add_bs(n$0);
         /*<<filename.ml:184:18>>*/ loop(i$0);
-        /*<<filename.ml:184:18>>*/ return sentinal;
+        /*<<filename.ml:184:18>>*/ return _l_;
       }
        /*<<filename.ml:183:18>>*/ var
         /*<<filename.ml:183:18>>*/ i$1 = i$0 + 1 | 0,
@@ -32286,19 +32273,19 @@
      }
      /*<<filename.ml:185:9>>*/ }
     function add_bs(n){
-      /*<<filename.ml:186:19>>*/  /*<<filename.ml:186:19>>*/ var _N_ = 1;
+      /*<<filename.ml:186:19>>*/  /*<<filename.ml:186:19>>*/ var _O_ = 1;
      if(n >= 1){
-      var j = _N_;
+      var j = _O_;
       for(;;){
         /*<<filename.ml:186:38>>*/  /*<<filename.ml:186:38>>*/ caml_call2
         (Stdlib_Buffer[12], b, 92);
         /*<<filename.ml:186:38>>*/  /*<<filename.ml:186:38>>*/ var
-        _O_ = j + 1 | 0;
+        _P_ = j + 1 | 0;
        if(n === j) break;
-       var j = _O_;
+       var j = _P_;
       }
      }
-     return sentinal;
+     return _l_;
      /*<<filename.ml:186:66>>*/ }
      /*<<filename.ml:188:4>>*/ loop(0);
      /*<<filename.ml:188:4>>*/ return  /*<<filename.ml:188:4>>*/ caml_call1
@@ -32313,62 +32300,62 @@
       (!  /*<<filename.ml:224:12>>*/ caml_call2(Stdlib_String[14], f, 32))
        /*<<filename.ml:227:6>>*/ return f;
       /*<<filename.ml:225:13>>*/  /*<<filename.ml:225:13>>*/ var
-      _M_ =  /*<<filename.ml:225:13>>*/ caml_call2(Stdlib[28], f, cst$6);
+      _N_ =  /*<<filename.ml:225:13>>*/ caml_call2(Stdlib[28], f, cst$6);
       /*<<filename.ml:225:13>>*/ return  /*<<filename.ml:225:13>>*/ caml_call2
-             (Stdlib[28], cst$7, _M_);
+             (Stdlib[28], cst$7, _N_);
     }
      /*<<filename.ml:223:15>>*/  /*<<filename.ml:223:15>>*/ var
-     _L_ =
+     _M_ =
         /*<<filename.ml:223:15>>*/ caml_call2
         (Stdlib[28], cst_Filename_quote_command_bad, f);
      /*<<filename.ml:223:15>>*/ return  /*<<filename.ml:223:15>>*/ caml_call1
-            (Stdlib[2], _L_);
+            (Stdlib[2], _M_);
     /*<<filename.ml:227:7>>*/ }
    function quote_command$0(cmd, stdin, stdout, stderr, args){
      /*<<filename.ml:232:4>>*/ if(stderr){
      var f = stderr[1];
       /*<<filename.ml:240:43>>*/ if
       ( /*<<filename.ml:240:43>>*/ caml_equal(stderr, stdout))
-      var _x_ = cst_2_1$0;
+      var _y_ = cst_2_1$0;
      else
        /*<<filename.ml:242:53>>*/ var
-        /*<<filename.ml:242:53>>*/ _J_ = quote_cmd_filename(f),
-       _x_ =  /*<<filename.ml:242:45>>*/ caml_call2(Stdlib[28], cst_2$0, _J_);
-     var _y_ = _x_;
+        /*<<filename.ml:242:53>>*/ _K_ = quote_cmd_filename(f),
+       _y_ =  /*<<filename.ml:242:45>>*/ caml_call2(Stdlib[28], cst_2$0, _K_);
+     var _z_ = _y_;
     }
     else
-     var _y_ = cst$16;
-    var _z_ = [0, _y_, _c_];
+     var _z_ = cst$16;
+    var _A_ = [0, _z_, _c_];
     if(stdout)
       /*<<filename.ml:238:55>>*/ var
       f$0 = stdout[1],
-       /*<<filename.ml:238:55>>*/ _A_ = quote_cmd_filename(f$0),
-      _B_ =  /*<<filename.ml:238:48>>*/ caml_call2(Stdlib[28], cst$8, _A_);
+       /*<<filename.ml:238:55>>*/ _B_ = quote_cmd_filename(f$0),
+      _C_ =  /*<<filename.ml:238:48>>*/ caml_call2(Stdlib[28], cst$8, _B_);
     else
-     var _B_ = cst$15;
-    var _C_ = [0, _B_, _z_];
+     var _C_ = cst$15;
+    var _D_ = [0, _C_, _A_];
     if(stdin)
       /*<<filename.ml:237:55>>*/ var
       f$1 = stdin[1],
-       /*<<filename.ml:237:55>>*/ _D_ = quote_cmd_filename(f$1),
-      _E_ =  /*<<filename.ml:237:48>>*/ caml_call2(Stdlib[28], cst$9, _D_);
+       /*<<filename.ml:237:55>>*/ _E_ = quote_cmd_filename(f$1),
+      _F_ =  /*<<filename.ml:237:48>>*/ caml_call2(Stdlib[28], cst$9, _E_);
     else
-     var _E_ = cst$14;
+     var _F_ = cst$14;
      /*<<filename.ml:236:35>>*/ var
-      /*<<filename.ml:236:35>>*/ _G_ =
+      /*<<filename.ml:236:35>>*/ _H_ =
         /*<<filename.ml:236:35>>*/ caml_call2(Stdlib_List[19], quote$0, args),
       /*<<filename.ml:236:16>>*/ s =
-        /*<<filename.ml:236:16>>*/ caml_call2(Stdlib_String[6], cst$10, _G_),
+        /*<<filename.ml:236:16>>*/ caml_call2(Stdlib_String[6], cst$10, _H_),
       /*<<filename.ml:211:12>>*/ b =
         /*<<filename.ml:211:12>>*/ caml_call1
         (Stdlib_Buffer[1], caml_ml_string_length(s) + 20 | 0),
-     _F_ = [0, _E_, _C_];
-    function _w_(c){
+     _G_ = [0, _F_, _D_];
+    function _x_(c){
       /*<<filename.ml:214:8>>*/ a:
      {
       if(62 <= c){
-       var _K_ = c - 63 | 0;
-       if(60 < _K_ >>> 0){if(62 <= _K_) break a;} else if(31 !== _K_) break a;
+       var _L_ = c - 63 | 0;
+       if(60 < _L_ >>> 0){if(62 <= _L_) break a;} else if(31 !== _L_) break a;
       }
       else
        if(42 <= c){
@@ -32388,21 +32375,21 @@
              (Stdlib_Buffer[12], b, c);
      /*<<filename.ml:218:31>>*/ }
      /*<<filename.ml:212:4>>*/  /*<<filename.ml:212:4>>*/ caml_call2
-     (Stdlib_String[29], _w_, s);
+     (Stdlib_String[29], _x_, s);
      /*<<filename.ml:232:21>>*/ var
-     _H_ =
+     _I_ =
        [0,
         cst$11,
-        [0,  /*<<filename.ml:212:4>>*/ caml_call1(Stdlib_Buffer[2], b), _F_]],
-      /*<<filename.ml:232:21>>*/ _I_ =
-       [0, cst$12, [0, quote_cmd_filename(cmd), _H_]];
+        [0,  /*<<filename.ml:212:4>>*/ caml_call1(Stdlib_Buffer[2], b), _G_]],
+      /*<<filename.ml:232:21>>*/ _J_ =
+       [0, cst$12, [0, quote_cmd_filename(cmd), _I_]];
      /*<<filename.ml:232:21>>*/ return  /*<<filename.ml:232:21>>*/ caml_call2
-            (Stdlib_String[6], cst$13, _I_);
+            (Stdlib_String[6], cst$13, _J_);
     /*<<filename.ml:244:5>>*/ }
    function drive_and_path(s){
      /*<<filename.ml:252:4>>*/ var
-     _s_ = 2 <=  /*<<filename.ml:250:4>>*/ caml_ml_string_length(s) ? 1 : 0;
-    if(_s_){
+     _t_ = 2 <=  /*<<filename.ml:250:4>>*/ caml_ml_string_length(s) ? 1 : 0;
+    if(_t_){
       /*<<filename.ml:250:38>>*/  /*<<filename.ml:250:38>>*/ var
       param =  /*<<filename.ml:250:38>>*/ caml_string_get(s, 0);
      a:
@@ -32413,28 +32400,28 @@
         if(25 < param - 97 >>> 0) break b;
        }
        else if(65 > param) break b;
-       var _t_ = 1;
+       var _u_ = 1;
        break a;
       }
-      var _t_ = 0;
+      var _u_ = 0;
      }
       /*<<filename.ml:250:28>>*/  /*<<filename.ml:250:28>>*/ var
-      _u_ =
-        _t_
+      _v_ =
+        _u_
          ? 58 ===  /*<<filename.ml:250:47>>*/ caml_string_get(s, 1) ? 1 : 0
-         : _t_;
+         : _u_;
     }
     else
-     var _u_ = _s_;
-     /*<<filename.ml:252:7>>*/ if(! _u_)
+     var _v_ = _t_;
+     /*<<filename.ml:252:7>>*/ if(! _v_)
       /*<<filename.ml:254:9>>*/ return [0, cst$17, s];
      /*<<filename.ml:253:28>>*/  /*<<filename.ml:253:28>>*/ var
-     _v_ =
+     _w_ =
         /*<<filename.ml:253:28>>*/ caml_call3
         (Stdlib_String[15], s, 2, caml_ml_string_length(s) - 2 | 0);
      /*<<filename.ml:253:9>>*/ return [0,
              /*<<filename.ml:253:10>>*/ caml_call3(Stdlib_String[15], s, 0, 2),
-            _v_];
+            _w_];
     /*<<filename.ml:254:16>>*/ }
    function dirname$0(s){
      /*<<filename.ml:256:4>>*/ var
@@ -32468,11 +32455,11 @@
        quote_command$0,
        basename$0,
        dirname$0];
-    /*<<filename.ml:277:17>>*/ function basename$1(_r_){
-     /*<<?>>*/ return generic_basename(is_dir_sep$0, current_dir_name$1, _r_);
+    /*<<filename.ml:277:17>>*/ function basename$1(_s_){
+     /*<<?>>*/ return generic_basename(is_dir_sep$0, current_dir_name$1, _s_);
    }
-    /*<<filename.ml:278:16>>*/ function dirname$1(_q_){
-     /*<<?>>*/ return generic_dirname(is_dir_sep$0, current_dir_name$1, _q_);
+    /*<<filename.ml:278:16>>*/ function dirname$1(_r_){
+     /*<<?>>*/ return generic_dirname(is_dir_sep$0, current_dir_name$1, _r_);
    }
     /*<<filename.ml:264:26>>*/ var
      /*<<filename.ml:264:26>>*/ Cygwin =
@@ -32515,11 +32502,11 @@
      /*<<filename.ml:291:14>>*/ if
      (0 !== l && ! is_dir_sep$1(dirname, l - 1 | 0)){
       /*<<filename.ml:293:17>>*/  /*<<filename.ml:293:17>>*/ var
-      _p_ =
+      _q_ =
          /*<<filename.ml:293:17>>*/ caml_call2
          (Stdlib[28], dir_sep$2, filename);
       /*<<filename.ml:293:17>>*/ return  /*<<filename.ml:293:17>>*/ caml_call2
-             (Stdlib[28], dirname, _p_);
+             (Stdlib[28], dirname, _q_);
     }
      /*<<filename.ml:292:7>>*/ return  /*<<filename.ml:292:7>>*/ caml_call2
             (Stdlib[28], dirname, filename);
@@ -32622,7 +32609,7 @@
     /*<<filename.ml:338:71>>*/ }
     /*<<filename.ml:338:40>>*/ var
      /*<<filename.ml:338:40>>*/ _g_ =
-      [0, function(_o_){ /*<<?>>*/ return _o_;}],
+      [0, function(_p_){ /*<<?>>*/ return _p_;}],
      /*<<filename.ml:338:2>>*/ current_temp_dir_name =
        /*<<filename.ml:338:2>>*/ caml_call2(Stdlib_Domain[10][1], _g_, _f_);
    function set_temp_dir_name(s){
@@ -32662,17 +32649,17 @@
      }
     }
     /*<<filename.ml:351:15>>*/ }
-   function open_temp_file(opt, _m_, _l_, prefix, suffix){
+   function open_temp_file(opt, _n_, _m_, prefix, suffix){
      /*<<filename.ml:356:2>>*/ if(opt)
      var sth = opt[1], mode = sth;
     else
      var mode = _i_;
-     /*<<filename.ml:356:2>>*/ if(_m_)
-     var sth$0 = _m_[1], perms = sth$0;
+     /*<<filename.ml:356:2>>*/ if(_n_)
+     var sth$0 = _n_[1], perms = sth$0;
     else
      var perms = 384;
-     /*<<filename.ml:356:2>>*/ if(_l_)
-     var sth$1 = _l_[1], temp_dir = sth$1;
+     /*<<filename.ml:356:2>>*/ if(_m_)
+     var sth$1 = _m_[1], temp_dir = sth$1;
     else
      var
       temp_dir =
@@ -32684,12 +32671,12 @@
       name = temp_file_name(temp_dir, prefix, suffix);
       /*<<filename.ml:358:4>>*/ try{
        /*<<filename.ml:359:6>>*/  /*<<filename.ml:359:6>>*/ var
-       _n_ =
+       _o_ =
          [0,
           name,
            /*<<filename.ml:360:7>>*/ caml_call3
            (Stdlib[62], [0, 1, [0, 3, [0, 5, mode]]], perms, name)];
-       /*<<filename.ml:359:6>>*/ return _n_;
+       /*<<filename.ml:359:6>>*/ return _o_;
      }
      catch(e$0){
       var e = caml_wrap_exception(e$0);

From d729df0beaf46b7ec106d3f2d16ecdcb81e78714 Mon Sep 17 00:00:00 2001
From: Micah Cantor <micahcantor01@gmail.com>
Date: Thu, 24 Aug 2023 20:25:53 -0500
Subject: [PATCH 060/112] update comment

---
 compiler/lib/deadcode_dgraph.ml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/compiler/lib/deadcode_dgraph.ml b/compiler/lib/deadcode_dgraph.ml
index d5c29c7068..4965d16ed2 100644
--- a/compiler/lib/deadcode_dgraph.ml
+++ b/compiler/lib/deadcode_dgraph.ml
@@ -278,7 +278,7 @@ let propagate uses defs live_vars live_table x =
         match Var.Tbl.get live_table y with
         (* If y is dead, then x is dead. *)
         | Dead -> Dead
-        (* If y is a live block, then x is live if it is used in a live field *)
+        (* If y is a live block, then x is the join of liveness fields that are x *)
         | Live fields -> (
             match defs.(Var.idx y) with
             | Expr (Block (_, vars, _)) ->
@@ -292,7 +292,7 @@ let propagate uses defs live_vars live_table x =
                 !live
             | Expr (Field (_, i)) ->(
                 match IntMap.find_opt i fields with
-                  | Some l -> l
+                  | Some l -> Live (IntMap.singleton i l)
                   | None -> Dead)
             | _ -> Top)
         (* If y is top and y is a field access, x depends only on that field *)

From 2264014850184e0afb1839f3be01c7908a22eb5f Mon Sep 17 00:00:00 2001
From: Micah Cantor <micahcantor01@gmail.com>
Date: Thu, 24 Aug 2023 20:26:02 -0500
Subject: [PATCH 061/112] Revert "fix printing vars"

This reverts commit 2e62a34a2110b7b2b72505c6eea455711772797c.
---
 compiler/lib/deadcode_dgraph.ml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/compiler/lib/deadcode_dgraph.ml b/compiler/lib/deadcode_dgraph.ml
index 4965d16ed2..b7cb3aecd9 100644
--- a/compiler/lib/deadcode_dgraph.ml
+++ b/compiler/lib/deadcode_dgraph.ml
@@ -412,7 +412,7 @@ module Print = struct
     Format.eprintf "Usages:\n";
     Array.iteri
       ~f:(fun i ds ->
-        Format.eprintf "%a: { " Var.print (Var.of_idx i);
+        Format.eprintf "v%d: { " i;
         Var.Map.iter
           (fun d k ->
             Format.eprintf
@@ -428,7 +428,7 @@ module Print = struct
 
   let print_liveness live_vars =
     Format.eprintf "Liveness:\n";
-    Array.iteri ~f:(fun i l -> Format.eprintf "%a: %s\n" Var.print (Var.of_idx i) (live_to_string l)) live_vars
+    Array.iteri ~f:(fun i l -> Format.eprintf "v%d: %s\n" i (live_to_string l)) live_vars
 
   let print_live_tbl live_table =
     Format.eprintf "Liveness with dependencies:\n";

From 7cb2d728d58b94d61acf19de2b4e4f608ebeb171 Mon Sep 17 00:00:00 2001
From: Micah Cantor <micahcantor01@gmail.com>
Date: Thu, 24 Aug 2023 20:27:05 -0500
Subject: [PATCH 062/112] Revert "sentinal name, start recursive liveness"

This reverts commit 89df59fb4e6d20cb99f49b152095c0b723967d38.
---
 compiler/lib/deadcode_dgraph.ml            |  51 +++-----
 compiler/tests-compiler/direct_calls.ml    |  20 +--
 compiler/tests-compiler/gh1007.ml          |  46 +++----
 compiler/tests-compiler/gh1494.ml          |   2 +-
 compiler/tests-compiler/global_deadcode.ml | 137 +++++++--------------
 5 files changed, 100 insertions(+), 156 deletions(-)

diff --git a/compiler/lib/deadcode_dgraph.ml b/compiler/lib/deadcode_dgraph.ml
index b7cb3aecd9..9f513a1242 100644
--- a/compiler/lib/deadcode_dgraph.ml
+++ b/compiler/lib/deadcode_dgraph.ml
@@ -41,7 +41,7 @@ type def =
 (** Liveness of a variable [x], forming a lattice structure. *)
 type live =
   | Top (** [x] is live and not a block. *)
-  | Live of live IntMap.t (** [x] is a live block with a (non-empty) set of live fields. *)
+  | Live of IntSet.t (** [x] is a live block with a (non-empty) set of live fields. *)
   | Dead (** [x] is dead. *)
 
 module G = Dgraph.Make_Imperative (Var) (Var.ISet) (Var.Tbl)
@@ -49,21 +49,19 @@ module G = Dgraph.Make_Imperative (Var) (Var.ISet) (Var.Tbl)
 module Domain = struct
   type t = live
 
-  let rec equal l1 l2 =
+  let equal l1 l2 =
     match l1, l2 with
     | Top, Top | Dead, Dead -> true
-    | Live f1, Live f2 -> IntMap.equal equal f1 f2
+    | Live f1, Live f2 -> IntSet.equal f1 f2
     | _ -> false
 
   let bot = Dead
 
   (** Join the liveness according to lattice structure. *)
-  let rec join l1 l2 =
+  let join l1 l2 =
     match l1, l2 with
     | _, Top | Top, _ -> Top
-    | Live f1, Live f2 -> 
-        let fields = IntMap.union (fun _ l1 l2 -> Some (join l1 l2)) f1 f2 in 
-        Live fields
+    | Live f1, Live f2 -> Live (IntSet.union f1 f2)
     | Dead, Live f | Live f, Dead -> Live f
     | Dead, Dead -> Dead
 end
@@ -213,22 +211,19 @@ let liveness nv prog pure_funs (global_info : Global_flow.info) =
     let idx = Var.idx v in
     live_vars.(idx) <- Top
   in
-  let add_live v i l =
+  let add_live v i =
     let idx = Var.idx v in
     match live_vars.(idx) with
-    | Live fields -> live_vars.(idx) <- Live (IntMap.add i l fields)
-    | _ -> live_vars.(idx) <- Live (IntMap.singleton i l)
+    | Live fields -> live_vars.(idx) <- Live (IntSet.add i fields)
+    | _ -> live_vars.(idx) <- Live (IntSet.singleton i)
   in
   let live_instruction i =
     match i with
-    | Let (_, e) ->
-        (* We add all variables in impure expressions as top to ensure they aren't removed. *)
+    | Let (_x, e) ->
         if not (pure_expr pure_funs e)
         then (
           let vars = expr_vars e in
           Var.ISet.iter add_top vars;)
-        (* We might be able to do better in pure fn applications. The function itself must be kept but
-           arguments might be dead if they don't escape. *)
         else (match e with
           | Apply { f; args; _} ->
               add_top f;
@@ -236,13 +231,13 @@ let liveness nv prog pure_funs (global_info : Global_flow.info) =
           | _ -> ()) 
     | Assign (_, _) -> ()
     | Set_field (x, i, y) ->
-        add_live x i Top;
+        add_live x i;
         add_top y
     | Array_set (x, y, z) ->
         add_top x;
         add_top y;
         add_top z
-    | Offset_ref (x, i) -> add_live x i Top
+    | Offset_ref (x, i) -> add_live x i
   in
   let live_block block =
     List.iter ~f:(fun (i, _) -> live_instruction i) block.body;
@@ -282,23 +277,17 @@ let propagate uses defs live_vars live_table x =
         | Live fields -> (
             match defs.(Var.idx y) with
             | Expr (Block (_, vars, _)) ->
-                let live = ref Dead in
-                Array.iteri ~f:(fun i v -> 
-                  if Var.equal v x
-                    then match IntMap.find_opt i fields with
-                    | Some l -> live := Domain.join !live l
-                    | None -> ())
+                let found = ref false in
+                Array.iteri
+                  ~f:(fun i v ->
+                    if Var.equal v x && IntSet.mem i fields then found := true)
                   vars;
-                !live
-            | Expr (Field (_, i)) ->(
-                match IntMap.find_opt i fields with
-                  | Some l -> Live (IntMap.singleton i l)
-                  | None -> Dead)
+                if !found then Top else Dead
             | _ -> Top)
         (* If y is top and y is a field access, x depends only on that field *)
         | Top -> (
             match defs.(Var.idx y) with
-            | Expr (Field (_, i)) -> Live (IntMap.singleton i Top)
+            | Expr (Field (_, i)) -> Live (IntSet.singleton i)
             | _ -> Top))
     (* If x is used as an argument for parameter y, then contribution is liveness of y *)
     | Propagate -> Var.Tbl.get live_table y
@@ -363,7 +352,7 @@ let zero prog sentinal live_table =
             | Live fields ->
                 let vars =
                   Array.mapi
-                    ~f:(fun i v -> if IntMap.mem i fields then v else sentinal)
+                    ~f:(fun i v -> if IntSet.mem i fields then v else sentinal)
                     vars
                   |> compact_vars
                 in
@@ -404,7 +393,7 @@ let zero prog sentinal live_table =
 module Print = struct
   let live_to_string = function
     | Live fields ->
-        "live { " ^ IntMap.fold (fun i _ s -> s ^ Format.sprintf "%d " i) fields "" ^ "}"
+        "live { " ^ IntSet.fold (fun i s -> s ^ Format.sprintf "%d " i) fields "" ^ "}"
     | Top -> "top"
     | Dead -> "dead"
 
@@ -439,7 +428,7 @@ end
 
 (** Add a sentinal variable declaration to the IR. The fresh variable is assigned to `undefined`. *)
 let add_sentinal p =
-  let sentinal = Var.fresh_n "sentinal" in
+  let sentinal = Var.fresh () in
   let undefined = Prim (Extern "%undefined", []) in
   let instr, loc = Let (sentinal, undefined), Before 0 in
   Code.prepend p [ instr, loc ], sentinal
diff --git a/compiler/tests-compiler/direct_calls.ml b/compiler/tests-compiler/direct_calls.ml
index e7c66cb85a..98b7a4249c 100644
--- a/compiler/tests-compiler/direct_calls.ml
+++ b/compiler/tests-compiler/direct_calls.ml
@@ -57,26 +57,26 @@ let%expect_test "direct calls without --enable effects" =
   [%expect
     {|
     function test1(param){
-     function f(g, x){caml_call1(g, x); return sentinal;}
-     var _d_ = 7;
-     f(function(x){return x + 1 | 0;}, _d_);
-     var _e_ = 4.;
-     f(function(x){return x * 2.;}, _e_);
+     function f(g, x){caml_call1(g, x); return _b_;}
+     var _e_ = 7;
+     f(function(x){return x + 1 | 0;}, _e_);
+     var _f_ = 4.;
+     f(function(x){return x * 2.;}, _f_);
      return 0;
     }
     //end
     function test2(param){
-     function f(g, x){caml_call1(g, x); return sentinal;}
-     var _c_ = 7;
-     f(function(x){return x + 1 | 0;}, _c_);
+     function f(g, x){caml_call1(g, x); return _b_;}
+     var _d_ = 7;
+     f(function(x){return x + 1 | 0;}, _d_);
      f(function(x){return caml_call2(Stdlib[28], x, cst_a$0);}, cst_a);
      return 0;
     }
     //end
     function test3(x){
      function F(symbol){function f(x){return x + 1 | 0;} return [0, f];}
-     var M1 = F([0]), M2 = F([0]), _b_ = M2[1].call(null, 2);
-     return [0, M1[1].call(null, 1), _b_];
+     var M1 = F([0]), M2 = F([0]), _c_ = M2[1].call(null, 2);
+     return [0, M1[1].call(null, 1), _c_];
     }
     //end
     function test4(x){
diff --git a/compiler/tests-compiler/gh1007.ml b/compiler/tests-compiler/gh1007.ml
index 6379531de1..6aed85957d 100644
--- a/compiler/tests-compiler/gh1007.ml
+++ b/compiler/tests-compiler/gh1007.ml
@@ -369,31 +369,31 @@ let ()  = M.run ()
           if(2 >= n >>> 0)
            switch(n){
              case 0:
-              return sentinal;
+              return _a_;
              case 1:
-              odd(0); return sentinal;
-             default: odd(1); return sentinal;
+              odd(0); return _a_;
+             default: odd(1); return _a_;
            }
           odd(n - 1 | 0);
-          return sentinal;
+          return _a_;
          },
        odd =
          function(n){
           if(2 >= n >>> 0)
            switch(n){
              case 0:
-              return sentinal;
+              return _a_;
              case 1:
-              even(0); return sentinal;
-             default: even(1); return sentinal;
+              even(0); return _a_;
+             default: even(1); return _a_;
            }
           even(n - 1 | 0);
-          return sentinal;
+          return _a_;
          };
       even(i);
-      var _a_ = i + 1 | 0;
+      var _b_ = i + 1 | 0;
       if(4 === i) return 0;
-      var i = _a_;
+      var i = _b_;
      }
     }
     //end |}]
@@ -467,13 +467,13 @@ let ()  = M.run ()
                 f = function(param){return caml_call2(Stdlib_Printf[2], _b_, i);};
                delayed[1] = [0, f, delayed[1]];
                f(0);
-               return sentinal;
+               return _c_;
               case 1:
-               odd(0); return sentinal;
-              default: odd(1); return sentinal;
+               odd(0); return _c_;
+              default: odd(1); return _c_;
             }
            odd(n - 1 | 0);
-           return sentinal;
+           return _c_;
           }
           function odd(n){
            if(2 >= n >>> 0)
@@ -483,13 +483,13 @@ let ()  = M.run ()
                 f = function(param){return caml_call2(Stdlib_Printf[2], _a_, i);};
                delayed[1] = [0, f, delayed[1]];
                f(0);
-               return sentinal;
+               return _c_;
               case 1:
-               even(0); return sentinal;
-              default: even(1); return sentinal;
+               even(0); return _c_;
+              default: even(1); return _c_;
             }
            even(n - 1 | 0);
-           return sentinal;
+           return _c_;
           }
           var block = [0, even, odd];
           return block;
@@ -497,14 +497,14 @@ let ()  = M.run ()
        closures$0 = closures(i),
        even = closures$0[1];
       even(i);
-      var _e_ = i + 1 | 0;
+      var _f_ = i + 1 | 0;
       if(4 === i){
        var
-        _c_ = caml_call1(Stdlib_List[9], delayed[1]),
-        _d_ = function(f){return caml_call1(f, 0);};
-       return caml_call2(Stdlib_List[17], _d_, _c_);
+        _d_ = caml_call1(Stdlib_List[9], delayed[1]),
+        _e_ = function(f){return caml_call1(f, 0);};
+       return caml_call2(Stdlib_List[17], _e_, _d_);
       }
-      var i = _e_;
+      var i = _f_;
      }
     }
     //end |}]
diff --git a/compiler/tests-compiler/gh1494.ml b/compiler/tests-compiler/gh1494.ml
index fd646b38f2..17cab23faf 100644
--- a/compiler/tests-compiler/gh1494.ml
+++ b/compiler/tests-compiler/gh1494.ml
@@ -39,7 +39,7 @@ let () =
   [%expect
     {|
     function bug(param){
-     var g = [0, function(x){return function(_c_){return _c_;};}];
+     var g = [0, function(x){return function(_d_){return _d_;};}];
      return [0, function(param){return caml_call1(g[1], 1);}, g];
     }
     //end |}]
diff --git a/compiler/tests-compiler/global_deadcode.ml b/compiler/tests-compiler/global_deadcode.ml
index eb48cf9a89..c82dd943ea 100644
--- a/compiler/tests-compiler/global_deadcode.ml
+++ b/compiler/tests-compiler/global_deadcode.ml
@@ -15,97 +15,41 @@ let%expect_test "Eliminates unused functions from functor" =
       |}
   in
   (* Expect: compiles functor members used in the program *)
-  print_fun_decl program (Some "_e_");
-  [%expect {|
-    function _e_(Ord){
-     function height(param){if(! param) return 0; var h = param[4]; return h;}
-     function create(l, v, r){
-      if(l) var h = l[4], hl = h; else var hl = 0;
-      if(r) var h$0 = r[4], hr = h$0; else var hr = 0;
-      var _m_ = hr <= hl ? hl + 1 | 0 : hr + 1 | 0;
-      return [0, l, v, r, _m_];
-     }
-     function bal(l, v, r){
-      if(l) var h = l[4], hl = h; else var hl = 0;
-      if(r) var h$0 = r[4], hr = h$0; else var hr = 0;
-      if((hr + 2 | 0) < hl){
-       if(! l) return invalid_arg(_b_);
-       var lr = l[3], lv = l[2], ll = l[1], _h_ = height(lr);
-       if(_h_ <= height(ll)) return create(ll, lv, create(lr, v, r));
-       if(! lr) return invalid_arg(_a_);
-       var lrr = lr[3], lrv = lr[2], lrl = lr[1], _i_ = create(lrr, v, r);
-       return create(create(ll, lv, lrl), lrv, _i_);
-      }
-      if((hl + 2 | 0) >= hr){
-       var _l_ = hr <= hl ? hl + 1 | 0 : hr + 1 | 0;
-       return [0, l, v, r, _l_];
-      }
-      if(! r) return invalid_arg(_d_);
-      var rr = r[3], rv = r[2], rl = r[1], _j_ = height(rl);
-      if(_j_ <= height(rr)) return create(create(l, v, rl), rv, rr);
-      if(! rl) return invalid_arg(_c_);
-      var rlr = rl[3], rlv = rl[2], rll = rl[1], _k_ = create(rlr, rv, rr);
-      return create(create(l, v, rll), rlv, _k_);
-     }
-     function add(x, t){
-      if(! t) return [0, 0, x, 0, 1];
-      var r = t[3], v = t[2], l = t[1], c = caml_call2(Ord[1], x, v);
-      if(0 === c) return t;
-      if(0 <= c){var rr = add(x, r); return r === rr ? t : bal(l, v, rr);}
-      var ll = add(x, l);
-      return l === ll ? t : bal(ll, v, r);
-     }
-     function singleton(x){return [0, 0, x, 0, 1];}
-     var empty = 0;
-     function find(x, param){
-      var param$0 = param;
-      for(;;){
-       if(! param$0) throw caml_maybe_attach_backtrace(Not_found, 1);
-       var
-        r = param$0[3],
-        v = param$0[2],
-        l = param$0[1],
-        c = caml_call2(Ord[1], x, v);
-       if(0 === c) return v;
-       var r$0 = 0 <= c ? r : l, param$0 = r$0;
-      }
+  print_fun_decl program (Some "find");
+  [%expect
+    {|
+    function find(x, param){
+     var param$0 = param;
+     for(;;){
+      if(! param$0) throw caml_maybe_attach_backtrace(Not_found, 1);
+      var
+       r = param$0[3],
+       v = param$0[2],
+       l = param$0[1],
+       c = caml_call2(Ord[1], x, v);
+      if(0 === c) return v;
+      var r$0 = 0 <= c ? r : l, param$0 = r$0;
      }
-     return [0,
-             empty,
-             sentinal,
-             sentinal,
-             add,
-             singleton,
-             sentinal,
-             sentinal,
-             sentinal,
-             sentinal,
-             sentinal,
-             sentinal,
-             sentinal,
-             sentinal,
-             sentinal,
-             sentinal,
-             sentinal,
-             sentinal,
-             sentinal,
-             sentinal,
-             sentinal,
-             sentinal,
-             sentinal,
-             sentinal,
-             sentinal,
-             sentinal,
-             sentinal,
-             sentinal,
-             sentinal,
-             sentinal,
-             sentinal,
-             find];
     }
-    //end |}]
+    //end |}];
+  print_fun_decl program (Some "add");
+  [%expect {|
+    function add(x, t){
+     if(! t) return [0, 0, x, 0, 1];
+     var r = t[3], v = t[2], l = t[1], c = caml_call2(Ord[1], x, v);
+     if(0 === c) return t;
+     if(0 <= c){var rr = add(x, r); return r === rr ? t : bal(l, v, rr);}
+     var ll = add(x, l);
+     return l === ll ? t : bal(ll, v, r);
+    }
+    //end |}];
+  (* Expect: does not compile unused functor member *)
+  print_fun_decl program (Some "union");
+  [%expect {| not found |}];
+  print_fun_decl program (Some "inter");
+  [%expect {| not found |}]
 
-let%expect_test "Substitutes unused fields with sentinal" =
+let%expect_test "Substitutes unused fields with undefined" =
   let program =
     compile_and_parse
       {|
@@ -120,12 +64,23 @@ let%expect_test "Substitutes unused fields with sentinal" =
   print_fun_decl program (Some "f");
   [%expect {|
     function f(b, x){
-     var t = b ? [0, 1, sentinal, x] : [0, 3, sentinal, 4], v = t[3], u = t[1];
+     var t = b ? [0, 1, _c_, x] : [0, 3, _c_, 4], v = t[3], u = t[1];
      return [0, u, v];
     }
     //end |}];
   (* And that variable is defined as `undefined` *)
-  print_var_decl program "sentinal";
+  print_var_decl program "_c_";
   [%expect {|
-    var sentinal = undefined;
+    var _c_ = undefined;
     //end |}]
+
+let%expect_test "Sets unused return value to undefined" =
+  let program =
+    compile_and_parse
+      {|
+
+      |}
+  in print_fun_decl program (Some "f");
+  [%expect {| not found |}];
+  print_var_decl program "__";
+  [%expect {| var __ = not found |}]
\ No newline at end of file

From db8cbbf85a9e193f0ff254cc7de7eae56be86b77 Mon Sep 17 00:00:00 2001
From: Micah Cantor <micahcantor01@gmail.com>
Date: Thu, 24 Aug 2023 20:28:34 -0500
Subject: [PATCH 063/112] sentinal name

---
 compiler/lib/deadcode_dgraph.ml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/compiler/lib/deadcode_dgraph.ml b/compiler/lib/deadcode_dgraph.ml
index 9f513a1242..7eb8f8944c 100644
--- a/compiler/lib/deadcode_dgraph.ml
+++ b/compiler/lib/deadcode_dgraph.ml
@@ -428,7 +428,7 @@ end
 
 (** Add a sentinal variable declaration to the IR. The fresh variable is assigned to `undefined`. *)
 let add_sentinal p =
-  let sentinal = Var.fresh () in
+  let sentinal = Var.fresh_n "sentinal" in
   let undefined = Prim (Extern "%undefined", []) in
   let instr, loc = Let (sentinal, undefined), Before 0 in
   Code.prepend p [ instr, loc ], sentinal

From 5bef65a3c8304d7a23cbe395d5baa738e8529497 Mon Sep 17 00:00:00 2001
From: Micah Cantor <micahcantor01@gmail.com>
Date: Thu, 24 Aug 2023 20:58:23 -0500
Subject: [PATCH 064/112] promote test changes

---
 compiler/tests-compiler/direct_calls.ml    |   20 +-
 compiler/tests-compiler/gh1007.ml          |   46 +-
 compiler/tests-compiler/gh1494.ml          |    2 +-
 compiler/tests-compiler/global_deadcode.ml |    6 +-
 compiler/tests-full/stdlib.cma.expected.js | 4557 ++++++++++----------
 5 files changed, 2322 insertions(+), 2309 deletions(-)

diff --git a/compiler/tests-compiler/direct_calls.ml b/compiler/tests-compiler/direct_calls.ml
index 98b7a4249c..e7c66cb85a 100644
--- a/compiler/tests-compiler/direct_calls.ml
+++ b/compiler/tests-compiler/direct_calls.ml
@@ -57,26 +57,26 @@ let%expect_test "direct calls without --enable effects" =
   [%expect
     {|
     function test1(param){
-     function f(g, x){caml_call1(g, x); return _b_;}
-     var _e_ = 7;
-     f(function(x){return x + 1 | 0;}, _e_);
-     var _f_ = 4.;
-     f(function(x){return x * 2.;}, _f_);
+     function f(g, x){caml_call1(g, x); return sentinal;}
+     var _d_ = 7;
+     f(function(x){return x + 1 | 0;}, _d_);
+     var _e_ = 4.;
+     f(function(x){return x * 2.;}, _e_);
      return 0;
     }
     //end
     function test2(param){
-     function f(g, x){caml_call1(g, x); return _b_;}
-     var _d_ = 7;
-     f(function(x){return x + 1 | 0;}, _d_);
+     function f(g, x){caml_call1(g, x); return sentinal;}
+     var _c_ = 7;
+     f(function(x){return x + 1 | 0;}, _c_);
      f(function(x){return caml_call2(Stdlib[28], x, cst_a$0);}, cst_a);
      return 0;
     }
     //end
     function test3(x){
      function F(symbol){function f(x){return x + 1 | 0;} return [0, f];}
-     var M1 = F([0]), M2 = F([0]), _c_ = M2[1].call(null, 2);
-     return [0, M1[1].call(null, 1), _c_];
+     var M1 = F([0]), M2 = F([0]), _b_ = M2[1].call(null, 2);
+     return [0, M1[1].call(null, 1), _b_];
     }
     //end
     function test4(x){
diff --git a/compiler/tests-compiler/gh1007.ml b/compiler/tests-compiler/gh1007.ml
index 6aed85957d..6379531de1 100644
--- a/compiler/tests-compiler/gh1007.ml
+++ b/compiler/tests-compiler/gh1007.ml
@@ -369,31 +369,31 @@ let ()  = M.run ()
           if(2 >= n >>> 0)
            switch(n){
              case 0:
-              return _a_;
+              return sentinal;
              case 1:
-              odd(0); return _a_;
-             default: odd(1); return _a_;
+              odd(0); return sentinal;
+             default: odd(1); return sentinal;
            }
           odd(n - 1 | 0);
-          return _a_;
+          return sentinal;
          },
        odd =
          function(n){
           if(2 >= n >>> 0)
            switch(n){
              case 0:
-              return _a_;
+              return sentinal;
              case 1:
-              even(0); return _a_;
-             default: even(1); return _a_;
+              even(0); return sentinal;
+             default: even(1); return sentinal;
            }
           even(n - 1 | 0);
-          return _a_;
+          return sentinal;
          };
       even(i);
-      var _b_ = i + 1 | 0;
+      var _a_ = i + 1 | 0;
       if(4 === i) return 0;
-      var i = _b_;
+      var i = _a_;
      }
     }
     //end |}]
@@ -467,13 +467,13 @@ let ()  = M.run ()
                 f = function(param){return caml_call2(Stdlib_Printf[2], _b_, i);};
                delayed[1] = [0, f, delayed[1]];
                f(0);
-               return _c_;
+               return sentinal;
               case 1:
-               odd(0); return _c_;
-              default: odd(1); return _c_;
+               odd(0); return sentinal;
+              default: odd(1); return sentinal;
             }
            odd(n - 1 | 0);
-           return _c_;
+           return sentinal;
           }
           function odd(n){
            if(2 >= n >>> 0)
@@ -483,13 +483,13 @@ let ()  = M.run ()
                 f = function(param){return caml_call2(Stdlib_Printf[2], _a_, i);};
                delayed[1] = [0, f, delayed[1]];
                f(0);
-               return _c_;
+               return sentinal;
               case 1:
-               even(0); return _c_;
-              default: even(1); return _c_;
+               even(0); return sentinal;
+              default: even(1); return sentinal;
             }
            even(n - 1 | 0);
-           return _c_;
+           return sentinal;
           }
           var block = [0, even, odd];
           return block;
@@ -497,14 +497,14 @@ let ()  = M.run ()
        closures$0 = closures(i),
        even = closures$0[1];
       even(i);
-      var _f_ = i + 1 | 0;
+      var _e_ = i + 1 | 0;
       if(4 === i){
        var
-        _d_ = caml_call1(Stdlib_List[9], delayed[1]),
-        _e_ = function(f){return caml_call1(f, 0);};
-       return caml_call2(Stdlib_List[17], _e_, _d_);
+        _c_ = caml_call1(Stdlib_List[9], delayed[1]),
+        _d_ = function(f){return caml_call1(f, 0);};
+       return caml_call2(Stdlib_List[17], _d_, _c_);
       }
-      var i = _f_;
+      var i = _e_;
      }
     }
     //end |}]
diff --git a/compiler/tests-compiler/gh1494.ml b/compiler/tests-compiler/gh1494.ml
index 17cab23faf..fd646b38f2 100644
--- a/compiler/tests-compiler/gh1494.ml
+++ b/compiler/tests-compiler/gh1494.ml
@@ -39,7 +39,7 @@ let () =
   [%expect
     {|
     function bug(param){
-     var g = [0, function(x){return function(_d_){return _d_;};}];
+     var g = [0, function(x){return function(_c_){return _c_;};}];
      return [0, function(param){return caml_call1(g[1], 1);}, g];
     }
     //end |}]
diff --git a/compiler/tests-compiler/global_deadcode.ml b/compiler/tests-compiler/global_deadcode.ml
index c82dd943ea..899ce4f854 100644
--- a/compiler/tests-compiler/global_deadcode.ml
+++ b/compiler/tests-compiler/global_deadcode.ml
@@ -64,14 +64,14 @@ let%expect_test "Substitutes unused fields with undefined" =
   print_fun_decl program (Some "f");
   [%expect {|
     function f(b, x){
-     var t = b ? [0, 1, _c_, x] : [0, 3, _c_, 4], v = t[3], u = t[1];
+     var t = b ? [0, 1, sentinal, x] : [0, 3, sentinal, 4], v = t[3], u = t[1];
      return [0, u, v];
     }
     //end |}];
   (* And that variable is defined as `undefined` *)
-  print_var_decl program "_c_";
+  print_var_decl program "sentinal";
   [%expect {|
-    var _c_ = undefined;
+    var sentinal = undefined;
     //end |}]
 
 let%expect_test "Sets unused return value to undefined" =
diff --git a/compiler/tests-full/stdlib.cma.expected.js b/compiler/tests-full/stdlib.cma.expected.js
index 7e201668fd..8249793bfe 100644
--- a/compiler/tests-full/stdlib.cma.expected.js
+++ b/compiler/tests-full/stdlib.cma.expected.js
@@ -1248,11 +1248,11 @@
             : runtime.caml_call_gen(f, [a0]);
    }
    var
+    sentinal = undefined,
     global_data = runtime.caml_get_global_data(),
     Stdlib = global_data.Stdlib,
     Assert_failure = global_data.Assert_failure,
     Stdlib_Sys = global_data.Stdlib__Sys,
-    _b_ = undefined,
     cst_Obj_Ephemeron_blit_key = "Obj.Ephemeron.blit_key",
     cst_Obj_Ephemeron_check_key = "Obj.Ephemeron.check_key",
     cst_Obj_Ephemeron_unset_key = "Obj.Ephemeron.unset_key",
@@ -1330,9 +1330,9 @@
     max_ephe_length = Stdlib_Sys[13] - 2 | 0;
    function create(l){
      /*<<obj.ml:135:4>>*/ var
-     _h_ = 0 <= l ? 1 : 0,
-     _i_ = _h_ ? l <= max_ephe_length ? 1 : 0 : _h_;
-    if(1 - _i_)
+     _g_ = 0 <= l ? 1 : 0,
+     _h_ = _g_ ? l <= max_ephe_length ? 1 : 0 : _g_;
+    if(1 - _h_)
       /*<<obj.ml:136:6>>*/  /*<<obj.ml:136:6>>*/ caml_call1
       (Stdlib[1], cst_Obj_Ephemeron_create);
      /*<<obj.ml:137:4>>*/ return  /*<<obj.ml:137:4>>*/ runtime.caml_ephe_create
@@ -1343,10 +1343,12 @@
     /*<<obj.ml:139:49>>*/ }
    function raise_if_invalid_offset(e, o, msg){
      /*<<obj.ml:142:4>>*/ var
-     _e_ = 0 <= o ? 1 : 0,
-     _f_ = _e_ ? o < length(e) ? 1 : 0 : _e_,
-     _g_ = 1 - _f_;
-    return _g_ ? ( /*<<obj.ml:143:6>>*/ caml_call1(Stdlib[1], msg), _b_) : _g_;
+     _d_ = 0 <= o ? 1 : 0,
+     _e_ = _d_ ? o < length(e) ? 1 : 0 : _d_,
+     _f_ = 1 - _e_;
+    return _f_
+            ? ( /*<<obj.ml:143:6>>*/ caml_call1(Stdlib[1], msg), sentinal)
+            : _f_;
     /*<<obj.ml:143:21>>*/ }
    function get_key(e, o){
      /*<<obj.ml:147:4>>*/ raise_if_invalid_offset
@@ -1385,13 +1387,13 @@
        0 <= o1
        && (length(e1) - l | 0) >= o1 && 0 <= o2 && (length(e2) - l | 0) >= o2){
      var
-      _c_ = 0 !== l ? 1 : 0,
-      _d_ =
-        _c_
+      _b_ = 0 !== l ? 1 : 0,
+      _c_ =
+        _b_
          ?  /*<<obj.ml:177:24>>*/ runtime.caml_ephe_blit_key
            (e1, o1, e2, o2, l)
-         : _c_;
-      /*<<obj.ml:177:24>>*/ return _d_;
+         : _b_;
+      /*<<obj.ml:177:24>>*/ return _c_;
     }
      /*<<obj.ml:176:9>>*/ return  /*<<obj.ml:176:9>>*/ caml_call1
             (Stdlib[1], cst_Obj_Ephemeron_blit_key);
@@ -4549,7 +4551,7 @@
             : runtime.caml_call_gen(f, [a0, a1]);
    }
    var
-    _g_ = undefined,
+    sentinal = undefined,
     global_data = runtime.caml_get_global_data(),
     Stdlib = global_data.Stdlib,
     Stdlib_Uchar = global_data.Stdlib__Uchar,
@@ -4594,15 +4596,15 @@
    function init(n, f){
      /*<<bytes.ml:47:2>>*/ var
       /*<<bytes.ml:47:10>>*/ s =  /*<<bytes.ml:47:10>>*/ caml_create_bytes(n),
-      /*<<bytes.ml:48:2>>*/ _ar_ = n - 1 | 0,
-      /*<<bytes.ml:47:10>>*/ _aq_ = 0;
-    if(_ar_ >= 0){
-     var i = _aq_;
+      /*<<bytes.ml:48:2>>*/ _aq_ = n - 1 | 0,
+      /*<<bytes.ml:47:10>>*/ _ap_ = 0;
+    if(_aq_ >= 0){
+     var i = _ap_;
      for(;;){
       caml_bytes_unsafe_set(s, i,  /*<<bytes.ml:49:19>>*/ caml_call1(f, i));
-       /*<<bytes.ml:48:2>>*/  /*<<bytes.ml:48:2>>*/ var _as_ = i + 1 | 0;
-      if(_ar_ === i) break;
-      var i = _as_;
+       /*<<bytes.ml:48:2>>*/  /*<<bytes.ml:48:2>>*/ var _ar_ = i + 1 | 0;
+      if(_aq_ === i) break;
+      var i = _ar_;
      }
     }
      /*<<bytes.ml:51:2>>*/ return s;
@@ -4644,11 +4646,11 @@
    function symbol(a, b){
      /*<<bytes.ml:77:2>>*/ var
      c = a + b | 0,
-     _ap_ = b < 0 ? 1 : 0,
+     _ao_ = b < 0 ? 1 : 0,
      match = c < 0 ? 1 : 0;
     a:
     {
-     if(a < 0){if(_ap_ && ! match) break a;} else if(! _ap_ && match) break a;
+     if(a < 0){if(_ao_ && ! match) break a;} else if(! _ao_ && match) break a;
       /*<<bytes.ml:81:9>>*/ return c;
     }
      /*<<bytes.ml:80:27>>*/ return  /*<<bytes.ml:80:27>>*/ caml_call1
@@ -4711,32 +4713,32 @@
     /*<<bytes.ml:106:45>>*/ }
    function iter(f, a){
      /*<<bytes.ml:110:2>>*/ var
-     _an_ = caml_ml_bytes_length(a) - 1 | 0,
-      /*<<bytes.ml:110:2>>*/ _am_ = 0;
-    if(_an_ >= 0){
-     var i = _am_;
+     _am_ = caml_ml_bytes_length(a) - 1 | 0,
+      /*<<bytes.ml:110:2>>*/ _al_ = 0;
+    if(_am_ >= 0){
+     var i = _al_;
      for(;;){
        /*<<bytes.ml:110:31>>*/  /*<<bytes.ml:110:31>>*/ caml_call1
        (f, caml_bytes_unsafe_get(a, i));
-       /*<<bytes.ml:110:31>>*/  /*<<bytes.ml:110:31>>*/ var _ao_ = i + 1 | 0;
-      if(_an_ === i) break;
-      var i = _ao_;
+       /*<<bytes.ml:110:31>>*/  /*<<bytes.ml:110:31>>*/ var _an_ = i + 1 | 0;
+      if(_am_ === i) break;
+      var i = _an_;
      }
     }
     return 0;
     /*<<bytes.ml:110:53>>*/ }
    function iteri(f, a){
      /*<<bytes.ml:114:2>>*/ var
-     _ak_ = caml_ml_bytes_length(a) - 1 | 0,
-      /*<<bytes.ml:114:2>>*/ _aj_ = 0;
-    if(_ak_ >= 0){
-     var i = _aj_;
+     _aj_ = caml_ml_bytes_length(a) - 1 | 0,
+      /*<<bytes.ml:114:2>>*/ _ai_ = 0;
+    if(_aj_ >= 0){
+     var i = _ai_;
      for(;;){
        /*<<bytes.ml:114:31>>*/  /*<<bytes.ml:114:31>>*/ caml_call2
        (f, i, caml_bytes_unsafe_get(a, i));
-       /*<<bytes.ml:114:31>>*/  /*<<bytes.ml:114:31>>*/ var _al_ = i + 1 | 0;
-      if(_ak_ === i) break;
-      var i = _al_;
+       /*<<bytes.ml:114:31>>*/  /*<<bytes.ml:114:31>>*/ var _ak_ = i + 1 | 0;
+      if(_aj_ === i) break;
+      var i = _ak_;
      }
     }
     return 0;
@@ -4759,13 +4761,13 @@
         param = tl;
        continue;
       }
-      var _ai_ = caml_ml_bytes_length(hd) + acc | 0;
+      var _ah_ = caml_ml_bytes_length(hd) + acc | 0;
      }
      else
-      var _ai_ = acc;
+      var _ah_ = acc;
       /*<<bytes.ml:136:12>>*/ var
        /*<<bytes.ml:136:12>>*/ dst =
-         /*<<bytes.ml:136:12>>*/ caml_create_bytes(_ai_),
+         /*<<bytes.ml:136:12>>*/ caml_create_bytes(_ah_),
       pos = pos$1,
       param$0 = l;
      for(;;){
@@ -4803,10 +4805,10 @@
     /*<<bytes.ml:145:3>>*/ }
    function is_space(param){
      /*<<bytes.ml:151:15>>*/  /*<<bytes.ml:151:15>>*/ var
-     _ah_ = param - 9 | 0;
+     _ag_ = param - 9 | 0;
     a:
     {
-     if(4 < _ah_ >>> 0){if(23 !== _ah_) break a;} else if(2 === _ah_) break a;
+     if(4 < _ag_ >>> 0){if(23 !== _ag_) break a;} else if(2 === _ag_) break a;
       /*<<bytes.ml:152:41>>*/ return 1;
     }
      /*<<bytes.ml:153:9>>*/ return 0;
@@ -4830,10 +4832,10 @@
    function unsafe_escape(s){
      /*<<bytes.ml:184:2>>*/ var
       /*<<bytes.ml:184:10>>*/ n = [0, 0],
-     _aa_ = caml_ml_bytes_length(s) - 1 | 0,
-      /*<<bytes.ml:184:10>>*/ _$_ = 0;
-    if(_aa_ >= 0){
-     var i$0 = _$_;
+     _$_ = caml_ml_bytes_length(s) - 1 | 0,
+      /*<<bytes.ml:184:10>>*/ ___ = 0;
+    if(_$_ >= 0){
+     var i$0 = ___;
      for(;;){
       var match = caml_bytes_unsafe_get(s, i$0);
       a:
@@ -4843,12 +4845,12 @@
         c:
         {
          if(32 <= match){
-          var _ae_ = match - 34 | 0;
-          if(58 < _ae_ >>> 0){
-           if(93 <= _ae_) break c;
+          var _ad_ = match - 34 | 0;
+          if(58 < _ad_ >>> 0){
+           if(93 <= _ad_) break c;
           }
-          else if(56 < _ae_ - 1 >>> 0) break b;
-          var _af_ = 1;
+          else if(56 < _ad_ - 1 >>> 0) break b;
+          var _ae_ = 1;
           break a;
          }
          if(11 <= match){
@@ -4856,15 +4858,15 @@
          }
          else if(8 <= match) break b;
         }
-        var _af_ = 4;
+        var _ae_ = 4;
         break a;
        }
-       var _af_ = 2;
+       var _ae_ = 2;
       }
-      n[1] = n[1] + _af_ | 0;
-       /*<<bytes.ml:185:2>>*/  /*<<bytes.ml:185:2>>*/ var _ag_ = i$0 + 1 | 0;
-      if(_aa_ === i$0) break;
-      var i$0 = _ag_;
+      n[1] = n[1] + _ae_ | 0;
+       /*<<bytes.ml:185:2>>*/  /*<<bytes.ml:185:2>>*/ var _af_ = i$0 + 1 | 0;
+      if(_$_ === i$0) break;
+      var i$0 = _af_;
      }
     }
     if(n[1] === caml_ml_bytes_length(s))  /*<<bytes.ml:192:24>>*/ return s;
@@ -4872,10 +4874,10 @@
      s$0 =  /*<<bytes.ml:194:13>>*/ caml_create_bytes(n[1]);
     n[1] = 0;
      /*<<bytes.ml:196:4>>*/ var
-     _ac_ = caml_ml_bytes_length(s) - 1 | 0,
-      /*<<bytes.ml:196:4>>*/ _ab_ = 0;
-    if(_ac_ >= 0){
-     var i = _ab_;
+     _ab_ = caml_ml_bytes_length(s) - 1 | 0,
+      /*<<bytes.ml:196:4>>*/ _aa_ = 0;
+    if(_ab_ >= 0){
+     var i = _aa_;
      for(;;){
       var c = caml_bytes_unsafe_get(s, i);
       a:
@@ -4933,9 +4935,9 @@
        caml_bytes_unsafe_set(s$0, n[1], c);
       }
       n[1]++;
-       /*<<bytes.ml:196:4>>*/  /*<<bytes.ml:196:4>>*/ var _ad_ = i + 1 | 0;
-      if(_ac_ === i) break;
-      var i = _ad_;
+       /*<<bytes.ml:196:4>>*/  /*<<bytes.ml:196:4>>*/ var _ac_ = i + 1 | 0;
+      if(_ab_ === i) break;
+      var i = _ac_;
      }
     }
      /*<<bytes.ml:221:4>>*/ return s$0;
@@ -4950,18 +4952,18 @@
      /*<<bytes.ml:233:12>>*/ var
       /*<<bytes.ml:233:12>>*/ r =
         /*<<bytes.ml:233:12>>*/ caml_create_bytes(l),
-      /*<<bytes.ml:234:4>>*/ _Z_ = l - 1 | 0,
-      /*<<bytes.ml:233:12>>*/ _Y_ = 0;
-    if(_Z_ >= 0){
-     var i = _Y_;
+      /*<<bytes.ml:234:4>>*/ _Y_ = l - 1 | 0,
+      /*<<bytes.ml:233:12>>*/ _X_ = 0;
+    if(_Y_ >= 0){
+     var i = _X_;
      for(;;){
       caml_bytes_unsafe_set
        (r,
         i,
          /*<<bytes.ml:234:41>>*/ caml_call1(f, caml_bytes_unsafe_get(s, i)));
-       /*<<bytes.ml:234:4>>*/  /*<<bytes.ml:234:4>>*/ var ___ = i + 1 | 0;
-      if(_Z_ === i) break;
-      var i = ___;
+       /*<<bytes.ml:234:4>>*/  /*<<bytes.ml:234:4>>*/ var _Z_ = i + 1 | 0;
+      if(_Y_ === i) break;
+      var i = _Z_;
      }
     }
      /*<<bytes.ml:235:4>>*/ return r;
@@ -4972,18 +4974,18 @@
      /*<<bytes.ml:241:12>>*/ var
       /*<<bytes.ml:241:12>>*/ r =
         /*<<bytes.ml:241:12>>*/ caml_create_bytes(l),
-      /*<<bytes.ml:242:4>>*/ _W_ = l - 1 | 0,
-      /*<<bytes.ml:241:12>>*/ _V_ = 0;
-    if(_W_ >= 0){
-     var i = _V_;
+      /*<<bytes.ml:242:4>>*/ _V_ = l - 1 | 0,
+      /*<<bytes.ml:241:12>>*/ _U_ = 0;
+    if(_V_ >= 0){
+     var i = _U_;
      for(;;){
       caml_bytes_unsafe_set
        (r,
         i,
          /*<<bytes.ml:242:41>>*/ caml_call2(f, i, caml_bytes_unsafe_get(s, i)));
-       /*<<bytes.ml:242:4>>*/  /*<<bytes.ml:242:4>>*/ var _X_ = i + 1 | 0;
-      if(_W_ === i) break;
-      var i = _X_;
+       /*<<bytes.ml:242:4>>*/  /*<<bytes.ml:242:4>>*/ var _W_ = i + 1 | 0;
+      if(_V_ === i) break;
+      var i = _W_;
      }
     }
      /*<<bytes.ml:243:4>>*/ return r;
@@ -4991,17 +4993,17 @@
    function fold_left(f, x, a){
      /*<<bytes.ml:247:2>>*/ var
       /*<<bytes.ml:247:10>>*/ r = [0, x],
-     _T_ = caml_ml_bytes_length(a) - 1 | 0,
-      /*<<bytes.ml:247:10>>*/ _S_ = 0;
-    if(_T_ >= 0){
-     var i = _S_;
+     _S_ = caml_ml_bytes_length(a) - 1 | 0,
+      /*<<bytes.ml:247:10>>*/ _R_ = 0;
+    if(_S_ >= 0){
+     var i = _R_;
      for(;;){
       r[1] =
         /*<<bytes.ml:249:9>>*/ caml_call2
         (f, r[1], caml_bytes_unsafe_get(a, i));
-       /*<<bytes.ml:248:2>>*/  /*<<bytes.ml:248:2>>*/ var _U_ = i + 1 | 0;
-      if(_T_ === i) break;
-      var i = _U_;
+       /*<<bytes.ml:248:2>>*/  /*<<bytes.ml:248:2>>*/ var _T_ = i + 1 | 0;
+      if(_S_ === i) break;
+      var i = _T_;
      }
     }
     return r[1];
@@ -5009,17 +5011,17 @@
    function fold_right(f, a, x){
      /*<<bytes.ml:254:2>>*/ var
       /*<<bytes.ml:254:10>>*/ r = [0, x],
-      /*<<bytes.ml:255:2>>*/ _Q_ =
+      /*<<bytes.ml:255:2>>*/ _P_ =
         /*<<bytes.ml:255:2>>*/ caml_ml_bytes_length(a) - 1 | 0;
-    if(_Q_ >= 0){
-     var i = _Q_;
+    if(_P_ >= 0){
+     var i = _P_;
      for(;;){
       r[1] =
         /*<<bytes.ml:256:9>>*/ caml_call2
         (f, caml_bytes_unsafe_get(a, i), r[1]);
-       /*<<bytes.ml:255:2>>*/  /*<<bytes.ml:255:2>>*/ var _R_ = i - 1 | 0;
+       /*<<bytes.ml:255:2>>*/  /*<<bytes.ml:255:2>>*/ var _Q_ = i - 1 | 0;
       if(0 === i) break;
-      var i = _R_;
+      var i = _Q_;
      }
     }
     return r[1];
@@ -5074,8 +5076,8 @@
      /*<<bytes.ml:291:2>>*/ var
      len_s = caml_ml_bytes_length(s),
      len_pre = caml_ml_bytes_length(prefix),
-     _P_ = len_pre <= len_s ? 1 : 0;
-    if(! _P_) return _P_;
+     _O_ = len_pre <= len_s ? 1 : 0;
+    if(! _O_) return _O_;
     var i = 0;
      /*<<bytes.ml:294:4>>*/ for(;;){
      if(i === len_pre)  /*<<bytes.ml:294:24>>*/ return 1;
@@ -5091,8 +5093,8 @@
      len_s = caml_ml_bytes_length(s),
      len_suf = caml_ml_bytes_length(suffix),
      diff = len_s - len_suf | 0,
-     _O_ = 0 <= diff ? 1 : 0;
-    if(! _O_) return _O_;
+     _N_ = 0 <= diff ? 1 : 0;
+    if(! _N_) return _N_;
     var i = 0;
      /*<<bytes.ml:305:4>>*/ for(;;){
      if(i === len_suf)  /*<<bytes.ml:305:24>>*/ return 1;
@@ -5191,13 +5193,13 @@
     if(0 <= i && l >= i)
       /*<<bytes.ml:377:4>>*/ try{
        /*<<bytes.ml:377:15>>*/ index_rec(s, l, i, c);
-       /*<<bytes.ml:377:36>>*/  /*<<bytes.ml:377:36>>*/ var _M_ = 1;
-       /*<<bytes.ml:377:36>>*/ return _M_;
+       /*<<bytes.ml:377:36>>*/  /*<<bytes.ml:377:36>>*/ var _L_ = 1;
+       /*<<bytes.ml:377:36>>*/ return _L_;
      }
-     catch(_N_){
-      var _L_ = caml_wrap_exception(_N_);
-      if(_L_ === Stdlib[8])  /*<<bytes.ml:377:59>>*/ return 0;
-      throw caml_maybe_attach_backtrace(_L_, 0);
+     catch(_M_){
+      var _K_ = caml_wrap_exception(_M_);
+      if(_K_ === Stdlib[8])  /*<<bytes.ml:377:59>>*/ return 0;
+      throw caml_maybe_attach_backtrace(_K_, 0);
      }
      /*<<bytes.ml:375:4>>*/ return  /*<<bytes.ml:375:4>>*/ caml_call1
             (Stdlib[1], cst_String_contains_from_Bytes);
@@ -5209,13 +5211,13 @@
      /*<<bytes.ml:385:2>>*/ if(0 <= i && caml_ml_bytes_length(s) > i)
       /*<<bytes.ml:388:4>>*/ try{
        /*<<bytes.ml:388:15>>*/ rindex_rec(s, i, c);
-       /*<<bytes.ml:388:35>>*/  /*<<bytes.ml:388:35>>*/ var _J_ = 1;
-       /*<<bytes.ml:388:35>>*/ return _J_;
+       /*<<bytes.ml:388:35>>*/  /*<<bytes.ml:388:35>>*/ var _I_ = 1;
+       /*<<bytes.ml:388:35>>*/ return _I_;
      }
-     catch(_K_){
-      var _I_ = caml_wrap_exception(_K_);
-      if(_I_ === Stdlib[8])  /*<<bytes.ml:388:58>>*/ return 0;
-      throw caml_maybe_attach_backtrace(_I_, 0);
+     catch(_J_){
+      var _H_ = caml_wrap_exception(_J_);
+      if(_H_ === Stdlib[8])  /*<<bytes.ml:388:58>>*/ return 0;
+      throw caml_maybe_attach_backtrace(_H_, 0);
      }
      /*<<bytes.ml:386:4>>*/ return  /*<<bytes.ml:386:4>>*/ caml_call1
             (Stdlib[1], cst_String_rcontains_from_Byte);
@@ -5226,23 +5228,23 @@
       /*<<bytes.ml:398:10>>*/ r = [0, 0],
       /*<<bytes.ml:399:10>>*/ j =
        [0,  /*<<bytes.ml:399:2>>*/ caml_ml_bytes_length(s)],
-      /*<<bytes.ml:400:2>>*/ _E_ =
+      /*<<bytes.ml:400:2>>*/ _D_ =
         /*<<bytes.ml:400:2>>*/ caml_ml_bytes_length(s) - 1 | 0;
-    if(_E_ >= 0){
-     var i = _E_;
+    if(_D_ >= 0){
+     var i = _D_;
      for(;;){
       if(caml_bytes_unsafe_get(s, i) === sep){
-       var _G_ = r[1];
-       r[1] = [0, sub(s, i + 1 | 0, (j[1] - i | 0) - 1 | 0), _G_];
+       var _F_ = r[1];
+       r[1] = [0, sub(s, i + 1 | 0, (j[1] - i | 0) - 1 | 0), _F_];
        j[1] = i;
       }
-       /*<<bytes.ml:400:2>>*/  /*<<bytes.ml:400:2>>*/ var _H_ = i - 1 | 0;
+       /*<<bytes.ml:400:2>>*/  /*<<bytes.ml:400:2>>*/ var _G_ = i - 1 | 0;
       if(0 === i) break;
-      var i = _H_;
+      var i = _G_;
      }
     }
-    var _F_ = r[1];
-     /*<<bytes.ml:406:2>>*/ return [0, sub(s, 0, j[1]), _F_];
+    var _E_ = r[1];
+     /*<<bytes.ml:406:2>>*/ return [0, sub(s, 0, j[1]), _E_];
     /*<<bytes.ml:406:18>>*/ }
    function to_seq(s){
     function aux(i, param){
@@ -5251,14 +5253,14 @@
       /*<<bytes.ml:414:14>>*/ var
        /*<<bytes.ml:414:14>>*/ x =
          /*<<bytes.ml:414:14>>*/ caml_bytes_get(s, i),
-       /*<<bytes.ml:414:14>>*/ _C_ = i + 1 | 0;
+       /*<<bytes.ml:414:14>>*/ _B_ = i + 1 | 0;
       /*<<bytes.ml:415:6>>*/ return [0,
              x,
-             function(_D_){ /*<<?>>*/ return aux(_C_, _D_);}];
+             function(_C_){ /*<<?>>*/ return aux(_B_, _C_);}];
      /*<<bytes.ml:415:29>>*/ }
-     /*<<bytes.ml:417:2>>*/  /*<<bytes.ml:417:2>>*/ var _A_ = 0;
-     /*<<bytes.ml:417:2>>*/ return function(_B_){
-      /*<<?>>*/ return aux(_A_, _B_);};
+     /*<<bytes.ml:417:2>>*/  /*<<bytes.ml:417:2>>*/ var _z_ = 0;
+     /*<<bytes.ml:417:2>>*/ return function(_A_){
+      /*<<?>>*/ return aux(_z_, _A_);};
     /*<<bytes.ml:417:7>>*/ }
    function to_seqi(s){
     function aux(i, param){
@@ -5267,20 +5269,20 @@
       /*<<bytes.ml:423:14>>*/ var
        /*<<bytes.ml:423:14>>*/ x =
          /*<<bytes.ml:423:14>>*/ caml_bytes_get(s, i),
-       /*<<bytes.ml:423:14>>*/ _y_ = i + 1 | 0;
+       /*<<bytes.ml:423:14>>*/ _x_ = i + 1 | 0;
       /*<<bytes.ml:424:6>>*/ return [0,
              [0, i, x],
-             function(_z_){ /*<<?>>*/ return aux(_y_, _z_);}];
+             function(_y_){ /*<<?>>*/ return aux(_x_, _y_);}];
      /*<<bytes.ml:424:33>>*/ }
-     /*<<bytes.ml:426:2>>*/  /*<<bytes.ml:426:2>>*/ var _w_ = 0;
-     /*<<bytes.ml:426:2>>*/ return function(_x_){
-      /*<<?>>*/ return aux(_w_, _x_);};
+     /*<<bytes.ml:426:2>>*/  /*<<bytes.ml:426:2>>*/ var _v_ = 0;
+     /*<<bytes.ml:426:2>>*/ return function(_w_){
+      /*<<?>>*/ return aux(_v_, _w_);};
     /*<<bytes.ml:426:7>>*/ }
    function of_seq(i){
      /*<<bytes.ml:429:2>>*/ var
       /*<<bytes.ml:429:10>>*/ n = [0, 0],
       /*<<bytes.ml:430:12>>*/ buf = [0, make(256, 0)];
-    function _v_(c){
+    function _u_(c){
       /*<<bytes.ml:441:7>>*/ if(n[1] === caml_ml_bytes_length(buf[1])){
        /*<<bytes.ml:433:18>>*/  /*<<bytes.ml:433:18>>*/ var
        new_len =
@@ -5302,7 +5304,7 @@
      return 0;
      /*<<bytes.ml:443:13>>*/ }
      /*<<bytes.ml:439:2>>*/  /*<<bytes.ml:439:2>>*/ caml_call2
-     (Stdlib_Seq[4], _v_, i);
+     (Stdlib_Seq[4], _u_, i);
     return sub(buf[1], 0, n[1]);
     /*<<bytes.ml:445:15>>*/ }
    function unsafe_get_uint16_le(b, i){
@@ -5319,9 +5321,9 @@
     /*<<bytes.ml:477:40>>*/ }
    function get_int8(b, i){
      /*<<bytes.ml:480:2>>*/ var
-      /*<<bytes.ml:480:2>>*/ _t_ = Stdlib_Sys[10] - 8 | 0,
-     _u_ = Stdlib_Sys[10] - 8 | 0;
-    return  /*<<bytes.ml:480:3>>*/ caml_bytes_get(b, i) << _u_ >> _t_;
+      /*<<bytes.ml:480:2>>*/ _s_ = Stdlib_Sys[10] - 8 | 0,
+     _t_ = Stdlib_Sys[10] - 8 | 0;
+    return  /*<<bytes.ml:480:3>>*/ caml_bytes_get(b, i) << _t_ >> _s_;
     /*<<bytes.ml:480:65>>*/ }
    function get_uint16_le(b, i){
      /*<<bytes.ml:483:2>>*/ return Stdlib_Sys[11]
@@ -5337,21 +5339,21 @@
     /*<<bytes.ml:488:24>>*/ }
    function get_int16_ne(b, i){
      /*<<bytes.ml:491:2>>*/ var
-      /*<<bytes.ml:491:2>>*/ _r_ = Stdlib_Sys[10] - 16 | 0,
-     _s_ = Stdlib_Sys[10] - 16 | 0;
-    return  /*<<bytes.ml:491:3>>*/ caml_bytes_get16(b, i) << _s_ >> _r_;
+      /*<<bytes.ml:491:2>>*/ _q_ = Stdlib_Sys[10] - 16 | 0,
+     _r_ = Stdlib_Sys[10] - 16 | 0;
+    return  /*<<bytes.ml:491:3>>*/ caml_bytes_get16(b, i) << _r_ >> _q_;
     /*<<bytes.ml:491:71>>*/ }
    function get_int16_le(b, i){
      /*<<bytes.ml:494:2>>*/ var
-      /*<<bytes.ml:494:2>>*/ _p_ = Stdlib_Sys[10] - 16 | 0,
-     _q_ = Stdlib_Sys[10] - 16 | 0;
-    return get_uint16_le(b, i) << _q_ >> _p_;
+      /*<<bytes.ml:494:2>>*/ _o_ = Stdlib_Sys[10] - 16 | 0,
+     _p_ = Stdlib_Sys[10] - 16 | 0;
+    return get_uint16_le(b, i) << _p_ >> _o_;
     /*<<bytes.ml:494:71>>*/ }
    function get_int16_be(b, i){
      /*<<bytes.ml:497:2>>*/ var
-      /*<<bytes.ml:497:2>>*/ _n_ = Stdlib_Sys[10] - 16 | 0,
-     _o_ = Stdlib_Sys[10] - 16 | 0;
-    return get_uint16_be(b, i) << _o_ >> _n_;
+      /*<<bytes.ml:497:2>>*/ _m_ = Stdlib_Sys[10] - 16 | 0,
+     _n_ = Stdlib_Sys[10] - 16 | 0;
+    return get_uint16_be(b, i) << _n_ >> _m_;
     /*<<bytes.ml:497:71>>*/ }
    function get_int32_le(b, i){
      /*<<bytes.ml:500:2>>*/ return Stdlib_Sys[11]
@@ -5381,15 +5383,15 @@
      /*<<bytes.ml:516:2>>*/ return Stdlib_Sys[11]
             ? ( /*<<bytes.ml:517:7>>*/ caml_bytes_set16
                (b, i, caml_bswap16(x)),
-              _g_)
-            : ( /*<<bytes.ml:518:7>>*/ caml_bytes_set16(b, i, x), _g_);
+              sentinal)
+            : ( /*<<bytes.ml:518:7>>*/ caml_bytes_set16(b, i, x), sentinal);
     /*<<bytes.ml:518:33>>*/ }
    function unsafe_set_uint16_be(b, i, x){
      /*<<bytes.ml:521:2>>*/ return Stdlib_Sys[11]
-            ? ( /*<<bytes.ml:522:7>>*/ caml_bytes_set16(b, i, x), _g_)
+            ? ( /*<<bytes.ml:522:7>>*/ caml_bytes_set16(b, i, x), sentinal)
             : ( /*<<bytes.ml:523:2>>*/ caml_bytes_set16
                (b, i, caml_bswap16(x)),
-              _g_);
+              sentinal);
     /*<<bytes.ml:523:37>>*/ }
    function set_int16_le(b, i, x){
      /*<<bytes.ml:526:2>>*/ return Stdlib_Sys[11]
@@ -5431,9 +5433,9 @@
     dec_invalid = Stdlib_Uchar[22];
    function dec_ret(n, u){
      /*<<bytes.ml:557:27>>*/  /*<<bytes.ml:557:46>>*/ var
-     _m_ =  /*<<bytes.ml:557:46>>*/ caml_call1(Stdlib_Uchar[9], u);
+     _l_ =  /*<<bytes.ml:557:46>>*/ caml_call1(Stdlib_Uchar[9], u);
      /*<<bytes.ml:557:46>>*/ return  /*<<bytes.ml:557:46>>*/ caml_call2
-            (Stdlib_Uchar[21], n, _m_);
+            (Stdlib_Uchar[21], n, _l_);
     /*<<bytes.ml:557:69>>*/ }
    function not_in_x80_to_xBF(b){
      /*<<bytes.ml:575:35>>*/ return 2 !== (b >>> 6 | 0) ? 1 : 0;
@@ -5446,9 +5448,9 @@
     /*<<bytes.ml:577:51>>*/ }
    function not_in_x90_to_xBF(b){
      /*<<bytes.ml:578:35>>*/ var
-     _k_ = b < 144 ? 1 : 0,
-     _l_ = _k_ || (191 < b ? 1 : 0);
-    return _l_;
+     _j_ = b < 144 ? 1 : 0,
+     _k_ = _j_ || (191 < b ? 1 : 0);
+    return _k_;
     /*<<bytes.ml:578:55>>*/ }
    function not_in_x80_to_x8F(b){
      /*<<bytes.ml:579:35>>*/ return 8 !== (b >>> 4 | 0) ? 1 : 0;
@@ -5645,9 +5647,9 @@
             (dec_invalid, 1);
     /*<<bytes.ml:648:22>>*/ }
    function set_utf_8_uchar(b, i, u){
-     /*<<bytes.ml:651:2>>*/ function set(_j_, _i_, _h_){
-      /*<<?>>*/ caml_bytes_unsafe_set(_j_, _i_, _h_);
-     return _g_;
+     /*<<bytes.ml:651:2>>*/ function set(_i_, _h_, _g_){
+      /*<<?>>*/ caml_bytes_unsafe_set(_i_, _h_, _g_);
+     return sentinal;
     }
      /*<<bytes.ml:652:2>>*/ var
       /*<<bytes.ml:652:2>>*/ max =
@@ -6861,7 +6863,7 @@
             : runtime.caml_call_gen(f, [a0, a1, a2]);
    }
     /*<<array.ml:37:20>>*/ var
-    _b_ = undefined,
+    sentinal = undefined,
     global_data = runtime.caml_get_global_data(),
     Stdlib_Seq = global_data.Stdlib__Seq,
     Assert_failure = global_data.Assert_failure,
@@ -6889,16 +6891,16 @@
       /*<<array.ml:53:13>>*/ res =
         /*<<array.ml:53:13>>*/ caml_make_vect
         (l,  /*<<array.ml:53:22>>*/ caml_call1(f, 0)),
-      /*<<array.ml:54:3>>*/ _at_ = l - 1 | 0,
-      /*<<array.ml:53:13>>*/ _as_ = 1;
-    if(_at_ >= 1){
-     var i = _as_;
+      /*<<array.ml:54:3>>*/ _as_ = l - 1 | 0,
+      /*<<array.ml:53:13>>*/ _ar_ = 1;
+    if(_as_ >= 1){
+     var i = _ar_;
      for(;;){
        /*<<array.ml:55:5>>*/ res[1 + i] =
         /*<<array.ml:55:22>>*/ caml_call1(f, i);
-       /*<<array.ml:55:5>>*/  /*<<array.ml:55:5>>*/ var _au_ = i + 1 | 0;
-      if(_at_ === i) break;
-      var i = _au_;
+       /*<<array.ml:55:5>>*/  /*<<array.ml:55:5>>*/ var _at_ = i + 1 | 0;
+      if(_as_ === i) break;
+      var i = _at_;
      }
     }
      /*<<array.ml:57:3>>*/ return res;
@@ -6907,15 +6909,15 @@
      /*<<array.ml:60:2>>*/ var
       /*<<array.ml:60:12>>*/ res =
         /*<<array.ml:60:12>>*/ caml_make_vect(sx, [0]),
-      /*<<array.ml:61:2>>*/ _aq_ = sx - 1 | 0,
-      /*<<array.ml:60:12>>*/ _ap_ = 0;
-    if(_aq_ >= 0){
-     var x = _ap_;
+      /*<<array.ml:61:2>>*/ _ap_ = sx - 1 | 0,
+      /*<<array.ml:60:12>>*/ _ao_ = 0;
+    if(_ap_ >= 0){
+     var x = _ao_;
      for(;;){
       res[1 + x] =  /*<<array.ml:62:21>>*/ caml_make_vect(sy, init);
-       /*<<array.ml:61:2>>*/  /*<<array.ml:61:2>>*/ var _ar_ = x + 1 | 0;
-      if(_aq_ === x) break;
-      var x = _ar_;
+       /*<<array.ml:61:2>>*/  /*<<array.ml:61:2>>*/ var _aq_ = x + 1 | 0;
+      if(_ap_ === x) break;
+      var x = _aq_;
      }
     }
      /*<<array.ml:64:2>>*/ return res;
@@ -6966,15 +6968,15 @@
     /*<<array.ml:89:38>>*/ }
    function iter(f, a){
      /*<<array.ml:92:2>>*/ var
-     _an_ = a.length - 1 - 1 | 0,
-      /*<<array.ml:92:2>>*/ _am_ = 0;
-    if(_an_ >= 0){
-     var i = _am_;
+     _am_ = a.length - 1 - 1 | 0,
+      /*<<array.ml:92:2>>*/ _al_ = 0;
+    if(_am_ >= 0){
+     var i = _al_;
      for(;;){
        /*<<array.ml:92:31>>*/  /*<<array.ml:92:31>>*/ caml_call1(f, a[1 + i]);
-       /*<<array.ml:92:31>>*/  /*<<array.ml:92:31>>*/ var _ao_ = i + 1 | 0;
-      if(_an_ === i) break;
-      var i = _ao_;
+       /*<<array.ml:92:31>>*/  /*<<array.ml:92:31>>*/ var _an_ = i + 1 | 0;
+      if(_am_ === i) break;
+      var i = _an_;
      }
     }
     return 0;
@@ -6984,16 +6986,16 @@
       /*<<array.ml:96:4>>*/ return  /*<<array.ml:96:4>>*/ caml_call1
              (Stdlib[1], cst_Array_iter2_arrays_must_ha);
      /*<<array.ml:98:4>>*/ var
-     _ak_ = a.length - 1 - 1 | 0,
-      /*<<array.ml:98:4>>*/ _aj_ = 0;
-    if(_ak_ >= 0){
-     var i = _aj_;
+     _aj_ = a.length - 1 - 1 | 0,
+      /*<<array.ml:98:4>>*/ _ai_ = 0;
+    if(_aj_ >= 0){
+     var i = _ai_;
      for(;;){
        /*<<array.ml:98:33>>*/  /*<<array.ml:98:33>>*/ caml_call2
        (f, a[1 + i], b[1 + i]);
-       /*<<array.ml:98:33>>*/  /*<<array.ml:98:33>>*/ var _al_ = i + 1 | 0;
-      if(_ak_ === i) break;
-      var i = _al_;
+       /*<<array.ml:98:33>>*/  /*<<array.ml:98:33>>*/ var _ak_ = i + 1 | 0;
+      if(_aj_ === i) break;
+      var i = _ak_;
      }
     }
     return 0;
@@ -7005,16 +7007,16 @@
       /*<<array.ml:103:12>>*/ r =
         /*<<array.ml:103:12>>*/ caml_make_vect
         (l,  /*<<array.ml:103:21>>*/ caml_call1(f, a[1])),
-      /*<<array.ml:104:4>>*/ _ah_ = l - 1 | 0,
-      /*<<array.ml:103:12>>*/ _ag_ = 1;
-    if(_ah_ >= 1){
-     var i = _ag_;
+      /*<<array.ml:104:4>>*/ _ag_ = l - 1 | 0,
+      /*<<array.ml:103:12>>*/ _af_ = 1;
+    if(_ag_ >= 1){
+     var i = _af_;
      for(;;){
        /*<<array.ml:105:6>>*/ r[1 + i] =
         /*<<array.ml:105:21>>*/ caml_call1(f, a[1 + i]);
-       /*<<array.ml:105:6>>*/  /*<<array.ml:105:6>>*/ var _ai_ = i + 1 | 0;
-      if(_ah_ === i) break;
-      var i = _ai_;
+       /*<<array.ml:105:6>>*/  /*<<array.ml:105:6>>*/ var _ah_ = i + 1 | 0;
+      if(_ag_ === i) break;
+      var i = _ah_;
      }
     }
      /*<<array.ml:107:4>>*/ return r;
@@ -7031,32 +7033,32 @@
       /*<<array.ml:117:14>>*/ r =
         /*<<array.ml:117:14>>*/ caml_make_vect
         (la,  /*<<array.ml:117:24>>*/ caml_call2(f, a[1], b[1])),
-      /*<<array.ml:118:6>>*/ _ae_ = la - 1 | 0,
-      /*<<array.ml:117:14>>*/ _ad_ = 1;
-    if(_ae_ >= 1){
-     var i = _ad_;
+      /*<<array.ml:118:6>>*/ _ad_ = la - 1 | 0,
+      /*<<array.ml:117:14>>*/ _ac_ = 1;
+    if(_ad_ >= 1){
+     var i = _ac_;
      for(;;){
        /*<<array.ml:119:8>>*/ r[1 + i] =
         /*<<array.ml:119:23>>*/ caml_call2(f, a[1 + i], b[1 + i]);
-       /*<<array.ml:119:8>>*/  /*<<array.ml:119:8>>*/ var _af_ = i + 1 | 0;
-      if(_ae_ === i) break;
-      var i = _af_;
+       /*<<array.ml:119:8>>*/  /*<<array.ml:119:8>>*/ var _ae_ = i + 1 | 0;
+      if(_ad_ === i) break;
+      var i = _ae_;
      }
     }
      /*<<array.ml:121:6>>*/ return r;
     /*<<array.ml:123:5>>*/ }
    function iteri(f, a){
      /*<<array.ml:126:2>>*/ var
-     _ab_ = a.length - 1 - 1 | 0,
-      /*<<array.ml:126:2>>*/ _aa_ = 0;
-    if(_ab_ >= 0){
-     var i = _aa_;
+     _aa_ = a.length - 1 - 1 | 0,
+      /*<<array.ml:126:2>>*/ _$_ = 0;
+    if(_aa_ >= 0){
+     var i = _$_;
      for(;;){
        /*<<array.ml:126:31>>*/  /*<<array.ml:126:31>>*/ caml_call2
        (f, i, a[1 + i]);
-       /*<<array.ml:126:31>>*/  /*<<array.ml:126:31>>*/ var _ac_ = i + 1 | 0;
-      if(_ab_ === i) break;
-      var i = _ac_;
+       /*<<array.ml:126:31>>*/  /*<<array.ml:126:31>>*/ var _ab_ = i + 1 | 0;
+      if(_aa_ === i) break;
+      var i = _ab_;
      }
     }
     return 0;
@@ -7068,16 +7070,16 @@
       /*<<array.ml:131:12>>*/ r =
         /*<<array.ml:131:12>>*/ caml_make_vect
         (l,  /*<<array.ml:131:21>>*/ caml_call2(f, 0, a[1])),
-      /*<<array.ml:132:4>>*/ ___ = l - 1 | 0,
-      /*<<array.ml:131:12>>*/ _Z_ = 1;
-    if(___ >= 1){
-     var i = _Z_;
+      /*<<array.ml:132:4>>*/ _Z_ = l - 1 | 0,
+      /*<<array.ml:131:12>>*/ _Y_ = 1;
+    if(_Z_ >= 1){
+     var i = _Y_;
      for(;;){
        /*<<array.ml:133:6>>*/ r[1 + i] =
         /*<<array.ml:133:21>>*/ caml_call2(f, i, a[1 + i]);
-       /*<<array.ml:133:6>>*/  /*<<array.ml:133:6>>*/ var _$_ = i + 1 | 0;
-      if(___ === i) break;
-      var i = _$_;
+       /*<<array.ml:133:6>>*/  /*<<array.ml:133:6>>*/ var ___ = i + 1 | 0;
+      if(_Z_ === i) break;
+      var i = ___;
      }
     }
      /*<<array.ml:135:4>>*/ return r;
@@ -7126,15 +7128,15 @@
    function fold_left(f, x, a){
      /*<<array.ml:158:2>>*/ var
       /*<<array.ml:158:10>>*/ r = [0, x],
-     _X_ = a.length - 1 - 1 | 0,
-      /*<<array.ml:158:10>>*/ _W_ = 0;
-    if(_X_ >= 0){
-     var i = _W_;
+     _W_ = a.length - 1 - 1 | 0,
+      /*<<array.ml:158:10>>*/ _V_ = 0;
+    if(_W_ >= 0){
+     var i = _V_;
      for(;;){
       r[1] =  /*<<array.ml:160:9>>*/ caml_call2(f, r[1], a[1 + i]);
-       /*<<array.ml:159:2>>*/  /*<<array.ml:159:2>>*/ var _Y_ = i + 1 | 0;
-      if(_X_ === i) break;
-      var i = _Y_;
+       /*<<array.ml:159:2>>*/  /*<<array.ml:159:2>>*/ var _X_ = i + 1 | 0;
+      if(_W_ === i) break;
+      var i = _X_;
      }
     }
     return r[1];
@@ -7151,10 +7153,10 @@
       /*<<array.ml:168:23>>*/ output_array =
         /*<<array.ml:168:23>>*/ caml_make_vect(len, elt),
       /*<<array.ml:169:14>>*/ acc$1 = [0, acc$0],
-      /*<<array.ml:170:4>>*/ _U_ = len - 1 | 0,
-      /*<<array.ml:169:14>>*/ _T_ = 1;
-    if(_U_ >= 1){
-     var i = _T_;
+      /*<<array.ml:170:4>>*/ _T_ = len - 1 | 0,
+      /*<<array.ml:169:14>>*/ _S_ = 1;
+    if(_T_ >= 1){
+     var i = _S_;
      for(;;){
        /*<<array.ml:171:22>>*/ var
         /*<<array.ml:171:22>>*/ match$0 =
@@ -7163,9 +7165,9 @@
        acc$2 = match$0[1];
       acc$1[1] = acc$2;
        /*<<array.ml:173:6>>*/ output_array[1 + i] = elt$0;
-       /*<<array.ml:170:4>>*/  /*<<array.ml:170:4>>*/ var _V_ = i + 1 | 0;
-      if(_U_ === i) break;
-      var i = _V_;
+       /*<<array.ml:170:4>>*/  /*<<array.ml:170:4>>*/ var _U_ = i + 1 | 0;
+      if(_T_ === i) break;
+      var i = _U_;
      }
     }
      /*<<array.ml:175:4>>*/ return [0, acc$1[1], output_array];
@@ -7173,14 +7175,14 @@
    function fold_right(f, a, x){
      /*<<array.ml:179:2>>*/ var
       /*<<array.ml:179:10>>*/ r = [0, x],
-      /*<<array.ml:180:2>>*/ _R_ = a.length - 1 - 1 | 0;
-    if(_R_ >= 0){
-     var i = _R_;
+      /*<<array.ml:180:2>>*/ _Q_ = a.length - 1 - 1 | 0;
+    if(_Q_ >= 0){
+     var i = _Q_;
      for(;;){
       r[1] =  /*<<array.ml:181:9>>*/ caml_call2(f, a[1 + i], r[1]);
-       /*<<array.ml:180:2>>*/  /*<<array.ml:180:2>>*/ var _S_ = i - 1 | 0;
+       /*<<array.ml:180:2>>*/  /*<<array.ml:180:2>>*/ var _R_ = i - 1 | 0;
       if(0 === i) break;
-      var i = _S_;
+      var i = _R_;
      }
     }
     return r[1];
@@ -7300,17 +7302,17 @@
         /*<<array.ml:264:12>>*/ caml_make_vect(n, a0),
       /*<<array.ml:265:12>>*/ b =
         /*<<array.ml:265:12>>*/ caml_make_vect(n, b0),
-      /*<<array.ml:266:4>>*/ _P_ = n - 1 | 0,
-      /*<<array.ml:265:12>>*/ _O_ = 1;
-    if(_P_ >= 1){
-     var i = _O_;
+      /*<<array.ml:266:4>>*/ _O_ = n - 1 | 0,
+      /*<<array.ml:265:12>>*/ _N_ = 1;
+    if(_O_ >= 1){
+     var i = _N_;
      for(;;){
       var match$0 = x[1 + i], bi = match$0[2], ai = match$0[1];
        /*<<array.ml:268:6>>*/ a[1 + i] = ai;
        /*<<array.ml:269:6>>*/ b[1 + i] = bi;
-       /*<<array.ml:266:4>>*/  /*<<array.ml:266:4>>*/ var _Q_ = i + 1 | 0;
-      if(_P_ === i) break;
-      var i = _Q_;
+       /*<<array.ml:266:4>>*/  /*<<array.ml:266:4>>*/ var _P_ = i + 1 | 0;
+      if(_O_ === i) break;
+      var i = _P_;
      }
     }
      /*<<array.ml:271:4>>*/ return [0, a, b];
@@ -7326,15 +7328,15 @@
      /*<<array.ml:280:12>>*/ var
       /*<<array.ml:280:12>>*/ x =
         /*<<array.ml:280:12>>*/ caml_make_vect(na, [0, a[1], b[1]]),
-      /*<<array.ml:281:4>>*/ _M_ = na - 1 | 0,
-      /*<<array.ml:280:12>>*/ _L_ = 1;
-    if(_M_ >= 1){
-     var i = _L_;
+      /*<<array.ml:281:4>>*/ _L_ = na - 1 | 0,
+      /*<<array.ml:280:12>>*/ _K_ = 1;
+    if(_L_ >= 1){
+     var i = _K_;
      for(;;){
       x[1 + i] = [0, a[1 + i], b[1 + i]];
-       /*<<array.ml:281:4>>*/  /*<<array.ml:281:4>>*/ var _N_ = i + 1 | 0;
-      if(_M_ === i) break;
-      var i = _N_;
+       /*<<array.ml:281:4>>*/  /*<<array.ml:281:4>>*/ var _M_ = i + 1 | 0;
+      if(_L_ === i) break;
+      var i = _M_;
      }
     }
      /*<<array.ml:284:4>>*/ return x;
@@ -7348,42 +7350,42 @@
        /*<<array.ml:291:12>>*/ x = [0, i31];
      if((i31 + 2 | 0) < l){
        /*<<array.ml:292:22>>*/ var
-        /*<<array.ml:292:22>>*/ _E_ = i31 + 1 | 0,
-        /*<<array.ml:293:25>>*/ _F_ = caml_check_bound(a, _E_)[1 + _E_];
+        /*<<array.ml:292:22>>*/ _D_ = i31 + 1 | 0,
+        /*<<array.ml:293:25>>*/ _E_ = caml_check_bound(a, _D_)[1 + _D_];
       if
        ( /*<<array.ml:293:9>>*/ caml_call2
-         (cmp, caml_check_bound(a, i31)[1 + i31], _F_)
+         (cmp, caml_check_bound(a, i31)[1 + i31], _E_)
         < 0)
        x[1] = i31 + 1 | 0;
        /*<<array.ml:294:6>>*/ var
-        /*<<array.ml:294:6>>*/ _G_ = i31 + 2 | 0,
-        /*<<array.ml:294:24>>*/ _H_ = caml_check_bound(a, _G_)[1 + _G_],
-       _I_ = x[1];
+        /*<<array.ml:294:6>>*/ _F_ = i31 + 2 | 0,
+        /*<<array.ml:294:24>>*/ _G_ = caml_check_bound(a, _F_)[1 + _F_],
+       _H_ = x[1];
       if
        ( /*<<array.ml:294:9>>*/ caml_call2
-         (cmp, caml_check_bound(a, _I_)[1 + _I_], _H_)
+         (cmp, caml_check_bound(a, _H_)[1 + _H_], _G_)
         < 0)
        x[1] = i31 + 2 | 0;
       return x[1];
      }
      if((i31 + 1 | 0) < l){
        /*<<array.ml:297:38>>*/ var
-       _J_ = i31 + 1 | 0,
-        /*<<array.ml:297:38>>*/ _K_ = caml_check_bound(a, _J_)[1 + _J_];
+       _I_ = i31 + 1 | 0,
+        /*<<array.ml:297:38>>*/ _J_ = caml_check_bound(a, _I_)[1 + _I_];
        /*<<array.ml:297:22>>*/ if
        (0
         >
           /*<<array.ml:297:22>>*/ caml_call2
-          (cmp, caml_check_bound(a, i31)[1 + i31], _K_))
+          (cmp, caml_check_bound(a, i31)[1 + i31], _J_))
         /*<<array.ml:298:11>>*/ return i31 + 1 | 0;
      }
      if(i31 < l)  /*<<array.ml:299:27>>*/ return i31;
       /*<<array.ml:299:36>>*/ throw  /*<<array.ml:299:36>>*/ caml_maybe_attach_backtrace
             ([0, Bottom, i], 1);
      /*<<array.ml:299:52>>*/ }
-    var l = a.length - 1, _y_ = ((l + 1 | 0) / 3 | 0) - 1 | 0;
-    if(_y_ >= 0){
-     var i$6 = _y_;
+    var l = a.length - 1, _x_ = ((l + 1 | 0) / 3 | 0) - 1 | 0;
+    if(_x_ >= 0){
+     var i$6 = _x_;
      for(;;){
        /*<<array.ml:328:50>>*/  /*<<array.ml:328:50>>*/ var
        e$1 = caml_check_bound(a, i$6)[1 + i$6];
@@ -7401,8 +7403,8 @@
          break;
         }
          /*<<array.ml:304:14>>*/  /*<<array.ml:304:14>>*/ var
-         _v_ = caml_check_bound(a, j)[1 + j];
-         /*<<array.ml:304:6>>*/ caml_check_bound(a, i)[1 + i] = _v_;
+         _u_ = caml_check_bound(a, j)[1 + j];
+         /*<<array.ml:304:6>>*/ caml_check_bound(a, i)[1 + i] = _u_;
         var i = j;
        }
       }
@@ -7412,14 +7414,14 @@
        var i$0 = exn[2];
         /*<<array.ml:310:61>>*/ caml_check_bound(a, i$0)[1 + i$0] = e$1;
       }
-       /*<<array.ml:328:38>>*/  /*<<array.ml:328:38>>*/ var _D_ = i$6 - 1 | 0;
+       /*<<array.ml:328:38>>*/  /*<<array.ml:328:38>>*/ var _C_ = i$6 - 1 | 0;
       if(0 === i$6) break;
-      var i$6 = _D_;
+      var i$6 = _C_;
      }
     }
-     /*<<array.ml:329:2>>*/  /*<<array.ml:329:2>>*/ var _z_ = l - 1 | 0;
-    if(_z_ >= 2){
-     var i$4 = _z_;
+     /*<<array.ml:329:2>>*/  /*<<array.ml:329:2>>*/ var _y_ = l - 1 | 0;
+    if(_y_ >= 2){
+     var i$4 = _y_;
      a:
      for(;;){
        /*<<array.ml:330:12>>*/  /*<<array.ml:330:12>>*/ var
@@ -7431,8 +7433,8 @@
         /*<<array.ml:312:4>>*/ for(;;){
          /*<<array.ml:312:12>>*/ var
           /*<<array.ml:312:12>>*/ j$0 = maxson(i$4, i$1),
-          /*<<array.ml:313:12>>*/ _w_ = caml_check_bound(a, j$0)[1 + j$0];
-         /*<<array.ml:313:4>>*/ caml_check_bound(a, i$1)[1 + i$1] = _w_;
+          /*<<array.ml:313:12>>*/ _v_ = caml_check_bound(a, j$0)[1 + j$0];
+         /*<<array.ml:313:4>>*/ caml_check_bound(a, i$1)[1 + i$1] = _v_;
         var i$1 = j$0;
        }
       }
@@ -7453,30 +7455,30 @@
           /*<<array.ml:323:13>>*/ caml_check_bound(a, i$3)[1 + i$3] = e$0;
         else{
           /*<<array.ml:321:14>>*/  /*<<array.ml:321:14>>*/ var
-          _x_ = caml_check_bound(a, father)[1 + father];
-          /*<<array.ml:321:6>>*/ caml_check_bound(a, i$3)[1 + i$3] = _x_;
+          _w_ = caml_check_bound(a, father)[1 + father];
+          /*<<array.ml:321:6>>*/ caml_check_bound(a, i$3)[1 + i$3] = _w_;
          if(0 < father){var i$3 = father; continue;}
           /*<<array.ml:322:49>>*/ caml_check_bound(a, 0)[1] = e$0;
         }
-         /*<<array.ml:329:2>>*/  /*<<array.ml:329:2>>*/ var _C_ = i$4 - 1 | 0;
+         /*<<array.ml:329:2>>*/  /*<<array.ml:329:2>>*/ var _B_ = i$4 - 1 | 0;
         if(2 === i$4) break a;
-        var i$4 = _C_;
+        var i$4 = _B_;
         break;
        }
       }
      }
     }
-    var _A_ = 1 < l ? 1 : 0;
-    if(_A_){
+    var _z_ = 1 < l ? 1 : 0;
+    if(_z_){
       /*<<array.ml:334:25>>*/  /*<<array.ml:334:25>>*/ var
       e = caml_check_bound(a, 1)[2];
       /*<<array.ml:334:38>>*/ a[2] = caml_check_bound(a, 0)[1];
       /*<<array.ml:334:57>>*/ a[1] = e;
-     var _B_ = 0;
+     var _A_ = 0;
     }
     else
-     var _B_ = _A_;
-     /*<<array.ml:334:57>>*/ return _B_;
+     var _A_ = _z_;
+     /*<<array.ml:334:57>>*/ return _A_;
     /*<<array.ml:334:67>>*/ }
    function stable_sort(cmp, a){
     function merge(src1ofs, src1len, src2, src2ofs, src2len, dst, dstofs){
@@ -7520,38 +7522,38 @@
      /*<<array.ml:357:70>>*/ }
     function isortto(srcofs, dst, dstofs, len){
       /*<<array.ml:360:4>>*/ var
-      _n_ = len - 1 | 0,
-       /*<<array.ml:360:4>>*/ _m_ = 0;
-     if(_n_ >= 0){
-      var i = _m_;
+      _m_ = len - 1 | 0,
+       /*<<array.ml:360:4>>*/ _l_ = 0;
+     if(_m_ >= 0){
+      var i = _l_;
       a:
       for(;;){
         /*<<array.ml:361:14>>*/ var
-        _o_ = srcofs + i | 0,
-         /*<<array.ml:361:14>>*/ e = caml_check_bound(a, _o_)[1 + _o_],
+        _n_ = srcofs + i | 0,
+         /*<<array.ml:361:14>>*/ e = caml_check_bound(a, _n_)[1 + _n_],
          /*<<array.ml:362:14>>*/ j = [0, (dstofs + i | 0) - 1 | 0];
        for(;;){
         if(dstofs <= j[1]){
-         var _p_ = j[1];
+         var _o_ = j[1];
           /*<<array.ml:363:29>>*/ if
           (0
            <
              /*<<array.ml:363:29>>*/ caml_call2
-             (cmp, caml_check_bound(dst, _p_)[1 + _p_], e)){
+             (cmp, caml_check_bound(dst, _o_)[1 + _o_], e)){
            /*<<array.ml:364:25>>*/ var
-           _q_ = j[1],
-            /*<<array.ml:364:25>>*/ _r_ = caml_check_bound(dst, _q_)[1 + _q_],
-           _s_ = j[1] + 1 | 0;
-           /*<<array.ml:364:8>>*/ caml_check_bound(dst, _s_)[1 + _s_] = _r_;
+           _p_ = j[1],
+            /*<<array.ml:364:25>>*/ _q_ = caml_check_bound(dst, _p_)[1 + _p_],
+           _r_ = j[1] + 1 | 0;
+           /*<<array.ml:364:8>>*/ caml_check_bound(dst, _r_)[1 + _r_] = _q_;
           j[1] += -1;
           continue;
          }
         }
-        var _t_ = j[1] + 1 | 0;
-         /*<<array.ml:367:6>>*/ caml_check_bound(dst, _t_)[1 + _t_] = e;
-         /*<<array.ml:360:4>>*/  /*<<array.ml:360:4>>*/ var _u_ = i + 1 | 0;
-        if(_n_ === i) break a;
-        var i = _u_;
+        var _s_ = j[1] + 1 | 0;
+         /*<<array.ml:367:6>>*/ caml_check_bound(dst, _s_)[1 + _s_] = e;
+         /*<<array.ml:360:4>>*/  /*<<array.ml:360:4>>*/ var _t_ = i + 1 | 0;
+        if(_m_ === i) break a;
+        var i = _t_;
         break;
        }
       }
@@ -7561,14 +7563,14 @@
     function sortto(srcofs, dst, dstofs, len){
       /*<<array.ml:371:4>>*/ if(len <= 5){
        /*<<array.ml:371:26>>*/ isortto(srcofs, dst, dstofs, len);
-       /*<<array.ml:371:26>>*/ return _b_;
+       /*<<array.ml:371:26>>*/ return sentinal;
      }
      var l1 = len / 2 | 0, l2 = len - l1 | 0;
       /*<<array.ml:374:6>>*/ sortto(srcofs + l1 | 0, dst, dstofs + l1 | 0, l2);
       /*<<array.ml:375:6>>*/ sortto(srcofs, a, srcofs + l2 | 0, l1);
       /*<<array.ml:375:6>>*/ merge
       (srcofs + l2 | 0, l1, dst, dstofs + l1 | 0, l2, dst, dstofs);
-      /*<<array.ml:375:6>>*/ return _b_;
+      /*<<array.ml:375:6>>*/ return sentinal;
      /*<<array.ml:377:7>>*/ }
     var l = a.length - 1;
     if(l <= 5)  /*<<array.ml:380:22>>*/ return isortto(0, a, 0, l);
@@ -7587,14 +7589,14 @@
        /*<<array.ml:400:9>>*/ return 0;
       /*<<array.ml:398:14>>*/ var
        /*<<array.ml:398:14>>*/ x = a[1 + i],
-       /*<<array.ml:398:14>>*/ _k_ = i + 1 | 0;
+       /*<<array.ml:398:14>>*/ _j_ = i + 1 | 0;
       /*<<array.ml:399:6>>*/ return [0,
              x,
-             function(_l_){ /*<<?>>*/ return aux(_k_, _l_);}];
+             function(_k_){ /*<<?>>*/ return aux(_j_, _k_);}];
      /*<<array.ml:400:16>>*/ }
-     /*<<array.ml:402:2>>*/  /*<<array.ml:402:2>>*/ var _i_ = 0;
-     /*<<array.ml:402:2>>*/ return function(_j_){
-      /*<<?>>*/ return aux(_i_, _j_);};
+     /*<<array.ml:402:2>>*/  /*<<array.ml:402:2>>*/ var _h_ = 0;
+     /*<<array.ml:402:2>>*/ return function(_i_){
+      /*<<?>>*/ return aux(_h_, _i_);};
     /*<<array.ml:402:7>>*/ }
    function to_seqi(a){
     function aux(i, param){
@@ -7602,22 +7604,22 @@
        /*<<array.ml:410:9>>*/ return 0;
       /*<<array.ml:408:14>>*/ var
        /*<<array.ml:408:14>>*/ x = a[1 + i],
-       /*<<array.ml:408:14>>*/ _g_ = i + 1 | 0;
+       /*<<array.ml:408:14>>*/ _f_ = i + 1 | 0;
       /*<<array.ml:409:6>>*/ return [0,
              [0, i, x],
-             function(_h_){ /*<<?>>*/ return aux(_g_, _h_);}];
+             function(_g_){ /*<<?>>*/ return aux(_f_, _g_);}];
      /*<<array.ml:410:16>>*/ }
-     /*<<array.ml:412:2>>*/  /*<<array.ml:412:2>>*/ var _e_ = 0;
-     /*<<array.ml:412:2>>*/ return function(_f_){
-      /*<<?>>*/ return aux(_e_, _f_);};
+     /*<<array.ml:412:2>>*/  /*<<array.ml:412:2>>*/ var _d_ = 0;
+     /*<<array.ml:412:2>>*/ return function(_e_){
+      /*<<?>>*/ return aux(_d_, _e_);};
     /*<<array.ml:412:7>>*/ }
    function of_seq(i$2){
-     /*<<array.ml:426:2>>*/ var _c_ = 0;
-    function _d_(acc, x){
+     /*<<array.ml:426:2>>*/ var _b_ = 0;
+    function _c_(acc, x){
       /*<<array.ml:426:38>>*/ return [0, x, acc];
      /*<<array.ml:426:44>>*/ }
      /*<<array.ml:426:10>>*/  /*<<array.ml:426:10>>*/ var
-     l =  /*<<array.ml:426:10>>*/ caml_call3(Stdlib_Seq[5], _d_, _c_, i$2);
+     l =  /*<<array.ml:426:10>>*/ caml_call3(Stdlib_Seq[5], _c_, _b_, i$2);
     if(! l)  /*<<array.ml:415:10>>*/ return [0];
      /*<<array.ml:417:16>>*/ var
      tl = l[2],
@@ -7716,7 +7718,7 @@
             : runtime.caml_call_gen(f, [a0, a1, a2]);
    }
    var
-    _j_ = undefined,
+    sentinal = undefined,
     global_data = runtime.caml_get_global_data(),
     Stdlib_Seq = global_data.Stdlib__Seq,
     Stdlib_List = global_data.Stdlib__List,
@@ -7759,8 +7761,8 @@
     pi = 3.141592653589793;
    function is_integer(x){
      /*<<float.ml:111:19>>*/ var
-     _ar_ = x ==  /*<<float.ml:111:23>>*/ runtime.caml_trunc_float(x) ? 1 : 0;
-    return _ar_ ? is_finite(x) : _ar_;
+     _aq_ = x ==  /*<<float.ml:111:23>>*/ runtime.caml_trunc_float(x) ? 1 : 0;
+    return _aq_ ? is_finite(x) : _aq_;
     /*<<float.ml:111:45>>*/ }
    function succ(x){
      /*<<float.ml:116:13>>*/ return  /*<<float.ml:116:13>>*/ caml_nextafter_float
@@ -7857,34 +7859,34 @@
             (10, 100, 0, x);
     /*<<float.ml:164:41>>*/ }
    function unsafe_fill(a, ofs, len, v){
-     /*<<float.ml:178:4>>*/ var _ap_ = (ofs + len | 0) - 1 | 0;
-    if(_ap_ >= ofs){
+     /*<<float.ml:178:4>>*/ var _ao_ = (ofs + len | 0) - 1 | 0;
+    if(_ao_ >= ofs){
      var i = ofs;
      for(;;){
        /*<<float.ml:178:36>>*/ a[1 + i] = v;
-       /*<<float.ml:178:36>>*/  /*<<float.ml:178:36>>*/ var _aq_ = i + 1 | 0;
-      if(_ap_ === i) break;
-      var i = _aq_;
+       /*<<float.ml:178:36>>*/  /*<<float.ml:178:36>>*/ var _ap_ = i + 1 | 0;
+      if(_ao_ === i) break;
+      var i = _ap_;
      }
     }
     return 0;
     /*<<float.ml:178:57>>*/ }
    function check(a, ofs, len, msg){
-     /*<<float.ml:184:4>>*/ var _al_ = ofs < 0 ? 1 : 0;
-    if(_al_)
-     var _am_ = _al_;
+     /*<<float.ml:184:4>>*/ var _ak_ = ofs < 0 ? 1 : 0;
+    if(_ak_)
+     var _al_ = _ak_;
     else{
-     var _an_ = len < 0 ? 1 : 0;
-     if(_an_)
-      var _am_ = _an_;
+     var _am_ = len < 0 ? 1 : 0;
+     if(_am_)
+      var _al_ = _am_;
      else
       var
-       _ao_ = (ofs + len | 0) < 0 ? 1 : 0,
-       _am_ = _ao_ || (a.length - 1 < (ofs + len | 0) ? 1 : 0);
+       _an_ = (ofs + len | 0) < 0 ? 1 : 0,
+       _al_ = _an_ || (a.length - 1 < (ofs + len | 0) ? 1 : 0);
     }
-    return _am_
-            ? ( /*<<float.ml:185:6>>*/ caml_call1(Stdlib[1], msg), _j_)
-            : _am_;
+    return _al_
+            ? ( /*<<float.ml:185:6>>*/ caml_call1(Stdlib[1], msg), sentinal)
+            : _al_;
     /*<<float.ml:185:21>>*/ }
    function make(n, v){
      /*<<float.ml:188:4>>*/  /*<<float.ml:188:17>>*/ var
@@ -7899,16 +7901,16 @@
      /*<<float.ml:195:16>>*/ var
       /*<<float.ml:195:16>>*/ res =
         /*<<float.ml:195:16>>*/ caml_floatarray_create(l),
-      /*<<float.ml:196:6>>*/ _aj_ = l - 1 | 0,
-      /*<<float.ml:195:16>>*/ _ai_ = 0;
-    if(_aj_ >= 0){
-     var i = _ai_;
+      /*<<float.ml:196:6>>*/ _ai_ = l - 1 | 0,
+      /*<<float.ml:195:16>>*/ _ah_ = 0;
+    if(_ai_ >= 0){
+     var i = _ah_;
      for(;;){
        /*<<float.ml:197:8>>*/ res[1 + i] =
         /*<<float.ml:197:25>>*/ caml_call1(f, i);
-       /*<<float.ml:197:8>>*/  /*<<float.ml:197:8>>*/ var _ak_ = i + 1 | 0;
-      if(_aj_ === i) break;
-      var i = _ak_;
+       /*<<float.ml:197:8>>*/  /*<<float.ml:197:8>>*/ var _aj_ = i + 1 | 0;
+      if(_ai_ === i) break;
+      var i = _aj_;
      }
     }
      /*<<float.ml:199:6>>*/ return res;
@@ -7990,11 +7992,11 @@
             (src, sofs, dst, dofs, len);
     /*<<float.ml:250:37>>*/ }
    function to_list(a){
-     /*<<float.ml:253:25>>*/ function _ag_(_ah_){
-      /*<<?>>*/ return a[1 + _ah_];
+     /*<<float.ml:253:25>>*/ function _af_(_ag_){
+      /*<<?>>*/ return a[1 + _ag_];
     }
      /*<<float.ml:253:25>>*/ return  /*<<float.ml:253:25>>*/ caml_call2
-            (Stdlib_List[10], a.length - 1, _ag_);
+            (Stdlib_List[10], a.length - 1, _af_);
     /*<<float.ml:253:39>>*/ }
    function of_list(l){
      /*<<float.ml:256:4>>*/ var
@@ -8015,16 +8017,16 @@
     /*<<float.ml:262:12>>*/ }
    function iter(f, a){
      /*<<float.ml:266:4>>*/ var
-     _ae_ = a.length - 1 - 1 | 0,
-      /*<<float.ml:266:4>>*/ _ad_ = 0;
-    if(_ae_ >= 0){
-     var i = _ad_;
+     _ad_ = a.length - 1 - 1 | 0,
+      /*<<float.ml:266:4>>*/ _ac_ = 0;
+    if(_ad_ >= 0){
+     var i = _ac_;
      for(;;){
        /*<<float.ml:266:33>>*/  /*<<float.ml:266:33>>*/ caml_call1
        (f, a[1 + i]);
-       /*<<float.ml:266:33>>*/  /*<<float.ml:266:33>>*/ var _af_ = i + 1 | 0;
-      if(_ae_ === i) break;
-      var i = _af_;
+       /*<<float.ml:266:33>>*/  /*<<float.ml:266:33>>*/ var _ae_ = i + 1 | 0;
+      if(_ad_ === i) break;
+      var i = _ae_;
      }
     }
     return 0;
@@ -8034,16 +8036,16 @@
       /*<<float.ml:271:6>>*/ return  /*<<float.ml:271:6>>*/ caml_call1
              (Stdlib[1], cst_Float_Array_iter2_arrays_m);
      /*<<float.ml:273:6>>*/ var
-     _ab_ = a.length - 1 - 1 | 0,
-      /*<<float.ml:273:6>>*/ _aa_ = 0;
-    if(_ab_ >= 0){
-     var i = _aa_;
+     _aa_ = a.length - 1 - 1 | 0,
+      /*<<float.ml:273:6>>*/ _$_ = 0;
+    if(_aa_ >= 0){
+     var i = _$_;
      for(;;){
        /*<<float.ml:273:35>>*/  /*<<float.ml:273:35>>*/ caml_call2
        (f, a[1 + i], b[1 + i]);
-       /*<<float.ml:273:35>>*/  /*<<float.ml:273:35>>*/ var _ac_ = i + 1 | 0;
-      if(_ab_ === i) break;
-      var i = _ac_;
+       /*<<float.ml:273:35>>*/  /*<<float.ml:273:35>>*/ var _ab_ = i + 1 | 0;
+      if(_aa_ === i) break;
+      var i = _ab_;
      }
     }
     return 0;
@@ -8053,16 +8055,16 @@
      l = a.length - 1,
       /*<<float.ml:277:12>>*/ r =
         /*<<float.ml:277:12>>*/ caml_floatarray_create(l),
-      /*<<float.ml:278:4>>*/ ___ = l - 1 | 0,
-      /*<<float.ml:277:12>>*/ _Z_ = 0;
-    if(___ >= 0){
-     var i = _Z_;
+      /*<<float.ml:278:4>>*/ _Z_ = l - 1 | 0,
+      /*<<float.ml:277:12>>*/ _Y_ = 0;
+    if(_Z_ >= 0){
+     var i = _Y_;
      for(;;){
        /*<<float.ml:279:6>>*/ r[1 + i] =
         /*<<float.ml:279:21>>*/ caml_call1(f, a[1 + i]);
-       /*<<float.ml:279:6>>*/  /*<<float.ml:279:6>>*/ var _$_ = i + 1 | 0;
-      if(___ === i) break;
-      var i = _$_;
+       /*<<float.ml:279:6>>*/  /*<<float.ml:279:6>>*/ var ___ = i + 1 | 0;
+      if(_Z_ === i) break;
+      var i = ___;
      }
     }
      /*<<float.ml:281:4>>*/ return r;
@@ -8077,32 +8079,32 @@
      /*<<float.ml:289:14>>*/ var
       /*<<float.ml:289:14>>*/ r =
         /*<<float.ml:289:14>>*/ caml_floatarray_create(la),
-      /*<<float.ml:290:6>>*/ _X_ = la - 1 | 0,
-      /*<<float.ml:289:14>>*/ _W_ = 0;
-    if(_X_ >= 0){
-     var i = _W_;
+      /*<<float.ml:290:6>>*/ _W_ = la - 1 | 0,
+      /*<<float.ml:289:14>>*/ _V_ = 0;
+    if(_W_ >= 0){
+     var i = _V_;
      for(;;){
        /*<<float.ml:291:8>>*/ r[1 + i] =
         /*<<float.ml:291:23>>*/ caml_call2(f, a[1 + i], b[1 + i]);
-       /*<<float.ml:291:8>>*/  /*<<float.ml:291:8>>*/ var _Y_ = i + 1 | 0;
-      if(_X_ === i) break;
-      var i = _Y_;
+       /*<<float.ml:291:8>>*/  /*<<float.ml:291:8>>*/ var _X_ = i + 1 | 0;
+      if(_W_ === i) break;
+      var i = _X_;
      }
     }
      /*<<float.ml:293:6>>*/ return r;
     /*<<float.ml:294:7>>*/ }
    function iteri(f, a){
      /*<<float.ml:298:4>>*/ var
-     _U_ = a.length - 1 - 1 | 0,
-      /*<<float.ml:298:4>>*/ _T_ = 0;
-    if(_U_ >= 0){
-     var i = _T_;
+     _T_ = a.length - 1 - 1 | 0,
+      /*<<float.ml:298:4>>*/ _S_ = 0;
+    if(_T_ >= 0){
+     var i = _S_;
      for(;;){
        /*<<float.ml:298:33>>*/  /*<<float.ml:298:33>>*/ caml_call2
        (f, i, a[1 + i]);
-       /*<<float.ml:298:33>>*/  /*<<float.ml:298:33>>*/ var _V_ = i + 1 | 0;
-      if(_U_ === i) break;
-      var i = _V_;
+       /*<<float.ml:298:33>>*/  /*<<float.ml:298:33>>*/ var _U_ = i + 1 | 0;
+      if(_T_ === i) break;
+      var i = _U_;
      }
     }
     return 0;
@@ -8112,16 +8114,16 @@
      l = a.length - 1,
       /*<<float.ml:302:12>>*/ r =
         /*<<float.ml:302:12>>*/ caml_floatarray_create(l),
-      /*<<float.ml:303:4>>*/ _R_ = l - 1 | 0,
-      /*<<float.ml:302:12>>*/ _Q_ = 0;
-    if(_R_ >= 0){
-     var i = _Q_;
+      /*<<float.ml:303:4>>*/ _Q_ = l - 1 | 0,
+      /*<<float.ml:302:12>>*/ _P_ = 0;
+    if(_Q_ >= 0){
+     var i = _P_;
      for(;;){
        /*<<float.ml:304:6>>*/ r[1 + i] =
         /*<<float.ml:304:21>>*/ caml_call2(f, i, a[1 + i]);
-       /*<<float.ml:304:6>>*/  /*<<float.ml:304:6>>*/ var _S_ = i + 1 | 0;
-      if(_R_ === i) break;
-      var i = _S_;
+       /*<<float.ml:304:6>>*/  /*<<float.ml:304:6>>*/ var _R_ = i + 1 | 0;
+      if(_Q_ === i) break;
+      var i = _R_;
      }
     }
      /*<<float.ml:306:4>>*/ return r;
@@ -8129,15 +8131,15 @@
    function fold_left(f, x, a){
      /*<<float.ml:310:4>>*/ var
       /*<<float.ml:310:12>>*/ r = [0, x],
-     _O_ = a.length - 1 - 1 | 0,
-      /*<<float.ml:310:12>>*/ _N_ = 0;
-    if(_O_ >= 0){
-     var i = _N_;
+     _N_ = a.length - 1 - 1 | 0,
+      /*<<float.ml:310:12>>*/ _M_ = 0;
+    if(_N_ >= 0){
+     var i = _M_;
      for(;;){
       r[1] =  /*<<float.ml:312:11>>*/ caml_call2(f, r[1], a[1 + i]);
-       /*<<float.ml:311:4>>*/  /*<<float.ml:311:4>>*/ var _P_ = i + 1 | 0;
-      if(_O_ === i) break;
-      var i = _P_;
+       /*<<float.ml:311:4>>*/  /*<<float.ml:311:4>>*/ var _O_ = i + 1 | 0;
+      if(_N_ === i) break;
+      var i = _O_;
      }
     }
     return r[1];
@@ -8145,14 +8147,14 @@
    function fold_right(f, a, x){
      /*<<float.ml:318:4>>*/ var
       /*<<float.ml:318:12>>*/ r = [0, x],
-      /*<<float.ml:319:4>>*/ _L_ = a.length - 1 - 1 | 0;
-    if(_L_ >= 0){
-     var i = _L_;
+      /*<<float.ml:319:4>>*/ _K_ = a.length - 1 - 1 | 0;
+    if(_K_ >= 0){
+     var i = _K_;
      for(;;){
       r[1] =  /*<<float.ml:320:11>>*/ caml_call2(f, a[1 + i], r[1]);
-       /*<<float.ml:319:4>>*/  /*<<float.ml:319:4>>*/ var _M_ = i - 1 | 0;
+       /*<<float.ml:319:4>>*/  /*<<float.ml:319:4>>*/ var _L_ = i - 1 | 0;
       if(0 === i) break;
-      var i = _M_;
+      var i = _L_;
      }
     }
     return r[1];
@@ -8240,9 +8242,9 @@
       /*<<float.ml:375:38>>*/ throw  /*<<float.ml:375:38>>*/ caml_maybe_attach_backtrace
             ([0, Bottom, i], 1);
      /*<<float.ml:375:54>>*/ }
-    var l = a.length - 1, _F_ = ((l + 1 | 0) / 3 | 0) - 1 | 0;
-    if(_F_ >= 0){
-     var i$6 = _F_;
+    var l = a.length - 1, _E_ = ((l + 1 | 0) / 3 | 0) - 1 | 0;
+    if(_E_ >= 0){
+     var i$6 = _E_;
      for(;;){
        /*<<float.ml:404:52>>*/  /*<<float.ml:404:52>>*/ var
        e$1 =  /*<<float.ml:404:52>>*/ caml_array_get(a, i$6);
@@ -8272,14 +8274,14 @@
         /*<<float.ml:386:63>>*/  /*<<float.ml:386:63>>*/ caml_array_set
         (a, i$0, e$1);
       }
-       /*<<float.ml:404:40>>*/  /*<<float.ml:404:40>>*/ var _K_ = i$6 - 1 | 0;
+       /*<<float.ml:404:40>>*/  /*<<float.ml:404:40>>*/ var _J_ = i$6 - 1 | 0;
       if(0 === i$6) break;
-      var i$6 = _K_;
+      var i$6 = _J_;
      }
     }
-     /*<<float.ml:405:4>>*/  /*<<float.ml:405:4>>*/ var _G_ = l - 1 | 0;
-    if(_G_ >= 2){
-     var i$4 = _G_;
+     /*<<float.ml:405:4>>*/  /*<<float.ml:405:4>>*/ var _F_ = l - 1 | 0;
+    if(_F_ >= 2){
+     var i$4 = _F_;
      a:
      for(;;){
        /*<<float.ml:406:14>>*/  /*<<float.ml:406:14>>*/ var
@@ -8320,25 +8322,25 @@
           /*<<float.ml:398:51>>*/  /*<<float.ml:398:51>>*/ caml_array_set
           (a, 0, e$0);
         }
-         /*<<float.ml:405:4>>*/  /*<<float.ml:405:4>>*/ var _J_ = i$4 - 1 | 0;
+         /*<<float.ml:405:4>>*/  /*<<float.ml:405:4>>*/ var _I_ = i$4 - 1 | 0;
         if(2 === i$4) break a;
-        var i$4 = _J_;
+        var i$4 = _I_;
         break;
        }
       }
      }
     }
-    var _H_ = 1 < l ? 1 : 0;
-    if(_H_){
+    var _G_ = 1 < l ? 1 : 0;
+    if(_G_){
       /*<<float.ml:410:27>>*/  /*<<float.ml:410:27>>*/ var
       e =  /*<<float.ml:410:27>>*/ caml_array_get(a, 1);
       /*<<float.ml:410:40>>*/  /*<<float.ml:410:40>>*/ caml_array_set
       (a, 1,  /*<<float.ml:410:48>>*/ caml_array_get(a, 0));
-     var _I_ =  /*<<float.ml:410:59>>*/ caml_array_set(a, 0, e);
+     var _H_ =  /*<<float.ml:410:59>>*/ caml_array_set(a, 0, e);
     }
     else
-     var _I_ = _H_;
-     /*<<float.ml:410:59>>*/ return _I_;
+     var _H_ = _G_;
+     /*<<float.ml:410:59>>*/ return _H_;
     /*<<float.ml:410:69>>*/ }
    function stable_sort(cmp, a){
     function merge(src1ofs, src1len, src2, src2ofs, src2len, dst, dstofs){
@@ -8388,10 +8390,10 @@
      /*<<float.ml:433:72>>*/ }
     function isortto(srcofs, dst, dstofs, len){
       /*<<float.ml:436:6>>*/ var
-      _D_ = len - 1 | 0,
-       /*<<float.ml:436:6>>*/ _C_ = 0;
-     if(_D_ >= 0){
-      var i = _C_;
+      _C_ = len - 1 | 0,
+       /*<<float.ml:436:6>>*/ _B_ = 0;
+     if(_C_ >= 0){
+      var i = _B_;
       a:
       for(;;){
         /*<<float.ml:437:16>>*/ var
@@ -8415,9 +8417,9 @@
         }
          /*<<float.ml:443:8>>*/  /*<<float.ml:443:8>>*/ caml_array_set
          (dst, j[1] + 1 | 0, e);
-         /*<<float.ml:436:6>>*/  /*<<float.ml:436:6>>*/ var _E_ = i + 1 | 0;
-        if(_D_ === i) break a;
-        var i = _E_;
+         /*<<float.ml:436:6>>*/  /*<<float.ml:436:6>>*/ var _D_ = i + 1 | 0;
+        if(_C_ === i) break a;
+        var i = _D_;
         break;
        }
       }
@@ -8427,14 +8429,14 @@
     function sortto(srcofs, dst, dstofs, len){
       /*<<float.ml:447:6>>*/ if(len <= 5){
        /*<<float.ml:447:28>>*/ isortto(srcofs, dst, dstofs, len);
-       /*<<float.ml:447:28>>*/ return _j_;
+       /*<<float.ml:447:28>>*/ return sentinal;
      }
      var l1 = len / 2 | 0, l2 = len - l1 | 0;
       /*<<float.ml:450:8>>*/ sortto(srcofs + l1 | 0, dst, dstofs + l1 | 0, l2);
       /*<<float.ml:451:8>>*/ sortto(srcofs, a, srcofs + l2 | 0, l1);
       /*<<float.ml:451:8>>*/ merge
       (srcofs + l2 | 0, l1, dst, dstofs + l1 | 0, l2, dst, dstofs);
-      /*<<float.ml:451:8>>*/ return _j_;
+      /*<<float.ml:451:8>>*/ return sentinal;
      /*<<float.ml:453:9>>*/ }
     var l = a.length - 1;
     if(l <= 5)  /*<<float.ml:456:24>>*/ return isortto(0, a, 0, l);
@@ -8453,14 +8455,14 @@
        /*<<float.ml:474:11>>*/ return 0;
       /*<<float.ml:472:16>>*/ var
        /*<<float.ml:472:16>>*/ x = a[1 + i],
-       /*<<float.ml:472:16>>*/ _A_ = i + 1 | 0;
+       /*<<float.ml:472:16>>*/ _z_ = i + 1 | 0;
       /*<<float.ml:473:8>>*/ return [0,
              x,
-             function(_B_){ /*<<?>>*/ return aux(_A_, _B_);}];
+             function(_A_){ /*<<?>>*/ return aux(_z_, _A_);}];
      /*<<float.ml:474:18>>*/ }
-     /*<<float.ml:476:4>>*/  /*<<float.ml:476:4>>*/ var _y_ = 0;
-     /*<<float.ml:476:4>>*/ return function(_z_){
-      /*<<?>>*/ return aux(_y_, _z_);};
+     /*<<float.ml:476:4>>*/  /*<<float.ml:476:4>>*/ var _x_ = 0;
+     /*<<float.ml:476:4>>*/ return function(_y_){
+      /*<<?>>*/ return aux(_x_, _y_);};
     /*<<float.ml:476:9>>*/ }
    function to_seqi(a){
     function aux(i, param){
@@ -8468,23 +8470,23 @@
        /*<<float.ml:485:11>>*/ return 0;
       /*<<float.ml:483:16>>*/ var
        /*<<float.ml:483:16>>*/ x = a[1 + i],
-       /*<<float.ml:483:16>>*/ _w_ = i + 1 | 0;
+       /*<<float.ml:483:16>>*/ _v_ = i + 1 | 0;
       /*<<float.ml:484:8>>*/ return [0,
              [0, i, x],
-             function(_x_){ /*<<?>>*/ return aux(_w_, _x_);}];
+             function(_w_){ /*<<?>>*/ return aux(_v_, _w_);}];
      /*<<float.ml:485:18>>*/ }
-     /*<<float.ml:487:4>>*/  /*<<float.ml:487:4>>*/ var _u_ = 0;
-     /*<<float.ml:487:4>>*/ return function(_v_){
-      /*<<?>>*/ return aux(_u_, _v_);};
+     /*<<float.ml:487:4>>*/  /*<<float.ml:487:4>>*/ var _t_ = 0;
+     /*<<float.ml:487:4>>*/ return function(_u_){
+      /*<<?>>*/ return aux(_t_, _u_);};
     /*<<float.ml:487:9>>*/ }
    function of_seq(i$2){
-     /*<<float.ml:501:4>>*/ var _s_ = 0;
-    function _t_(acc, x){
+     /*<<float.ml:501:4>>*/ var _r_ = 0;
+    function _s_(acc, x){
       /*<<float.ml:501:40>>*/ return [0, x, acc];
      /*<<float.ml:501:46>>*/ }
      /*<<float.ml:501:12>>*/ var
       /*<<float.ml:501:12>>*/ l =
-        /*<<float.ml:501:12>>*/ caml_call3(Stdlib_Seq[5], _t_, _s_, i$2),
+        /*<<float.ml:501:12>>*/ caml_call3(Stdlib_Seq[5], _s_, _r_, i$2),
       /*<<float.ml:491:14>>*/ len =
         /*<<float.ml:491:14>>*/ caml_call1(Stdlib_List[1], l),
       /*<<float.ml:492:12>>*/ a =
@@ -8509,16 +8511,16 @@
       /*<<float.ml:508:14>>*/ r =
         /*<<float.ml:508:14>>*/ runtime.caml_make_vect
         (l,  /*<<float.ml:508:27>>*/ caml_call1(f, a[1])),
-      /*<<float.ml:509:6>>*/ _q_ = l - 1 | 0,
-      /*<<float.ml:508:14>>*/ _p_ = 1;
-    if(_q_ >= 1){
-     var i = _p_;
+      /*<<float.ml:509:6>>*/ _p_ = l - 1 | 0,
+      /*<<float.ml:508:14>>*/ _o_ = 1;
+    if(_p_ >= 1){
+     var i = _o_;
      for(;;){
        /*<<float.ml:510:8>>*/ r[1 + i] =
         /*<<float.ml:510:29>>*/ caml_call1(f, a[1 + i]);
-       /*<<float.ml:510:8>>*/  /*<<float.ml:510:8>>*/ var _r_ = i + 1 | 0;
-      if(_q_ === i) break;
-      var i = _r_;
+       /*<<float.ml:510:8>>*/  /*<<float.ml:510:8>>*/ var _q_ = i + 1 | 0;
+      if(_p_ === i) break;
+      var i = _q_;
      }
     }
      /*<<float.ml:512:6>>*/ return r;
@@ -8528,16 +8530,16 @@
      l = a.length - 1,
       /*<<float.ml:517:12>>*/ r =
         /*<<float.ml:517:12>>*/ caml_floatarray_create(l),
-      /*<<float.ml:518:4>>*/ _n_ = l - 1 | 0,
-      /*<<float.ml:517:12>>*/ _m_ = 0;
-    if(_n_ >= 0){
-     var i = _m_;
+      /*<<float.ml:518:4>>*/ _m_ = l - 1 | 0,
+      /*<<float.ml:517:12>>*/ _l_ = 0;
+    if(_m_ >= 0){
+     var i = _l_;
      for(;;){
        /*<<float.ml:519:6>>*/ r[1 + i] =
         /*<<float.ml:519:21>>*/ caml_call1(f, a[1 + i]);
-       /*<<float.ml:519:6>>*/  /*<<float.ml:519:6>>*/ var _o_ = i + 1 | 0;
-      if(_n_ === i) break;
-      var i = _o_;
+       /*<<float.ml:519:6>>*/  /*<<float.ml:519:6>>*/ var _n_ = i + 1 | 0;
+      if(_m_ === i) break;
+      var i = _n_;
      }
     }
      /*<<float.ml:521:4>>*/ return r;
@@ -8548,7 +8550,7 @@
     _e_ = caml_array_get,
     _f_ =
       [0,
-       function(_l_){ /*<<?>>*/ return _l_.length - 1;},
+       function(_k_){ /*<<?>>*/ return _k_.length - 1;},
        _e_,
        _d_,
        make,
@@ -8615,7 +8617,7 @@
        min_max_num,
        hash,
        [0,
-        function(_k_){ /*<<?>>*/ return _k_.length - 1;},
+        function(_j_){ /*<<?>>*/ return _j_.length - 1;},
         _i_,
         _h_,
         make,
@@ -9414,6 +9416,7 @@
             : runtime.caml_call_gen(f, [a0, a1, a2, a3, a4]);
    }
     /*<<parsing.ml:59:0>>*/ var
+    sentinal = undefined,
     global_data = runtime.caml_get_global_data(),
     Stdlib_Obj = global_data.Stdlib__Obj,
     Stdlib_Array = global_data.Stdlib__Array,
@@ -9440,7 +9443,6 @@
        0,
        0,
        0],
-    _a_ = undefined,
     cst_syntax_error = "syntax error";
    function grow_stacks(param){
      /*<<parsing.ml:108:2>>*/ var
@@ -9467,7 +9469,7 @@
      (Stdlib_Array[8], env[4], 0, new_end, 0, oldsize);
     env[4] = new_end;
     env[5] = newsize;
-    return _a_;
+    return sentinal;
     /*<<parsing.ml:122:28>>*/ }
    function clear_parser(param){
      /*<<parsing.ml:125:2>>*/  /*<<parsing.ml:125:2>>*/ caml_call4
@@ -9520,17 +9522,17 @@
         case 4:
          try{
            /*<<parsing.ml:143:39>>*/ var
-           _j_ = env[13],
-            /*<<parsing.ml:143:39>>*/ _k_ =
+           _i_ = env[13],
+            /*<<parsing.ml:143:39>>*/ _j_ =
               /*<<parsing.ml:143:39>>*/ caml_call1
-              (caml_check_bound(tables[1], _j_)[1 + _j_], env),
-            /*<<parsing.ml:143:39>>*/ _l_ = 4,
-           value = _k_,
-           action = _l_;
+              (caml_check_bound(tables[1], _i_)[1 + _i_], env),
+            /*<<parsing.ml:143:39>>*/ _k_ = 4,
+           value = _j_,
+           action = _k_;
          }
-         catch(_n_){
-          var _i_ = caml_wrap_exception(_n_);
-          if(_i_ !== Parse_error) throw caml_maybe_attach_backtrace(_i_, 0);
+         catch(_m_){
+          var _h_ = caml_wrap_exception(_m_);
+          if(_h_ !== Parse_error) throw caml_maybe_attach_backtrace(_h_, 0);
           var value = 0, action = 5;
          }
          var cmd = action, arg = value;
@@ -9566,9 +9568,9 @@
                 ? 1
                 : 0;
         /*<<parsing.ml:182:38>>*/  /*<<parsing.ml:182:38>>*/ var
-        _m_ =  /*<<parsing.ml:182:38>>*/ runtime.caml_obj_tag(tok);
-        /*<<parsing.ml:182:17>>*/ return caml_check_bound(tables[3], _m_)
-                [1 + _m_]
+        _l_ =  /*<<parsing.ml:182:38>>*/ runtime.caml_obj_tag(tok);
+        /*<<parsing.ml:182:17>>*/ return caml_check_bound(tables[3], _l_)
+                [1 + _l_]
                === curr_char
                ? 1
                : 0;
@@ -9578,21 +9580,21 @@
     }
     /*<<parsing.ml:184:17>>*/ }
    function peek_val(env, n){
-     /*<<parsing.ml:187:2>>*/ var _h_ = env[11] - n | 0;
-     /*<<parsing.ml:187:12>>*/ return caml_check_bound(env[2], _h_)[1 + _h_];
+     /*<<parsing.ml:187:2>>*/ var _g_ = env[11] - n | 0;
+     /*<<parsing.ml:187:12>>*/ return caml_check_bound(env[2], _g_)[1 + _g_];
     /*<<parsing.ml:187:37>>*/ }
    function symbol_start_pos(param){
      /*<<parsing.ml:190:2>>*/ var i$1 = env[12], i = i$1;
      /*<<parsing.ml:191:4>>*/ for(;;){
      if(0 >= i){
-      var _g_ = env[11];
-       /*<<parsing.ml:191:19>>*/ return caml_check_bound(env[4], _g_)[1 + _g_];
+      var _f_ = env[11];
+       /*<<parsing.ml:191:19>>*/ return caml_check_bound(env[4], _f_)[1 + _f_];
      }
       /*<<parsing.ml:193:15>>*/ var
+      _d_ = (env[11] - i | 0) + 1 | 0,
+       /*<<parsing.ml:193:15>>*/ st = caml_check_bound(env[3], _d_)[1 + _d_],
       _e_ = (env[11] - i | 0) + 1 | 0,
-       /*<<parsing.ml:193:15>>*/ st = caml_check_bound(env[3], _e_)[1 + _e_],
-      _f_ = (env[11] - i | 0) + 1 | 0,
-       /*<<parsing.ml:194:15>>*/ en = caml_check_bound(env[4], _f_)[1 + _f_];
+       /*<<parsing.ml:194:15>>*/ en = caml_check_bound(env[4], _e_)[1 + _e_];
       /*<<parsing.ml:195:9>>*/ if
       ( /*<<parsing.ml:195:9>>*/ runtime.caml_notequal(st, en))
        /*<<parsing.ml:195:23>>*/ return st;
@@ -9602,16 +9604,16 @@
     }
     /*<<parsing.ml:198:19>>*/ }
    function symbol_end_pos(param){
-     /*<<parsing.ml:200:24>>*/ var _d_ = env[11];
-     /*<<parsing.ml:200:24>>*/ return caml_check_bound(env[4], _d_)[1 + _d_];
+     /*<<parsing.ml:200:24>>*/ var _c_ = env[11];
+     /*<<parsing.ml:200:24>>*/ return caml_check_bound(env[4], _c_)[1 + _c_];
     /*<<parsing.ml:200:52>>*/ }
    function rhs_start_pos(n){
-     /*<<parsing.ml:201:22>>*/ var _c_ = env[11] - (env[12] - n | 0) | 0;
-     /*<<parsing.ml:201:22>>*/ return caml_check_bound(env[3], _c_)[1 + _c_];
+     /*<<parsing.ml:201:22>>*/ var _b_ = env[11] - (env[12] - n | 0) | 0;
+     /*<<parsing.ml:201:22>>*/ return caml_check_bound(env[3], _b_)[1 + _b_];
     /*<<parsing.ml:201:73>>*/ }
    function rhs_end_pos(n){
-     /*<<parsing.ml:202:20>>*/ var _b_ = env[11] - (env[12] - n | 0) | 0;
-     /*<<parsing.ml:202:20>>*/ return caml_check_bound(env[4], _b_)[1 + _b_];
+     /*<<parsing.ml:202:20>>*/ var _a_ = env[11] - (env[12] - n | 0) | 0;
+     /*<<parsing.ml:202:20>>*/ return caml_check_bound(env[4], _a_)[1 + _a_];
     /*<<parsing.ml:202:69>>*/ }
    function symbol_start(param){
      /*<<parsing.ml:204:22>>*/ return symbol_start_pos(0)[4];
@@ -12006,6 +12008,7 @@
             : runtime.caml_call_gen(f, [a0, a1, a2, a3, a4]);
    }
    var
+    sentinal = undefined,
     global_data = runtime.caml_get_global_data(),
     Stdlib_Bytes = global_data.Stdlib__Bytes,
     Stdlib_Sys = global_data.Stdlib__Sys,
@@ -12013,7 +12016,6 @@
     Stdlib = global_data.Stdlib,
     Stdlib_String = global_data.Stdlib__String,
     Assert_failure = global_data.Assert_failure,
-    _b_ = undefined,
     cst_Buffer_truncate = "Buffer.truncate",
     _a_ = [0, "buffer.ml", 220, 9],
     cst_Buffer_add_channel = "Buffer.add_channel",
@@ -12102,7 +12104,7 @@
        /*<<buffer.ml:99:2>>*/  /*<<buffer.ml:99:2>>*/ caml_call5
        (Stdlib_Bytes[11], b[1][1], 0, new_buffer, 0, b[2]);
       b[1] = [0, new_buffer, new_len[1]];
-      return _b_;
+      return sentinal;
      }
      new_len[1] = 2 * new_len[1] | 0;
     }
@@ -12164,14 +12166,14 @@
     }
     /*<<buffer.ml:147:30>>*/ }
    function add_substring(b, s, offset, len){
-     /*<<buffer.ml:150:2>>*/ var _s_ = offset < 0 ? 1 : 0;
-    if(_s_)
-     var _t_ = _s_;
+     /*<<buffer.ml:150:2>>*/ var _r_ = offset < 0 ? 1 : 0;
+    if(_r_)
+     var _s_ = _r_;
     else
      var
-      _u_ = len < 0 ? 1 : 0,
-      _t_ = _u_ || ((caml_ml_string_length(s) - len | 0) < offset ? 1 : 0);
-    if(_t_)
+      _t_ = len < 0 ? 1 : 0,
+      _s_ = _t_ || ((caml_ml_string_length(s) - len | 0) < offset ? 1 : 0);
+    if(_s_)
       /*<<buffer.ml:151:7>>*/  /*<<buffer.ml:151:7>>*/ caml_call1
       (Stdlib[1], cst_Buffer_add_substring_add_s);
      /*<<buffer.ml:153:2>>*/ var
@@ -12226,9 +12228,9 @@
     /*<<buffer.ml:180:46>>*/ }
    function add_channel(b, ic, to_read$1){
      /*<<buffer.ml:206:2>>*/ var
-     _q_ = to_read$1 < 0 ? 1 : 0,
-     _r_ = _q_ || (Stdlib_Sys[12] < to_read$1 ? 1 : 0);
-    if(_r_)
+     _p_ = to_read$1 < 0 ? 1 : 0,
+     _q_ = _p_ || (Stdlib_Sys[12] < to_read$1 ? 1 : 0);
+    if(_q_)
       /*<<buffer.ml:207:4>>*/  /*<<buffer.ml:207:4>>*/ caml_call1
       (Stdlib[1], cst_Buffer_add_channel);
     if(b[1][2] < (b[2] + to_read$1 | 0))
@@ -12274,8 +12276,8 @@
      i$4 = 0;
      /*<<buffer.ml:262:4>>*/ for(;;){
      if(i$4 >= lim$1){
-      var _p_ = 92 === previous ? 1 : 0;
-      return _p_ ? add_char(b, previous) : _p_;
+      var _o_ = 92 === previous ? 1 : 0;
+      return _o_ ? add_char(b, previous) : _o_;
      }
       /*<<buffer.ml:263:12>>*/  /*<<buffer.ml:263:12>>*/ var
       previous$0 =  /*<<buffer.ml:263:12>>*/ caml_string_get(s, i$4);
@@ -12415,14 +12417,14 @@
       /*<<buffer.ml:298:14>>*/ var
        /*<<buffer.ml:298:14>>*/ x =
          /*<<buffer.ml:298:14>>*/ caml_bytes_get(b[1][1], i),
-       /*<<buffer.ml:298:14>>*/ _n_ = i + 1 | 0;
+       /*<<buffer.ml:298:14>>*/ _m_ = i + 1 | 0;
       /*<<buffer.ml:299:6>>*/ return [0,
              x,
-             function(_o_){ /*<<?>>*/ return aux(_n_, _o_);}];
+             function(_n_){ /*<<?>>*/ return aux(_m_, _n_);}];
      /*<<buffer.ml:299:29>>*/ }
-     /*<<buffer.ml:301:2>>*/  /*<<buffer.ml:301:2>>*/ var _l_ = 0;
-     /*<<buffer.ml:301:2>>*/ return function(_m_){
-      /*<<?>>*/ return aux(_l_, _m_);};
+     /*<<buffer.ml:301:2>>*/  /*<<buffer.ml:301:2>>*/ var _k_ = 0;
+     /*<<buffer.ml:301:2>>*/ return function(_l_){
+      /*<<?>>*/ return aux(_k_, _l_);};
     /*<<buffer.ml:301:7>>*/ }
    function to_seqi(b){
     function aux(i, param){
@@ -12431,21 +12433,21 @@
       /*<<buffer.ml:308:14>>*/ var
        /*<<buffer.ml:308:14>>*/ x =
          /*<<buffer.ml:308:14>>*/ caml_bytes_get(b[1][1], i),
-       /*<<buffer.ml:308:14>>*/ _j_ = i + 1 | 0;
+       /*<<buffer.ml:308:14>>*/ _i_ = i + 1 | 0;
       /*<<buffer.ml:309:6>>*/ return [0,
              [0, i, x],
-             function(_k_){ /*<<?>>*/ return aux(_j_, _k_);}];
+             function(_j_){ /*<<?>>*/ return aux(_i_, _j_);}];
      /*<<buffer.ml:309:33>>*/ }
-     /*<<buffer.ml:311:2>>*/  /*<<buffer.ml:311:2>>*/ var _h_ = 0;
-     /*<<buffer.ml:311:2>>*/ return function(_i_){
-      /*<<?>>*/ return aux(_h_, _i_);};
+     /*<<buffer.ml:311:2>>*/  /*<<buffer.ml:311:2>>*/ var _g_ = 0;
+     /*<<buffer.ml:311:2>>*/ return function(_h_){
+      /*<<?>>*/ return aux(_g_, _h_);};
     /*<<buffer.ml:311:7>>*/ }
    function add_seq(b, seq){
-     /*<<buffer.ml:313:29>>*/ function _f_(_g_){
-      /*<<?>>*/ return add_char(b, _g_);
+     /*<<buffer.ml:313:29>>*/ function _e_(_f_){
+      /*<<?>>*/ return add_char(b, _f_);
     }
      /*<<buffer.ml:313:20>>*/ return  /*<<buffer.ml:313:20>>*/ caml_call2
-            (Stdlib_Seq[4], _f_, seq);
+            (Stdlib_Seq[4], _e_, seq);
     /*<<buffer.ml:313:45>>*/ }
    function of_seq(i){
      /*<<buffer.ml:316:2>>*/  /*<<buffer.ml:316:10>>*/ var b = create(32);
@@ -12524,8 +12526,8 @@
     return 0;
     /*<<buffer.ml:378:28>>*/ }
    function add_int16_le(b, x){
-     /*<<buffer.ml:381:2>>*/ var _e_ = Stdlib_Sys[11] ? caml_bswap16(x) : x;
-    return add_int16_ne(b, _e_);
+     /*<<buffer.ml:381:2>>*/ var _d_ = Stdlib_Sys[11] ? caml_bswap16(x) : x;
+    return add_int16_ne(b, _d_);
     /*<<buffer.ml:381:57>>*/ }
    function add_int16_be(b, x){
      /*<<buffer.ml:384:2>>*/ var x$0 = Stdlib_Sys[11] ? x : caml_bswap16(x);
@@ -12533,8 +12535,8 @@
     /*<<buffer.ml:384:57>>*/ }
    function add_int32_le(b, x){
      /*<<buffer.ml:387:2>>*/ var
-     _d_ = Stdlib_Sys[11] ?  /*<<buffer.ml:387:41>>*/ caml_int32_bswap(x) : x;
-     /*<<buffer.ml:387:41>>*/ return add_int32_ne(b, _d_);
+     _c_ = Stdlib_Sys[11] ?  /*<<buffer.ml:387:41>>*/ caml_int32_bswap(x) : x;
+     /*<<buffer.ml:387:41>>*/ return add_int32_ne(b, _c_);
     /*<<buffer.ml:387:57>>*/ }
    function add_int32_be(b, x){
      /*<<buffer.ml:390:2>>*/ var
@@ -12543,8 +12545,8 @@
     /*<<buffer.ml:390:57>>*/ }
    function add_int64_le(b, x){
      /*<<buffer.ml:393:2>>*/ var
-     _c_ = Stdlib_Sys[11] ?  /*<<buffer.ml:393:41>>*/ caml_int64_bswap(x) : x;
-     /*<<buffer.ml:393:41>>*/ return add_int64_ne(b, _c_);
+     _b_ = Stdlib_Sys[11] ?  /*<<buffer.ml:393:41>>*/ caml_int64_bswap(x) : x;
+     /*<<buffer.ml:393:41>>*/ return add_int64_ne(b, _b_);
     /*<<buffer.ml:393:57>>*/ }
    function add_int64_be(b, x){
      /*<<buffer.ml:396:2>>*/ var
@@ -12785,7 +12787,7 @@
             : runtime.caml_call_gen(f, [a0, a1, a2, a3, a4]);
    }
    var
-    _a_ = undefined,
+    sentinal = undefined,
     global_data = runtime.caml_get_global_data(),
     Stdlib_Mutex = global_data.Stdlib__Mutex,
     Stdlib_Condition = global_data.Stdlib__Condition,
@@ -12805,7 +12807,7 @@
      /*<<domain.ml:59:4>>*/  /*<<domain.ml:59:13>>*/ var
      st =  /*<<domain.ml:59:13>>*/ caml_make_vect(8, unique_value);
      /*<<domain.ml:60:4>>*/  /*<<domain.ml:60:4>>*/ caml_domain_dls_set(st);
-     /*<<domain.ml:60:4>>*/ return _a_;
+     /*<<domain.ml:60:4>>*/ return sentinal;
     /*<<domain.ml:60:20>>*/ }
     /*<<domain.ml:62:10>>*/ create_dls(0);
     /*<<domain.ml:66:20>>*/ var
@@ -12894,7 +12896,7 @@
      /*<<domain.ml:147:27>>*/ first_spawn_function =
       [0,
        function(param){
-         /*<<domain.ml:147:42>>*/ return _a_;
+         /*<<domain.ml:147:42>>*/ return sentinal;
         /*<<domain.ml:147:44>>*/ }];
    function before_first_spawn(f){
      /*<<domain.ml:150:2>>*/ if
@@ -12915,7 +12917,7 @@
     at_exit_key =
       new_key
        (0,
-        function(param, _f_){
+        function(param, _e_){
           /*<<domain.ml:166:52>>*/ return 0;
          /*<<domain.ml:166:54>>*/ });
    function at_exit(f){
@@ -12950,8 +12952,8 @@
        /*<<domain.ml:163:41>>*/ };
     }
      /*<<domain.ml:124:6>>*/  /*<<domain.ml:124:6>>*/ var
-     _b_ =  /*<<domain.ml:124:6>>*/ caml_call1(Stdlib_Atomic[2], parent_keys);
-    function _c_(param){
+     _a_ =  /*<<domain.ml:124:6>>*/ caml_call1(Stdlib_Atomic[2], parent_keys);
+    function _b_(param){
       /*<<domain.ml:122:6>>*/ var split = param[2], k = param[1], idx = k[1];
       /*<<domain.ml:123:11>>*/ return [0,
              idx,
@@ -12959,7 +12961,7 @@
      /*<<domain.ml:123:43>>*/ }
      /*<<domain.ml:124:6>>*/ var
       /*<<domain.ml:124:6>>*/ pk =
-        /*<<domain.ml:124:6>>*/ caml_call2(Stdlib_List[19], _c_, _b_),
+        /*<<domain.ml:124:6>>*/ caml_call2(Stdlib_List[19], _b_, _a_),
       /*<<domain.ml:193:19>>*/ term_mutex =
         /*<<domain.ml:193:19>>*/ caml_call1(Stdlib_Mutex[1], 0),
       /*<<domain.ml:194:23>>*/ term_condition =
@@ -12971,7 +12973,7 @@
        /*<<domain.ml:198:4>>*/ try{
         /*<<domain.ml:200:8>>*/ create_dls(0);
        var
-        _d_ =
+        _c_ =
           function(param){
             /*<<domain.ml:128:6>>*/ var
             v = param[2],
@@ -12981,7 +12983,7 @@
             /*<<domain.ml:129:35>>*/ return 0;
            /*<<domain.ml:129:49>>*/ };
         /*<<domain.ml:127:4>>*/  /*<<domain.ml:127:4>>*/ caml_call2
-        (Stdlib_List[17], _d_, pk);
+        (Stdlib_List[17], _c_, pk);
         /*<<domain.ml:202:18>>*/  /*<<domain.ml:202:18>>*/ var
         res =  /*<<domain.ml:202:18>>*/ caml_call1(f, 0);
       }
@@ -12998,8 +13000,8 @@
      catch(ex){
        /*<<domain.ml:215:10>>*/ var
        ex$0 = caml_wrap_exception(ex),
-        /*<<domain.ml:215:10>>*/ _e_ = 0 === result[0] ? [1, ex$0] : result,
-       result$0 = _e_;
+        /*<<domain.ml:215:10>>*/ _d_ = 0 === result[0] ? [1, ex$0] : result,
+       result$0 = _d_;
      }
       /*<<domain.ml:230:4>>*/  /*<<domain.ml:230:4>>*/ caml_call1
       (Stdlib_Mutex[2], term_mutex);
@@ -13130,7 +13132,7 @@
             : runtime.caml_call_gen(f, [a0, a1, a2, a3, a4]);
    }
    var
-    _$_ = undefined,
+    sentinal = undefined,
     global_data = runtime.caml_get_global_data(),
     cst$9 = "%{",
     cst$10 = "%}",
@@ -13457,14 +13459,14 @@
      /*<<camlinternalFormat.ml:28:2>>*/ var
      str_ind = c >>> 3 | 0,
      mask = 1 << (c & 7),
-      /*<<camlinternalFormat.ml:31:30>>*/ _dT_ =
+      /*<<camlinternalFormat.ml:31:30>>*/ _dS_ =
         /*<<camlinternalFormat.ml:31:30>>*/ runtime.caml_bytes_get
         (char_set, str_ind)
        | mask;
      /*<<camlinternalFormat.ml:30:2>>*/ return  /*<<camlinternalFormat.ml:30:2>>*/ caml_bytes_set
             (char_set,
              str_ind,
-              /*<<camlinternalFormat.ml:31:4>>*/ caml_call1(Stdlib[29], _dT_));
+              /*<<camlinternalFormat.ml:31:4>>*/ caml_call1(Stdlib[29], _dS_));
     /*<<camlinternalFormat.ml:31:69>>*/ }
    function freeze_char_set(char_set){
      /*<<camlinternalFormat.ml:34:2>>*/ return  /*<<camlinternalFormat.ml:34:2>>*/ caml_call1
@@ -13476,19 +13478,19 @@
      i = 0;
     for(;;){
       /*<<camlinternalFormat.ml:41:32>>*/  /*<<camlinternalFormat.ml:41:32>>*/ var
-      _dR_ =
+      _dQ_ =
          /*<<camlinternalFormat.ml:41:32>>*/ caml_string_get(char_set, i)
         ^ 255;
       /*<<camlinternalFormat.ml:40:4>>*/  /*<<camlinternalFormat.ml:40:4>>*/ caml_bytes_set
       (char_set$0,
        i,
-        /*<<camlinternalFormat.ml:41:6>>*/ caml_call1(Stdlib[29], _dR_));
+        /*<<camlinternalFormat.ml:41:6>>*/ caml_call1(Stdlib[29], _dQ_));
       /*<<camlinternalFormat.ml:40:4>>*/  /*<<camlinternalFormat.ml:40:4>>*/ var
-      _dS_ = i + 1 | 0;
+      _dR_ = i + 1 | 0;
      if(31 === i)
        /*<<camlinternalFormat.ml:43:2>>*/ return  /*<<camlinternalFormat.ml:43:2>>*/ caml_call1
               (Stdlib_Bytes[44], char_set$0);
-     var i = _dS_;
+     var i = _dR_;
     }
     /*<<camlinternalFormat.ml:43:34>>*/ }
    function is_in_char_set(char_set, c){
@@ -13548,11 +13550,11 @@
       case 6:
        var prec_opt = ign[2], pad_opt$5 = ign[1];
        if(prec_opt)
-        var ndec = prec_opt[1], _dQ_ = [0, ndec];
+        var ndec = prec_opt[1], _dP_ = [0, ndec];
        else
-        var _dQ_ = 0;
+        var _dP_ = 0;
         /*<<camlinternalFormat.ml:97:4>>*/ return [0,
-               [8, _a_, pad_of_pad_opt(pad_opt$5), _dQ_, fmt]];
+               [8, _a_, pad_of_pad_opt(pad_opt$5), _dP_, fmt]];
       case 7:
        var pad_opt$6 = ign[1];
         /*<<camlinternalFormat.ml:101:4>>*/ return [0,
@@ -13597,14 +13599,14 @@
       (Stdlib_Bytes[11], buf[2], 0, new_str, 0, len);
      buf[2] = new_str;
     }
-    return _$_;
+    return sentinal;
     /*<<camlinternalFormat.ml:267:3>>*/ }
    function buffer_add_char(buf, c){
      /*<<camlinternalFormat.ml:271:2>>*/ buffer_check_size(buf, 1);
      /*<<camlinternalFormat.ml:272:2>>*/  /*<<camlinternalFormat.ml:272:2>>*/ caml_bytes_set
      (buf[2], buf[1], c);
     buf[1] = buf[1] + 1 | 0;
-    return _$_;
+    return sentinal;
     /*<<camlinternalFormat.ml:273:24>>*/ }
    function buffer_add_string(buf, s){
      /*<<camlinternalFormat.ml:277:2>>*/ var
@@ -13613,7 +13615,7 @@
      /*<<camlinternalFormat.ml:279:2>>*/  /*<<camlinternalFormat.ml:279:2>>*/ caml_call5
      (Stdlib_String[48], s, 0, buf[2], buf[1], str_len);
     buf[1] = buf[1] + str_len | 0;
-    return _$_;
+    return sentinal;
     /*<<camlinternalFormat.ml:280:30>>*/ }
    function buffer_contents(buf){
      /*<<camlinternalFormat.ml:284:2>>*/ return caml_call3
@@ -13670,64 +13672,64 @@
      /*<<camlinternalFormat.ml:374:29>>*/ switch(padty){
       case 0:
         /*<<camlinternalFormat.ml:375:13>>*/ buffer_add_char(buf, 45);
-        /*<<camlinternalFormat.ml:375:13>>*/ return _$_;
+        /*<<camlinternalFormat.ml:375:13>>*/ return sentinal;
       case 1:
-        /*<<camlinternalFormat.ml:376:13>>*/ return _$_;
+        /*<<camlinternalFormat.ml:376:13>>*/ return sentinal;
       default:
         /*<<camlinternalFormat.ml:377:13>>*/ buffer_add_char(buf, 48);
-        /*<<camlinternalFormat.ml:377:13>>*/ return _$_;
+        /*<<camlinternalFormat.ml:377:13>>*/ return sentinal;
     }
     /*<<camlinternalFormat.ml:377:36>>*/ }
    function bprint_ignored_flag(buf, ign_flag){
      /*<<camlinternalFormat.ml:381:2>>*/ return ign_flag
-            ? (buffer_add_char(buf, 95), _$_)
+            ? (buffer_add_char(buf, 95), sentinal)
             : ign_flag;
     /*<<camlinternalFormat.ml:381:42>>*/ }
    function bprint_pad_opt(buf, pad_opt){
      /*<<camlinternalFormat.ml:385:33>>*/ if(! pad_opt)
-      /*<<camlinternalFormat.ml:386:12>>*/ return _$_;
+      /*<<camlinternalFormat.ml:386:12>>*/ return sentinal;
     var width = pad_opt[1];
      /*<<camlinternalFormat.ml:387:40>>*/ buffer_add_string
      (buf,
        /*<<camlinternalFormat.ml:387:40>>*/ caml_call1(Stdlib_Int[12], width));
-     /*<<camlinternalFormat.ml:387:40>>*/ return _$_;
+     /*<<camlinternalFormat.ml:387:40>>*/ return sentinal;
     /*<<camlinternalFormat.ml:387:61>>*/ }
    function bprint_padding(buf, pad){
      /*<<camlinternalFormat.ml:393:15>>*/ if(typeof pad === "number")
-      /*<<camlinternalFormat.ml:394:18>>*/ return _$_;
+      /*<<camlinternalFormat.ml:394:18>>*/ return sentinal;
     if(0 === pad[0]){
      var n = pad[2], padty = pad[1];
       /*<<camlinternalFormat.ml:396:4>>*/ bprint_padty(buf, padty);
       /*<<camlinternalFormat.ml:397:26>>*/ buffer_add_string
       (buf,
         /*<<camlinternalFormat.ml:397:26>>*/ caml_call1(Stdlib_Int[12], n));
-      /*<<camlinternalFormat.ml:397:26>>*/ return _$_;
+      /*<<camlinternalFormat.ml:397:26>>*/ return sentinal;
     }
     var padty$0 = pad[1];
      /*<<camlinternalFormat.ml:399:4>>*/ bprint_padty(buf, padty$0);
      /*<<camlinternalFormat.ml:399:4>>*/ buffer_add_char(buf, 42);
-     /*<<camlinternalFormat.ml:399:4>>*/ return _$_;
+     /*<<camlinternalFormat.ml:399:4>>*/ return sentinal;
     /*<<camlinternalFormat.ml:400:27>>*/ }
    function bprint_precision(buf, prec){
      /*<<camlinternalFormat.ml:404:18>>*/ if(typeof prec === "number")
-     return prec ? (buffer_add_string(buf, cst), _$_) : _$_;
+     return prec ? (buffer_add_string(buf, cst), sentinal) : sentinal;
     var n = prec[1];
      /*<<camlinternalFormat.ml:407:4>>*/ buffer_add_char(buf, 46);
      /*<<camlinternalFormat.ml:408:26>>*/ buffer_add_string
      (buf,
        /*<<camlinternalFormat.ml:408:26>>*/ caml_call1(Stdlib_Int[12], n));
-     /*<<camlinternalFormat.ml:408:26>>*/ return _$_;
+     /*<<camlinternalFormat.ml:408:26>>*/ return sentinal;
     /*<<camlinternalFormat.ml:410:30>>*/ }
    function bprint_iconv_flag(buf, iconv){
      /*<<camlinternalFormat.ml:415:34>>*/ switch(iconv){
       case 1:
       case 4:
         /*<<camlinternalFormat.ml:416:23>>*/ buffer_add_char(buf, 43);
-        /*<<camlinternalFormat.ml:416:23>>*/ return _$_;
+        /*<<camlinternalFormat.ml:416:23>>*/ return sentinal;
       case 2:
       case 5:
         /*<<camlinternalFormat.ml:417:23>>*/ buffer_add_char(buf, 32);
-        /*<<camlinternalFormat.ml:417:23>>*/ return _$_;
+        /*<<camlinternalFormat.ml:417:23>>*/ return sentinal;
       case 7:
       case 9:
       case 11:
@@ -13735,8 +13737,8 @@
       case 14:
       case 15:
         /*<<camlinternalFormat.ml:419:6>>*/ buffer_add_char(buf, 35);
-        /*<<camlinternalFormat.ml:419:6>>*/ return _$_;
-      default:  /*<<camlinternalFormat.ml:420:53>>*/ return _$_;
+        /*<<camlinternalFormat.ml:419:6>>*/ return sentinal;
+      default:  /*<<camlinternalFormat.ml:420:53>>*/ return sentinal;
     }
     /*<<camlinternalFormat.ml:420:55>>*/ }
    function bprint_altint_fmt(buf, ign_flag, iconv, pad, prec, c){
@@ -13748,7 +13750,7 @@
      /*<<camlinternalFormat.ml:438:2>>*/ buffer_add_char(buf, c);
      /*<<camlinternalFormat.ml:439:22>>*/ buffer_add_char
      (buf, char_of_iconv(iconv));
-     /*<<camlinternalFormat.ml:439:22>>*/ return _$_;
+     /*<<camlinternalFormat.ml:439:22>>*/ return sentinal;
     /*<<camlinternalFormat.ml:439:43>>*/ }
    function bprint_fconv_flag(buf, fconv){
      /*<<camlinternalFormat.ml:445:2>>*/ switch(fconv[1]){
@@ -13757,7 +13759,7 @@
         /*<<camlinternalFormat.ml:446:20>>*/ buffer_add_char(buf, 43); break;
       default:  /*<<camlinternalFormat.ml:447:20>>*/ buffer_add_char(buf, 32);
     }
-    return 8 <= fconv[2] ? (buffer_add_char(buf, 35), _$_) : _$_;
+    return 8 <= fconv[2] ? (buffer_add_char(buf, 35), sentinal) : sentinal;
     /*<<camlinternalFormat.ml:452:37>>*/ }
    function string_of_formatting_lit(formatting_lit){
      /*<<camlinternalFormat.ml:465:46>>*/ if
@@ -13787,40 +13789,40 @@
       default:
         /*<<camlinternalFormat.ml:475:26>>*/ var
         c = formatting_lit[1],
-         /*<<camlinternalFormat.ml:475:26>>*/ _dP_ =
+         /*<<camlinternalFormat.ml:475:26>>*/ _dO_ =
            /*<<camlinternalFormat.ml:475:26>>*/ caml_call2
            (Stdlib_String[1], 1, c);
         /*<<camlinternalFormat.ml:475:26>>*/ return  /*<<camlinternalFormat.ml:475:26>>*/ caml_call2
-               (Stdlib[28], cst$7, _dP_);
+               (Stdlib[28], cst$7, _dO_);
     }
     /*<<camlinternalFormat.ml:475:43>>*/ }
    function bprint_char_literal(buf, chr){
      /*<<camlinternalFormat.ml:480:34>>*/ return 37 === chr
-            ? (buffer_add_string(buf, cst$8), _$_)
-            : (buffer_add_char(buf, chr), _$_);
+            ? (buffer_add_string(buf, cst$8), sentinal)
+            : (buffer_add_char(buf, chr), sentinal);
     /*<<camlinternalFormat.ml:482:32>>*/ }
    function bprint_string_literal(buf, str){
      /*<<camlinternalFormat.ml:486:2>>*/ var
-     _dN_ = caml_ml_string_length(str) - 1 | 0,
-      /*<<camlinternalFormat.ml:486:2>>*/ _dM_ = 0;
-    if(_dN_ >= 0){
-     var i = _dM_;
+     _dM_ = caml_ml_string_length(str) - 1 | 0,
+      /*<<camlinternalFormat.ml:486:2>>*/ _dL_ = 0;
+    if(_dM_ >= 0){
+     var i = _dL_;
      for(;;){
        /*<<camlinternalFormat.ml:487:4>>*/ bprint_char_literal
        (buf,  /*<<camlinternalFormat.ml:487:28>>*/ caml_string_get(str, i));
        /*<<camlinternalFormat.ml:487:4>>*/  /*<<camlinternalFormat.ml:487:4>>*/ var
-       _dO_ = i + 1 | 0;
-      if(_dN_ === i) break;
-      var i = _dO_;
+       _dN_ = i + 1 | 0;
+      if(_dM_ === i) break;
+      var i = _dN_;
      }
     }
-    return _$_;
+    return sentinal;
     /*<<camlinternalFormat.ml:488:6>>*/ }
    function bprint_fmtty(buf, fmtty){
      /*<<camlinternalFormat.ml:496:17>>*/ var fmtty$0 = fmtty;
      /*<<camlinternalFormat.ml:496:17>>*/ for(;;){
      if(typeof fmtty$0 === "number")
-       /*<<camlinternalFormat.ml:521:20>>*/ return _$_;
+       /*<<camlinternalFormat.ml:521:20>>*/ return sentinal;
      switch(fmtty$0[0]){
        case 0:
         var fmtty$1 = fmtty$0[1];
@@ -13918,7 +13920,7 @@
       ign_flag$0 = ign_flag;
       /*<<camlinternalFormat.ml:535:22>>*/ for(;;){
       if(typeof fmt$0 === "number")
-        /*<<camlinternalFormat.ml:636:23>>*/ return _$_;
+        /*<<camlinternalFormat.ml:636:23>>*/ return sentinal;
       switch(fmt$0[0]){
         case 0:
          var rest = fmt$0[1];
@@ -14122,11 +14124,17 @@
                  /*<<camlinternalFormat.ml:358:31>>*/ caml_call1
                  (Stdlib[29], i);
              return 37 === c
-                     ? (buffer_add_char(buf, 37), buffer_add_char(buf, 37), _$_)
+                     ? (buffer_add_char
+                        (buf, 37),
+                       buffer_add_char(buf, 37),
+                       sentinal)
                      : 64
                        === c
-                       ? (buffer_add_char(buf, 37), buffer_add_char(buf, 64), _$_)
-                       : (buffer_add_char(buf, c), _$_);
+                       ? (buffer_add_char
+                          (buf, 37),
+                         buffer_add_char(buf, 64),
+                         sentinal)
+                       : (buffer_add_char(buf, c), sentinal);
              /*<<camlinternalFormat.ml:361:35>>*/ };
           /*<<camlinternalFormat.ml:363:2>>*/ buffer_add_char(buf, 91);
           /*<<camlinternalFormat.ml:365:7>>*/ var
@@ -14144,18 +14152,18 @@
                 /*<<camlinternalFormat.ml:316:32>>*/ before =
                   /*<<camlinternalFormat.ml:316:32>>*/ caml_call1
                   (Stdlib_Char[1], c - 1 | 0),
-                /*<<camlinternalFormat.ml:317:6>>*/ _dI_ =
+                /*<<camlinternalFormat.ml:317:6>>*/ _dH_ =
                  is_in_char_set(set, c);
-               /*<<camlinternalFormat.ml:317:6>>*/ if(_dI_)
+               /*<<camlinternalFormat.ml:317:6>>*/ if(_dH_)
                 /*<<camlinternalFormat.ml:318:14>>*/ var
-                 /*<<camlinternalFormat.ml:318:14>>*/ _dJ_ =
+                 /*<<camlinternalFormat.ml:318:14>>*/ _dI_ =
                   is_in_char_set(set, before),
-                 /*<<camlinternalFormat.ml:318:14>>*/ _dK_ =
-                  _dJ_ ? is_in_char_set(set, after) : _dJ_,
-                _dL_ = 1 - _dK_;
+                 /*<<camlinternalFormat.ml:318:14>>*/ _dJ_ =
+                  _dI_ ? is_in_char_set(set, after) : _dI_,
+                _dK_ = 1 - _dJ_;
               else
-               var _dL_ = _dI_;
-               /*<<camlinternalFormat.ml:318:43>>*/ return _dL_;
+               var _dK_ = _dH_;
+               /*<<camlinternalFormat.ml:318:43>>*/ return _dK_;
               /*<<camlinternalFormat.ml:318:68>>*/ }
              return is_alone;
             },
@@ -14289,12 +14297,12 @@
           (buf, ign_flag$0);
          switch(counter){
            case 0:
-            var _dE_ = 108; break;
+            var _dD_ = 108; break;
            case 1:
-            var _dE_ = 110; break;
-           default: var _dE_ = 78;
+            var _dD_ = 110; break;
+           default: var _dD_ = 78;
          }
-          /*<<camlinternalFormat.ml:614:6>>*/ buffer_add_char(buf, _dE_);
+          /*<<camlinternalFormat.ml:614:6>>*/ buffer_add_char(buf, _dD_);
          var fmt$0 = rest$20, ign_flag$0 = 0;
          break;
         case 22:
@@ -14318,20 +14326,20 @@
           /*<<camlinternalFormat.ml:578:20>>*/ var
           rest$23 = fmt$0[3],
           arity = fmt$0[1],
-           /*<<camlinternalFormat.ml:578:20>>*/ _dG_ =
+           /*<<camlinternalFormat.ml:578:20>>*/ _dF_ =
             int_of_custom_arity(arity),
-          _dF_ = 1;
-         if(_dG_ >= 1){
-          var i$8 = _dF_;
+          _dE_ = 1;
+         if(_dF_ >= 1){
+          var i$8 = _dE_;
           for(;;){
             /*<<camlinternalFormat.ml:579:8>>*/ buffer_add_char(buf, 37);
             /*<<camlinternalFormat.ml:579:33>>*/ bprint_ignored_flag
             (buf, ign_flag$0);
             /*<<camlinternalFormat.ml:580:8>>*/ buffer_add_char(buf, 63);
             /*<<camlinternalFormat.ml:580:8>>*/  /*<<camlinternalFormat.ml:580:8>>*/ var
-            _dH_ = i$8 + 1 | 0;
-           if(_dG_ === i$8) break;
-           var i$8 = _dH_;
+            _dG_ = i$8 + 1 | 0;
+           if(_dF_ === i$8) break;
+           var i$8 = _dG_;
           }
          }
          var fmt$0 = rest$23, ign_flag$0 = 0;
@@ -14403,17 +14411,17 @@
          ed = match[3],
          af = match[2],
          fa = match[1],
-         _dj_ =
+         _di_ =
            function(param){
              /*<<camlinternalFormat.ml:698:17>>*/ af(0);
-             /*<<camlinternalFormat.ml:698:39>>*/ return _$_;
+             /*<<camlinternalFormat.ml:698:39>>*/ return sentinal;
             /*<<camlinternalFormat.ml:698:43>>*/ };
          /*<<camlinternalFormat.ml:697:4>>*/ return [0,
                 function(param){
                   /*<<camlinternalFormat.ml:697:17>>*/ fa(0);
-                  /*<<camlinternalFormat.ml:697:39>>*/ return _$_;
+                  /*<<camlinternalFormat.ml:697:39>>*/ return sentinal;
                  /*<<camlinternalFormat.ml:697:43>>*/ },
-                _dj_,
+                _di_,
                 ed,
                 de];
        case 1:
@@ -14424,17 +14432,17 @@
          ed$0 = match$0[3],
          af$0 = match$0[2],
          fa$0 = match$0[1],
-         _dk_ =
+         _dj_ =
            function(param){
              /*<<camlinternalFormat.ml:703:17>>*/ af$0(0);
-             /*<<camlinternalFormat.ml:703:39>>*/ return _$_;
+             /*<<camlinternalFormat.ml:703:39>>*/ return sentinal;
             /*<<camlinternalFormat.ml:703:43>>*/ };
          /*<<camlinternalFormat.ml:702:4>>*/ return [0,
                 function(param){
                   /*<<camlinternalFormat.ml:702:17>>*/ fa$0(0);
-                  /*<<camlinternalFormat.ml:702:39>>*/ return _$_;
+                  /*<<camlinternalFormat.ml:702:39>>*/ return sentinal;
                  /*<<camlinternalFormat.ml:702:43>>*/ },
-                _dk_,
+                _dj_,
                 ed$0,
                 de$0];
        case 2:
@@ -14445,17 +14453,17 @@
          ed$1 = match$1[3],
          af$1 = match$1[2],
          fa$1 = match$1[1],
-         _dl_ =
+         _dk_ =
            function(param){
              /*<<camlinternalFormat.ml:708:17>>*/ af$1(0);
-             /*<<camlinternalFormat.ml:708:39>>*/ return _$_;
+             /*<<camlinternalFormat.ml:708:39>>*/ return sentinal;
             /*<<camlinternalFormat.ml:708:43>>*/ };
          /*<<camlinternalFormat.ml:707:4>>*/ return [0,
                 function(param){
                   /*<<camlinternalFormat.ml:707:17>>*/ fa$1(0);
-                  /*<<camlinternalFormat.ml:707:39>>*/ return _$_;
+                  /*<<camlinternalFormat.ml:707:39>>*/ return sentinal;
                  /*<<camlinternalFormat.ml:707:43>>*/ },
-                _dl_,
+                _dk_,
                 ed$1,
                 de$1];
        case 3:
@@ -14466,17 +14474,17 @@
          ed$2 = match$2[3],
          af$2 = match$2[2],
          fa$2 = match$2[1],
-         _dm_ =
+         _dl_ =
            function(param){
              /*<<camlinternalFormat.ml:713:17>>*/ af$2(0);
-             /*<<camlinternalFormat.ml:713:39>>*/ return _$_;
+             /*<<camlinternalFormat.ml:713:39>>*/ return sentinal;
             /*<<camlinternalFormat.ml:713:43>>*/ };
          /*<<camlinternalFormat.ml:712:4>>*/ return [0,
                 function(param){
                   /*<<camlinternalFormat.ml:712:17>>*/ fa$2(0);
-                  /*<<camlinternalFormat.ml:712:39>>*/ return _$_;
+                  /*<<camlinternalFormat.ml:712:39>>*/ return sentinal;
                  /*<<camlinternalFormat.ml:712:43>>*/ },
-                _dm_,
+                _dl_,
                 ed$2,
                 de$2];
        case 4:
@@ -14487,17 +14495,17 @@
          ed$3 = match$3[3],
          af$3 = match$3[2],
          fa$3 = match$3[1],
-         _dn_ =
+         _dm_ =
            function(param){
              /*<<camlinternalFormat.ml:723:17>>*/ af$3(0);
-             /*<<camlinternalFormat.ml:723:39>>*/ return _$_;
+             /*<<camlinternalFormat.ml:723:39>>*/ return sentinal;
             /*<<camlinternalFormat.ml:723:43>>*/ };
          /*<<camlinternalFormat.ml:722:4>>*/ return [0,
                 function(param){
                   /*<<camlinternalFormat.ml:722:17>>*/ fa$3(0);
-                  /*<<camlinternalFormat.ml:722:39>>*/ return _$_;
+                  /*<<camlinternalFormat.ml:722:39>>*/ return sentinal;
                  /*<<camlinternalFormat.ml:722:43>>*/ },
-                _dn_,
+                _dm_,
                 ed$3,
                 de$3];
        case 5:
@@ -14508,17 +14516,17 @@
          ed$4 = match$4[3],
          af$4 = match$4[2],
          fa$4 = match$4[1],
-         _do_ =
+         _dn_ =
            function(param){
              /*<<camlinternalFormat.ml:718:17>>*/ af$4(0);
-             /*<<camlinternalFormat.ml:718:39>>*/ return _$_;
+             /*<<camlinternalFormat.ml:718:39>>*/ return sentinal;
             /*<<camlinternalFormat.ml:718:43>>*/ };
          /*<<camlinternalFormat.ml:717:4>>*/ return [0,
                 function(param){
                   /*<<camlinternalFormat.ml:717:17>>*/ fa$4(0);
-                  /*<<camlinternalFormat.ml:717:39>>*/ return _$_;
+                  /*<<camlinternalFormat.ml:717:39>>*/ return sentinal;
                  /*<<camlinternalFormat.ml:717:43>>*/ },
-                _do_,
+                _dn_,
                 ed$4,
                 de$4];
        case 6:
@@ -14529,17 +14537,17 @@
          ed$5 = match$5[3],
          af$5 = match$5[2],
          fa$5 = match$5[1],
-         _dp_ =
+         _do_ =
            function(param){
              /*<<camlinternalFormat.ml:728:17>>*/ af$5(0);
-             /*<<camlinternalFormat.ml:728:39>>*/ return _$_;
+             /*<<camlinternalFormat.ml:728:39>>*/ return sentinal;
             /*<<camlinternalFormat.ml:728:43>>*/ };
          /*<<camlinternalFormat.ml:727:4>>*/ return [0,
                 function(param){
                   /*<<camlinternalFormat.ml:727:17>>*/ fa$5(0);
-                  /*<<camlinternalFormat.ml:727:39>>*/ return _$_;
+                  /*<<camlinternalFormat.ml:727:39>>*/ return sentinal;
                  /*<<camlinternalFormat.ml:727:43>>*/ },
-                _dp_,
+                _do_,
                 ed$5,
                 de$5];
        case 7:
@@ -14550,17 +14558,17 @@
          ed$6 = match$6[3],
          af$6 = match$6[2],
          fa$6 = match$6[1],
-         _dq_ =
+         _dp_ =
            function(param){
              /*<<camlinternalFormat.ml:733:17>>*/ af$6(0);
-             /*<<camlinternalFormat.ml:733:39>>*/ return _$_;
+             /*<<camlinternalFormat.ml:733:39>>*/ return sentinal;
             /*<<camlinternalFormat.ml:733:43>>*/ };
          /*<<camlinternalFormat.ml:732:4>>*/ return [0,
                 function(param){
                   /*<<camlinternalFormat.ml:732:17>>*/ fa$6(0);
-                  /*<<camlinternalFormat.ml:732:39>>*/ return _$_;
+                  /*<<camlinternalFormat.ml:732:39>>*/ return sentinal;
                  /*<<camlinternalFormat.ml:732:43>>*/ },
-                _dq_,
+                _dp_,
                 ed$6,
                 de$6];
        case 8:
@@ -14571,17 +14579,17 @@
          ed$7 = match$7[3],
          af$7 = match$7[2],
          fa$7 = match$7[1],
-         _dr_ =
+         _dq_ =
            function(param){
              /*<<camlinternalFormat.ml:766:17>>*/ af$7(0);
-             /*<<camlinternalFormat.ml:766:39>>*/ return _$_;
+             /*<<camlinternalFormat.ml:766:39>>*/ return sentinal;
             /*<<camlinternalFormat.ml:766:43>>*/ };
          /*<<camlinternalFormat.ml:765:4>>*/ return [0,
                 function(param){
                   /*<<camlinternalFormat.ml:765:17>>*/ fa$7(0);
-                  /*<<camlinternalFormat.ml:765:39>>*/ return _$_;
+                  /*<<camlinternalFormat.ml:765:39>>*/ return sentinal;
                  /*<<camlinternalFormat.ml:765:43>>*/ },
-                _dr_,
+                _dq_,
                 ed$7,
                 de$7];
        case 9:
@@ -14600,33 +14608,33 @@
          dj = match$9[3],
          ga = match$9[2],
          ag = match$9[1],
-         _ds_ =
+         _dr_ =
            function(param){
              /*<<camlinternalFormat.ml:775:17>>*/ jd(0);
              /*<<camlinternalFormat.ml:775:50>>*/ de$8(0);
-             /*<<camlinternalFormat.ml:775:61>>*/ return _$_;
+             /*<<camlinternalFormat.ml:775:61>>*/ return sentinal;
             /*<<camlinternalFormat.ml:775:65>>*/ },
-         _dt_ =
+         _ds_ =
            function(param){
              /*<<camlinternalFormat.ml:774:17>>*/ ed$8(0);
              /*<<camlinternalFormat.ml:774:50>>*/ dj(0);
-             /*<<camlinternalFormat.ml:774:61>>*/ return _$_;
+             /*<<camlinternalFormat.ml:774:61>>*/ return sentinal;
             /*<<camlinternalFormat.ml:774:65>>*/ },
-         _du_ =
+         _dt_ =
            function(param){
              /*<<camlinternalFormat.ml:773:17>>*/ ga(0);
              /*<<camlinternalFormat.ml:773:50>>*/ af$8(0);
-             /*<<camlinternalFormat.ml:773:61>>*/ return _$_;
+             /*<<camlinternalFormat.ml:773:61>>*/ return sentinal;
             /*<<camlinternalFormat.ml:773:65>>*/ };
          /*<<camlinternalFormat.ml:772:4>>*/ return [0,
                 function(param){
                   /*<<camlinternalFormat.ml:772:17>>*/ fa$8(0);
                   /*<<camlinternalFormat.ml:772:50>>*/ ag(0);
-                  /*<<camlinternalFormat.ml:772:61>>*/ return _$_;
+                  /*<<camlinternalFormat.ml:772:61>>*/ return sentinal;
                  /*<<camlinternalFormat.ml:772:65>>*/ },
-                _du_,
                 _dt_,
-                _ds_];
+                _ds_,
+                _dr_];
        case 10:
          /*<<camlinternalFormat.ml:742:25>>*/ var
          rest$9 = param[1],
@@ -14636,17 +14644,17 @@
          ed$9 = match$10[3],
          af$9 = match$10[2],
          fa$9 = match$10[1],
-         _dv_ =
+         _du_ =
            function(param){
              /*<<camlinternalFormat.ml:744:17>>*/ af$9(0);
-             /*<<camlinternalFormat.ml:744:39>>*/ return _$_;
+             /*<<camlinternalFormat.ml:744:39>>*/ return sentinal;
             /*<<camlinternalFormat.ml:744:43>>*/ };
          /*<<camlinternalFormat.ml:743:4>>*/ return [0,
                 function(param){
                   /*<<camlinternalFormat.ml:743:17>>*/ fa$9(0);
-                  /*<<camlinternalFormat.ml:743:39>>*/ return _$_;
+                  /*<<camlinternalFormat.ml:743:39>>*/ return sentinal;
                  /*<<camlinternalFormat.ml:743:43>>*/ },
-                _dv_,
+                _du_,
                 ed$9,
                 de$9];
        case 11:
@@ -14658,17 +14666,17 @@
          ed$10 = match$11[3],
          af$10 = match$11[2],
          fa$10 = match$11[1],
-         _dw_ =
+         _dv_ =
            function(param){
              /*<<camlinternalFormat.ml:739:17>>*/ af$10(0);
-             /*<<camlinternalFormat.ml:739:39>>*/ return _$_;
+             /*<<camlinternalFormat.ml:739:39>>*/ return sentinal;
             /*<<camlinternalFormat.ml:739:43>>*/ };
          /*<<camlinternalFormat.ml:738:4>>*/ return [0,
                 function(param){
                   /*<<camlinternalFormat.ml:738:17>>*/ fa$10(0);
-                  /*<<camlinternalFormat.ml:738:39>>*/ return _$_;
+                  /*<<camlinternalFormat.ml:738:39>>*/ return sentinal;
                  /*<<camlinternalFormat.ml:738:43>>*/ },
-                _dw_,
+                _dv_,
                 ed$10,
                 de$10];
        case 12:
@@ -14680,17 +14688,17 @@
          ed$11 = match$12[3],
          af$11 = match$12[2],
          fa$11 = match$12[1],
-         _dx_ =
+         _dw_ =
            function(param){
              /*<<camlinternalFormat.ml:749:17>>*/ af$11(0);
-             /*<<camlinternalFormat.ml:749:39>>*/ return _$_;
+             /*<<camlinternalFormat.ml:749:39>>*/ return sentinal;
             /*<<camlinternalFormat.ml:749:43>>*/ };
          /*<<camlinternalFormat.ml:748:4>>*/ return [0,
                 function(param){
                   /*<<camlinternalFormat.ml:748:17>>*/ fa$11(0);
-                  /*<<camlinternalFormat.ml:748:39>>*/ return _$_;
+                  /*<<camlinternalFormat.ml:748:39>>*/ return sentinal;
                  /*<<camlinternalFormat.ml:748:43>>*/ },
-                _dx_,
+                _dw_,
                 ed$11,
                 de$11];
        case 13:
@@ -14702,29 +14710,29 @@
          ed$12 = match$13[3],
          af$12 = match$13[2],
          fa$12 = match$13[1],
-          /*<<camlinternalFormat.ml:753:4>>*/ _dy_ =
+          /*<<camlinternalFormat.ml:753:4>>*/ _dx_ =
            function(param){
              /*<<camlinternalFormat.ml:756:17>>*/ de$12(0);
-             /*<<camlinternalFormat.ml:756:39>>*/ return _$_;
+             /*<<camlinternalFormat.ml:756:39>>*/ return sentinal;
             /*<<camlinternalFormat.ml:756:43>>*/ },
-         _dz_ =
+         _dy_ =
            function(param){
              /*<<camlinternalFormat.ml:755:17>>*/ ed$12(0);
-             /*<<camlinternalFormat.ml:755:39>>*/ return _$_;
+             /*<<camlinternalFormat.ml:755:39>>*/ return sentinal;
             /*<<camlinternalFormat.ml:755:43>>*/ },
-         _dA_ =
+         _dz_ =
            function(param){
              /*<<camlinternalFormat.ml:754:17>>*/ af$12(0);
-             /*<<camlinternalFormat.ml:754:39>>*/ return _$_;
+             /*<<camlinternalFormat.ml:754:39>>*/ return sentinal;
             /*<<camlinternalFormat.ml:754:43>>*/ };
          /*<<camlinternalFormat.ml:753:4>>*/ return [0,
                 function(param){
                   /*<<camlinternalFormat.ml:753:17>>*/ fa$12(0);
-                  /*<<camlinternalFormat.ml:753:39>>*/ return _$_;
+                  /*<<camlinternalFormat.ml:753:39>>*/ return sentinal;
                  /*<<camlinternalFormat.ml:753:43>>*/ },
-                _dA_,
                 _dz_,
-                _dy_];
+                _dy_,
+                _dx_];
        default:
          /*<<camlinternalFormat.ml:758:25>>*/ var
          rest$13 = param[1],
@@ -14734,46 +14742,46 @@
          ed$13 = match$14[3],
          af$13 = match$14[2],
          fa$13 = match$14[1],
-          /*<<camlinternalFormat.ml:759:4>>*/ _dB_ =
+          /*<<camlinternalFormat.ml:759:4>>*/ _dA_ =
            function(param){
              /*<<camlinternalFormat.ml:762:17>>*/ de$13(0);
-             /*<<camlinternalFormat.ml:762:39>>*/ return _$_;
+             /*<<camlinternalFormat.ml:762:39>>*/ return sentinal;
             /*<<camlinternalFormat.ml:762:43>>*/ },
-         _dC_ =
+         _dB_ =
            function(param){
              /*<<camlinternalFormat.ml:761:17>>*/ ed$13(0);
-             /*<<camlinternalFormat.ml:761:39>>*/ return _$_;
+             /*<<camlinternalFormat.ml:761:39>>*/ return sentinal;
             /*<<camlinternalFormat.ml:761:43>>*/ },
-         _dD_ =
+         _dC_ =
            function(param){
              /*<<camlinternalFormat.ml:760:17>>*/ af$13(0);
-             /*<<camlinternalFormat.ml:760:39>>*/ return _$_;
+             /*<<camlinternalFormat.ml:760:39>>*/ return sentinal;
             /*<<camlinternalFormat.ml:760:43>>*/ };
          /*<<camlinternalFormat.ml:759:4>>*/ return [0,
                 function(param){
                   /*<<camlinternalFormat.ml:759:17>>*/ fa$13(0);
-                  /*<<camlinternalFormat.ml:759:39>>*/ return _$_;
+                  /*<<camlinternalFormat.ml:759:39>>*/ return sentinal;
                  /*<<camlinternalFormat.ml:759:43>>*/ },
-                _dD_,
                 _dC_,
-                _dB_];
+                _dB_,
+                _dA_];
      }
-     /*<<camlinternalFormat.ml:691:4>>*/ function _dg_(param){
-      /*<<camlinternalFormat.ml:694:17>>*/ return _$_;
+     /*<<camlinternalFormat.ml:691:4>>*/ function _df_(param){
+      /*<<camlinternalFormat.ml:694:17>>*/ return sentinal;
      /*<<camlinternalFormat.ml:694:21>>*/ }
-    function _dh_(param){
-      /*<<camlinternalFormat.ml:693:17>>*/ return _$_;
+    function _dg_(param){
+      /*<<camlinternalFormat.ml:693:17>>*/ return sentinal;
      /*<<camlinternalFormat.ml:693:21>>*/ }
-    function _di_(param){
-      /*<<camlinternalFormat.ml:692:17>>*/ return _$_;
+    function _dh_(param){
+      /*<<camlinternalFormat.ml:692:17>>*/ return sentinal;
      /*<<camlinternalFormat.ml:692:21>>*/ }
      /*<<camlinternalFormat.ml:691:4>>*/ return [0,
             function(param){
-              /*<<camlinternalFormat.ml:691:17>>*/ return _$_;
+              /*<<camlinternalFormat.ml:691:17>>*/ return sentinal;
              /*<<camlinternalFormat.ml:691:21>>*/ },
-            _di_,
             _dh_,
-            _dg_];
+            _dg_,
+            _df_];
     /*<<camlinternalFormat.ml:775:66>>*/ }
    function trans(ty1, ty2){
      /*<<camlinternalFormat.ml:803:17>>*/ a:
@@ -14992,11 +15000,11 @@
                     /*<<camlinternalFormat.ml:835:34>>*/ var
                     rest2$7 = ty2[2],
                     ty2$0 = ty2[1],
-                     /*<<camlinternalFormat.ml:835:34>>*/ _df_ =
+                     /*<<camlinternalFormat.ml:835:34>>*/ _de_ =
                       trans(rest1$7, rest2$7);
                     /*<<camlinternalFormat.ml:835:4>>*/ return [8,
                            trans(ty1$0, ty2$0),
-                           _df_];
+                           _de_];
                   case 10:
                    break a;
                   case 11:
@@ -15286,13 +15294,13 @@
          /*<<camlinternalFormat.ml:914:54>>*/ var
          rest$13 = fmtty$0[2],
          formatting_gen = fmtty$0[1],
-          /*<<camlinternalFormat.ml:914:54>>*/ _dc_ = fmtty_of_fmt(rest$13);
+          /*<<camlinternalFormat.ml:914:54>>*/ _db_ = fmtty_of_fmt(rest$13);
         if(0 === formatting_gen[0])
-         var fmt = formatting_gen[1][1], _dd_ = fmtty_of_fmt(fmt);
+         var fmt = formatting_gen[1][1], _dc_ = fmtty_of_fmt(fmt);
         else
-         var fmt$0 = formatting_gen[1][1], _dd_ = fmtty_of_fmt(fmt$0);
+         var fmt$0 = formatting_gen[1][1], _dc_ = fmtty_of_fmt(fmt$0);
          /*<<camlinternalFormat.ml:914:54>>*/ return  /*<<camlinternalFormat.ml:914:54>>*/ caml_call2
-                (CamlinternalFormatBasics[1], _dd_, _dc_);
+                (CamlinternalFormatBasics[1], _dc_, _db_);
        case 19:
         var rest$14 = fmtty$0[1];
          /*<<camlinternalFormat.ml:897:34>>*/ return [13,
@@ -15345,10 +15353,10 @@
            case 9:
              /*<<camlinternalFormat.ml:943:58>>*/ var
              fmtty$6 = ign[2],
-              /*<<camlinternalFormat.ml:943:58>>*/ _de_ =
+              /*<<camlinternalFormat.ml:943:58>>*/ _dd_ =
                fmtty_of_fmt(fmtty$5);
              /*<<camlinternalFormat.ml:943:58>>*/ return  /*<<camlinternalFormat.ml:943:58>>*/ caml_call2
-                    (CamlinternalFormatBasics[1], fmtty$6, _de_);
+                    (CamlinternalFormatBasics[1], fmtty$6, _dd_);
            case 10:
             var fmtty$0 = fmtty$5; break;
            default: var fmtty$0 = fmtty$5;
@@ -15404,11 +15412,11 @@
     /*<<camlinternalFormat.ml:996:54>>*/ }
    function type_format(fmt, fmtty){
      /*<<camlinternalFormat.ml:1008:19>>*/  /*<<camlinternalFormat.ml:1008:25>>*/ var
-     _db_ = type_format_gen(fmt, fmtty);
-    if(typeof _db_[2] !== "number")
+     _da_ = type_format_gen(fmt, fmtty);
+    if(typeof _da_[2] !== "number")
       /*<<camlinternalFormat.ml:1010:9>>*/ throw  /*<<camlinternalFormat.ml:1010:9>>*/ caml_maybe_attach_backtrace
             (Type_mismatch, 1);
-    var fmt$0 = _db_[1];
+    var fmt$0 = _da_[1];
      /*<<camlinternalFormat.ml:1009:42>>*/ return fmt$0;
     /*<<camlinternalFormat.ml:1010:28>>*/ }
    function type_ignored_param_one(ign, fmt, fmtty){
@@ -15693,7 +15701,7 @@
          fmt_rest$13 = fmt[3],
          sub_fmtty$1 = fmt[2],
          pad_opt$0 = fmt[1],
-          /*<<camlinternalFormat.ml:1099:42>>*/ _c$_ =
+          /*<<camlinternalFormat.ml:1099:42>>*/ _c__ =
            [0,
              /*<<camlinternalFormat.ml:1099:52>>*/ caml_call1
              (CamlinternalFormatBasics[2], sub_fmtty1)];
@@ -15702,7 +15710,7 @@
            ([0,
               /*<<camlinternalFormat.ml:1099:17>>*/ caml_call1
               (CamlinternalFormatBasics[2], sub_fmtty$1)],
-            _c$_))
+            _c__))
           /*<<camlinternalFormat.ml:1100:6>>*/ throw  /*<<camlinternalFormat.ml:1100:6>>*/ caml_maybe_attach_backtrace
                 (Type_mismatch, 1);
          /*<<camlinternalFormat.ml:1102:6>>*/ var
@@ -15872,12 +15880,12 @@
             /*<<camlinternalFormat.ml:1176:6>>*/ var
             sub_fmtty$3 = ign[2],
             pad_opt$2 = ign[1],
-             /*<<camlinternalFormat.ml:1176:6>>*/ _da_ =
+             /*<<camlinternalFormat.ml:1176:6>>*/ _c$_ =
               type_ignored_format_substituti(sub_fmtty$3, rest, fmtty0),
-            match$43 = _da_[2],
+            match$43 = _c$_[2],
             fmtty$21 = match$43[2],
             fmt$22 = match$43[1],
-            sub_fmtty$4 = _da_[1];
+            sub_fmtty$4 = _c$_[1];
             /*<<camlinternalFormat.ml:1177:4>>*/ return [0,
                    [23, [9, pad_opt$2, sub_fmtty$4], fmt$22],
                    fmtty$21];
@@ -16069,7 +16077,7 @@
          sub_fmtty_rest$17 = sub_fmtty[3],
          sub2_fmtty$2 = sub_fmtty[2],
          sub1_fmtty$0 = sub_fmtty[1],
-          /*<<camlinternalFormat.ml:1261:43>>*/ _c9_ =
+          /*<<camlinternalFormat.ml:1261:43>>*/ _c8_ =
            [0,
              /*<<camlinternalFormat.ml:1261:53>>*/ caml_call1
              (CamlinternalFormatBasics[2], sub1_fmtty)];
@@ -16078,11 +16086,11 @@
            ([0,
               /*<<camlinternalFormat.ml:1261:17>>*/ caml_call1
               (CamlinternalFormatBasics[2], sub1_fmtty$0)],
-            _c9_))
+            _c8_))
           /*<<camlinternalFormat.ml:1262:9>>*/ throw  /*<<camlinternalFormat.ml:1262:9>>*/ caml_maybe_attach_backtrace
                 (Type_mismatch, 1);
          /*<<camlinternalFormat.ml:1263:43>>*/  /*<<camlinternalFormat.ml:1263:43>>*/ var
-         _c__ =
+         _c9_ =
            [0,
              /*<<camlinternalFormat.ml:1263:53>>*/ caml_call1
              (CamlinternalFormatBasics[2], sub2_fmtty$1)];
@@ -16091,7 +16099,7 @@
            ([0,
               /*<<camlinternalFormat.ml:1263:17>>*/ caml_call1
               (CamlinternalFormatBasics[2], sub2_fmtty$2)],
-            _c__))
+            _c9_))
           /*<<camlinternalFormat.ml:1264:9>>*/ throw  /*<<camlinternalFormat.ml:1264:9>>*/ caml_maybe_attach_backtrace
                 (Type_mismatch, 1);
          /*<<camlinternalFormat.ml:1265:21>>*/ var
@@ -16183,11 +16191,11 @@
     /*<<camlinternalFormat.ml:1277:28>>*/ }
    function recast(fmt, fmtty){
      /*<<camlinternalFormat.ml:1312:2>>*/  /*<<camlinternalFormat.ml:1312:29>>*/ var
-     _c8_ = symm(fmtty);
+     _c7_ = symm(fmtty);
      /*<<camlinternalFormat.ml:1312:18>>*/ return type_format
             (fmt,
               /*<<camlinternalFormat.ml:1312:18>>*/ caml_call1
-              (CamlinternalFormatBasics[2], _c8_));
+              (CamlinternalFormatBasics[2], _c7_));
     /*<<camlinternalFormat.ml:1312:42>>*/ }
    function fix_padding(padty, width, str){
      /*<<camlinternalFormat.ml:1319:2>>*/ var
@@ -16197,10 +16205,10 @@
         /*<<camlinternalFormat.ml:1321:4>>*/ caml_call1(Stdlib[18], width);
     if(width$0 <= len)  /*<<camlinternalFormat.ml:1332:23>>*/ return str;
      /*<<camlinternalFormat.ml:1333:14>>*/ var
-     _c7_ = 2 === padty$0 ? 48 : 32,
+     _c6_ = 2 === padty$0 ? 48 : 32,
       /*<<camlinternalFormat.ml:1333:14>>*/ res =
         /*<<camlinternalFormat.ml:1333:14>>*/ caml_call2
-        (Stdlib_Bytes[1], width$0, _c7_);
+        (Stdlib_Bytes[1], width$0, _c6_);
      /*<<camlinternalFormat.ml:1334:4>>*/ switch(padty$0){
       case 0:
         /*<<camlinternalFormat.ml:1335:15>>*/  /*<<camlinternalFormat.ml:1335:15>>*/ caml_call5
@@ -16392,16 +16400,16 @@
       /*<<camlinternalFormat.ml:1447:9>>*/ return s;
      /*<<camlinternalFormat.ml:1428:14>>*/ var
       /*<<camlinternalFormat.ml:1428:14>>*/ n = [0, 0],
-     _c2_ = caml_ml_string_length(s) - 1 | 0,
-      /*<<camlinternalFormat.ml:1428:14>>*/ _c1_ = 0;
-    if(_c2_ >= 0){
-     var i$0 = _c1_;
+     _c1_ = caml_ml_string_length(s) - 1 | 0,
+      /*<<camlinternalFormat.ml:1428:14>>*/ _c0_ = 0;
+    if(_c1_ >= 0){
+     var i$0 = _c0_;
      for(;;){
       if(9 >= caml_string_unsafe_get(s, i$0) - 48 >>> 0) n[1]++;
        /*<<camlinternalFormat.ml:1429:6>>*/  /*<<camlinternalFormat.ml:1429:6>>*/ var
-       _c6_ = i$0 + 1 | 0;
-      if(_c2_ === i$0) break;
-      var i$0 = _c6_;
+       _c5_ = i$0 + 1 | 0;
+      if(_c1_ === i$0) break;
+      var i$0 = _c5_;
      }
     }
      /*<<camlinternalFormat.ml:1436:14>>*/ var
@@ -16414,15 +16422,15 @@
       /*<<camlinternalFormat.ml:1438:16>>*/  /*<<camlinternalFormat.ml:1438:16>>*/ caml_bytes_set
       (buf, pos[1], c);
      pos[1]++;
-     return _$_;
+     return sentinal;
      /*<<camlinternalFormat.ml:1438:46>>*/ }
      /*<<camlinternalFormat.ml:1439:15>>*/ var
       /*<<camlinternalFormat.ml:1439:15>>*/ left =
        [0, ((digits - 1 | 0) % 3 | 0) + 1 | 0],
-     _c4_ = caml_ml_string_length(s) - 1 | 0,
-      /*<<camlinternalFormat.ml:1439:15>>*/ _c3_ = 0;
-    if(_c4_ >= 0){
-     var i = _c3_;
+     _c3_ = caml_ml_string_length(s) - 1 | 0,
+      /*<<camlinternalFormat.ml:1439:15>>*/ _c2_ = 0;
+    if(_c3_ >= 0){
+     var i = _c2_;
      for(;;){
       var c = caml_string_unsafe_get(s, i);
       if(9 < c - 48 >>> 0)
@@ -16436,9 +16444,9 @@
         /*<<camlinternalFormat.ml:1443:61>>*/ put(c);
       }
        /*<<camlinternalFormat.ml:1440:4>>*/  /*<<camlinternalFormat.ml:1440:4>>*/ var
-       _c5_ = i + 1 | 0;
-      if(_c4_ === i) break;
-      var i = _c5_;
+       _c4_ = i + 1 | 0;
+      if(_c3_ === i) break;
+      var i = _c4_;
      }
     }
      /*<<camlinternalFormat.ml:1446:4>>*/ return  /*<<camlinternalFormat.ml:1446:4>>*/ caml_call1
@@ -16447,139 +16455,139 @@
    function convert_int(iconv, n){
      /*<<camlinternalFormat.ml:1451:2>>*/ switch(iconv){
       case 1:
-       var _c0_ = cst_d$0; break;
+       var _cZ_ = cst_d$0; break;
       case 2:
-       var _c0_ = cst_d$1; break;
+       var _cZ_ = cst_d$1; break;
       case 4:
-       var _c0_ = cst_i$1; break;
+       var _cZ_ = cst_i$1; break;
       case 5:
-       var _c0_ = cst_i$2; break;
+       var _cZ_ = cst_i$2; break;
       case 6:
-       var _c0_ = cst_x; break;
+       var _cZ_ = cst_x; break;
       case 7:
-       var _c0_ = cst_x$0; break;
+       var _cZ_ = cst_x$0; break;
       case 8:
-       var _c0_ = cst_X; break;
+       var _cZ_ = cst_X; break;
       case 9:
-       var _c0_ = cst_X$0; break;
+       var _cZ_ = cst_X$0; break;
       case 10:
-       var _c0_ = cst_o; break;
+       var _cZ_ = cst_o; break;
       case 11:
-       var _c0_ = cst_o$0; break;
+       var _cZ_ = cst_o$0; break;
       case 0:
       case 13:
-       var _c0_ = cst_d; break;
+       var _cZ_ = cst_d; break;
       case 3:
       case 14:
-       var _c0_ = cst_i$0; break;
-      default: var _c0_ = cst_u;
+       var _cZ_ = cst_i$0; break;
+      default: var _cZ_ = cst_u;
     }
      /*<<camlinternalFormat.ml:1451:26>>*/ return transform_int_alt
             (iconv,
-              /*<<camlinternalFormat.ml:1451:26>>*/ caml_format_int(_c0_, n));
+              /*<<camlinternalFormat.ml:1451:26>>*/ caml_format_int(_cZ_, n));
     /*<<camlinternalFormat.ml:1451:64>>*/ }
    function convert_int32(iconv, n){
      /*<<camlinternalFormat.ml:1453:2>>*/ switch(iconv){
       case 1:
-       var _cZ_ = cst_ld$0; break;
+       var _cY_ = cst_ld$0; break;
       case 2:
-       var _cZ_ = cst_ld$1; break;
+       var _cY_ = cst_ld$1; break;
       case 4:
-       var _cZ_ = cst_li$1; break;
+       var _cY_ = cst_li$1; break;
       case 5:
-       var _cZ_ = cst_li$2; break;
+       var _cY_ = cst_li$2; break;
       case 6:
-       var _cZ_ = cst_lx; break;
+       var _cY_ = cst_lx; break;
       case 7:
-       var _cZ_ = cst_lx$0; break;
+       var _cY_ = cst_lx$0; break;
       case 8:
-       var _cZ_ = cst_lX; break;
+       var _cY_ = cst_lX; break;
       case 9:
-       var _cZ_ = cst_lX$0; break;
+       var _cY_ = cst_lX$0; break;
       case 10:
-       var _cZ_ = cst_lo; break;
+       var _cY_ = cst_lo; break;
       case 11:
-       var _cZ_ = cst_lo$0; break;
+       var _cY_ = cst_lo$0; break;
       case 0:
       case 13:
-       var _cZ_ = cst_ld; break;
+       var _cY_ = cst_ld; break;
       case 3:
       case 14:
-       var _cZ_ = cst_li$0; break;
-      default: var _cZ_ = cst_lu;
+       var _cY_ = cst_li$0; break;
+      default: var _cY_ = cst_lu;
     }
      /*<<camlinternalFormat.ml:1453:26>>*/ return transform_int_alt
             (iconv,
-              /*<<camlinternalFormat.ml:1453:26>>*/ caml_format_int(_cZ_, n));
+              /*<<camlinternalFormat.ml:1453:26>>*/ caml_format_int(_cY_, n));
     /*<<camlinternalFormat.ml:1453:67>>*/ }
    function convert_nativeint(iconv, n){
      /*<<camlinternalFormat.ml:1455:2>>*/ switch(iconv){
       case 1:
-       var _cY_ = cst_nd$0; break;
+       var _cX_ = cst_nd$0; break;
       case 2:
-       var _cY_ = cst_nd$1; break;
+       var _cX_ = cst_nd$1; break;
       case 4:
-       var _cY_ = cst_ni$1; break;
+       var _cX_ = cst_ni$1; break;
       case 5:
-       var _cY_ = cst_ni$2; break;
+       var _cX_ = cst_ni$2; break;
       case 6:
-       var _cY_ = cst_nx; break;
+       var _cX_ = cst_nx; break;
       case 7:
-       var _cY_ = cst_nx$0; break;
+       var _cX_ = cst_nx$0; break;
       case 8:
-       var _cY_ = cst_nX; break;
+       var _cX_ = cst_nX; break;
       case 9:
-       var _cY_ = cst_nX$0; break;
+       var _cX_ = cst_nX$0; break;
       case 10:
-       var _cY_ = cst_no; break;
+       var _cX_ = cst_no; break;
       case 11:
-       var _cY_ = cst_no$0; break;
+       var _cX_ = cst_no$0; break;
       case 0:
       case 13:
-       var _cY_ = cst_nd; break;
+       var _cX_ = cst_nd; break;
       case 3:
       case 14:
-       var _cY_ = cst_ni$0; break;
-      default: var _cY_ = cst_nu;
+       var _cX_ = cst_ni$0; break;
+      default: var _cX_ = cst_nu;
     }
      /*<<camlinternalFormat.ml:1455:26>>*/ return transform_int_alt
             (iconv,
-              /*<<camlinternalFormat.ml:1455:26>>*/ caml_format_int(_cY_, n));
+              /*<<camlinternalFormat.ml:1455:26>>*/ caml_format_int(_cX_, n));
     /*<<camlinternalFormat.ml:1455:71>>*/ }
    function convert_int64(iconv, n){
      /*<<camlinternalFormat.ml:1457:2>>*/ switch(iconv){
       case 1:
-       var _cX_ = cst_Ld$0; break;
+       var _cW_ = cst_Ld$0; break;
       case 2:
-       var _cX_ = cst_Ld$1; break;
+       var _cW_ = cst_Ld$1; break;
       case 4:
-       var _cX_ = cst_Li$1; break;
+       var _cW_ = cst_Li$1; break;
       case 5:
-       var _cX_ = cst_Li$2; break;
+       var _cW_ = cst_Li$2; break;
       case 6:
-       var _cX_ = cst_Lx; break;
+       var _cW_ = cst_Lx; break;
       case 7:
-       var _cX_ = cst_Lx$0; break;
+       var _cW_ = cst_Lx$0; break;
       case 8:
-       var _cX_ = cst_LX; break;
+       var _cW_ = cst_LX; break;
       case 9:
-       var _cX_ = cst_LX$0; break;
+       var _cW_ = cst_LX$0; break;
       case 10:
-       var _cX_ = cst_Lo; break;
+       var _cW_ = cst_Lo; break;
       case 11:
-       var _cX_ = cst_Lo$0; break;
+       var _cW_ = cst_Lo$0; break;
       case 0:
       case 13:
-       var _cX_ = cst_Ld; break;
+       var _cW_ = cst_Ld; break;
       case 3:
       case 14:
-       var _cX_ = cst_Li$0; break;
-      default: var _cX_ = cst_Lu;
+       var _cW_ = cst_Li$0; break;
+      default: var _cW_ = cst_Lu;
     }
      /*<<camlinternalFormat.ml:1457:26>>*/ return transform_int_alt
             (iconv,
               /*<<camlinternalFormat.ml:1457:26>>*/ runtime.caml_int64_format
-              (_cX_, n));
+              (_cW_, n));
     /*<<camlinternalFormat.ml:1457:67>>*/ }
    function convert_float(fconv, prec, x){
     function hex(param){
@@ -16611,41 +16619,41 @@
         i = 0;
         /*<<camlinternalFormat.ml:1472:6>>*/ for(;;){
         if(i === len)
-         var _cU_ = 0;
+         var _cT_ = 0;
         else{
           /*<<camlinternalFormat.ml:1473:14>>*/  /*<<camlinternalFormat.ml:1473:14>>*/ var
-          _cT_ =
+          _cS_ =
              /*<<camlinternalFormat.ml:1473:14>>*/ caml_string_get(str, i)
             - 46
             | 0;
          a:
          {
-          if(23 < _cT_ >>> 0){
-           if(55 === _cT_) break a;
+          if(23 < _cS_ >>> 0){
+           if(55 === _cS_) break a;
           }
-          else if(21 < _cT_ - 1 >>> 0) break a;
+          else if(21 < _cS_ - 1 >>> 0) break a;
            /*<<camlinternalFormat.ml:1475:15>>*/ var
             /*<<camlinternalFormat.ml:1475:15>>*/ i$0 = i + 1 | 0,
            i = i$0;
           continue;
          }
-         var _cU_ = 1;
+         var _cT_ = 1;
         }
          /*<<camlinternalFormat.ml:1476:7>>*/  /*<<camlinternalFormat.ml:1476:7>>*/ var
-         _cV_ =
-           _cU_
+         _cU_ =
+           _cT_
             ? str
             :  /*<<camlinternalFormat.ml:1476:32>>*/ caml_call2
               (Stdlib[28], str, cst$17);
-         /*<<camlinternalFormat.ml:1487:21>>*/ return caml_special_val(_cV_);
+         /*<<camlinternalFormat.ml:1487:21>>*/ return caml_special_val(_cU_);
        }
       case 6:
         /*<<camlinternalFormat.ml:1482:15>>*/ return hex(0);
       case 7:
         /*<<camlinternalFormat.ml:1483:38>>*/  /*<<camlinternalFormat.ml:1483:38>>*/ var
-        _cW_ = hex(0);
+        _cV_ = hex(0);
         /*<<camlinternalFormat.ml:1483:38>>*/ return  /*<<camlinternalFormat.ml:1483:38>>*/ caml_call1
-               (Stdlib_String[25], _cW_);
+               (Stdlib_String[25], _cV_);
       case 8:
         /*<<camlinternalFormat.ml:1484:33>>*/ return caml_special_val(hex(0));
       default:
@@ -17030,12 +17038,12 @@
          /*<<camlinternalFormat.ml:1573:4>>*/ return function(param){
           /*<<camlinternalFormat.ml:1573:4>>*/ var
           fmt = param[1],
-           /*<<camlinternalFormat.ml:1574:18>>*/ _cS_ = recast(fmt, fmtty);
+           /*<<camlinternalFormat.ml:1574:18>>*/ _cR_ = recast(fmt, fmtty);
           /*<<camlinternalFormat.ml:1574:6>>*/ return make_printf
                  (k$0,
                   acc$0,
                    /*<<camlinternalFormat.ml:1574:6>>*/ caml_call2
-                   (CamlinternalFormatBasics[3], _cS_, rest$13)); /*<<camlinternalFormat.ml:1574:42>>*/ };
+                   (CamlinternalFormatBasics[3], _cR_, rest$13)); /*<<camlinternalFormat.ml:1574:42>>*/ };
        case 15:
         var rest$14 = fmt$0[1];
          /*<<camlinternalFormat.ml:1544:4>>*/ return function(f, x){
@@ -17062,11 +17070,11 @@
          fmt$0 = rest$16;
         break;
        case 18:
-        var _cQ_ = fmt$0[1];
-        if(0 === _cQ_[0])
+        var _cP_ = fmt$0[1];
+        if(0 === _cP_[0])
          var
           rest$17 = fmt$0[2],
-          fmt$1 = _cQ_[1][1],
+          fmt$1 = _cP_[1][1],
           k$3 =
             function(acc, k, rest){
              function k$0(kacc){
@@ -17082,7 +17090,7 @@
         else
          var
           rest$18 = fmt$0[2],
-          fmt$2 = _cQ_[1][1],
+          fmt$2 = _cP_[1][1],
           k$4 =
             function(acc, k, rest){
              function k$0(kacc){
@@ -17138,14 +17146,14 @@
          rest$23 = fmt$0[3],
          f = fmt$0[2],
          arity = fmt$0[1],
-          /*<<camlinternalFormat.ml:1548:33>>*/ _cR_ =
+          /*<<camlinternalFormat.ml:1548:33>>*/ _cQ_ =
             /*<<camlinternalFormat.ml:1548:33>>*/ caml_call1(f, 0);
          /*<<camlinternalFormat.ml:1548:33>>*/ if(counter >= 50)
           /*<<camlinternalFormat.ml:1548:33>>*/ return  /*<<camlinternalFormat.ml:1548:33>>*/ caml_trampoline_return
-                 (make_custom$0, [0, k$0, acc$0, rest$23, arity, _cR_]);
+                 (make_custom$0, [0, k$0, acc$0, rest$23, arity, _cQ_]);
         var counter$0 = counter + 1 | 0;
          /*<<camlinternalFormat.ml:1548:33>>*/ return make_custom$0
-                (counter$0, k$0, acc$0, rest$23, arity, _cR_);
+                (counter$0, k$0, acc$0, rest$23, arity, _cQ_);
      }
     }
     /*<<camlinternalFormat.ml:1605:9>>*/ }
@@ -17328,7 +17336,7 @@
                   fmt); /*<<camlinternalFormat.ml:1655:61>>*/ };
        case 10:
         var rest$9 = fmtty[1];
-         /*<<camlinternalFormat.ml:1646:31>>*/ return function(param, _cP_){
+         /*<<camlinternalFormat.ml:1646:31>>*/ return function(param, _cO_){
           /*<<camlinternalFormat.ml:1646:42>>*/ return make_from_fmtty
                  (k, acc, rest$9, fmt); /*<<camlinternalFormat.ml:1646:72>>*/ };
        case 11:
@@ -17357,13 +17365,13 @@
     /*<<camlinternalFormat.ml:1655:61>>*/ }
    function make_invalid_arg(counter, k, acc, fmt){
      /*<<camlinternalFormat.ml:1663:2>>*/  /*<<camlinternalFormat.ml:1663:16>>*/ var
-     _cO_ = [8, acc, cst_Printf_bad_conversion$0];
+     _cN_ = [8, acc, cst_Printf_bad_conversion$0];
      /*<<camlinternalFormat.ml:1663:2>>*/ if(counter >= 50)
       /*<<camlinternalFormat.ml:1663:2>>*/ return  /*<<camlinternalFormat.ml:1663:2>>*/ caml_trampoline_return
-             (make_printf$0, [0, k, _cO_, fmt]);
+             (make_printf$0, [0, k, _cN_, fmt]);
     var counter$0 = counter + 1 | 0;
      /*<<camlinternalFormat.ml:1663:2>>*/ return make_printf$0
-            (counter$0, k, _cO_, fmt);
+            (counter$0, k, _cN_, fmt);
     /*<<camlinternalFormat.ml:1663:72>>*/ }
    function make_custom$0(counter, k, acc, rest, arity, f){
      /*<<camlinternalFormat.ml:1778:28>>*/ if(arity){
@@ -17377,13 +17385,13 @@
                 /*<<camlinternalFormat.ml:1782:35>>*/ caml_call1(f, x)); /*<<camlinternalFormat.ml:1782:40>>*/ };
     }
      /*<<camlinternalFormat.ml:1779:33>>*/  /*<<camlinternalFormat.ml:1779:33>>*/ var
-     _cN_ = [4, acc, f];
+     _cM_ = [4, acc, f];
      /*<<camlinternalFormat.ml:1779:19>>*/ if(counter >= 50)
       /*<<camlinternalFormat.ml:1779:19>>*/ return  /*<<camlinternalFormat.ml:1779:19>>*/ caml_trampoline_return
-             (make_printf$0, [0, k, _cN_, rest]);
+             (make_printf$0, [0, k, _cM_, rest]);
     var counter$0 = counter + 1 | 0;
      /*<<camlinternalFormat.ml:1779:19>>*/ return make_printf$0
-            (counter$0, k, _cN_, rest);
+            (counter$0, k, _cM_, rest);
     /*<<camlinternalFormat.ml:1782:40>>*/ }
    function make_printf(k, acc, fmt){
      /*<<?>>*/ return caml_trampoline(make_printf$0(0, k, acc, fmt));
@@ -17404,68 +17412,68 @@
      /*<<camlinternalFormat.ml:1863:26>>*/ if(typeof pad === "number"){
      if(typeof prec !== "number"){
        /*<<camlinternalFormat.ml:1867:14>>*/  /*<<camlinternalFormat.ml:1867:14>>*/ var
-       _cm_ = make_iprintf(k, o, fmt);
-       /*<<camlinternalFormat.ml:1867:14>>*/ return function(_cM_){
-        /*<<?>>*/ return _cm_;};
+       _cl_ = make_iprintf(k, o, fmt);
+       /*<<camlinternalFormat.ml:1867:14>>*/ return function(_cL_){
+        /*<<?>>*/ return _cl_;};
      }
      if(prec){
        /*<<camlinternalFormat.ml:1869:21>>*/ var
-        /*<<camlinternalFormat.ml:1869:21>>*/ _cj_ = make_iprintf(k, o, fmt),
-        /*<<camlinternalFormat.ml:1869:14>>*/ _ck_ =
-         function(_cL_){ /*<<?>>*/ return _cj_;};
-       /*<<camlinternalFormat.ml:1869:14>>*/ return function(_cK_){
-        /*<<?>>*/ return _ck_;};
+        /*<<camlinternalFormat.ml:1869:21>>*/ _ci_ = make_iprintf(k, o, fmt),
+        /*<<camlinternalFormat.ml:1869:14>>*/ _cj_ =
+         function(_cK_){ /*<<?>>*/ return _ci_;};
+       /*<<camlinternalFormat.ml:1869:14>>*/ return function(_cJ_){
+        /*<<?>>*/ return _cj_;};
      }
       /*<<camlinternalFormat.ml:1865:14>>*/  /*<<camlinternalFormat.ml:1865:14>>*/ var
-      _cl_ = make_iprintf(k, o, fmt);
-      /*<<camlinternalFormat.ml:1865:14>>*/ return function(_cJ_){
-       /*<<?>>*/ return _cl_;};
+      _ck_ = make_iprintf(k, o, fmt);
+      /*<<camlinternalFormat.ml:1865:14>>*/ return function(_cI_){
+       /*<<?>>*/ return _ck_;};
     }
     if(0 === pad[0]){
      if(typeof prec !== "number"){
        /*<<camlinternalFormat.ml:1873:14>>*/  /*<<camlinternalFormat.ml:1873:14>>*/ var
-       _cq_ = make_iprintf(k, o, fmt);
-       /*<<camlinternalFormat.ml:1873:14>>*/ return function(_cI_){
-        /*<<?>>*/ return _cq_;};
+       _cp_ = make_iprintf(k, o, fmt);
+       /*<<camlinternalFormat.ml:1873:14>>*/ return function(_cH_){
+        /*<<?>>*/ return _cp_;};
      }
      if(prec){
        /*<<camlinternalFormat.ml:1875:21>>*/ var
-        /*<<camlinternalFormat.ml:1875:21>>*/ _cn_ = make_iprintf(k, o, fmt),
-        /*<<camlinternalFormat.ml:1875:14>>*/ _co_ =
-         function(_cH_){ /*<<?>>*/ return _cn_;};
-       /*<<camlinternalFormat.ml:1875:14>>*/ return function(_cG_){
-        /*<<?>>*/ return _co_;};
+        /*<<camlinternalFormat.ml:1875:21>>*/ _cm_ = make_iprintf(k, o, fmt),
+        /*<<camlinternalFormat.ml:1875:14>>*/ _cn_ =
+         function(_cG_){ /*<<?>>*/ return _cm_;};
+       /*<<camlinternalFormat.ml:1875:14>>*/ return function(_cF_){
+        /*<<?>>*/ return _cn_;};
      }
       /*<<camlinternalFormat.ml:1871:14>>*/  /*<<camlinternalFormat.ml:1871:14>>*/ var
-      _cp_ = make_iprintf(k, o, fmt);
-      /*<<camlinternalFormat.ml:1871:14>>*/ return function(_cF_){
-       /*<<?>>*/ return _cp_;};
+      _co_ = make_iprintf(k, o, fmt);
+      /*<<camlinternalFormat.ml:1871:14>>*/ return function(_cE_){
+       /*<<?>>*/ return _co_;};
     }
     if(typeof prec !== "number"){
       /*<<camlinternalFormat.ml:1879:21>>*/ var
-       /*<<camlinternalFormat.ml:1879:21>>*/ _cw_ = make_iprintf(k, o, fmt),
-       /*<<camlinternalFormat.ml:1879:14>>*/ _cx_ =
-        function(_cE_){ /*<<?>>*/ return _cw_;};
-      /*<<camlinternalFormat.ml:1879:14>>*/ return function(_cD_){
-       /*<<?>>*/ return _cx_;};
+       /*<<camlinternalFormat.ml:1879:21>>*/ _cv_ = make_iprintf(k, o, fmt),
+       /*<<camlinternalFormat.ml:1879:14>>*/ _cw_ =
+        function(_cD_){ /*<<?>>*/ return _cv_;};
+      /*<<camlinternalFormat.ml:1879:14>>*/ return function(_cC_){
+       /*<<?>>*/ return _cw_;};
     }
     if(prec){
       /*<<camlinternalFormat.ml:1881:28>>*/ var
-       /*<<camlinternalFormat.ml:1881:28>>*/ _cr_ = make_iprintf(k, o, fmt),
-       /*<<camlinternalFormat.ml:1881:21>>*/ _cs_ =
-        function(_cC_){ /*<<?>>*/ return _cr_;},
-       /*<<camlinternalFormat.ml:1881:14>>*/ _ct_ =
-        function(_cB_){ /*<<?>>*/ return _cs_;};
-      /*<<camlinternalFormat.ml:1881:14>>*/ return function(_cA_){
-       /*<<?>>*/ return _ct_;};
+       /*<<camlinternalFormat.ml:1881:28>>*/ _cq_ = make_iprintf(k, o, fmt),
+       /*<<camlinternalFormat.ml:1881:21>>*/ _cr_ =
+        function(_cB_){ /*<<?>>*/ return _cq_;},
+       /*<<camlinternalFormat.ml:1881:14>>*/ _cs_ =
+        function(_cA_){ /*<<?>>*/ return _cr_;};
+      /*<<camlinternalFormat.ml:1881:14>>*/ return function(_cz_){
+       /*<<?>>*/ return _cs_;};
     }
      /*<<camlinternalFormat.ml:1877:21>>*/  /*<<camlinternalFormat.ml:1877:21>>*/ var
-     _cu_ = make_iprintf(k, o, fmt);
-     /*<<camlinternalFormat.ml:1877:14>>*/ function _cv_(_cz_){
-      /*<<?>>*/ return _cu_;
+     _ct_ = make_iprintf(k, o, fmt);
+     /*<<camlinternalFormat.ml:1877:14>>*/ function _cu_(_cy_){
+      /*<<?>>*/ return _ct_;
     }
-     /*<<camlinternalFormat.ml:1877:14>>*/ return function(_cy_){
-      /*<<?>>*/ return _cv_;};
+     /*<<camlinternalFormat.ml:1877:14>>*/ return function(_cx_){
+      /*<<?>>*/ return _cu_;};
     /*<<camlinternalFormat.ml:1881:52>>*/ }
    function make_iprintf$0(counter, k, o, fmt){
      /*<<camlinternalFormat.ml:1788:17>>*/ var k$0 = k, fmt$0 = fmt;
@@ -17477,69 +17485,69 @@
        case 0:
          /*<<camlinternalFormat.ml:1790:14>>*/ var
          rest = fmt$0[1],
-          /*<<camlinternalFormat.ml:1790:14>>*/ _bz_ =
+          /*<<camlinternalFormat.ml:1790:14>>*/ _by_ =
            make_iprintf(k$0, o, rest);
-         /*<<camlinternalFormat.ml:1790:14>>*/ return function(_ci_){
-          /*<<?>>*/ return _bz_;};
+         /*<<camlinternalFormat.ml:1790:14>>*/ return function(_ch_){
+          /*<<?>>*/ return _by_;};
        case 1:
          /*<<camlinternalFormat.ml:1792:14>>*/ var
          rest$0 = fmt$0[1],
-          /*<<camlinternalFormat.ml:1792:14>>*/ _bA_ =
+          /*<<camlinternalFormat.ml:1792:14>>*/ _bz_ =
            make_iprintf(k$0, o, rest$0);
-         /*<<camlinternalFormat.ml:1792:14>>*/ return function(_ch_){
-          /*<<?>>*/ return _bA_;};
+         /*<<camlinternalFormat.ml:1792:14>>*/ return function(_cg_){
+          /*<<?>>*/ return _bz_;};
        case 2:
-        var _bB_ = fmt$0[1];
-        if(typeof _bB_ === "number"){
+        var _bA_ = fmt$0[1];
+        if(typeof _bA_ === "number"){
           /*<<camlinternalFormat.ml:1794:14>>*/ var
           rest$1 = fmt$0[2],
-           /*<<camlinternalFormat.ml:1794:14>>*/ _bC_ =
+           /*<<camlinternalFormat.ml:1794:14>>*/ _bB_ =
             make_iprintf(k$0, o, rest$1);
-          /*<<camlinternalFormat.ml:1794:14>>*/ return function(_cg_){
-           /*<<?>>*/ return _bC_;};
+          /*<<camlinternalFormat.ml:1794:14>>*/ return function(_cf_){
+           /*<<?>>*/ return _bB_;};
         }
-        if(0 === _bB_[0]){
+        if(0 === _bA_[0]){
           /*<<camlinternalFormat.ml:1796:14>>*/ var
           rest$2 = fmt$0[2],
-           /*<<camlinternalFormat.ml:1796:14>>*/ _bD_ =
+           /*<<camlinternalFormat.ml:1796:14>>*/ _bC_ =
             make_iprintf(k$0, o, rest$2);
-          /*<<camlinternalFormat.ml:1796:14>>*/ return function(_cf_){
-           /*<<?>>*/ return _bD_;};
+          /*<<camlinternalFormat.ml:1796:14>>*/ return function(_ce_){
+           /*<<?>>*/ return _bC_;};
         }
          /*<<camlinternalFormat.ml:1798:21>>*/ var
          rest$3 = fmt$0[2],
-          /*<<camlinternalFormat.ml:1798:21>>*/ _bE_ =
+          /*<<camlinternalFormat.ml:1798:21>>*/ _bD_ =
            make_iprintf(k$0, o, rest$3),
-          /*<<camlinternalFormat.ml:1798:14>>*/ _bF_ =
-           function(_ce_){ /*<<?>>*/ return _bE_;};
-         /*<<camlinternalFormat.ml:1798:14>>*/ return function(_cd_){
-          /*<<?>>*/ return _bF_;};
+          /*<<camlinternalFormat.ml:1798:14>>*/ _bE_ =
+           function(_cd_){ /*<<?>>*/ return _bD_;};
+         /*<<camlinternalFormat.ml:1798:14>>*/ return function(_cc_){
+          /*<<?>>*/ return _bE_;};
        case 3:
-        var _bG_ = fmt$0[1];
-        if(typeof _bG_ === "number"){
+        var _bF_ = fmt$0[1];
+        if(typeof _bF_ === "number"){
           /*<<camlinternalFormat.ml:1800:14>>*/ var
           rest$4 = fmt$0[2],
-           /*<<camlinternalFormat.ml:1800:14>>*/ _bH_ =
+           /*<<camlinternalFormat.ml:1800:14>>*/ _bG_ =
             make_iprintf(k$0, o, rest$4);
-          /*<<camlinternalFormat.ml:1800:14>>*/ return function(_cc_){
-           /*<<?>>*/ return _bH_;};
+          /*<<camlinternalFormat.ml:1800:14>>*/ return function(_cb_){
+           /*<<?>>*/ return _bG_;};
         }
-        if(0 === _bG_[0]){
+        if(0 === _bF_[0]){
           /*<<camlinternalFormat.ml:1802:14>>*/ var
           rest$5 = fmt$0[2],
-           /*<<camlinternalFormat.ml:1802:14>>*/ _bI_ =
+           /*<<camlinternalFormat.ml:1802:14>>*/ _bH_ =
             make_iprintf(k$0, o, rest$5);
-          /*<<camlinternalFormat.ml:1802:14>>*/ return function(_cb_){
-           /*<<?>>*/ return _bI_;};
+          /*<<camlinternalFormat.ml:1802:14>>*/ return function(_ca_){
+           /*<<?>>*/ return _bH_;};
         }
          /*<<camlinternalFormat.ml:1804:21>>*/ var
          rest$6 = fmt$0[2],
-          /*<<camlinternalFormat.ml:1804:21>>*/ _bJ_ =
+          /*<<camlinternalFormat.ml:1804:21>>*/ _bI_ =
            make_iprintf(k$0, o, rest$6),
-          /*<<camlinternalFormat.ml:1804:14>>*/ _bK_ =
-           function(_ca_){ /*<<?>>*/ return _bJ_;};
-         /*<<camlinternalFormat.ml:1804:14>>*/ return function(_b$_){
-          /*<<?>>*/ return _bK_;};
+          /*<<camlinternalFormat.ml:1804:14>>*/ _bJ_ =
+           function(_b$_){ /*<<?>>*/ return _bI_;};
+         /*<<camlinternalFormat.ml:1804:14>>*/ return function(_b__){
+          /*<<?>>*/ return _bJ_;};
        case 4:
         var rest$7 = fmt$0[4], prec = fmt$0[3], pad = fmt$0[2];
          /*<<camlinternalFormat.ml:1806:8>>*/ return fn_of_padding_precision
@@ -17561,31 +17569,31 @@
          /*<<camlinternalFormat.ml:1814:8>>*/ return fn_of_padding_precision
                 (k$0, o, rest$11, pad$3, prec$3);
        case 9:
-        var _bL_ = fmt$0[1];
-        if(typeof _bL_ === "number"){
+        var _bK_ = fmt$0[1];
+        if(typeof _bK_ === "number"){
           /*<<camlinternalFormat.ml:1816:14>>*/ var
           rest$12 = fmt$0[2],
-           /*<<camlinternalFormat.ml:1816:14>>*/ _bM_ =
+           /*<<camlinternalFormat.ml:1816:14>>*/ _bL_ =
             make_iprintf(k$0, o, rest$12);
-          /*<<camlinternalFormat.ml:1816:14>>*/ return function(_b__){
-           /*<<?>>*/ return _bM_;};
+          /*<<camlinternalFormat.ml:1816:14>>*/ return function(_b9_){
+           /*<<?>>*/ return _bL_;};
         }
-        if(0 === _bL_[0]){
+        if(0 === _bK_[0]){
           /*<<camlinternalFormat.ml:1818:14>>*/ var
           rest$13 = fmt$0[2],
-           /*<<camlinternalFormat.ml:1818:14>>*/ _bN_ =
+           /*<<camlinternalFormat.ml:1818:14>>*/ _bM_ =
             make_iprintf(k$0, o, rest$13);
-          /*<<camlinternalFormat.ml:1818:14>>*/ return function(_b9_){
-           /*<<?>>*/ return _bN_;};
+          /*<<camlinternalFormat.ml:1818:14>>*/ return function(_b8_){
+           /*<<?>>*/ return _bM_;};
         }
          /*<<camlinternalFormat.ml:1820:21>>*/ var
          rest$14 = fmt$0[2],
-          /*<<camlinternalFormat.ml:1820:21>>*/ _bO_ =
+          /*<<camlinternalFormat.ml:1820:21>>*/ _bN_ =
            make_iprintf(k$0, o, rest$14),
-          /*<<camlinternalFormat.ml:1820:14>>*/ _bP_ =
-           function(_b8_){ /*<<?>>*/ return _bO_;};
-         /*<<camlinternalFormat.ml:1820:14>>*/ return function(_b7_){
-          /*<<?>>*/ return _bP_;};
+          /*<<camlinternalFormat.ml:1820:14>>*/ _bO_ =
+           function(_b7_){ /*<<?>>*/ return _bN_;};
+         /*<<camlinternalFormat.ml:1820:14>>*/ return function(_b6_){
+          /*<<?>>*/ return _bO_;};
        case 10:
         var rest$15 = fmt$0[1], fmt$0 = rest$15; break;
        case 11:
@@ -17595,45 +17603,45 @@
        case 13:
          /*<<camlinternalFormat.ml:1838:14>>*/ var
          rest$18 = fmt$0[3],
-          /*<<camlinternalFormat.ml:1838:14>>*/ _bQ_ =
+          /*<<camlinternalFormat.ml:1838:14>>*/ _bP_ =
            make_iprintf(k$0, o, rest$18);
-         /*<<camlinternalFormat.ml:1838:14>>*/ return function(_b6_){
-          /*<<?>>*/ return _bQ_;};
+         /*<<camlinternalFormat.ml:1838:14>>*/ return function(_b5_){
+          /*<<?>>*/ return _bP_;};
        case 14:
         var rest$19 = fmt$0[3], fmtty = fmt$0[2];
          /*<<camlinternalFormat.ml:1840:8>>*/ return function(param){
           /*<<camlinternalFormat.ml:1840:8>>*/ var
           fmt = param[1],
-           /*<<camlinternalFormat.ml:1842:24>>*/ _b5_ = recast(fmt, fmtty);
+           /*<<camlinternalFormat.ml:1842:24>>*/ _b4_ = recast(fmt, fmtty);
           /*<<camlinternalFormat.ml:1842:12>>*/ return make_iprintf
                  (k$0,
                   o,
                    /*<<camlinternalFormat.ml:1842:12>>*/ caml_call2
-                   (CamlinternalFormatBasics[3], _b5_, rest$19)); /*<<camlinternalFormat.ml:1842:48>>*/ };
+                   (CamlinternalFormatBasics[3], _b4_, rest$19)); /*<<camlinternalFormat.ml:1842:48>>*/ };
        case 15:
          /*<<camlinternalFormat.ml:1822:21>>*/ var
          rest$20 = fmt$0[1],
-          /*<<camlinternalFormat.ml:1822:21>>*/ _bR_ =
+          /*<<camlinternalFormat.ml:1822:21>>*/ _bQ_ =
            make_iprintf(k$0, o, rest$20),
-          /*<<camlinternalFormat.ml:1822:14>>*/ _bS_ =
-           function(_b4_){ /*<<?>>*/ return _bR_;};
-         /*<<camlinternalFormat.ml:1822:14>>*/ return function(_b3_){
-          /*<<?>>*/ return _bS_;};
+          /*<<camlinternalFormat.ml:1822:14>>*/ _bR_ =
+           function(_b3_){ /*<<?>>*/ return _bQ_;};
+         /*<<camlinternalFormat.ml:1822:14>>*/ return function(_b2_){
+          /*<<?>>*/ return _bR_;};
        case 16:
          /*<<camlinternalFormat.ml:1824:14>>*/ var
          rest$21 = fmt$0[1],
-          /*<<camlinternalFormat.ml:1824:14>>*/ _bT_ =
+          /*<<camlinternalFormat.ml:1824:14>>*/ _bS_ =
            make_iprintf(k$0, o, rest$21);
-         /*<<camlinternalFormat.ml:1824:14>>*/ return function(_b2_){
-          /*<<?>>*/ return _bT_;};
+         /*<<camlinternalFormat.ml:1824:14>>*/ return function(_b1_){
+          /*<<?>>*/ return _bS_;};
        case 17:
         var rest$22 = fmt$0[2], fmt$0 = rest$22; break;
        case 18:
-        var _bU_ = fmt$0[1];
-        if(0 === _bU_[0])
+        var _bT_ = fmt$0[1];
+        if(0 === _bT_[0])
          var
           rest$23 = fmt$0[2],
-          fmt$1 = _bU_[1][1],
+          fmt$1 = _bT_[1][1],
           k$3 =
             function(k, rest){
              function k$0(koc){
@@ -17648,7 +17656,7 @@
         else
          var
           rest$24 = fmt$0[2],
-          fmt$2 = _bU_[1][1],
+          fmt$2 = _bT_[1][1],
           k$4 =
             function(k, rest){
              function k$0(koc){
@@ -17667,32 +17675,32 @@
        case 20:
          /*<<camlinternalFormat.ml:1844:14>>*/ var
          rest$25 = fmt$0[3],
-          /*<<camlinternalFormat.ml:1844:14>>*/ _bV_ =
+          /*<<camlinternalFormat.ml:1844:14>>*/ _bU_ =
            make_iprintf(k$0, o, rest$25);
-         /*<<camlinternalFormat.ml:1844:14>>*/ return function(_b1_){
-          /*<<?>>*/ return _bV_;};
+         /*<<camlinternalFormat.ml:1844:14>>*/ return function(_b0_){
+          /*<<?>>*/ return _bU_;};
        case 21:
          /*<<camlinternalFormat.ml:1846:14>>*/ var
          rest$26 = fmt$0[2],
-          /*<<camlinternalFormat.ml:1846:14>>*/ _bW_ =
+          /*<<camlinternalFormat.ml:1846:14>>*/ _bV_ =
            make_iprintf(k$0, o, rest$26);
-         /*<<camlinternalFormat.ml:1846:14>>*/ return function(_b0_){
-          /*<<?>>*/ return _bW_;};
+         /*<<camlinternalFormat.ml:1846:14>>*/ return function(_bZ_){
+          /*<<?>>*/ return _bV_;};
        case 22:
          /*<<camlinternalFormat.ml:1848:14>>*/ var
          rest$27 = fmt$0[1],
-          /*<<camlinternalFormat.ml:1848:14>>*/ _bX_ =
+          /*<<camlinternalFormat.ml:1848:14>>*/ _bW_ =
            make_iprintf(k$0, o, rest$27);
-         /*<<camlinternalFormat.ml:1848:14>>*/ return function(_bZ_){
-          /*<<?>>*/ return _bX_;};
+         /*<<camlinternalFormat.ml:1848:14>>*/ return function(_bY_){
+          /*<<?>>*/ return _bW_;};
        case 23:
-        var rest$28 = fmt$0[2], ign = fmt$0[1], _bY_ = 0;
+        var rest$28 = fmt$0[2], ign = fmt$0[1], _bX_ = 0;
          /*<<camlinternalFormat.ml:1850:8>>*/ return make_ignored_param
                 (function(param){
                    /*<<camlinternalFormat.ml:1850:37>>*/ return caml_call1
                           (k$0, o);
                   /*<<camlinternalFormat.ml:1850:40>>*/ },
-                 _bY_,
+                 _bX_,
                  ign,
                  rest$28);
        default:
@@ -17710,10 +17718,10 @@
      /*<<camlinternalFormat.ml:1882:4>>*/ if(param){
       /*<<camlinternalFormat.ml:1889:14>>*/ var
       arity = param[1],
-       /*<<camlinternalFormat.ml:1889:14>>*/ _bx_ =
+       /*<<camlinternalFormat.ml:1889:14>>*/ _bw_ =
         fn_of_custom_arity(k, o, fmt, arity);
-      /*<<camlinternalFormat.ml:1889:14>>*/ return function(_by_){
-       /*<<?>>*/ return _bx_;};
+      /*<<camlinternalFormat.ml:1889:14>>*/ return function(_bx_){
+       /*<<?>>*/ return _bw_;};
     }
      /*<<camlinternalFormat.ml:1887:8>>*/ if(counter >= 50)
       /*<<camlinternalFormat.ml:1887:8>>*/ return  /*<<camlinternalFormat.ml:1887:8>>*/ caml_trampoline_return
@@ -17884,9 +17892,9 @@
         var f = acc$0[2], p$3 = acc$0[1];
          /*<<camlinternalFormat.ml:1950:32>>*/ strput_acc(b, p$3);
          /*<<camlinternalFormat.ml:1950:68>>*/  /*<<camlinternalFormat.ml:1950:68>>*/ var
-         _bw_ =  /*<<camlinternalFormat.ml:1950:68>>*/ caml_call1(f, 0);
+         _bv_ =  /*<<camlinternalFormat.ml:1950:68>>*/ caml_call1(f, 0);
          /*<<camlinternalFormat.ml:1950:68>>*/ return  /*<<camlinternalFormat.ml:1950:68>>*/ caml_call2
-                (Stdlib_Buffer[16], b, _bw_);
+                (Stdlib_Buffer[16], b, _bv_);
        case 7:
         var acc$3 = acc$0[1], acc$0 = acc$3; break;
        case 8:
@@ -17917,11 +17925,11 @@
     function k(acc){
       /*<<camlinternalFormat.ml:1961:14>>*/ strput_acc(buf, acc);
       /*<<camlinternalFormat.ml:1961:43>>*/  /*<<camlinternalFormat.ml:1961:43>>*/ var
-      _bv_ =
+      _bu_ =
          /*<<camlinternalFormat.ml:1961:43>>*/ caml_call1
          (Stdlib_Buffer[2], buf);
       /*<<camlinternalFormat.ml:1961:43>>*/ return  /*<<camlinternalFormat.ml:1961:43>>*/ caml_call1
-             (Stdlib[2], _bv_);
+             (Stdlib[2], _bu_);
      /*<<camlinternalFormat.ml:1961:64>>*/ }
      /*<<camlinternalFormat.ml:1962:2>>*/ return make_printf(k, 0, fmt);
    }
@@ -17996,15 +18004,15 @@
       else
         /*<<camlinternalFormat.ml:1994:8>>*/ try{
          /*<<camlinternalFormat.ml:1994:12>>*/ var
-          /*<<camlinternalFormat.ml:1994:12>>*/ _bt_ =
+          /*<<camlinternalFormat.ml:1994:12>>*/ _bs_ =
             /*<<camlinternalFormat.ml:1994:12>>*/ runtime.caml_int_of_string
             ( /*<<camlinternalFormat.ml:1994:26>>*/ caml_call3
               (Stdlib_String[15], str, nstart, nend - nstart | 0)),
-         indent = _bt_;
+         indent = _bs_;
        }
-       catch(_bu_){
-        var _bs_ = caml_wrap_exception(_bu_);
-        if(_bs_[1] !== Stdlib[7]) throw caml_maybe_attach_backtrace(_bs_, 0);
+       catch(_bt_){
+        var _br_ = caml_wrap_exception(_bt_);
+        if(_br_[1] !== Stdlib[7]) throw caml_maybe_attach_backtrace(_br_, 0);
         var indent = invalid_box(0);
        }
        /*<<camlinternalFormat.ml:1996:18>>*/  /*<<camlinternalFormat.ml:1996:18>>*/ var
@@ -18070,7 +18078,7 @@
     (end_ind){
       /*<<camlinternalFormat.ml:2092:4>>*/ invalid_format_message
       (end_ind, cst_unexpected_end_of_format);
-      /*<<camlinternalFormat.ml:2092:4>>*/ return _$_;
+      /*<<camlinternalFormat.ml:2092:4>>*/ return sentinal;
      /*<<camlinternalFormat.ml:2093:32>>*/ }
     function invalid_format_without(str_ind, c, s){
       /*<<camlinternalFormat.ml:2104:4>>*/ return  /*<<camlinternalFormat.ml:2104:4>>*/ caml_call4
@@ -18208,9 +18216,9 @@
              b:
              try{
               var
-               _bh_ = str_ind$3 === end_ind ? 1 : 0,
-               _bi_ =
-                 _bh_
+               _bg_ = str_ind$3 === end_ind ? 1 : 0,
+               _bh_ =
+                 _bg_
                  ||
                   (60
                     !==
@@ -18218,7 +18226,7 @@
                       (str, str_ind$3)
                     ? 1
                     : 0);
-              if(_bi_)
+              if(_bh_)
                 /*<<camlinternalFormat.ml:2666:58>>*/ throw  /*<<camlinternalFormat.ml:2666:58>>*/ caml_maybe_attach_backtrace
                       (Stdlib[8], 1);
                /*<<camlinternalFormat.ml:2667:24>>*/ var
@@ -18257,12 +18265,12 @@
                      str,
                      str_ind$3 - 2 | 0,
                      (str_ind_3 - str_ind$3 | 0) + 3 | 0),
-                  /*<<camlinternalFormat.ml:2675:31>>*/ _bj_ =
+                  /*<<camlinternalFormat.ml:2675:31>>*/ _bi_ =
                    [0, s, width, 0],
-                  /*<<camlinternalFormat.ml:2675:31>>*/ _bk_ =
+                  /*<<camlinternalFormat.ml:2675:31>>*/ _bj_ =
                    str_ind_3 + 1 | 0,
-                 formatting_lit$0 = _bj_,
-                 next_ind = _bk_;
+                 formatting_lit$0 = _bi_,
+                 next_ind = _bj_;
                 break b;
                }
               }
@@ -18288,21 +18296,21 @@
                     str,
                     str_ind$3 - 2 | 0,
                     (str_ind_5 - str_ind$3 | 0) + 3 | 0),
-                 /*<<camlinternalFormat.ml:2681:31>>*/ _bl_ =
+                 /*<<camlinternalFormat.ml:2681:31>>*/ _bk_ =
                   [0, s$0, width, offset],
-                 /*<<camlinternalFormat.ml:2681:31>>*/ _bm_ =
+                 /*<<camlinternalFormat.ml:2681:31>>*/ _bl_ =
                   str_ind_5 + 1 | 0,
-                formatting_lit$0 = _bl_,
-                next_ind = _bm_;
+                formatting_lit$0 = _bk_,
+                next_ind = _bl_;
                break b;
               }
                /*<<camlinternalFormat.ml:2682:21>>*/ throw  /*<<camlinternalFormat.ml:2682:21>>*/ caml_maybe_attach_backtrace
                      (Stdlib[8], 1);
              }
-             catch(_br_){
-              var _bg_ = caml_wrap_exception(_br_);
-              if(_bg_ !== Stdlib[8] && _bg_[1] !== Stdlib[7])
-               throw caml_maybe_attach_backtrace(_bg_, 0);
+             catch(_bq_){
+              var _bf_ = caml_wrap_exception(_bq_);
+              if(_bf_ !== Stdlib[8] && _bf_[1] !== Stdlib[7])
+               throw caml_maybe_attach_backtrace(_bf_, 0);
               var formatting_lit$0 = formatting_lit, next_ind = str_ind$3;
              }
              var
@@ -18326,7 +18334,7 @@
                  if(58 > match$6) break c;
                 }
                 else if(45 === match$6) break c;
-                var _bp_ = 0;
+                var _bo_ = 0;
                 break b;
                }
                 /*<<camlinternalFormat.ml:2699:32>>*/ var
@@ -18350,28 +18358,28 @@
                     str,
                     str_ind$4 - 2 | 0,
                     (str_ind_3$0 - str_ind$4 | 0) + 3 | 0),
-                _bp_ = [0, [0, str_ind_3$0 + 1 | 0, [1, s$1, size]]];
+                _bo_ = [0, [0, str_ind_3$0 + 1 | 0, [1, s$1, size]]];
               }
-              var _bo_ = _bp_;
+              var _bn_ = _bo_;
              }
-             catch(_bq_){
-              var _bn_ = caml_wrap_exception(_bq_);
-              if(_bn_ !== Stdlib[8] && _bn_[1] !== Stdlib[7])
-               throw caml_maybe_attach_backtrace(_bn_, 0);
-              var _bo_ = 0;
+             catch(_bp_){
+              var _bm_ = caml_wrap_exception(_bp_);
+              if(_bm_ !== Stdlib[8] && _bm_[1] !== Stdlib[7])
+               throw caml_maybe_attach_backtrace(_bm_, 0);
+              var _bn_ = 0;
              }
-             if(_bo_)
+             if(_bn_)
               var
-               match$5 = _bo_[1],
+               match$5 = _bn_[1],
                formatting_lit$1 = match$5[2],
                next_ind$0 = match$5[1],
                fmt_rest$13 = parse(next_ind$0, end_ind)[1],
-               _bf_ = [0, [17, formatting_lit$1, fmt_rest$13]];
+               _be_ = [0, [17, formatting_lit$1, fmt_rest$13]];
              else
               var
                fmt_rest$14 = parse(str_ind$4, end_ind)[1],
-               _bf_ = [0, [17, _Q_, fmt_rest$14]];
-             var match$0 = _bf_;
+               _be_ = [0, [17, _Q_, fmt_rest$14]];
+             var match$0 = _be_;
              break a;
             case 31:
              var
@@ -18529,29 +18537,29 @@
             /*<<camlinternalFormat.ml:2536:22>>*/ var
              /*<<camlinternalFormat.ml:2536:22>>*/ ignored$2 =
               [9, get_pad_opt(95), sub_fmtty],
-            _aO_ = [0, [23, ignored$2, fmt_rest$7]];
+            _aN_ = [0, [23, ignored$2, fmt_rest$7]];
           else
-           var _aO_ = [0, [14, get_pad_opt(40), sub_fmtty, fmt_rest$7]];
-          var fmt_result = _aO_;
+           var _aN_ = [0, [14, get_pad_opt(40), sub_fmtty, fmt_rest$7]];
+          var fmt_result = _aN_;
           break a;
          case 44:
           var fmt_result = parse(str_ind, end_ind); break a;
          case 67:
            /*<<camlinternalFormat.ml:2397:9>>*/ var
            fmt_rest$10 = parse(str_ind, end_ind)[1],
-            /*<<camlinternalFormat.ml:2397:9>>*/ _aQ_ =
+            /*<<camlinternalFormat.ml:2397:9>>*/ _aP_ =
              get_ign(0) ? [0, [23, 1, fmt_rest$10]] : [0, [1, fmt_rest$10]],
-           fmt_result = _aQ_;
+           fmt_result = _aP_;
           break a;
          case 78:
           var fmt_rest$14 = parse(str_ind, end_ind)[1], counter$0 = 2;
            /*<<camlinternalFormat.ml:2433:9>>*/ if(get_ign(0))
             /*<<camlinternalFormat.ml:2434:22>>*/ var
              /*<<camlinternalFormat.ml:2434:22>>*/ ignored$6 = [11, counter$0],
-            _aW_ = [0, [23, ignored$6, fmt_rest$14]];
+            _aV_ = [0, [23, ignored$6, fmt_rest$14]];
           else
-           var _aW_ = [0, [21, counter$0, fmt_rest$14]];
-          var fmt_result = _aW_;
+           var _aV_ = [0, [21, counter$0, fmt_rest$14]];
+          var fmt_result = _aV_;
           break a;
          case 83:
            /*<<camlinternalFormat.ml:2410:16>>*/ var
@@ -18562,15 +18570,15 @@
             /*<<camlinternalFormat.ml:2413:22>>*/ var
              /*<<camlinternalFormat.ml:2413:22>>*/ ignored$7 =
               [1, get_padprec_opt(95)],
-            _aX_ = [0, [23, ignored$7, fmt_rest$15]];
+            _aW_ = [0, [23, ignored$7, fmt_rest$15]];
           else
             /*<<camlinternalFormat.ml:2417:10>>*/ var
              /*<<camlinternalFormat.ml:2417:10>>*/ match$5 =
               make_padding_fmt_ebb(pad$6, fmt_rest$15),
             fmt_rest$16 = match$5[2],
             pad$7 = match$5[1],
-            _aX_ = [0, [3, pad$7, fmt_rest$16]];
-          var fmt_result = _aX_;
+            _aW_ = [0, [3, pad$7, fmt_rest$16]];
+          var fmt_result = _aW_;
           break a;
          case 91:
           if(str_ind === end_ind)
@@ -18583,7 +18591,7 @@
              function(c){
                /*<<camlinternalFormat.ml:2721:6>>*/ add_in_char_set
                (char_set, c);
-               /*<<camlinternalFormat.ml:2721:6>>*/ return _$_;
+               /*<<camlinternalFormat.ml:2721:6>>*/ return sentinal;
               /*<<camlinternalFormat.ml:2721:32>>*/ },
            add_range =
              function(c$0, c){
@@ -18595,12 +18603,12 @@
                    /*<<camlinternalFormat.ml:2725:33>>*/ caml_call1
                    (Stdlib[29], i));
                  /*<<camlinternalFormat.ml:2725:8>>*/  /*<<camlinternalFormat.ml:2725:8>>*/ var
-                 _be_ = i + 1 | 0;
+                 _bd_ = i + 1 | 0;
                 if(c === i) break;
-                var i = _be_;
+                var i = _bd_;
                }
               }
-              return _$_;
+              return sentinal;
               /*<<camlinternalFormat.ml:2726:10>>*/ },
            fail_single_percent =
              function(str_ind){
@@ -18622,13 +18630,13 @@
                 if(93 === c)
                   /*<<camlinternalFormat.ml:2746:8>>*/ return str_ind$0 + 1
                         | 0;
-                var _bd_ = str_ind$0 + 1 | 0;
+                var _bc_ = str_ind$0 + 1 | 0;
                  /*<<camlinternalFormat.ml:2751:8>>*/ if(counter >= 50)
                   /*<<camlinternalFormat.ml:2751:8>>*/ return  /*<<camlinternalFormat.ml:2751:8>>*/ caml_trampoline_return
-                         (parse_char_set_after_char$0, [0, _bd_, end_ind, c]);
+                         (parse_char_set_after_char$0, [0, _bc_, end_ind, c]);
                 var counter$0 = counter + 1 | 0;
                  /*<<camlinternalFormat.ml:2751:8>>*/ return parse_char_set_after_char$0
-                        (counter$0, _bd_, end_ind, c);
+                        (counter$0, _bc_, end_ind, c);
                }
                 /*<<camlinternalFormat.ml:2748:8>>*/ add_char(45);
                var str_ind$1 = str_ind$0 + 1 | 0, str_ind$0 = str_ind$1;
@@ -18679,13 +18687,13 @@
                     /*<<camlinternalFormat.ml:2787:17>>*/ return fail_single_percent
                            (str_ind$2);
                    /*<<camlinternalFormat.ml:2785:12>>*/ add_range(c$0, c$3);
-                  var _bb_ = str_ind$2 + 2 | 0;
+                  var _ba_ = str_ind$2 + 2 | 0;
                    /*<<camlinternalFormat.ml:2785:12>>*/ if(counter >= 50)
                     /*<<camlinternalFormat.ml:2785:12>>*/ return  /*<<camlinternalFormat.ml:2785:12>>*/ caml_trampoline_return
-                           (parse_char_set_content, [0, _bb_, end_ind]);
+                           (parse_char_set_content, [0, _ba_, end_ind]);
                   var counter$2 = counter + 1 | 0;
                    /*<<camlinternalFormat.ml:2785:12>>*/ return parse_char_set_content
-                          (counter$2, _bb_, end_ind);
+                          (counter$2, _ba_, end_ind);
                  }
                  if(93 === c$2){
                    /*<<camlinternalFormat.ml:2778:8>>*/ add_char(c$0);
@@ -18694,23 +18702,23 @@
                          | 0;
                  }
                   /*<<camlinternalFormat.ml:2790:8>>*/ add_range(c$0, c$2);
-                 var _bc_ = str_ind$2 + 1 | 0;
+                 var _bb_ = str_ind$2 + 1 | 0;
                   /*<<camlinternalFormat.ml:2790:8>>*/ if(counter >= 50)
                    /*<<camlinternalFormat.ml:2790:8>>*/ return  /*<<camlinternalFormat.ml:2790:8>>*/ caml_trampoline_return
-                          (parse_char_set_content, [0, _bc_, end_ind]);
+                          (parse_char_set_content, [0, _bb_, end_ind]);
                  var counter$1 = counter + 1 | 0;
                   /*<<camlinternalFormat.ml:2790:8>>*/ return parse_char_set_content
-                         (counter$1, _bc_, end_ind);
+                         (counter$1, _bb_, end_ind);
                 }
                 if(37 === c$0){
                   /*<<camlinternalFormat.ml:2763:8>>*/ add_char(c$1);
-                 var _ba_ = str_ind$0 + 1 | 0;
+                 var _a$_ = str_ind$0 + 1 | 0;
                   /*<<camlinternalFormat.ml:2763:8>>*/ if(counter >= 50)
                    /*<<camlinternalFormat.ml:2763:8>>*/ return  /*<<camlinternalFormat.ml:2763:8>>*/ caml_trampoline_return
-                          (parse_char_set_content, [0, _ba_, end_ind]);
+                          (parse_char_set_content, [0, _a$_, end_ind]);
                  var counter$0 = counter + 1 | 0;
                   /*<<camlinternalFormat.ml:2763:8>>*/ return parse_char_set_content
-                         (counter$0, _ba_, end_ind);
+                         (counter$0, _a$_, end_ind);
                 }
                }
                if(37 === c$0)
@@ -18760,10 +18768,10 @@
             /*<<camlinternalFormat.ml:2544:22>>*/ var
              /*<<camlinternalFormat.ml:2544:22>>*/ ignored$9 =
               [10, get_pad_opt(95), char_set$1],
-            _a2_ = [0, [23, ignored$9, fmt_rest$19]];
+            _a1_ = [0, [23, ignored$9, fmt_rest$19]];
           else
-           var _a2_ = [0, [20, get_pad_opt(91), char_set$1, fmt_rest$19]];
-          var fmt_result = _a2_;
+           var _a1_ = [0, [20, get_pad_opt(91), char_set$1, fmt_rest$19]];
+          var fmt_result = _a1_;
           break a;
          case 97:
           var
@@ -18783,28 +18791,28 @@
           if(match$7){
            if(0 === match$7[1])
              /*<<camlinternalFormat.ml:2382:11>>*/ var
-              /*<<camlinternalFormat.ml:2382:11>>*/ _a3_ =
+              /*<<camlinternalFormat.ml:2382:11>>*/ _a2_ =
                get_ign(0) ? [0, [23, 3, fmt_rest$21]] : [0, [22, fmt_rest$21]],
-             _a4_ = _a3_;
+             _a3_ = _a2_;
            else
             var
-             _a4_ =
+             _a3_ =
                legacy_behavior$0
                 ? char_format(fmt_rest$21)
                 : invalid_format_message
                   (str_ind, cst_non_zero_widths_are_unsupp);
-           var _a5_ = _a4_;
+           var _a4_ = _a3_;
           }
           else
-           var _a5_ = char_format(fmt_rest$21);
-          var fmt_result = _a5_;
+           var _a4_ = char_format(fmt_rest$21);
+          var fmt_result = _a4_;
           break a;
          case 114:
            /*<<camlinternalFormat.ml:2512:9>>*/ var
            fmt_rest$22 = parse(str_ind, end_ind)[1],
-            /*<<camlinternalFormat.ml:2512:9>>*/ _a6_ =
+            /*<<camlinternalFormat.ml:2512:9>>*/ _a5_ =
              get_ign(0) ? [0, [23, 2, fmt_rest$22]] : [0, [19, fmt_rest$22]],
-           fmt_result = _a6_;
+           fmt_result = _a5_;
           break a;
          case 115:
            /*<<camlinternalFormat.ml:2400:16>>*/ var
@@ -18815,15 +18823,15 @@
             /*<<camlinternalFormat.ml:2403:22>>*/ var
              /*<<camlinternalFormat.ml:2403:22>>*/ ignored$10 =
               [0, get_padprec_opt(95)],
-            _a7_ = [0, [23, ignored$10, fmt_rest$23]];
+            _a6_ = [0, [23, ignored$10, fmt_rest$23]];
           else
             /*<<camlinternalFormat.ml:2407:10>>*/ var
              /*<<camlinternalFormat.ml:2407:10>>*/ match$8 =
               make_padding_fmt_ebb(pad$9, fmt_rest$23),
             fmt_rest$24 = match$8[2],
             pad$10 = match$8[1],
-            _a7_ = [0, [2, pad$10, fmt_rest$24]];
-          var fmt_result = _a7_;
+            _a6_ = [0, [2, pad$10, fmt_rest$24]];
+          var fmt_result = _a6_;
           break a;
          case 116:
           var
@@ -18842,10 +18850,10 @@
             /*<<camlinternalFormat.ml:2526:22>>*/ var
              /*<<camlinternalFormat.ml:2526:22>>*/ ignored$11 =
               [8, get_pad_opt(95), sub_fmtty$0],
-            _a8_ = [0, [23, ignored$11, fmt_rest$26]];
+            _a7_ = [0, [23, ignored$11, fmt_rest$26]];
           else
-           var _a8_ = [0, [13, get_pad_opt(123), sub_fmtty$0, fmt_rest$26]];
-          var fmt_result = _a8_;
+           var _a7_ = [0, [13, get_pad_opt(123), sub_fmtty$0, fmt_rest$26]];
+          var fmt_result = _a7_;
           break a;
          case 66:
          case 98:
@@ -18857,15 +18865,15 @@
             /*<<camlinternalFormat.ml:2498:22>>*/ var
              /*<<camlinternalFormat.ml:2498:22>>*/ ignored$3 =
               [7, get_padprec_opt(95)],
-            _aP_ = [0, [23, ignored$3, fmt_rest$8]];
+            _aO_ = [0, [23, ignored$3, fmt_rest$8]];
           else
             /*<<camlinternalFormat.ml:2502:10>>*/ var
              /*<<camlinternalFormat.ml:2502:10>>*/ match$3 =
               make_padding_fmt_ebb(pad$3, fmt_rest$8),
             fmt_rest$9 = match$3[2],
             pad$4 = match$3[1],
-            _aP_ = [0, [9, pad$4, fmt_rest$9]];
-          var fmt_result = _aP_;
+            _aO_ = [0, [9, pad$4, fmt_rest$9]];
+          var fmt_result = _aO_;
           break a;
          case 37:
          case 64:
@@ -18881,22 +18889,22 @@
              /*<<camlinternalFormat.ml:2438:63>>*/ symb$0 =
                /*<<camlinternalFormat.ml:2438:63>>*/ caml_string_get
                (str, str_ind),
-             /*<<camlinternalFormat.ml:2892:25>>*/ _a9_ = symb$0 - 88 | 0;
+             /*<<camlinternalFormat.ml:2892:25>>*/ _a8_ = symb$0 - 88 | 0;
            b:
            {
-            if(32 >= _a9_ >>> 0)
-             switch(_a9_){
+            if(32 >= _a8_ >>> 0)
+             switch(_a8_){
                case 0:
                case 12:
                case 17:
                case 23:
                case 29:
                case 32:
-                var _aV_ = 1; break b;
+                var _aU_ = 1; break b;
              }
-            var _aV_ = 0;
+            var _aU_ = 0;
            }
-            /*<<camlinternalFormat.ml:2438:50>>*/ if(_aV_) break;
+            /*<<camlinternalFormat.ml:2438:50>>*/ if(_aU_) break;
           }
           var fmt_rest$13 = parse(str_ind, end_ind)[1];
           b:
@@ -18917,10 +18925,10 @@
            /*<<camlinternalFormat.ml:2441:9>>*/ if(get_ign(0))
             /*<<camlinternalFormat.ml:2442:22>>*/ var
              /*<<camlinternalFormat.ml:2442:22>>*/ ignored$5 = [11, counter],
-            _aU_ = [0, [23, ignored$5, fmt_rest$13]];
+            _aT_ = [0, [23, ignored$5, fmt_rest$13]];
           else
-           var _aU_ = [0, [21, counter, fmt_rest$13]];
-          var fmt_result = _aU_;
+           var _aT_ = [0, [21, counter, fmt_rest$13]];
+          var fmt_result = _aT_;
           break a;
          case 32:
          case 35:
@@ -18939,26 +18947,26 @@
          case 117:
          case 120:
            /*<<camlinternalFormat.ml:2421:8>>*/ var
-            /*<<camlinternalFormat.ml:2421:8>>*/ _aY_ = get_space(0),
-            /*<<camlinternalFormat.ml:2420:65>>*/ _aZ_ = get_hash(0),
+            /*<<camlinternalFormat.ml:2421:8>>*/ _aX_ = get_space(0),
+            /*<<camlinternalFormat.ml:2420:65>>*/ _aY_ = get_hash(0),
             /*<<camlinternalFormat.ml:2420:18>>*/ iconv$2 =
-             compute_int_conv(pct_ind, str_ind, get_plus(0), _aZ_, _aY_, symb),
+             compute_int_conv(pct_ind, str_ind, get_plus(0), _aY_, _aX_, symb),
            fmt_rest$17 = parse(str_ind, end_ind)[1];
            /*<<camlinternalFormat.ml:2423:9>>*/ if(get_ign(0))
             /*<<camlinternalFormat.ml:2424:22>>*/ var
              /*<<camlinternalFormat.ml:2424:22>>*/ ignored$8 =
               [2, iconv$2, get_pad_opt(95)],
-            _a0_ = [0, [23, ignored$8, fmt_rest$17]];
+            _aZ_ = [0, [23, ignored$8, fmt_rest$17]];
           else
             /*<<camlinternalFormat.ml:2428:48>>*/ var
-             /*<<camlinternalFormat.ml:2428:48>>*/ _a1_ = get_prec(0),
+             /*<<camlinternalFormat.ml:2428:48>>*/ _a0_ = get_prec(0),
              /*<<camlinternalFormat.ml:2428:10>>*/ match$6 =
-              make_padprec_fmt_ebb(get_int_pad(0), _a1_, fmt_rest$17),
+              make_padprec_fmt_ebb(get_int_pad(0), _a0_, fmt_rest$17),
             fmt_rest$18 = match$6[3],
             prec$4 = match$6[2],
             pad$8 = match$6[1],
-            _a0_ = [0, [4, iconv$2, pad$8, prec$4, fmt_rest$18]];
-          var fmt_result = _a0_;
+            _aZ_ = [0, [4, iconv$2, pad$8, prec$4, fmt_rest$18]];
+          var fmt_result = _aZ_;
           break a;
          case 69:
          case 70:
@@ -18988,28 +18996,28 @@
             if(3 >= switcher >>> 0){
              switch(switcher){
                case 0:
-                var _a__ = 1; break;
+                var _a9_ = 1; break;
                case 1:
-                var _a__ = 0; break;
+                var _a9_ = 0; break;
                case 2:
-                var _a__ = 3; break;
-               default: var _a__ = 6;
+                var _a9_ = 3; break;
+               default: var _a9_ = 6;
              }
-             var kind = _a__;
+             var kind = _a9_;
              break b;
             }
            }
            else if(69 <= symb){
             switch(symb - 69 | 0){
               case 0:
-               var _a$_ = 2; break;
+               var _a__ = 2; break;
               case 1:
                break c;
               case 2:
-               var _a$_ = 4; break;
-              default: var _a$_ = 7;
+               var _a__ = 4; break;
+              default: var _a__ = 7;
             }
-            var kind = _a$_;
+            var kind = _a__;
             break b;
            }
            if(hash$1){
@@ -19027,25 +19035,25 @@
             match = get_prec(0);
            if(typeof match === "number")
             var
-             _aR_ =
+             _aQ_ =
                match ? incompatible_flag(pct_ind, str_ind, 95, cst$26) : 0;
            else
-            var ndec = match[1], _aR_ = [0, ndec];
+            var ndec = match[1], _aQ_ = [0, ndec];
             /*<<camlinternalFormat.ml:2488:22>>*/ var
              /*<<camlinternalFormat.ml:2488:22>>*/ ignored$4 =
-              [6, get_pad_opt(95), _aR_],
-            _aS_ = [0, [23, ignored$4, fmt_rest$11]];
+              [6, get_pad_opt(95), _aQ_],
+            _aR_ = [0, [23, ignored$4, fmt_rest$11]];
           }
           else
             /*<<camlinternalFormat.ml:2492:44>>*/ var
-             /*<<camlinternalFormat.ml:2492:44>>*/ _aT_ = get_prec(0),
+             /*<<camlinternalFormat.ml:2492:44>>*/ _aS_ = get_prec(0),
              /*<<camlinternalFormat.ml:2492:10>>*/ match$4 =
-              make_padprec_fmt_ebb(get_pad(0), _aT_, fmt_rest$11),
+              make_padprec_fmt_ebb(get_pad(0), _aS_, fmt_rest$11),
             fmt_rest$12 = match$4[3],
             prec$3 = match$4[2],
             pad$5 = match$4[1],
-            _aS_ = [0, [8, fconv, pad$5, prec$3, fmt_rest$12]];
-          var fmt_result = _aS_;
+            _aR_ = [0, [8, fconv, pad$5, prec$3, fmt_rest$12]];
+          var fmt_result = _aR_;
           break a;
        }
       b:
@@ -19054,89 +19062,89 @@
         switch(symb - 108 | 0){
           case 0:
             /*<<camlinternalFormat.ml:2449:25>>*/ var
-             /*<<camlinternalFormat.ml:2449:25>>*/ _ay_ =
+             /*<<camlinternalFormat.ml:2449:25>>*/ _ax_ =
                /*<<camlinternalFormat.ml:2449:25>>*/ caml_string_get
                (str, str_ind),
-             /*<<camlinternalFormat.ml:2449:10>>*/ _az_ = get_space(0),
-             /*<<camlinternalFormat.ml:2448:61>>*/ _aA_ = get_hash(0),
+             /*<<camlinternalFormat.ml:2449:10>>*/ _ay_ = get_space(0),
+             /*<<camlinternalFormat.ml:2448:61>>*/ _az_ = get_hash(0),
              /*<<camlinternalFormat.ml:2448:8>>*/ iconv =
               compute_int_conv
-               (pct_ind, str_ind + 1 | 0, get_plus(0), _aA_, _az_, _ay_),
+               (pct_ind, str_ind + 1 | 0, get_plus(0), _az_, _ay_, _ax_),
             fmt_rest = parse(str_ind + 1 | 0, end_ind)[1];
             /*<<camlinternalFormat.ml:2451:9>>*/ if(get_ign(0))
              /*<<camlinternalFormat.ml:2452:22>>*/ var
               /*<<camlinternalFormat.ml:2452:22>>*/ ignored =
                [3, iconv, get_pad_opt(95)],
-             _aB_ = [0, [23, ignored, fmt_rest]];
+             _aA_ = [0, [23, ignored, fmt_rest]];
            else
              /*<<camlinternalFormat.ml:2456:48>>*/ var
-              /*<<camlinternalFormat.ml:2456:48>>*/ _aD_ = get_prec(0),
+              /*<<camlinternalFormat.ml:2456:48>>*/ _aC_ = get_prec(0),
               /*<<camlinternalFormat.ml:2456:10>>*/ match$0 =
-               make_padprec_fmt_ebb(get_int_pad(0), _aD_, fmt_rest),
+               make_padprec_fmt_ebb(get_int_pad(0), _aC_, fmt_rest),
              fmt_rest$0 = match$0[3],
              prec$0 = match$0[2],
              pad$0 = match$0[1],
-             _aB_ = [0, [5, iconv, pad$0, prec$0, fmt_rest$0]];
-           var _aC_ = _aB_;
+             _aA_ = [0, [5, iconv, pad$0, prec$0, fmt_rest$0]];
+           var _aB_ = _aA_;
            break;
           case 1:
            break b;
           default:
             /*<<camlinternalFormat.ml:2461:39>>*/ var
-             /*<<camlinternalFormat.ml:2461:39>>*/ _aE_ =
+             /*<<camlinternalFormat.ml:2461:39>>*/ _aD_ =
                /*<<camlinternalFormat.ml:2461:39>>*/ caml_string_get
                (str, str_ind),
-             /*<<camlinternalFormat.ml:2461:24>>*/ _aF_ = get_space(0),
-             /*<<camlinternalFormat.ml:2461:10>>*/ _aG_ = get_hash(0),
+             /*<<camlinternalFormat.ml:2461:24>>*/ _aE_ = get_space(0),
+             /*<<camlinternalFormat.ml:2461:10>>*/ _aF_ = get_hash(0),
              /*<<camlinternalFormat.ml:2460:8>>*/ iconv$0 =
               compute_int_conv
-               (pct_ind, str_ind + 1 | 0, get_plus(0), _aG_, _aF_, _aE_),
+               (pct_ind, str_ind + 1 | 0, get_plus(0), _aF_, _aE_, _aD_),
             fmt_rest$1 = parse(str_ind + 1 | 0, end_ind)[1];
             /*<<camlinternalFormat.ml:2463:9>>*/ if(get_ign(0))
              /*<<camlinternalFormat.ml:2464:22>>*/ var
               /*<<camlinternalFormat.ml:2464:22>>*/ ignored$0 =
                [4, iconv$0, get_pad_opt(95)],
-             _aH_ = [0, [23, ignored$0, fmt_rest$1]];
+             _aG_ = [0, [23, ignored$0, fmt_rest$1]];
            else
              /*<<camlinternalFormat.ml:2468:48>>*/ var
-              /*<<camlinternalFormat.ml:2468:48>>*/ _aI_ = get_prec(0),
+              /*<<camlinternalFormat.ml:2468:48>>*/ _aH_ = get_prec(0),
               /*<<camlinternalFormat.ml:2468:10>>*/ match$1 =
-               make_padprec_fmt_ebb(get_int_pad(0), _aI_, fmt_rest$1),
+               make_padprec_fmt_ebb(get_int_pad(0), _aH_, fmt_rest$1),
              fmt_rest$2 = match$1[3],
              prec$1 = match$1[2],
              pad$1 = match$1[1],
-             _aH_ = [0, [6, iconv$0, pad$1, prec$1, fmt_rest$2]];
-           var _aC_ = _aH_;
+             _aG_ = [0, [6, iconv$0, pad$1, prec$1, fmt_rest$2]];
+           var _aB_ = _aG_;
         }
-        var fmt_result = _aC_;
+        var fmt_result = _aB_;
         break a;
        }
       }
       else if(76 === symb){
         /*<<camlinternalFormat.ml:2473:25>>*/ var
-         /*<<camlinternalFormat.ml:2473:25>>*/ _aJ_ =
+         /*<<camlinternalFormat.ml:2473:25>>*/ _aI_ =
            /*<<camlinternalFormat.ml:2473:25>>*/ caml_string_get(str, str_ind),
-         /*<<camlinternalFormat.ml:2473:10>>*/ _aK_ = get_space(0),
-         /*<<camlinternalFormat.ml:2472:61>>*/ _aL_ = get_hash(0),
+         /*<<camlinternalFormat.ml:2473:10>>*/ _aJ_ = get_space(0),
+         /*<<camlinternalFormat.ml:2472:61>>*/ _aK_ = get_hash(0),
          /*<<camlinternalFormat.ml:2472:8>>*/ iconv$1 =
           compute_int_conv
-           (pct_ind, str_ind + 1 | 0, get_plus(0), _aL_, _aK_, _aJ_),
+           (pct_ind, str_ind + 1 | 0, get_plus(0), _aK_, _aJ_, _aI_),
         fmt_rest$3 = parse(str_ind + 1 | 0, end_ind)[1];
         /*<<camlinternalFormat.ml:2475:9>>*/ if(get_ign(0))
          /*<<camlinternalFormat.ml:2476:22>>*/ var
           /*<<camlinternalFormat.ml:2476:22>>*/ ignored$1 =
            [5, iconv$1, get_pad_opt(95)],
-         _aM_ = [0, [23, ignored$1, fmt_rest$3]];
+         _aL_ = [0, [23, ignored$1, fmt_rest$3]];
        else
          /*<<camlinternalFormat.ml:2480:48>>*/ var
-          /*<<camlinternalFormat.ml:2480:48>>*/ _aN_ = get_prec(0),
+          /*<<camlinternalFormat.ml:2480:48>>*/ _aM_ = get_prec(0),
           /*<<camlinternalFormat.ml:2480:10>>*/ match$2 =
-           make_padprec_fmt_ebb(get_int_pad(0), _aN_, fmt_rest$3),
+           make_padprec_fmt_ebb(get_int_pad(0), _aM_, fmt_rest$3),
          fmt_rest$4 = match$2[3],
          prec$2 = match$2[2],
          pad$2 = match$2[1],
-         _aM_ = [0, [7, iconv$1, pad$2, prec$2, fmt_rest$4]];
-       var fmt_result = _aM_;
+         _aL_ = [0, [7, iconv$1, pad$2, prec$2, fmt_rest$4]];
+       var fmt_result = _aL_;
        break a;
       }
       var
@@ -19145,46 +19153,46 @@
           (failwith_message(_J_), str, str_ind - 1 | 0, symb);
      }
      if(1 - legacy_behavior$0){
-      var _ap_ = 1 - plus_used[1], plus$0 = _ap_ ? plus : _ap_;
+      var _ao_ = 1 - plus_used[1], plus$0 = _ao_ ? plus : _ao_;
       if(plus$0)
         /*<<camlinternalFormat.ml:2564:6>>*/ incompatible_flag
         (pct_ind, str_ind, symb, cst$27);
-      var _aq_ = 1 - hash_used[1], hash$0 = _aq_ ? hash : _aq_;
+      var _ap_ = 1 - hash_used[1], hash$0 = _ap_ ? hash : _ap_;
       if(hash$0)
         /*<<camlinternalFormat.ml:2566:6>>*/ incompatible_flag
         (pct_ind, str_ind, symb, cst$28);
-      var _ar_ = 1 - space_used[1], space$0 = _ar_ ? space : _ar_;
+      var _aq_ = 1 - space_used[1], space$0 = _aq_ ? space : _aq_;
       if(space$0)
         /*<<camlinternalFormat.ml:2568:6>>*/ incompatible_flag
         (pct_ind, str_ind, symb, cst$29);
       var
-       _as_ = 1 - pad_used[1],
-       _at_ =
-         _as_
+       _ar_ = 1 - pad_used[1],
+       _as_ =
+         _ar_
           ?  /*<<camlinternalFormat.ml:2569:25>>*/ caml_notequal
             ([0, pad], _K_)
-          : _as_;
-       /*<<camlinternalFormat.ml:2569:25>>*/ if(_at_)
+          : _ar_;
+       /*<<camlinternalFormat.ml:2569:25>>*/ if(_as_)
         /*<<camlinternalFormat.ml:2570:6>>*/ incompatible_flag
         (pct_ind, str_ind, symb, cst_padding$0);
       var
-       _au_ = 1 - prec_used[1],
-       _av_ =
-         _au_
+       _at_ = 1 - prec_used[1],
+       _au_ =
+         _at_
           ?  /*<<camlinternalFormat.ml:2571:25>>*/ caml_notequal
             ([0, prec], _L_)
-          : _au_;
-       /*<<camlinternalFormat.ml:2571:25>>*/ if(_av_){
-       var _aw_ = ign ? 95 : symb;
+          : _at_;
+       /*<<camlinternalFormat.ml:2571:25>>*/ if(_au_){
+       var _av_ = ign ? 95 : symb;
         /*<<camlinternalFormat.ml:2572:6>>*/ incompatible_flag
-        (pct_ind, str_ind, _aw_, cst_precision$2);
+        (pct_ind, str_ind, _av_, cst_precision$2);
       }
       var plus$1 = ign ? plus : ign;
       if(plus$1)
         /*<<camlinternalFormat.ml:2574:24>>*/ incompatible_flag
         (pct_ind, str_ind, 95, cst$30);
      }
-     var _ax_ = 1 - ign_used[1], ign$0 = _ax_ ? ign : _ax_;
+     var _aw_ = 1 - ign_used[1], ign$0 = _aw_ ? ign : _aw_;
      a:
      if(ign$0){
       b:
@@ -19301,10 +19309,10 @@
         case 3:
          if(legacy_behavior$0){
            /*<<camlinternalFormat.ml:2249:6>>*/ var
-            /*<<camlinternalFormat.ml:2249:6>>*/ _ao_ = str_ind$0 + 1 | 0,
+            /*<<camlinternalFormat.ml:2249:6>>*/ _an_ = str_ind$0 + 1 | 0,
            minus$0 = minus || (45 === symb$0 ? 1 : 0);
            /*<<camlinternalFormat.ml:2249:6>>*/ return parse_literal
-                  (minus$0, _ao_);
+                  (minus$0, _an_);
          }
          break;
       }
@@ -19331,17 +19339,17 @@
        /*<<camlinternalFormat.ml:2151:15>>*/ hash = [0, 0];
      function set_flag(str_ind, flag){
        /*<<camlinternalFormat.ml:2154:6>>*/ var
-       _al_ = flag[1],
-       _am_ = _al_ ? 1 - legacy_behavior$0 : _al_;
-      if(_am_){
+       _ak_ = flag[1],
+       _al_ = _ak_ ? 1 - legacy_behavior$0 : _ak_;
+      if(_al_){
         /*<<camlinternalFormat.ml:2157:22>>*/  /*<<camlinternalFormat.ml:2157:22>>*/ var
-        _an_ =
+        _am_ =
            /*<<camlinternalFormat.ml:2157:22>>*/ caml_string_get(str, str_ind);
         /*<<camlinternalFormat.ml:2155:8>>*/  /*<<camlinternalFormat.ml:2155:8>>*/ caml_call3
-        (failwith_message(_C_), str, str_ind, _an_);
+        (failwith_message(_C_), str, str_ind, _am_);
       }
       flag[1] = 1;
-      return _$_;
+      return sentinal;
       /*<<camlinternalFormat.ml:2158:19>>*/ }
      var str_ind$0 = str_ind;
       /*<<camlinternalFormat.ml:2161:6>>*/ for(;;){
@@ -19511,13 +19519,13 @@
          [0, sub_fmt, sub_str],
         /*<<camlinternalFormat.ml:2649:8>>*/ formatting$0 =
          is_open_tag ? [0, sub_format$0] : [1, sub_format$0],
-        /*<<camlinternalFormat.ml:2651:8>>*/ _aj_ =
+        /*<<camlinternalFormat.ml:2651:8>>*/ _ai_ =
          [0, [18, formatting$0, fmt_rest$0]];
-       /*<<camlinternalFormat.ml:2651:8>>*/ return _aj_;
+       /*<<camlinternalFormat.ml:2651:8>>*/ return _ai_;
      }
-     catch(_ak_){
-      var _ai_ = caml_wrap_exception(_ak_);
-      if(_ai_ !== Stdlib[8]) throw caml_maybe_attach_backtrace(_ai_, 0);
+     catch(_aj_){
+      var _ah_ = caml_wrap_exception(_aj_);
+      if(_ah_ !== Stdlib[8]) throw caml_maybe_attach_backtrace(_ah_, 0);
        /*<<camlinternalFormat.ml:2657:6>>*/ var
        fmt_rest = parse(str_ind, end_ind)[1],
         /*<<camlinternalFormat.ml:2657:6>>*/ formatting =
@@ -19557,9 +19565,9 @@
       var new_acc = (acc$0 * 10 | 0) + (c - 48 | 0) | 0;
       if(Stdlib_Sys[12] < new_acc){
         /*<<camlinternalFormat.ml:2815:8>>*/  /*<<camlinternalFormat.ml:2815:8>>*/ var
-        _ah_ = Stdlib_Sys[12];
+        _ag_ = Stdlib_Sys[12];
         /*<<camlinternalFormat.ml:2815:8>>*/ return  /*<<camlinternalFormat.ml:2815:8>>*/ caml_call3
-               (failwith_message(_S_), str, new_acc, _ah_);
+               (failwith_message(_S_), str, new_acc, _ag_);
       }
       var
        str_ind$1 = str_ind$0 + 1 | 0,
@@ -19813,16 +19821,16 @@
      fmt = fmt_ebb_of_string(0, str)[1];
      /*<<camlinternalFormat.ml:2978:2>>*/ try{
       /*<<camlinternalFormat.ml:2978:6>>*/  /*<<camlinternalFormat.ml:2978:6>>*/ var
-      _af_ = [0, type_format(fmt, fmtty), str];
-      /*<<camlinternalFormat.ml:2978:6>>*/ return _af_;
+      _ae_ = [0, type_format(fmt, fmtty), str];
+      /*<<camlinternalFormat.ml:2978:6>>*/ return _ae_;
     }
-    catch(_ag_){
-     var _ad_ = caml_wrap_exception(_ag_);
-     if(_ad_ !== Type_mismatch) throw caml_maybe_attach_backtrace(_ad_, 0);
+    catch(_af_){
+     var _ac_ = caml_wrap_exception(_af_);
+     if(_ac_ !== Type_mismatch) throw caml_maybe_attach_backtrace(_ac_, 0);
       /*<<camlinternalFormat.ml:2982:10>>*/  /*<<camlinternalFormat.ml:2982:10>>*/ var
-      _ae_ = string_of_fmtty(fmtty);
+      _ad_ = string_of_fmtty(fmtty);
       /*<<camlinternalFormat.ml:2982:10>>*/ return  /*<<camlinternalFormat.ml:2982:10>>*/ caml_call2
-             (failwith_message(_Z_), str, _ae_);
+             (failwith_message(_Z_), str, _ad_);
     }
     /*<<camlinternalFormat.ml:2982:33>>*/ }
    function format_of_string_format(str, param){
@@ -19832,15 +19840,15 @@
      fmt$0 = fmt_ebb_of_string(0, str)[1];
      /*<<camlinternalFormat.ml:2988:2>>*/ try{
       /*<<camlinternalFormat.ml:2988:6>>*/  /*<<camlinternalFormat.ml:2988:6>>*/ var
-      _ab_ = [0, type_format(fmt$0, fmtty_of_fmt(fmt)), str];
-      /*<<camlinternalFormat.ml:2988:6>>*/ return _ab_;
+      _aa_ = [0, type_format(fmt$0, fmtty_of_fmt(fmt)), str];
+      /*<<camlinternalFormat.ml:2988:6>>*/ return _aa_;
     }
-    catch(_ac_){
-     var _aa_ = caml_wrap_exception(_ac_);
-     if(_aa_ === Type_mismatch)
+    catch(_ab_){
+     var _$_ = caml_wrap_exception(_ab_);
+     if(_$_ === Type_mismatch)
        /*<<camlinternalFormat.ml:2990:4>>*/ return  /*<<camlinternalFormat.ml:2990:4>>*/ caml_call2
               (failwith_message(___), str, str$0);
-     throw caml_maybe_attach_backtrace(_aa_, 0);
+     throw caml_maybe_attach_backtrace(_$_, 0);
     }
    }
    var
@@ -20048,7 +20056,7 @@
             : runtime.caml_call_gen(f, [a0, a1, a2, a3, a4, a5]);
    }
     /*<<arg.ml:50:0>>*/ var
-    _y_ = undefined,
+    sentinal = undefined,
     global_data = runtime.caml_get_global_data(),
     cst$6 = "\n",
     cst$3 = cst$7,
@@ -20139,18 +20147,18 @@
      /*<<arg.ml:79:53>>*/ var
      t = l[2],
      h = l[1],
-      /*<<arg.ml:79:53>>*/ _aE_ =
+      /*<<arg.ml:79:53>>*/ _aD_ =
         /*<<arg.ml:79:53>>*/ caml_call2(Stdlib[28], prefix, h);
-    function _aF_(x, y){
+    function _aE_(x, y){
       /*<<arg.ml:79:40>>*/  /*<<arg.ml:79:44>>*/ var
-      _aH_ =  /*<<arg.ml:79:44>>*/ caml_call2(Stdlib[28], sep, y);
+      _aG_ =  /*<<arg.ml:79:44>>*/ caml_call2(Stdlib[28], sep, y);
       /*<<arg.ml:79:44>>*/ return  /*<<arg.ml:79:44>>*/ caml_call2
-             (Stdlib[28], x, _aH_);
+             (Stdlib[28], x, _aG_);
      /*<<arg.ml:79:51>>*/ }
      /*<<arg.ml:79:12>>*/  /*<<arg.ml:79:12>>*/ var
-     _aG_ =  /*<<arg.ml:79:12>>*/ caml_call3(Stdlib_List[25], _aF_, _aE_, t);
+     _aF_ =  /*<<arg.ml:79:12>>*/ caml_call3(Stdlib_List[25], _aE_, _aD_, t);
      /*<<arg.ml:79:12>>*/ return  /*<<arg.ml:79:12>>*/ caml_call2
-            (Stdlib[28], _aG_, suffix);
+            (Stdlib[28], _aF_, suffix);
     /*<<arg.ml:79:77>>*/ }
    function help_action(param){
      /*<<arg.ml:91:21>>*/ throw  /*<<arg.ml:91:21>>*/ caml_maybe_attach_backtrace
@@ -20159,11 +20167,11 @@
    function add_help(speclist){
      /*<<arg.ml:94:2>>*/ try{
       /*<<arg.ml:95:15>>*/ assoc3(cst_help$2, speclist);
-      /*<<arg.ml:95:42>>*/ var  /*<<arg.ml:95:42>>*/ _aB_ = 0, add1 = _aB_;
+      /*<<arg.ml:95:42>>*/ var  /*<<arg.ml:95:42>>*/ _aA_ = 0, add1 = _aA_;
     }
-    catch(_aD_){
-     var _ax_ = caml_wrap_exception(_aD_);
-     if(_ax_ !== Stdlib[8]) throw caml_maybe_attach_backtrace(_ax_, 0);
+    catch(_aC_){
+     var _aw_ = caml_wrap_exception(_aC_);
+     if(_aw_ !== Stdlib[8]) throw caml_maybe_attach_backtrace(_aw_, 0);
      var
       add1 =
         [0,
@@ -20172,11 +20180,11 @@
     }
     try{
       /*<<arg.ml:99:15>>*/ assoc3(cst_help$1, speclist);
-      /*<<arg.ml:99:43>>*/ var  /*<<arg.ml:99:43>>*/ _aA_ = 0, add2 = _aA_;
+      /*<<arg.ml:99:43>>*/ var  /*<<arg.ml:99:43>>*/ _az_ = 0, add2 = _az_;
     }
-    catch(_aC_){
-     var _ay_ = caml_wrap_exception(_aC_);
-     if(_ay_ !== Stdlib[8]) throw caml_maybe_attach_backtrace(_ay_, 0);
+    catch(_aB_){
+     var _ax_ = caml_wrap_exception(_aB_);
+     if(_ax_ !== Stdlib[8]) throw caml_maybe_attach_backtrace(_ax_, 0);
      var
       add2 =
         [0,
@@ -20184,34 +20192,34 @@
          0];
     }
      /*<<arg.ml:103:13>>*/  /*<<arg.ml:103:13>>*/ var
-     _az_ =  /*<<arg.ml:103:13>>*/ caml_call2(Stdlib[37], add1, add2);
+     _ay_ =  /*<<arg.ml:103:13>>*/ caml_call2(Stdlib[37], add1, add2);
      /*<<arg.ml:103:13>>*/ return  /*<<arg.ml:103:13>>*/ caml_call2
-            (Stdlib[37], speclist, _az_);
+            (Stdlib[37], speclist, _ay_);
     /*<<arg.ml:103:26>>*/ }
    function usage_b(buf, speclist, errmsg){
      /*<<arg.ml:107:2>>*/  /*<<arg.ml:107:2>>*/ caml_call3
      (Stdlib_Printf[5], buf, _d_, errmsg);
      /*<<arg.ml:108:29>>*/  /*<<arg.ml:108:29>>*/ var
-     _at_ = add_help(speclist);
-     /*<<arg.ml:108:12>>*/ function _au_(param){
+     _as_ = add_help(speclist);
+     /*<<arg.ml:108:12>>*/ function _at_(param){
      var
       doc = param[3],
       spec = param[2],
       key = param[1],
-      _av_ = 0 <  /*<<arg.ml:83:2>>*/ caml_ml_string_length(doc) ? 1 : 0;
-     if(! _av_) return _av_;
+      _au_ = 0 <  /*<<arg.ml:83:2>>*/ caml_ml_string_length(doc) ? 1 : 0;
+     if(! _au_) return _au_;
      if(11 !== spec[0])
        /*<<arg.ml:88:8>>*/ return  /*<<arg.ml:88:8>>*/ caml_call4
               (Stdlib_Printf[5], buf, _a_, key, doc);
       /*<<arg.ml:86:38>>*/ var
       l = spec[1],
-       /*<<arg.ml:86:38>>*/ _aw_ = make_symlist(cst$1, cst$0, cst, l);
+       /*<<arg.ml:86:38>>*/ _av_ = make_symlist(cst$1, cst$0, cst, l);
       /*<<arg.ml:86:8>>*/ return  /*<<arg.ml:86:8>>*/ caml_call5
-             (Stdlib_Printf[5], buf, _b_, key, _aw_, doc);
+             (Stdlib_Printf[5], buf, _b_, key, _av_, doc);
     }
      /*<<arg.ml:108:29>>*/  /*<<arg.ml:108:29>>*/ caml_call2
-     (Stdlib_List[17], _au_, _at_);
-     /*<<arg.ml:108:29>>*/ return _y_;
+     (Stdlib_List[17], _at_, _as_);
+     /*<<arg.ml:108:29>>*/ return sentinal;
     /*<<arg.ml:108:48>>*/ }
    function usage_string(speclist, errmsg){
      /*<<arg.ml:112:2>>*/  /*<<arg.ml:112:10>>*/ var
@@ -20222,33 +20230,33 @@
     /*<<arg.ml:114:19>>*/ }
    function usage(speclist, errmsg){
      /*<<arg.ml:118:2>>*/  /*<<arg.ml:118:15>>*/ var
-     _as_ = usage_string(speclist, errmsg);
+     _ar_ = usage_string(speclist, errmsg);
      /*<<arg.ml:118:15>>*/ return  /*<<arg.ml:118:15>>*/ caml_call2
-            (Stdlib_Printf[3], _e_, _as_);
+            (Stdlib_Printf[3], _e_, _ar_);
     /*<<arg.ml:118:45>>*/ }
     /*<<arg.ml:121:14>>*/  /*<<arg.ml:121:14>>*/ var current = [0, 0];
    function int_of_string_opt(x){
      /*<<arg.ml:128:2>>*/ try{
       /*<<arg.ml:128:6>>*/  /*<<arg.ml:128:6>>*/ var
-      _aq_ = [0,  /*<<arg.ml:128:11>>*/ runtime.caml_int_of_string(x)];
-      /*<<arg.ml:128:6>>*/ return _aq_;
+      _ap_ = [0,  /*<<arg.ml:128:11>>*/ runtime.caml_int_of_string(x)];
+      /*<<arg.ml:128:6>>*/ return _ap_;
     }
-    catch(_ar_){
-     var _ap_ = caml_wrap_exception(_ar_);
-     if(_ap_[1] === Stdlib[7])  /*<<arg.ml:129:20>>*/ return 0;
-     throw caml_maybe_attach_backtrace(_ap_, 0);
+    catch(_aq_){
+     var _ao_ = caml_wrap_exception(_aq_);
+     if(_ao_[1] === Stdlib[7])  /*<<arg.ml:129:20>>*/ return 0;
+     throw caml_maybe_attach_backtrace(_ao_, 0);
     }
     /*<<arg.ml:129:24>>*/ }
    function float_of_string_opt(x){
      /*<<arg.ml:132:2>>*/ try{
       /*<<arg.ml:132:6>>*/  /*<<arg.ml:132:6>>*/ var
-      _an_ = [0,  /*<<arg.ml:132:11>>*/ runtime.caml_float_of_string(x)];
-      /*<<arg.ml:132:6>>*/ return _an_;
+      _am_ = [0,  /*<<arg.ml:132:11>>*/ runtime.caml_float_of_string(x)];
+      /*<<arg.ml:132:6>>*/ return _am_;
     }
-    catch(_ao_){
-     var _am_ = caml_wrap_exception(_ao_);
-     if(_am_[1] === Stdlib[7])  /*<<arg.ml:133:20>>*/ return 0;
-     throw caml_maybe_attach_backtrace(_am_, 0);
+    catch(_an_){
+     var _al_ = caml_wrap_exception(_an_);
+     if(_al_[1] === Stdlib[7])  /*<<arg.ml:133:20>>*/ return 0;
+     throw caml_maybe_attach_backtrace(_al_, 0);
     }
     /*<<arg.ml:133:24>>*/ }
    function parse_and_expand_argv_dynamic_
@@ -20303,8 +20311,8 @@
      if(current[1] >= argv[1].length - 1) return 0;
       /*<<arg.ml:166:4>>*/ try{
        /*<<arg.ml:167:14>>*/ var
-       _Z_ = current[1],
-        /*<<arg.ml:167:14>>*/ s = caml_check_bound(argv[1], _Z_)[1 + _Z_];
+       _Y_ = current[1],
+        /*<<arg.ml:167:14>>*/ s = caml_check_bound(argv[1], _Y_)[1 + _Y_];
       a:
       {
         /*<<arg.ml:168:33>>*/ if
@@ -20313,13 +20321,13 @@
         try{
           /*<<arg.ml:170:14>>*/ var
           follow$1 = 0,
-           /*<<arg.ml:170:14>>*/ _ab_ = assoc3(s, speclist[1]),
+           /*<<arg.ml:170:14>>*/ _aa_ = assoc3(s, speclist[1]),
           follow$0 = follow$1,
-          action = _ab_;
+          action = _aa_;
         }
-        catch(_ak_){
-         var ___ = caml_wrap_exception(_ak_);
-         if(___ !== Stdlib[8]) throw caml_maybe_attach_backtrace(___, 0);
+        catch(_aj_){
+         var _Z_ = caml_wrap_exception(_aj_);
+         if(_Z_ !== Stdlib[8]) throw caml_maybe_attach_backtrace(_Z_, 0);
           /*<<arg.ml:172:10>>*/ try{
            /*<<arg.ml:71:10>>*/ var
             /*<<arg.ml:71:10>>*/ i =
@@ -20332,16 +20340,16 @@
             /*<<arg.ml:73:2>>*/ keyword =
               /*<<arg.ml:73:2>>*/ caml_call3(Stdlib_String[15], s, 0, i),
             /*<<arg.ml:174:38>>*/ follow = [0, arg],
-            /*<<arg.ml:174:12>>*/ _aa_ = assoc3(keyword, speclist[1]),
+            /*<<arg.ml:174:12>>*/ _$_ = assoc3(keyword, speclist[1]),
            follow$0 = follow,
-           action = _aa_;
+           action = _$_;
          }
-         catch(_al_){
-          var _$_ = caml_wrap_exception(_al_);
-          if(_$_ === Stdlib[8])
+         catch(_ak_){
+          var ___ = caml_wrap_exception(_ak_);
+          if(___ === Stdlib[8])
             /*<<arg.ml:175:28>>*/ throw  /*<<arg.ml:175:28>>*/ caml_maybe_attach_backtrace
                   ([0, Stop, [0, s]], 1);
-          throw caml_maybe_attach_backtrace(_$_, 0);
+          throw caml_maybe_attach_backtrace(___, 0);
          }
         }
         var
@@ -20349,7 +20357,7 @@
            function(s, follow){
             function no_arg(param){
               /*<<arg.ml:178:10>>*/ if(! follow)
-               /*<<arg.ml:179:20>>*/ return _y_;
+               /*<<arg.ml:179:20>>*/ return sentinal;
              var arg = follow[1];
               /*<<arg.ml:180:24>>*/ throw  /*<<arg.ml:180:24>>*/ caml_maybe_attach_backtrace
                     ([0, Stop, [1, s, arg, cst_no_argument]], 1);
@@ -20367,9 +20375,9 @@
              if((current[1] + 1 | 0) >= argv[1].length - 1)
                /*<<arg.ml:185:19>>*/ throw  /*<<arg.ml:185:19>>*/ caml_maybe_attach_backtrace
                      ([0, Stop, [2, s]], 1);
-             var _aj_ = current[1] + 1 | 0;
-              /*<<arg.ml:184:58>>*/ return caml_check_bound(argv[1], _aj_)
-                     [1 + _aj_];
+             var _ai_ = current[1] + 1 | 0;
+              /*<<arg.ml:184:58>>*/ return caml_check_bound(argv[1], _ai_)
+                     [1 + _ai_];
              /*<<arg.ml:186:27>>*/ }
             return get_arg;
            },
@@ -20397,14 +20405,14 @@
                   /*<<arg.ml:196:22>>*/ arg = get_arg(0);
                  /*<<arg.ml:124:2>>*/ try{
                   /*<<arg.ml:124:6>>*/ var
-                   /*<<arg.ml:124:6>>*/ _ad_ =
+                   /*<<arg.ml:124:6>>*/ _ac_ =
                     [0,  /*<<arg.ml:124:11>>*/ caml_call1(Stdlib[32], arg)],
-                  match = _ad_;
+                  match = _ac_;
                 }
-                catch(_ai_){
-                 var _ac_ = caml_wrap_exception(_ai_);
-                 if(_ac_[1] !== Stdlib[6])
-                  throw caml_maybe_attach_backtrace(_ac_, 0);
+                catch(_ah_){
+                 var _ab_ = caml_wrap_exception(_ah_);
+                 if(_ab_[1] !== Stdlib[6])
+                  throw caml_maybe_attach_backtrace(_ab_, 0);
                  var match = 0;
                 }
                 if(! match)
@@ -20499,7 +20507,7 @@
                   /*<<arg.ml:211:14>>*/ return consume_arg(0);
                 }
                  /*<<arg.ml:215:44>>*/  /*<<arg.ml:215:44>>*/ var
-                 _ae_ = make_symlist(cst$5, cst$4, cst$3, symb);
+                 _ad_ = make_symlist(cst$5, cst$4, cst$3, symb);
                  /*<<arg.ml:213:21>>*/ throw  /*<<arg.ml:213:21>>*/ caml_maybe_attach_backtrace
                        ([0,
                          Stop,
@@ -20507,16 +20515,16 @@
                           s,
                           arg$5,
                            /*<<arg.ml:214:42>>*/ caml_call2
-                           (Stdlib[28], cst_one_of, _ae_)]],
+                           (Stdlib[28], cst_one_of, _ad_)]],
                         1);
                case 12:
                 var f$5 = param[1];
                  /*<<arg.ml:252:12>>*/ no_arg(0);
                  /*<<arg.ml:255:14>>*/ for(;;){
                  if(current[1] >= (argv[1].length - 1 - 1 | 0)) return 0;
-                 var _af_ = current[1] + 1 | 0;
+                 var _ae_ = current[1] + 1 | 0;
                   /*<<arg.ml:254:14>>*/  /*<<arg.ml:254:14>>*/ caml_call1
-                  (f$5, caml_check_bound(argv[1], _af_)[1 + _af_]);
+                  (f$5, caml_check_bound(argv[1], _ae_)[1 + _ae_]);
                   /*<<arg.ml:255:14>>*/ consume_arg(0);
                 }
                 break;
@@ -20530,8 +20538,8 @@
                    /*<<arg.ml:264:14>>*/ return  /*<<arg.ml:264:14>>*/ caml_call1
                           (f$6,
                             /*<<arg.ml:264:14>>*/ caml_call1(Stdlib_List[9], acc[1]));
-                 var _ah_ = current[1] + 1 | 0, _ag_ = acc[1];
-                 acc[1] = [0, caml_check_bound(argv[1], _ah_)[1 + _ah_], _ag_];
+                 var _ag_ = current[1] + 1 | 0, _af_ = acc[1];
+                 acc[1] = [0, caml_check_bound(argv[1], _ag_)[1 + _ag_], _af_];
                   /*<<arg.ml:262:14>>*/ consume_arg(0);
                 }
                 break;
@@ -20609,8 +20617,8 @@
    function parse(l, f, msg){
      /*<<arg.ml:299:2>>*/ try{
       /*<<arg.ml:300:4>>*/  /*<<arg.ml:300:4>>*/ var
-      _Y_ = parse_argv(0, caml_sys_argv(0), l, f, msg);
-      /*<<arg.ml:300:4>>*/ return _Y_;
+      _X_ = parse_argv(0, caml_sys_argv(0), l, f, msg);
+      /*<<arg.ml:300:4>>*/ return _X_;
     }
     catch(exn$0){
      var exn = caml_wrap_exception(exn$0);
@@ -20632,8 +20640,8 @@
    function parse_dynamic(l, f, msg){
      /*<<arg.ml:307:2>>*/ try{
       /*<<arg.ml:308:4>>*/  /*<<arg.ml:308:4>>*/ var
-      _X_ = parse_argv_dynamic(0, caml_sys_argv(0), l, f, msg);
-      /*<<arg.ml:308:4>>*/ return _X_;
+      _W_ = parse_argv_dynamic(0, caml_sys_argv(0), l, f, msg);
+      /*<<arg.ml:308:4>>*/ return _W_;
     }
     catch(exn$0){
      var exn = caml_wrap_exception(exn$0);
@@ -20658,9 +20666,9 @@
        /*<<arg.ml:315:15>>*/ argv = [0, caml_sys_argv(0)],
        /*<<arg.ml:316:15>>*/ spec = [0, l],
        /*<<arg.ml:317:18>>*/ current$0 = [0, current[1]],
-       /*<<arg.ml:318:4>>*/ _W_ =
+       /*<<arg.ml:318:4>>*/ _V_ =
         parse_and_expand_argv_dynamic(current$0, argv, spec, f, msg);
-      /*<<arg.ml:318:4>>*/ return _W_;
+      /*<<arg.ml:318:4>>*/ return _V_;
     }
     catch(exn$0){
      var exn = caml_wrap_exception(exn$0);
@@ -20697,17 +20705,17 @@
       /*<<arg.ml:331:8>>*/  /*<<arg.ml:331:8>>*/ var
       n$0 =  /*<<arg.ml:331:8>>*/ caml_call2(Stdlib_String[35], s, 9);
     }
-    catch(_U_){
-     var _S_ = caml_wrap_exception(_U_);
-     if(_S_ !== Stdlib[8]) throw caml_maybe_attach_backtrace(_S_, 0);
+    catch(_T_){
+     var _R_ = caml_wrap_exception(_T_);
+     if(_R_ !== Stdlib[8]) throw caml_maybe_attach_backtrace(_R_, 0);
       /*<<arg.ml:334:6>>*/ try{
        /*<<arg.ml:334:18>>*/  /*<<arg.ml:334:18>>*/ var
        n =  /*<<arg.ml:334:18>>*/ caml_call2(Stdlib_String[35], s, 32);
      }
-     catch(_V_){
-      var _T_ = caml_wrap_exception(_V_);
-      if(_T_ === Stdlib[8])  /*<<arg.ml:336:31>>*/ return len;
-      throw caml_maybe_attach_backtrace(_T_, 0);
+     catch(_U_){
+      var _S_ = caml_wrap_exception(_U_);
+      if(_S_ === Stdlib[8])  /*<<arg.ml:336:31>>*/ return len;
+      throw caml_maybe_attach_backtrace(_S_, 0);
      }
       /*<<arg.ml:334:18>>*/ return loop(n + 1 | 0);
     }
@@ -20717,12 +20725,12 @@
     var doc = param[3], spec = param[2], kwd = param[1];
      /*<<arg.ml:341:2>>*/ if(11 === spec[0])
      return caml_call2(Stdlib_Int[11], cur, caml_ml_string_length(kwd));
-    var _R_ = caml_ml_string_length(kwd) + second_word(doc) | 0;
-    return caml_call2(Stdlib_Int[11], cur, _R_);
+    var _Q_ = caml_ml_string_length(kwd) + second_word(doc) | 0;
+    return caml_call2(Stdlib_Int[11], cur, _Q_);
    }
    function replace_leading_tab(s){
      /*<<arg.ml:347:2>>*/  /*<<arg.ml:347:13>>*/ var seen = [0, 0];
-    function _Q_(c){
+    function _P_(c){
       /*<<arg.ml:348:13>>*/ if(9 === c && ! seen[1]){
       seen[1] = 1;
        /*<<arg.ml:348:60>>*/ return 32;
@@ -20730,7 +20738,7 @@
       /*<<arg.ml:348:71>>*/ return c;
      /*<<arg.ml:348:73>>*/ }
      /*<<arg.ml:348:2>>*/ return  /*<<arg.ml:348:2>>*/ caml_call2
-            (Stdlib_String[17], _Q_, s);
+            (Stdlib_String[17], _P_, s);
     /*<<arg.ml:348:75>>*/ }
    function align(opt, speclist){
      /*<<arg.ml:374:2>>*/ if(opt)
@@ -20744,7 +20752,7 @@
         (Stdlib_List[25], max_arg_len, 0, completed),
       /*<<arg.ml:376:12>>*/ len$0 =
         /*<<arg.ml:376:12>>*/ caml_call2(Stdlib_Int[10], len, limit);
-     /*<<arg.ml:377:11>>*/ function _K_(ksd){
+     /*<<arg.ml:377:11>>*/ function _J_(ksd){
      var kwd = ksd[1], spec = ksd[2];
      if(! caml_string_notequal(ksd[3], cst$7))
        /*<<arg.ml:355:6>>*/ return ksd;
@@ -20752,20 +20760,20 @@
        /*<<arg.ml:357:19>>*/ var
        msg$0 = ksd[3],
         /*<<arg.ml:357:19>>*/ cutcol$0 = second_word(msg$0),
-        /*<<arg.ml:358:32>>*/ _N_ =
+        /*<<arg.ml:358:32>>*/ _M_ =
           /*<<arg.ml:358:32>>*/ caml_call2
           (Stdlib_Int[11], 0, len$0 - cutcol$0 | 0)
          + 3
          | 0,
         /*<<arg.ml:358:19>>*/ spaces$0 =
-          /*<<arg.ml:358:19>>*/ caml_call2(Stdlib_String[1], _N_, 32),
-        /*<<arg.ml:359:34>>*/ _O_ = replace_leading_tab(msg$0),
-        /*<<arg.ml:359:25>>*/ _P_ =
-          /*<<arg.ml:359:25>>*/ caml_call2(Stdlib[28], spaces$0, _O_);
+          /*<<arg.ml:358:19>>*/ caml_call2(Stdlib_String[1], _M_, 32),
+        /*<<arg.ml:359:34>>*/ _N_ = replace_leading_tab(msg$0),
+        /*<<arg.ml:359:25>>*/ _O_ =
+          /*<<arg.ml:359:25>>*/ caml_call2(Stdlib[28], spaces$0, _N_);
        /*<<arg.ml:359:6>>*/ return [0,
               kwd,
               spec,
-               /*<<arg.ml:359:18>>*/ caml_call2(Stdlib[28], cst$6, _P_)];
+               /*<<arg.ml:359:18>>*/ caml_call2(Stdlib[28], cst$6, _O_)];
      }
       /*<<arg.ml:361:19>>*/ var
       msg = ksd[3],
@@ -20779,24 +20787,24 @@
       /*<<arg.ml:367:21>>*/ var
        /*<<arg.ml:367:21>>*/ spaces =
          /*<<arg.ml:367:21>>*/ caml_call2(Stdlib_String[1], diff, 32),
-       /*<<arg.ml:368:32>>*/ _L_ = replace_leading_tab(msg),
+       /*<<arg.ml:368:32>>*/ _K_ = replace_leading_tab(msg),
        /*<<arg.ml:368:21>>*/ prefix =
-         /*<<arg.ml:368:21>>*/ caml_call3(Stdlib_String[15], _L_, 0, cutcol),
+         /*<<arg.ml:368:21>>*/ caml_call3(Stdlib_String[15], _K_, 0, cutcol),
        /*<<arg.ml:369:21>>*/ suffix =
          /*<<arg.ml:369:21>>*/ caml_call3
          (Stdlib_String[15],
           msg,
           cutcol,
           caml_ml_string_length(msg) - cutcol | 0),
-       /*<<arg.ml:370:29>>*/ _M_ =
+       /*<<arg.ml:370:29>>*/ _L_ =
          /*<<arg.ml:370:29>>*/ caml_call2(Stdlib[28], spaces, suffix);
       /*<<arg.ml:370:8>>*/ return [0,
              kwd,
              spec$0,
-              /*<<arg.ml:370:20>>*/ caml_call2(Stdlib[28], prefix, _M_)];
+              /*<<arg.ml:370:20>>*/ caml_call2(Stdlib[28], prefix, _L_)];
     }
      /*<<arg.ml:377:2>>*/ return  /*<<arg.ml:377:2>>*/ caml_call2
-            (Stdlib_List[19], _K_, completed);
+            (Stdlib_List[19], _J_, completed);
     /*<<arg.ml:377:38>>*/ }
    function read_aux(trim, sep, file){
      /*<<arg.ml:387:2>>*/ var
@@ -20816,21 +20824,21 @@
         (0 < len
          && 13 ===  /*<<arg.ml:381:16>>*/ caml_string_get(word, len - 1 | 0)){
         var
-         _J_ =
+         _I_ =
             /*<<arg.ml:382:4>>*/ caml_call3
             (Stdlib_String[15], word, 0, len - 1 | 0);
         break a;
        }
-       var _J_ = word;
+       var _I_ = word;
       }
-      var word$0 = _J_;
+      var word$0 = _I_;
      }
      else
       var word$0 = word;
      words[1] = [0, word$0, words[1]];
       /*<<arg.ml:390:2>>*/  /*<<arg.ml:390:2>>*/ caml_call1
       (Stdlib_Buffer[8], buf);
-      /*<<arg.ml:390:2>>*/ return _y_;
+      /*<<arg.ml:390:2>>*/ return sentinal;
      /*<<arg.ml:394:20>>*/ }
      /*<<arg.ml:396:2>>*/ try{
      for(;;){
@@ -20843,45 +20851,45 @@
         (Stdlib_Buffer[12], buf, c);
      }
     }
-    catch(_I_){
-     var _G_ = caml_wrap_exception(_I_);
-     if(_G_ !== Stdlib[12]) throw caml_maybe_attach_backtrace(_G_, 0);
+    catch(_H_){
+     var _F_ = caml_wrap_exception(_H_);
+     if(_F_ !== Stdlib[12]) throw caml_maybe_attach_backtrace(_F_, 0);
      if(0 <  /*<<arg.ml:403:5>>*/ caml_call1(Stdlib_Buffer[7], buf))
        /*<<arg.ml:403:32>>*/ stash(0);
       /*<<arg.ml:404:2>>*/  /*<<arg.ml:404:2>>*/ caml_call1(Stdlib[93], ic);
       /*<<arg.ml:405:16>>*/  /*<<arg.ml:405:16>>*/ var
-      _H_ =  /*<<arg.ml:405:16>>*/ caml_call1(Stdlib_List[9], words[1]);
+      _G_ =  /*<<arg.ml:405:16>>*/ caml_call1(Stdlib_List[9], words[1]);
       /*<<arg.ml:405:16>>*/ return  /*<<arg.ml:405:16>>*/ caml_call1
-             (Stdlib_Array[10], _H_);
+             (Stdlib_Array[10], _G_);
     }
     /*<<arg.ml:405:33>>*/ }
    var _r_ = 10, _s_ = 1;
-    /*<<arg.ml:407:15>>*/ function read_arg(_F_){
-     /*<<?>>*/ return read_aux(_s_, _r_, _F_);
+    /*<<arg.ml:407:15>>*/ function read_arg(_E_){
+     /*<<?>>*/ return read_aux(_s_, _r_, _E_);
    }
     /*<<arg.ml:407:15>>*/ var  /*<<arg.ml:407:15>>*/ _t_ = 0, _u_ = 0;
-    /*<<arg.ml:409:16>>*/ function read_arg0(_E_){
-     /*<<?>>*/ return read_aux(_u_, _t_, _E_);
+    /*<<arg.ml:409:16>>*/ function read_arg0(_D_){
+     /*<<?>>*/ return read_aux(_u_, _t_, _D_);
    }
    function write_aux(sep, file, args){
      /*<<arg.ml:412:2>>*/  /*<<arg.ml:412:11>>*/ var
      oc =  /*<<arg.ml:412:11>>*/ caml_call1(Stdlib[61], file);
-    function _D_(s){
+    function _C_(s){
       /*<<arg.ml:413:23>>*/ return caml_call4
              (Stdlib_Printf[1], oc, _v_, s, sep);
      /*<<arg.ml:413:46>>*/ }
      /*<<arg.ml:413:2>>*/  /*<<arg.ml:413:2>>*/ caml_call2
-     (Stdlib_Array[11], _D_, args);
+     (Stdlib_Array[11], _C_, args);
      /*<<arg.ml:413:2>>*/ return  /*<<arg.ml:413:2>>*/ caml_call1
             (Stdlib[76], oc);
     /*<<arg.ml:414:14>>*/ }
    var _w_ = 10;
-    /*<<arg.ml:416:16>>*/ function write_arg(_B_, _C_){
-     /*<<?>>*/ return write_aux(_w_, _B_, _C_);
+    /*<<arg.ml:416:16>>*/ function write_arg(_A_, _B_){
+     /*<<?>>*/ return write_aux(_w_, _A_, _B_);
    }
     /*<<arg.ml:416:16>>*/  /*<<arg.ml:416:16>>*/ var _x_ = 0;
-    /*<<arg.ml:418:17>>*/ function write_arg0(_z_, _A_){
-     /*<<?>>*/ return write_aux(_x_, _z_, _A_);
+    /*<<arg.ml:418:17>>*/ function write_arg0(_y_, _z_){
+     /*<<?>>*/ return write_aux(_x_, _y_, _z_);
    }
    var
     Stdlib_Arg =
@@ -21544,10 +21552,10 @@
             : runtime.caml_call_gen(f, [a0, a1]);
    }
    var
+    sentinal = undefined,
     global_data = runtime.caml_get_global_data(),
     Stdlib_Printexc = global_data.Stdlib__Printexc,
     Stdlib = global_data.Stdlib,
-    _b_ = undefined,
     cst_Fun_Finally_raised = "Fun.Finally_raised: ",
     cst_Stdlib_Fun_Finally_raised = "Stdlib.Fun.Finally_raised";
    function const$0(c, param){
@@ -21567,11 +21575,11 @@
       /*<<fun.ml:25:7>>*/ return 0;
      /*<<fun.ml:24:55>>*/ var
      exn = param[2],
-      /*<<fun.ml:24:55>>*/ _c_ =
+      /*<<fun.ml:24:55>>*/ _b_ =
         /*<<fun.ml:24:55>>*/ caml_call1(Stdlib_Printexc[1], exn);
      /*<<fun.ml:24:24>>*/ return [0,
              /*<<fun.ml:24:29>>*/ caml_call2
-             (Stdlib[28], cst_Fun_Finally_raised, _c_)];
+             (Stdlib[28], cst_Fun_Finally_raised, _b_)];
     /*<<fun.ml:25:11>>*/ }
     /*<<fun.ml:23:9>>*/  /*<<fun.ml:23:9>>*/ caml_call1
     (Stdlib_Printexc[9], _a_);
@@ -21579,7 +21587,7 @@
     function finally_no_exn(param){
       /*<<fun.ml:29:4>>*/ try{
        /*<<fun.ml:29:8>>*/  /*<<fun.ml:29:8>>*/ caml_call1(finally$0, 0);
-       /*<<fun.ml:29:8>>*/ return _b_;
+       /*<<fun.ml:29:8>>*/ return sentinal;
      }
      catch(e$0){
        /*<<fun.ml:30:15>>*/ var
@@ -22037,7 +22045,7 @@
             : runtime.caml_call_gen(f, [a0, a1, a2]);
    }
    var
-    _a_ = undefined,
+    sentinal = undefined,
     global_data = runtime.caml_get_global_data(),
     Stdlib = global_data.Stdlib,
     Stdlib_Array = global_data.Stdlib__Array,
@@ -22099,46 +22107,46 @@
      /*<<bigarray.ml:104:4>>*/ if(col === idx.length - 1){
       /*<<bigarray.ml:104:35>>*/  /*<<bigarray.ml:104:35>>*/ caml_ba_set_generic
       (arr, idx,  /*<<bigarray.ml:104:47>>*/ caml_call1(f, idx));
-      /*<<bigarray.ml:104:35>>*/ return _a_;
+      /*<<bigarray.ml:104:35>>*/ return sentinal;
     }
      /*<<bigarray.ml:105:27>>*/ var
-      /*<<bigarray.ml:105:27>>*/ _an_ =
+      /*<<bigarray.ml:105:27>>*/ _am_ =
        caml_check_bound(max, col)[1 + col] - 1 | 0,
-      /*<<bigarray.ml:105:9>>*/ _am_ = 0;
-    if(_an_ >= 0){
-     var j = _am_;
+      /*<<bigarray.ml:105:9>>*/ _al_ = 0;
+    if(_am_ >= 0){
+     var j = _al_;
      for(;;){
        /*<<bigarray.ml:106:11>>*/ caml_check_bound(idx, col)[1 + col] = j;
        /*<<bigarray.ml:107:11>>*/ cloop(arr, idx, f, col + 1 | 0, max);
        /*<<bigarray.ml:107:11>>*/  /*<<bigarray.ml:107:11>>*/ var
-       _ao_ = j + 1 | 0;
-      if(_an_ === j) break;
-      var j = _ao_;
+       _an_ = j + 1 | 0;
+      if(_am_ === j) break;
+      var j = _an_;
      }
     }
-    return _a_;
+    return sentinal;
     /*<<bigarray.ml:108:13>>*/ }
    function floop(arr, idx, f, col, max){
      /*<<bigarray.ml:110:4>>*/ if(0 > col){
       /*<<bigarray.ml:110:20>>*/  /*<<bigarray.ml:110:20>>*/ caml_ba_set_generic
       (arr, idx,  /*<<bigarray.ml:110:32>>*/ caml_call1(f, idx));
-      /*<<bigarray.ml:110:20>>*/ return _a_;
+      /*<<bigarray.ml:110:20>>*/ return sentinal;
     }
      /*<<bigarray.ml:111:22>>*/ var
-      /*<<bigarray.ml:111:22>>*/ _ak_ = caml_check_bound(max, col)[1 + col],
-      /*<<bigarray.ml:111:9>>*/ _aj_ = 1;
-    if(_ak_ >= 1){
-     var j = _aj_;
+      /*<<bigarray.ml:111:22>>*/ _aj_ = caml_check_bound(max, col)[1 + col],
+      /*<<bigarray.ml:111:9>>*/ _ai_ = 1;
+    if(_aj_ >= 1){
+     var j = _ai_;
      for(;;){
        /*<<bigarray.ml:112:11>>*/ caml_check_bound(idx, col)[1 + col] = j;
        /*<<bigarray.ml:113:11>>*/ floop(arr, idx, f, col - 1 | 0, max);
        /*<<bigarray.ml:113:11>>*/  /*<<bigarray.ml:113:11>>*/ var
-       _al_ = j + 1 | 0;
-      if(_ak_ === j) break;
-      var j = _al_;
+       _ak_ = j + 1 | 0;
+      if(_aj_ === j) break;
+      var j = _ak_;
      }
     }
-    return _a_;
+    return sentinal;
     /*<<bigarray.ml:114:13>>*/ }
    function init(kind, layout, dims, f){
      /*<<bigarray.ml:116:4>>*/ var
@@ -22167,31 +22175,31 @@
         /*<<bigarray.ml:125:12>>*/ caml_ba_num_dims(a),
       /*<<bigarray.ml:126:12>>*/ d =
         /*<<bigarray.ml:126:12>>*/ caml_make_vect(n, 0),
-      /*<<bigarray.ml:127:4>>*/ _ag_ = n - 1 | 0,
-      /*<<bigarray.ml:126:12>>*/ _af_ = 0;
-    if(_ag_ >= 0){
-     var i = _af_;
+      /*<<bigarray.ml:127:4>>*/ _af_ = n - 1 | 0,
+      /*<<bigarray.ml:126:12>>*/ _ae_ = 0;
+    if(_af_ >= 0){
+     var i = _ae_;
      for(;;){
        /*<<bigarray.ml:127:33>>*/  /*<<bigarray.ml:127:33>>*/ var
-       _ah_ =  /*<<bigarray.ml:127:33>>*/ runtime.caml_ba_dim(a, i);
-       /*<<bigarray.ml:127:24>>*/ caml_check_bound(d, i)[1 + i] = _ah_;
+       _ag_ =  /*<<bigarray.ml:127:33>>*/ runtime.caml_ba_dim(a, i);
+       /*<<bigarray.ml:127:24>>*/ caml_check_bound(d, i)[1 + i] = _ag_;
        /*<<bigarray.ml:127:24>>*/  /*<<bigarray.ml:127:24>>*/ var
-       _ai_ = i + 1 | 0;
-      if(_ag_ === i) break;
-      var i = _ai_;
+       _ah_ = i + 1 | 0;
+      if(_af_ === i) break;
+      var i = _ah_;
      }
     }
      /*<<bigarray.ml:128:4>>*/ return d;
     /*<<bigarray.ml:128:5>>*/ }
    function size_in_bytes(arr){
      /*<<bigarray.ml:136:4>>*/ var
-      /*<<bigarray.ml:136:63>>*/ _ad_ = dims(arr),
-      /*<<bigarray.ml:136:38>>*/ _ae_ =
+      /*<<bigarray.ml:136:63>>*/ _ac_ = dims(arr),
+      /*<<bigarray.ml:136:38>>*/ _ad_ =
         /*<<bigarray.ml:136:38>>*/ caml_call3
-        (Stdlib_Array[15], caml_mul, 1, _ad_);
+        (Stdlib_Array[15], caml_mul, 1, _ac_);
      /*<<bigarray.ml:136:4>>*/ return  /*<<bigarray.ml:136:4>>*/ caml_mul
             (kind_size_in_bytes( /*<<bigarray.ml:136:24>>*/ caml_ba_kind(arr)),
-             _ae_);
+             _ad_);
     /*<<bigarray.ml:136:74>>*/ }
    function create(kind, layout){
      /*<<bigarray.ml:157:4>>*/ return  /*<<bigarray.ml:157:4>>*/ caml_ba_create
@@ -22202,9 +22210,9 @@
             (arr, [0]);
     /*<<bigarray.ml:158:37>>*/ }
    function set(arr){
-     /*<<bigarray.ml:159:16>>*/  /*<<bigarray.ml:159:16>>*/ var _ab_ = [0];
-     /*<<bigarray.ml:159:33>>*/ return function(_ac_){
-      /*<<?>>*/ return caml_ba_set_generic(arr, _ab_, _ac_);};
+     /*<<bigarray.ml:159:16>>*/  /*<<bigarray.ml:159:16>>*/ var _aa_ = [0];
+     /*<<bigarray.ml:159:33>>*/ return function(_ab_){
+      /*<<?>>*/ return caml_ba_set_generic(arr, _aa_, _ab_);};
     /*<<bigarray.ml:159:37>>*/ }
    function size_in_bytes$0(arr){
      /*<<bigarray.ml:166:26>>*/ return kind_size_in_bytes
@@ -22222,10 +22230,10 @@
     /*<<bigarray.ml:181:39>>*/ }
    function size_in_bytes$1(arr){
      /*<<bigarray.ml:195:4>>*/  /*<<bigarray.ml:195:38>>*/ var
-     _aa_ =  /*<<bigarray.ml:195:38>>*/ caml_ba_dim_1(arr);
+     _$_ =  /*<<bigarray.ml:195:38>>*/ caml_ba_dim_1(arr);
      /*<<bigarray.ml:195:4>>*/ return  /*<<bigarray.ml:195:4>>*/ caml_mul
             (kind_size_in_bytes( /*<<bigarray.ml:195:24>>*/ caml_ba_kind(arr)),
-             _aa_);
+             _$_);
     /*<<bigarray.ml:195:47>>*/ }
    function slice(a, n){
      /*<<bigarray.ml:199:4>>*/ return  /*<<bigarray.ml:199:10>>*/ runtime.caml_ba_layout
@@ -22237,32 +22245,32 @@
      /*<<bigarray.ml:209:4>>*/  /*<<bigarray.ml:209:14>>*/ var
      arr = create$0(kind, layout, dim);
      /*<<bigarray.ml:210:4>>*/ if(layout){
-      /*<<bigarray.ml:207:4>>*/  /*<<bigarray.ml:207:4>>*/ var ___ = 1;
+      /*<<bigarray.ml:207:4>>*/  /*<<bigarray.ml:207:4>>*/ var _Z_ = 1;
      if(dim >= 1){
-      var i$0 = ___;
+      var i$0 = _Z_;
       for(;;){
         /*<<bigarray.ml:207:24>>*/  /*<<bigarray.ml:207:24>>*/ caml_ba_set_1
         (arr, i$0,  /*<<bigarray.ml:207:41>>*/ caml_call1(f, i$0));
         /*<<bigarray.ml:207:24>>*/  /*<<bigarray.ml:207:24>>*/ var
-        _$_ = i$0 + 1 | 0;
+        ___ = i$0 + 1 | 0;
        if(dim === i$0) break;
-       var i$0 = _$_;
+       var i$0 = ___;
       }
      }
       /*<<bigarray.ml:212:24>>*/ return arr;
     }
      /*<<bigarray.ml:205:4>>*/ var
-     _Y_ = dim - 1 | 0,
-      /*<<bigarray.ml:205:4>>*/ _X_ = 0;
-    if(_Y_ >= 0){
-     var i = _X_;
+     _X_ = dim - 1 | 0,
+      /*<<bigarray.ml:205:4>>*/ _W_ = 0;
+    if(_X_ >= 0){
+     var i = _W_;
      for(;;){
        /*<<bigarray.ml:205:29>>*/  /*<<bigarray.ml:205:29>>*/ caml_ba_set_1
        (arr, i,  /*<<bigarray.ml:205:46>>*/ caml_call1(f, i));
        /*<<bigarray.ml:205:29>>*/  /*<<bigarray.ml:205:29>>*/ var
-       _Z_ = i + 1 | 0;
-      if(_Y_ === i) break;
-      var i = _Z_;
+       _Y_ = i + 1 | 0;
+      if(_X_ === i) break;
+      var i = _Y_;
      }
     }
      /*<<bigarray.ml:211:18>>*/ return arr;
@@ -22271,17 +22279,17 @@
      /*<<bigarray.ml:214:4>>*/ var
       /*<<bigarray.ml:214:13>>*/ ba = create$0(kind, layout, data.length - 1),
       /*<<bigarray.ml:215:4>>*/ ofs = layout ? 1 : 0,
-     _V_ = data.length - 1 - 1 | 0,
-     _U_ = 0;
-    if(_V_ >= 0){
-     var i = _U_;
+     _U_ = data.length - 1 - 1 | 0,
+     _T_ = 0;
+    if(_U_ >= 0){
+     var i = _T_;
      for(;;){
        /*<<bigarray.ml:220:42>>*/  /*<<bigarray.ml:220:42>>*/ caml_ba_set_1
        (ba, i + ofs | 0, caml_check_bound(data, i)[1 + i]);
        /*<<bigarray.ml:220:42>>*/  /*<<bigarray.ml:220:42>>*/ var
-       _W_ = i + 1 | 0;
-      if(_V_ === i) break;
-      var i = _W_;
+       _V_ = i + 1 | 0;
+      if(_U_ === i) break;
+      var i = _V_;
      }
     }
      /*<<bigarray.ml:221:4>>*/ return ba;
@@ -22292,16 +22300,16 @@
     /*<<bigarray.ml:227:46>>*/ }
    function size_in_bytes$2(arr){
      /*<<bigarray.ml:243:4>>*/ var
-      /*<<bigarray.ml:243:51>>*/ _S_ =
+      /*<<bigarray.ml:243:51>>*/ _R_ =
         /*<<bigarray.ml:243:51>>*/ caml_ba_dim_2(arr),
-      /*<<bigarray.ml:243:38>>*/ _T_ =
+      /*<<bigarray.ml:243:38>>*/ _S_ =
         /*<<bigarray.ml:243:38>>*/ caml_ba_dim_1(arr);
     return caml_mul
             ( /*<<bigarray.ml:243:4>>*/ caml_mul
               (kind_size_in_bytes
                 ( /*<<bigarray.ml:243:24>>*/ caml_ba_kind(arr)),
-               _T_),
-             _S_);
+               _S_),
+             _R_);
     /*<<bigarray.ml:243:61>>*/ }
    function slice_left(a, n){
      /*<<bigarray.ml:250:23>>*/ return  /*<<bigarray.ml:250:23>>*/ caml_ba_slice
@@ -22315,54 +22323,54 @@
      /*<<bigarray.ml:267:4>>*/  /*<<bigarray.ml:267:14>>*/ var
      arr = create$1(kind, layout, dim1, dim2);
      /*<<bigarray.ml:268:4>>*/ if(layout){
-      /*<<bigarray.ml:261:4>>*/  /*<<bigarray.ml:261:4>>*/ var _O_ = 1;
+      /*<<bigarray.ml:261:4>>*/  /*<<bigarray.ml:261:4>>*/ var _N_ = 1;
      if(dim2 >= 1){
-      var j$0 = _O_;
+      var j$0 = _N_;
       for(;;){
-        /*<<bigarray.ml:262:6>>*/  /*<<bigarray.ml:262:6>>*/ var _P_ = 1;
+        /*<<bigarray.ml:262:6>>*/  /*<<bigarray.ml:262:6>>*/ var _O_ = 1;
        if(dim1 >= 1){
-        var i$0 = _P_;
+        var i$0 = _O_;
         for(;;){
           /*<<bigarray.ml:263:8>>*/  /*<<bigarray.ml:263:8>>*/ caml_ba_set_2
           (arr, i$0, j$0,  /*<<bigarray.ml:263:27>>*/ caml_call2(f, i$0, j$0));
           /*<<bigarray.ml:263:8>>*/  /*<<bigarray.ml:263:8>>*/ var
-          _R_ = i$0 + 1 | 0;
+          _Q_ = i$0 + 1 | 0;
          if(dim1 === i$0) break;
-         var i$0 = _R_;
+         var i$0 = _Q_;
         }
        }
         /*<<bigarray.ml:261:4>>*/  /*<<bigarray.ml:261:4>>*/ var
-        _Q_ = j$0 + 1 | 0;
+        _P_ = j$0 + 1 | 0;
        if(dim2 === j$0) break;
-       var j$0 = _Q_;
+       var j$0 = _P_;
       }
      }
       /*<<bigarray.ml:270:24>>*/ return arr;
     }
      /*<<bigarray.ml:255:4>>*/ var
-     _J_ = dim1 - 1 | 0,
-      /*<<bigarray.ml:255:4>>*/ _I_ = 0;
-    if(_J_ >= 0){
-     var i = _I_;
+     _I_ = dim1 - 1 | 0,
+      /*<<bigarray.ml:255:4>>*/ _H_ = 0;
+    if(_I_ >= 0){
+     var i = _H_;
      for(;;){
        /*<<bigarray.ml:256:6>>*/ var
-       _L_ = dim2 - 1 | 0,
-        /*<<bigarray.ml:256:6>>*/ _K_ = 0;
-      if(_L_ >= 0){
-       var j = _K_;
+       _K_ = dim2 - 1 | 0,
+        /*<<bigarray.ml:256:6>>*/ _J_ = 0;
+      if(_K_ >= 0){
+       var j = _J_;
        for(;;){
          /*<<bigarray.ml:257:8>>*/  /*<<bigarray.ml:257:8>>*/ caml_ba_set_2
          (arr, i, j,  /*<<bigarray.ml:257:27>>*/ caml_call2(f, i, j));
          /*<<bigarray.ml:257:8>>*/  /*<<bigarray.ml:257:8>>*/ var
-         _N_ = j + 1 | 0;
-        if(_L_ === j) break;
-        var j = _N_;
+         _M_ = j + 1 | 0;
+        if(_K_ === j) break;
+        var j = _M_;
        }
       }
        /*<<bigarray.ml:255:4>>*/  /*<<bigarray.ml:255:4>>*/ var
-       _M_ = i + 1 | 0;
-      if(_J_ === i) break;
-      var i = _M_;
+       _L_ = i + 1 | 0;
+      if(_I_ === i) break;
+      var i = _L_;
      }
     }
      /*<<bigarray.ml:269:18>>*/ return arr;
@@ -22374,10 +22382,10 @@
        0 === dim1 ? 0 : caml_check_bound(data, 0)[1].length - 1,
       /*<<bigarray.ml:274:13>>*/ ba = create$1(kind, layout, dim1, dim2),
       /*<<bigarray.ml:275:4>>*/ ofs = layout ? 1 : 0,
-      /*<<bigarray.ml:280:4>>*/ _D_ = dim1 - 1 | 0,
-     _C_ = 0;
-    if(_D_ >= 0){
-     var i = _C_;
+      /*<<bigarray.ml:280:4>>*/ _C_ = dim1 - 1 | 0,
+     _B_ = 0;
+    if(_C_ >= 0){
+     var i = _B_;
      for(;;){
        /*<<bigarray.ml:281:16>>*/  /*<<bigarray.ml:281:16>>*/ var
        row = caml_check_bound(data, i)[1 + i];
@@ -22385,23 +22393,23 @@
         /*<<bigarray.ml:283:8>>*/  /*<<bigarray.ml:283:8>>*/ caml_call1
         (Stdlib[1], cst_Bigarray_Array2_of_array_n);
        /*<<bigarray.ml:273:32>>*/ var
-        /*<<bigarray.ml:273:32>>*/ _F_ = dim2 - 1 | 0,
-        /*<<bigarray.ml:283:8>>*/ _E_ = 0;
-      if(_F_ >= 0){
-       var j = _E_;
+        /*<<bigarray.ml:273:32>>*/ _E_ = dim2 - 1 | 0,
+        /*<<bigarray.ml:283:8>>*/ _D_ = 0;
+      if(_E_ >= 0){
+       var j = _D_;
        for(;;){
          /*<<bigarray.ml:285:8>>*/  /*<<bigarray.ml:285:8>>*/ caml_ba_set_2
          (ba, i + ofs | 0, j + ofs | 0, caml_check_bound(row, j)[1 + j]);
          /*<<bigarray.ml:285:8>>*/  /*<<bigarray.ml:285:8>>*/ var
-         _H_ = j + 1 | 0;
-        if(_F_ === j) break;
-        var j = _H_;
+         _G_ = j + 1 | 0;
+        if(_E_ === j) break;
+        var j = _G_;
        }
       }
        /*<<bigarray.ml:280:4>>*/  /*<<bigarray.ml:280:4>>*/ var
-       _G_ = i + 1 | 0;
-      if(_D_ === i) break;
-      var i = _G_;
+       _F_ = i + 1 | 0;
+      if(_C_ === i) break;
+      var i = _F_;
      }
     }
      /*<<bigarray.ml:288:4>>*/ return ba;
@@ -22412,20 +22420,20 @@
     /*<<bigarray.ml:294:52>>*/ }
    function size_in_bytes$3(arr){
      /*<<bigarray.ml:312:4>>*/ var
-      /*<<bigarray.ml:312:64>>*/ _z_ =
+      /*<<bigarray.ml:312:64>>*/ _y_ =
         /*<<bigarray.ml:312:64>>*/ runtime.caml_ba_dim_3(arr),
-      /*<<bigarray.ml:312:51>>*/ _A_ =
+      /*<<bigarray.ml:312:51>>*/ _z_ =
         /*<<bigarray.ml:312:51>>*/ caml_ba_dim_2(arr),
-      /*<<bigarray.ml:312:38>>*/ _B_ =
+      /*<<bigarray.ml:312:38>>*/ _A_ =
         /*<<bigarray.ml:312:38>>*/ caml_ba_dim_1(arr);
     return caml_mul
             (caml_mul
               ( /*<<bigarray.ml:312:4>>*/ caml_mul
                 (kind_size_in_bytes
                   ( /*<<bigarray.ml:312:24>>*/ caml_ba_kind(arr)),
-                 _B_),
-               _A_),
-             _z_);
+                 _A_),
+               _z_),
+             _y_);
     /*<<bigarray.ml:312:74>>*/ }
    function slice_left_1(a, n, m){
      /*<<bigarray.ml:319:27>>*/ return  /*<<bigarray.ml:319:27>>*/ caml_ba_slice
@@ -22447,17 +22455,17 @@
      /*<<bigarray.ml:342:4>>*/  /*<<bigarray.ml:342:14>>*/ var
      arr = create$2(kind, layout, dim1, dim2, dim3);
      /*<<bigarray.ml:343:4>>*/ if(layout){
-      /*<<bigarray.ml:334:4>>*/  /*<<bigarray.ml:334:4>>*/ var _t_ = 1;
+      /*<<bigarray.ml:334:4>>*/  /*<<bigarray.ml:334:4>>*/ var _s_ = 1;
      if(dim3 >= 1){
-      var k$0 = _t_;
+      var k$0 = _s_;
       for(;;){
-        /*<<bigarray.ml:335:6>>*/  /*<<bigarray.ml:335:6>>*/ var _u_ = 1;
+        /*<<bigarray.ml:335:6>>*/  /*<<bigarray.ml:335:6>>*/ var _t_ = 1;
        if(dim2 >= 1){
-        var j$0 = _u_;
+        var j$0 = _t_;
         for(;;){
-          /*<<bigarray.ml:336:8>>*/  /*<<bigarray.ml:336:8>>*/ var _w_ = 1;
+          /*<<bigarray.ml:336:8>>*/  /*<<bigarray.ml:336:8>>*/ var _v_ = 1;
          if(dim1 >= 1){
-          var i$0 = _w_;
+          var i$0 = _v_;
           for(;;){
             /*<<bigarray.ml:337:10>>*/  /*<<bigarray.ml:337:10>>*/ caml_ba_set_3
             (arr,
@@ -22466,61 +22474,61 @@
              k$0,
               /*<<bigarray.ml:337:31>>*/ caml_call3(f, i$0, j$0, k$0));
             /*<<bigarray.ml:337:10>>*/  /*<<bigarray.ml:337:10>>*/ var
-            _y_ = i$0 + 1 | 0;
+            _x_ = i$0 + 1 | 0;
            if(dim1 === i$0) break;
-           var i$0 = _y_;
+           var i$0 = _x_;
           }
          }
           /*<<bigarray.ml:335:6>>*/  /*<<bigarray.ml:335:6>>*/ var
-          _x_ = j$0 + 1 | 0;
+          _w_ = j$0 + 1 | 0;
          if(dim2 === j$0) break;
-         var j$0 = _x_;
+         var j$0 = _w_;
         }
        }
         /*<<bigarray.ml:334:4>>*/  /*<<bigarray.ml:334:4>>*/ var
-        _v_ = k$0 + 1 | 0;
+        _u_ = k$0 + 1 | 0;
        if(dim3 === k$0) break;
-       var k$0 = _v_;
+       var k$0 = _u_;
       }
      }
       /*<<bigarray.ml:345:24>>*/ return arr;
     }
      /*<<bigarray.ml:326:4>>*/ var
-     _l_ = dim1 - 1 | 0,
-      /*<<bigarray.ml:326:4>>*/ _k_ = 0;
-    if(_l_ >= 0){
-     var i = _k_;
+     _k_ = dim1 - 1 | 0,
+      /*<<bigarray.ml:326:4>>*/ _j_ = 0;
+    if(_k_ >= 0){
+     var i = _j_;
      for(;;){
        /*<<bigarray.ml:327:6>>*/ var
-       _n_ = dim2 - 1 | 0,
-        /*<<bigarray.ml:327:6>>*/ _m_ = 0;
-      if(_n_ >= 0){
-       var j = _m_;
+       _m_ = dim2 - 1 | 0,
+        /*<<bigarray.ml:327:6>>*/ _l_ = 0;
+      if(_m_ >= 0){
+       var j = _l_;
        for(;;){
          /*<<bigarray.ml:328:8>>*/ var
-         _q_ = dim3 - 1 | 0,
-          /*<<bigarray.ml:328:8>>*/ _p_ = 0;
-        if(_q_ >= 0){
-         var k = _p_;
+         _p_ = dim3 - 1 | 0,
+          /*<<bigarray.ml:328:8>>*/ _o_ = 0;
+        if(_p_ >= 0){
+         var k = _o_;
          for(;;){
            /*<<bigarray.ml:329:10>>*/  /*<<bigarray.ml:329:10>>*/ caml_ba_set_3
            (arr, i, j, k,  /*<<bigarray.ml:329:31>>*/ caml_call3(f, i, j, k));
            /*<<bigarray.ml:329:10>>*/  /*<<bigarray.ml:329:10>>*/ var
-           _s_ = k + 1 | 0;
-          if(_q_ === k) break;
-          var k = _s_;
+           _r_ = k + 1 | 0;
+          if(_p_ === k) break;
+          var k = _r_;
          }
         }
          /*<<bigarray.ml:327:6>>*/  /*<<bigarray.ml:327:6>>*/ var
-         _r_ = j + 1 | 0;
-        if(_n_ === j) break;
-        var j = _r_;
+         _q_ = j + 1 | 0;
+        if(_m_ === j) break;
+        var j = _q_;
        }
       }
        /*<<bigarray.ml:326:4>>*/  /*<<bigarray.ml:326:4>>*/ var
-       _o_ = i + 1 | 0;
-      if(_l_ === i) break;
-      var i = _o_;
+       _n_ = i + 1 | 0;
+      if(_k_ === i) break;
+      var i = _n_;
      }
     }
      /*<<bigarray.ml:344:18>>*/ return arr;
@@ -22536,10 +22544,10 @@
         : caml_check_bound(caml_check_bound(data, 0)[1], 0)[1].length - 1,
       /*<<bigarray.ml:350:13>>*/ ba = create$2(kind, layout, dim1, dim2, dim3),
       /*<<bigarray.ml:351:4>>*/ ofs = layout ? 1 : 0,
-      /*<<bigarray.ml:356:4>>*/ _c_ = dim1 - 1 | 0,
-     _b_ = 0;
-    if(_c_ >= 0){
-     var i = _b_;
+      /*<<bigarray.ml:356:4>>*/ _b_ = dim1 - 1 | 0,
+     _a_ = 0;
+    if(_b_ >= 0){
+     var i = _a_;
      for(;;){
        /*<<bigarray.ml:357:16>>*/  /*<<bigarray.ml:357:16>>*/ var
        row = caml_check_bound(data, i)[1 + i];
@@ -22547,10 +22555,10 @@
         /*<<bigarray.ml:359:8>>*/  /*<<bigarray.ml:359:8>>*/ caml_call1
         (Stdlib[1], cst_Bigarray_Array3_of_array_n);
        /*<<bigarray.ml:348:32>>*/ var
-        /*<<bigarray.ml:348:32>>*/ _e_ = dim2 - 1 | 0,
-        /*<<bigarray.ml:359:8>>*/ _d_ = 0;
-      if(_e_ >= 0){
-       var j = _d_;
+        /*<<bigarray.ml:348:32>>*/ _d_ = dim2 - 1 | 0,
+        /*<<bigarray.ml:359:8>>*/ _c_ = 0;
+      if(_d_ >= 0){
+       var j = _c_;
        for(;;){
          /*<<bigarray.ml:361:18>>*/  /*<<bigarray.ml:361:18>>*/ var
          col = caml_check_bound(row, j)[1 + j];
@@ -22558,10 +22566,10 @@
           /*<<bigarray.ml:363:10>>*/  /*<<bigarray.ml:363:10>>*/ caml_call1
           (Stdlib[1], cst_Bigarray_Array3_of_array_n$0);
          /*<<bigarray.ml:349:32>>*/ var
-          /*<<bigarray.ml:349:32>>*/ _h_ = dim3 - 1 | 0,
-          /*<<bigarray.ml:363:10>>*/ _g_ = 0;
-        if(_h_ >= 0){
-         var k = _g_;
+          /*<<bigarray.ml:349:32>>*/ _g_ = dim3 - 1 | 0,
+          /*<<bigarray.ml:363:10>>*/ _f_ = 0;
+        if(_g_ >= 0){
+         var k = _f_;
          for(;;){
            /*<<bigarray.ml:365:10>>*/  /*<<bigarray.ml:365:10>>*/ caml_ba_set_3
            (ba,
@@ -22570,21 +22578,21 @@
             k + ofs | 0,
             caml_check_bound(col, k)[1 + k]);
            /*<<bigarray.ml:365:10>>*/  /*<<bigarray.ml:365:10>>*/ var
-           _j_ = k + 1 | 0;
-          if(_h_ === k) break;
-          var k = _j_;
+           _i_ = k + 1 | 0;
+          if(_g_ === k) break;
+          var k = _i_;
          }
         }
          /*<<bigarray.ml:359:8>>*/  /*<<bigarray.ml:359:8>>*/ var
-         _i_ = j + 1 | 0;
-        if(_e_ === j) break;
-        var j = _i_;
+         _h_ = j + 1 | 0;
+        if(_d_ === j) break;
+        var j = _h_;
        }
       }
        /*<<bigarray.ml:356:4>>*/  /*<<bigarray.ml:356:4>>*/ var
-       _f_ = i + 1 | 0;
-      if(_c_ === i) break;
-      var i = _f_;
+       _e_ = i + 1 | 0;
+      if(_b_ === i) break;
+      var i = _e_;
      }
     }
      /*<<bigarray.ml:369:4>>*/ return ba;
@@ -24163,13 +24171,13 @@
             : runtime.caml_call_gen(f, [a0, a1, a2, a3, a4]);
    }
    var
+    sentinal = undefined,
     global_data = runtime.caml_get_global_data(),
     Stdlib = global_data.Stdlib,
     Stdlib_Sys = global_data.Stdlib__Sys,
     Stdlib_Int = global_data.Stdlib__Int,
     Stdlib_Array = global_data.Stdlib__Array,
     Stdlib_Obj = global_data.Stdlib__Obj,
-    _a_ = undefined,
     cst_Weak_Make_hash_bucket_cann = "Weak.Make: hash bucket cannot grow more",
     cst_Weak_fill = "Weak.fill",
     cst_Weak_blit = "Weak.blit",
@@ -24180,9 +24188,9 @@
     cst_Weak_create = "Weak.create";
    function create(l){
      /*<<weak.ml:28:2>>*/ var
-     _X_ = 0 <= l ? 1 : 0,
-     _Y_ = _X_ ? l <= Stdlib_Obj[24][15] ? 1 : 0 : _X_;
-    if(1 - _Y_)
+     _W_ = 0 <= l ? 1 : 0,
+     _X_ = _W_ ? l <= Stdlib_Obj[24][15] ? 1 : 0 : _W_;
+    if(1 - _X_)
       /*<<weak.ml:29:4>>*/  /*<<weak.ml:29:4>>*/ caml_call1
       (Stdlib[1], cst_Weak_create);
      /*<<weak.ml:30:2>>*/ return  /*<<weak.ml:30:2>>*/ runtime.caml_weak_create
@@ -24193,10 +24201,12 @@
     /*<<weak.ml:33:55>>*/ }
    function raise_if_invalid_offset(e, o, msg){
      /*<<weak.ml:36:2>>*/ var
-     _U_ = 0 <= o ? 1 : 0,
-     _V_ = _U_ ? o < length(e) ? 1 : 0 : _U_,
-     _W_ = 1 - _V_;
-    return _W_ ? ( /*<<weak.ml:37:4>>*/ caml_call1(Stdlib[1], msg), _a_) : _W_;
+     _T_ = 0 <= o ? 1 : 0,
+     _U_ = _T_ ? o < length(e) ? 1 : 0 : _T_,
+     _V_ = 1 - _U_;
+    return _V_
+            ? ( /*<<weak.ml:37:4>>*/ caml_call1(Stdlib[1], msg), sentinal)
+            : _V_;
     /*<<weak.ml:37:20>>*/ }
    function set(e, o, x){
      /*<<weak.ml:42:2>>*/ raise_if_invalid_offset(e, o, cst_Weak_set);
@@ -24229,13 +24239,13 @@
        0 <= o1
        && (length(e1) - l | 0) >= o1 && 0 <= o2 && (length(e2) - l | 0) >= o2){
      var
-      _S_ = 0 !== l ? 1 : 0,
-      _T_ =
-        _S_
+      _R_ = 0 !== l ? 1 : 0,
+      _S_ =
+        _R_
          ?  /*<<weak.ml:69:22>>*/ runtime.caml_ephe_blit_key
            (e1, o1, e2, o2, l)
-         : _S_;
-      /*<<weak.ml:69:22>>*/ return _T_;
+         : _R_;
+      /*<<weak.ml:69:22>>*/ return _S_;
     }
      /*<<weak.ml:68:7>>*/ return  /*<<weak.ml:68:7>>*/ caml_call1
             (Stdlib[1], cst_Weak_blit);
@@ -24243,14 +24253,14 @@
    function fill(ar, ofs, len, x){
      /*<<weak.ml:72:2>>*/ if
      (0 <= ofs && 0 <= len && (length(ar) - len | 0) >= ofs){
-     var _Q_ = (ofs + len | 0) - 1 | 0;
-     if(_Q_ >= ofs){
+     var _P_ = (ofs + len | 0) - 1 | 0;
+     if(_P_ >= ofs){
       var i = ofs;
       for(;;){
         /*<<weak.ml:76:6>>*/ set(ar, i, x);
-        /*<<weak.ml:76:6>>*/  /*<<weak.ml:76:6>>*/ var _R_ = i + 1 | 0;
-       if(_Q_ === i) break;
-       var i = _R_;
+        /*<<weak.ml:76:6>>*/  /*<<weak.ml:76:6>>*/ var _Q_ = i + 1 | 0;
+       if(_P_ === i) break;
+       var i = _Q_;
       }
      }
      return 0;
@@ -24278,16 +24288,16 @@
      /*<<weak.ml:131:5>>*/ }
     function clear(t){
       /*<<weak.ml:134:4>>*/ var
-      _O_ = t[1].length - 1 - 1 | 0,
-       /*<<weak.ml:134:4>>*/ _N_ = 0;
-     if(_O_ >= 0){
-      var i = _N_;
+      _N_ = t[1].length - 1 - 1 | 0,
+       /*<<weak.ml:134:4>>*/ _M_ = 0;
+     if(_N_ >= 0){
+      var i = _M_;
       for(;;){
         /*<<weak.ml:135:6>>*/ caml_check_bound(t[1], i)[1 + i] = emptybucket;
         /*<<weak.ml:136:6>>*/ caml_check_bound(t[2], i)[1 + i] = [0];
-        /*<<weak.ml:136:6>>*/  /*<<weak.ml:136:6>>*/ var _P_ = i + 1 | 0;
-       if(_O_ === i) break;
-       var i = _P_;
+        /*<<weak.ml:136:6>>*/  /*<<weak.ml:136:6>>*/ var _O_ = i + 1 | 0;
+       if(_N_ === i) break;
+       var i = _O_;
       }
      }
      t[3] = limit;
@@ -24295,8 +24305,8 @@
      return 0;
      /*<<weak.ml:139:19>>*/ }
     function fold(f, t, init){
-      /*<<weak.ml:143:4>>*/ var _L_ = t[1], i = 0;
-      /*<<weak.ml:149:21>>*/ function _M_(b, accu$1){
+      /*<<weak.ml:143:4>>*/ var _K_ = t[1], i = 0;
+      /*<<weak.ml:149:21>>*/ function _L_(b, accu$1){
       var i$0 = i, accu = accu$1;
        /*<<weak.ml:144:6>>*/ for(;;){
        if(length(b) <= i$0)  /*<<weak.ml:144:28>>*/ return accu;
@@ -24315,11 +24325,11 @@
       }
      }
       /*<<weak.ml:149:4>>*/ return  /*<<weak.ml:149:4>>*/ caml_call3
-             (Stdlib_Array[17], _M_, _L_, init);
+             (Stdlib_Array[17], _L_, _K_, init);
      /*<<weak.ml:149:49>>*/ }
     function iter(f, t){
-      /*<<weak.ml:153:4>>*/ var _J_ = t[1], i = 0;
-      /*<<weak.ml:159:15>>*/ function _K_(b){
+      /*<<weak.ml:153:4>>*/ var _I_ = t[1], i = 0;
+      /*<<weak.ml:159:15>>*/ function _J_(b){
       var i$0 = i;
        /*<<weak.ml:154:6>>*/ for(;;){
        if(length(b) <= i$0)  /*<<weak.ml:154:28>>*/ return 0;
@@ -24335,15 +24345,15 @@
       }
      }
       /*<<weak.ml:159:15>>*/ return  /*<<weak.ml:159:15>>*/ caml_call2
-             (Stdlib_Array[11], _K_, _J_);
+             (Stdlib_Array[11], _J_, _I_);
      /*<<weak.ml:159:38>>*/ }
     function count_bucket(i, b, accu){
       /*<<weak.ml:173:4>>*/ var i$0 = i, accu$0 = accu;
       /*<<weak.ml:173:4>>*/ for(;;){
       if(length(b) <= i$0)  /*<<weak.ml:173:26>>*/ return accu$0;
        /*<<weak.ml:174:37>>*/ var
-        /*<<weak.ml:174:37>>*/ _I_ = check(b, i$0) ? 1 : 0,
-       accu$1 = accu$0 + _I_ | 0,
+        /*<<weak.ml:174:37>>*/ _H_ = check(b, i$0) ? 1 : 0,
+       accu$1 = accu$0 + _H_ | 0,
        i$1 = i$0 + 1 | 0,
        i$0 = i$1,
        accu$0 = accu$1;
@@ -24351,14 +24361,14 @@
      /*<<weak.ml:174:62>>*/ }
     function count(t){
       /*<<weak.ml:178:4>>*/ var
-       /*<<weak.ml:178:4>>*/ _C_ = 0,
-      _D_ = t[1],
-      _E_ = 0;
-      /*<<weak.ml:178:21>>*/ function _F_(_G_, _H_){
-       /*<<?>>*/ return count_bucket(_E_, _G_, _H_);
+       /*<<weak.ml:178:4>>*/ _B_ = 0,
+      _C_ = t[1],
+      _D_ = 0;
+      /*<<weak.ml:178:21>>*/ function _E_(_F_, _G_){
+       /*<<?>>*/ return count_bucket(_D_, _F_, _G_);
      }
       /*<<weak.ml:178:4>>*/ return  /*<<weak.ml:178:4>>*/ caml_call3
-             (Stdlib_Array[17], _F_, _D_, _C_);
+             (Stdlib_Array[17], _E_, _C_, _B_);
      /*<<weak.ml:178:47>>*/ }
     function add_aux(t, setter, d, h, index){
       /*<<weak.ml:238:4>>*/ var
@@ -24391,18 +24401,18 @@
         /*<<weak.ml:252:8>>*/ caml_check_bound(newhashes, sz)[1 + sz] = h;
         /*<<weak.ml:253:8>>*/ caml_check_bound(t[1], index)[1 + index] = newbucket$0;
         /*<<weak.ml:254:8>>*/ caml_check_bound(t[2], index)[1 + index] = newhashes;
-       var _y_ = sz <= t[3] ? 1 : 0, _z_ = _y_ ? t[3] < newsz ? 1 : 0 : _y_;
-       if(_z_){
+       var _x_ = sz <= t[3] ? 1 : 0, _y_ = _x_ ? t[3] < newsz ? 1 : 0 : _x_;
+       if(_y_){
         t[4] = t[4] + 1 | 0;
         var i$4 = 0;
         for(;;){
           /*<<weak.ml:185:17>>*/ var
-          _o_ = t[5],
+          _n_ = t[5],
            /*<<weak.ml:185:17>>*/ bucket =
-            caml_check_bound(t[1], _o_)[1 + _o_],
-           /*<<weak.ml:186:4>>*/ _p_ = t[5],
+            caml_check_bound(t[1], _n_)[1 + _n_],
+           /*<<weak.ml:186:4>>*/ _o_ = t[5],
            /*<<weak.ml:186:18>>*/ hbucket =
-            caml_check_bound(t[2], _p_)[1 + _p_],
+            caml_check_bound(t[2], _o_)[1 + _o_],
            /*<<weak.ml:187:14>>*/ len = length(bucket),
           prev_len = (((len - 3 | 0) * 2 | 0) + 2 | 0) / 3 | 0,
            /*<<weak.ml:189:15>>*/ live = count_bucket(0, bucket, 0);
@@ -24414,28 +24424,28 @@
            /*<<weak.ml:192:8>>*/ for(;;){
            if(prev_len > j){
             if(0 === prev_len){
+             var _q_ = t[5];
+              /*<<weak.ml:203:8>>*/ caml_check_bound(t[1], _q_)[1 + _q_] = emptybucket;
              var _r_ = t[5];
-              /*<<weak.ml:203:8>>*/ caml_check_bound(t[1], _r_)[1 + _r_] = emptybucket;
-             var _s_ = t[5];
-              /*<<weak.ml:204:8>>*/ caml_check_bound(t[2], _s_)[1 + _s_] = [0];
+              /*<<weak.ml:204:8>>*/ caml_check_bound(t[2], _r_)[1 + _r_] = [0];
             }
             else{
               /*<<weak.ml:206:24>>*/  /*<<weak.ml:206:24>>*/ var
               newbucket = create(prev_len);
               /*<<weak.ml:207:8>>*/ blit(bucket, 0, newbucket, 0, prev_len);
-             var _v_ = t[5];
-              /*<<weak.ml:208:8>>*/ caml_check_bound(t[1], _v_)[1 + _v_] = newbucket;
+             var _u_ = t[5];
+              /*<<weak.ml:208:8>>*/ caml_check_bound(t[1], _u_)[1 + _u_] = newbucket;
               /*<<weak.ml:209:30>>*/ var
-               /*<<weak.ml:209:30>>*/ _w_ =
+               /*<<weak.ml:209:30>>*/ _v_ =
                  /*<<weak.ml:209:30>>*/ caml_call3
                  (Stdlib_Array[5], hbucket, 0, prev_len),
-              _x_ = t[5];
-              /*<<weak.ml:209:8>>*/ caml_check_bound(t[2], _x_)[1 + _x_] = _w_;
+              _w_ = t[5];
+              /*<<weak.ml:209:8>>*/ caml_check_bound(t[2], _w_)[1 + _w_] = _v_;
             }
             var
-             _t_ = t[3] < len ? 1 : 0,
-             _u_ = _t_ ? prev_len <= t[3] ? 1 : 0 : _t_;
-            if(_u_) t[4] = t[4] - 1 | 0;
+             _s_ = t[3] < len ? 1 : 0,
+             _t_ = _s_ ? prev_len <= t[3] ? 1 : 0 : _s_;
+            if(_t_) t[4] = t[4] - 1 | 0;
             break;
            }
             /*<<weak.ml:193:13>>*/ if(check(bucket, i$0))
@@ -24443,8 +24453,8 @@
            else if(check(bucket, j)){
              /*<<weak.ml:195:12>>*/ blit(bucket, j, bucket, i$0, 1);
              /*<<weak.ml:196:27>>*/  /*<<weak.ml:196:27>>*/ var
-             _q_ = caml_check_bound(hbucket, j)[1 + j];
-             /*<<weak.ml:196:12>>*/ caml_check_bound(hbucket, i$0)[1 + i$0] = _q_;
+             _p_ = caml_check_bound(hbucket, j)[1 + j];
+             /*<<weak.ml:196:12>>*/ caml_check_bound(hbucket, i$0)[1 + i$0] = _p_;
              /*<<weak.ml:196:12>>*/ var
               /*<<weak.ml:196:12>>*/ j$0 = j - 1 | 0,
              i$2 = i$0 + 1 | 0,
@@ -24459,13 +24469,13 @@
          }
          t[5] = caml_mod(t[5] + 1 | 0, t[1].length - 1);
           /*<<weak.ml:257:38>>*/  /*<<weak.ml:257:38>>*/ var
-          _B_ = i$4 + 1 | 0;
+          _A_ = i$4 + 1 | 0;
          if(2 === i$4) break;
-         var i$4 = _B_;
+         var i$4 = _A_;
         }
        }
-       var _A_ = ((t[1].length - 1) / 2 | 0) < t[4] ? 1 : 0;
-       if(! _A_) return _A_;
+       var _z_ = ((t[1].length - 1) / 2 | 0) < t[4] ? 1 : 0;
+       if(! _z_) return _z_;
         /*<<weak.ml:181:18>>*/ var
         oldlen = t[1].length - 1,
          /*<<weak.ml:181:18>>*/ newlen =
@@ -24476,9 +24486,9 @@
        if(oldlen < newlen){
          /*<<weak.ml:220:17>>*/ var
           /*<<weak.ml:220:17>>*/ newt = create$0(newlen),
-         _m_ = t[1],
+         _l_ = t[1],
          i = 0,
-          /*<<weak.ml:169:16>>*/ _n_ =
+          /*<<weak.ml:169:16>>*/ _m_ =
            function(j, ob){
             var oi = i;
              /*<<weak.ml:164:6>>*/ for(;;){
@@ -24504,7 +24514,7 @@
             }
            };
          /*<<weak.ml:169:16>>*/  /*<<weak.ml:169:16>>*/ caml_call2
-         (Stdlib_Array[12], _n_, _m_);
+         (Stdlib_Array[12], _m_, _l_);
         t[1] = newt[1];
         t[2] = newt[2];
         t[3] = newt[3];
@@ -24665,24 +24675,24 @@
      }
      /*<<weak.ml:337:10>>*/ }
     function remove(t, d){
-      /*<<weak.ml:340:19>>*/  /*<<weak.ml:340:19>>*/ var _l_ = 0;
+      /*<<weak.ml:340:19>>*/  /*<<weak.ml:340:19>>*/ var _k_ = 0;
       /*<<weak.ml:340:19>>*/ return find_shadow
              (t,
               d,
               function(w, i){
                 /*<<weak.ml:340:47>>*/ return set(w, i, 0);
                /*<<weak.ml:340:59>>*/ },
-              _l_);
+              _k_);
      /*<<weak.ml:340:63>>*/ }
     function mem(t, d){
-      /*<<weak.ml:343:16>>*/  /*<<weak.ml:343:16>>*/ var _k_ = 0;
+      /*<<weak.ml:343:16>>*/  /*<<weak.ml:343:16>>*/ var _j_ = 0;
       /*<<weak.ml:343:16>>*/ return find_shadow
              (t,
               d,
               function(w, i){
                 /*<<weak.ml:343:46>>*/ return 1;
                /*<<weak.ml:343:50>>*/ },
-              _k_);
+              _j_);
      /*<<weak.ml:343:57>>*/ }
     function find_all(t, d){
       /*<<weak.ml:347:4>>*/ var
@@ -24732,17 +24742,17 @@
          /*<<weak.ml:369:15>>*/ caml_call2(Stdlib_Array[13], length, t[1]);
       /*<<weak.ml:370:4>>*/  /*<<weak.ml:370:4>>*/ caml_call2
       (Stdlib_Array[30], runtime.caml_int_compare, lens);
-     var _b_ = 0;
-     function _c_(_j_, _i_){ /*<<?>>*/ return _j_ + _i_ | 0;}
+     var _a_ = 0;
+     function _b_(_i_, _h_){ /*<<?>>*/ return _i_ + _h_ | 0;}
       /*<<weak.ml:371:17>>*/ var
        /*<<weak.ml:371:17>>*/ totlen =
-         /*<<weak.ml:371:17>>*/ caml_call3(Stdlib_Array[15], _c_, _b_, lens),
-       /*<<weak.ml:371:17>>*/ _d_ = len - 1 | 0,
-      _f_ = len / 2 | 0,
-       /*<<weak.ml:372:51>>*/ _e_ = caml_check_bound(lens, _d_)[1 + _d_],
-       /*<<weak.ml:372:37>>*/ _g_ = caml_check_bound(lens, _f_)[1 + _f_],
-       /*<<weak.ml:372:27>>*/ _h_ = caml_check_bound(lens, 0)[1];
-      /*<<weak.ml:372:4>>*/ return [0, len, count(t), totlen, _h_, _g_, _e_];
+         /*<<weak.ml:371:17>>*/ caml_call3(Stdlib_Array[15], _b_, _a_, lens),
+       /*<<weak.ml:371:17>>*/ _c_ = len - 1 | 0,
+      _e_ = len / 2 | 0,
+       /*<<weak.ml:372:51>>*/ _d_ = caml_check_bound(lens, _c_)[1 + _c_],
+       /*<<weak.ml:372:37>>*/ _f_ = caml_check_bound(lens, _e_)[1 + _e_],
+       /*<<weak.ml:372:27>>*/ _g_ = caml_check_bound(lens, 0)[1];
+      /*<<weak.ml:372:4>>*/ return [0, len, count(t), totlen, _g_, _f_, _d_];
      /*<<weak.ml:372:64>>*/ }
      /*<<weak.ml:101:66>>*/ return [0,
             create$0,
@@ -24799,7 +24809,7 @@
             : runtime.caml_call_gen(f, [a0, a1, a2, a3]);
    }
    var
-    _m_ = undefined,
+    sentinal = undefined,
     global_data = runtime.caml_get_global_data(),
     cst$14 = ".",
     cst$11 = cst$15,
@@ -24849,25 +24859,25 @@
    function pp_output_string(state, s){
      /*<<format.ml:251:31>>*/ caml_call3
      (state[17], s, 0, caml_ml_string_length(s));
-    return _m_;
+    return sentinal;
     /*<<format.ml:251:72>>*/ }
    function pp_output_newline(state){
      /*<<format.ml:252:30>>*/  /*<<format.ml:252:30>>*/ caml_call1
      (state[19], 0);
-     /*<<format.ml:252:30>>*/ return _m_;
+     /*<<format.ml:252:30>>*/ return sentinal;
     /*<<format.ml:252:53>>*/ }
    function format_pp_text(state, size, text){
      /*<<format.ml:258:2>>*/ state[9] = state[9] - size | 0;
      /*<<format.ml:259:2>>*/ pp_output_string(state, text);
     state[11] = 0;
-    return _m_;
+    return sentinal;
     /*<<format.ml:260:31>>*/ }
    function format_string(state, s){
      /*<<format.ml:264:2>>*/  /*<<format.ml:264:5>>*/ var
-     _bO_ =  /*<<format.ml:264:5>>*/ runtime.caml_string_notequal(s, cst$16);
-     /*<<format.ml:264:5>>*/ return _bO_
-            ? (format_pp_text(state, caml_ml_string_length(s), s), _m_)
-            : _bO_;
+     _bN_ =  /*<<format.ml:264:5>>*/ runtime.caml_string_notequal(s, cst$16);
+     /*<<format.ml:264:5>>*/ return _bN_
+            ? (format_pp_text(state, caml_ml_string_length(s), s), sentinal)
+            : _bN_;
     /*<<format.ml:264:58>>*/ }
    function break_new_line(state, param, width){
     var after = param[3], offset = param[2], before = param[1];
@@ -24884,11 +24894,11 @@
      /*<<format.ml:254:31>>*/  /*<<format.ml:254:31>>*/ caml_call1
      (state[21], n);
      /*<<format.ml:276:2>>*/ format_string(state, after);
-     /*<<format.ml:276:2>>*/ return _m_;
+     /*<<format.ml:276:2>>*/ return sentinal;
    }
    function break_line(state, width){
      /*<<format.ml:281:29>>*/ break_new_line(state, _a_, width);
-     /*<<format.ml:281:29>>*/ return _m_;
+     /*<<format.ml:281:29>>*/ return sentinal;
     /*<<format.ml:281:67>>*/ }
    function break_same_line(state, param){
     var after = param[3], width = param[2], before = param[1];
@@ -24897,7 +24907,7 @@
      /*<<format.ml:253:31>>*/  /*<<format.ml:253:31>>*/ caml_call1
      (state[20], width);
      /*<<format.ml:287:2>>*/ format_string(state, after);
-     /*<<format.ml:287:2>>*/ return _m_;
+     /*<<format.ml:287:2>>*/ return sentinal;
    }
    function format_pp_token(state, size$0, param){
      /*<<?>>*/ if(typeof param === "number")
@@ -24906,7 +24916,7 @@
          /*<<format.ml:348:16>>*/  /*<<format.ml:348:16>>*/ var
          match$3 =
             /*<<format.ml:348:16>>*/ caml_call1(Stdlib_Stack[7], state[3]);
-        if(! match$3)  /*<<format.ml:349:14>>*/ return _m_;
+        if(! match$3)  /*<<format.ml:349:14>>*/ return sentinal;
          /*<<format.ml:351:6>>*/ var
          tabs = match$3[1][1],
           /*<<format.ml:351:6>>*/ add_tab =
@@ -24919,15 +24929,15 @@
                     : [0, x, add_tab(n, l)];
            };
         tabs[1] = add_tab(state[6] - state[9] | 0, tabs[1]);
-        return _m_;
+        return sentinal;
        case 1:
          /*<<format.ml:339:4>>*/  /*<<format.ml:339:4>>*/ caml_call1
          (Stdlib_Stack[5], state[2]);
-         /*<<format.ml:339:4>>*/ return _m_;
+         /*<<format.ml:339:4>>*/ return sentinal;
        case 2:
          /*<<format.ml:345:4>>*/  /*<<format.ml:345:4>>*/ caml_call1
          (Stdlib_Stack[5], state[3]);
-         /*<<format.ml:345:4>>*/ return _m_;
+         /*<<format.ml:345:4>>*/ return sentinal;
        case 3:
          /*<<format.ml:378:16>>*/  /*<<format.ml:378:16>>*/ var
          match$4 =
@@ -24935,38 +24945,38 @@
         if(match$4){
          var width$0 = match$4[1][2];
           /*<<format.ml:380:26>>*/ break_line(state, width$0);
-          /*<<format.ml:380:26>>*/ return _m_;
+          /*<<format.ml:380:26>>*/ return sentinal;
         }
          /*<<format.ml:379:14>>*/ pp_output_newline(state);
-         /*<<format.ml:379:14>>*/ return _m_;
+         /*<<format.ml:379:14>>*/ return sentinal;
        case 4:
-        var _bM_ = state[10] !== (state[6] - state[9] | 0) ? 1 : 0;
-        if(! _bM_) return _bM_;
+        var _bL_ = state[10] !== (state[6] - state[9] | 0) ? 1 : 0;
+        if(! _bL_) return _bL_;
          /*<<format.ml:306:8>>*/  /*<<format.ml:306:8>>*/ var
          match$1 =
             /*<<format.ml:306:8>>*/ caml_call1(Stdlib_Queue[6], state[28]);
-        if(! match$1)  /*<<format.ml:307:12>>*/ return _m_;
+        if(! match$1)  /*<<format.ml:307:12>>*/ return sentinal;
         var match$2 = match$1[1], size = match$2[1], length = match$2[3];
         state[12] = state[12] - length | 0;
         state[9] = state[9] + size | 0;
-        return _m_;
+        return sentinal;
        default:
          /*<<format.ml:419:17>>*/  /*<<format.ml:419:17>>*/ var
          match$5 =
             /*<<format.ml:419:17>>*/ caml_call1(Stdlib_Stack[5], state[5]);
-        if(! match$5)  /*<<format.ml:420:15>>*/ return _m_;
+        if(! match$5)  /*<<format.ml:420:15>>*/ return sentinal;
          /*<<format.ml:422:20>>*/ var
          tag_name = match$5[1],
           /*<<format.ml:422:20>>*/ marker =
             /*<<format.ml:422:20>>*/ caml_call1(state[25], tag_name);
          /*<<format.ml:423:7>>*/ pp_output_string(state, marker);
-         /*<<format.ml:423:7>>*/ return _m_;
+         /*<<format.ml:423:7>>*/ return sentinal;
      }
     switch(param[0]){
       case 0:
        var s = param[1];
         /*<<format.ml:323:4>>*/ format_pp_text(state, size$0, s);
-        /*<<format.ml:323:4>>*/ return _m_;
+        /*<<format.ml:323:4>>*/ return sentinal;
       case 1:
         /*<<format.ml:388:4>>*/ var
         breaks = param[2],
@@ -24975,7 +24985,7 @@
         before = breaks[1],
          /*<<format.ml:389:16>>*/ match$6 =
            /*<<format.ml:389:16>>*/ caml_call1(Stdlib_Stack[7], state[2]);
-       if(! match$6)  /*<<format.ml:390:14>>*/ return _m_;
+       if(! match$6)  /*<<format.ml:390:14>>*/ return sentinal;
        var
         match$7 = match$6[1],
         width$1 = match$7[2],
@@ -24983,24 +24993,24 @@
         /*<<format.ml:392:6>>*/ switch(box_type$0){
          case 0:
            /*<<format.ml:409:19>>*/ break_same_line(state, fits);
-           /*<<format.ml:409:19>>*/ return _m_;
+           /*<<format.ml:409:19>>*/ return sentinal;
          case 1:
            /*<<format.ml:408:19>>*/ break_new_line(state, breaks, width$1);
-           /*<<format.ml:408:19>>*/ return _m_;
+           /*<<format.ml:408:19>>*/ return sentinal;
          case 2:
            /*<<format.ml:406:20>>*/ break_new_line(state, breaks, width$1);
-           /*<<format.ml:406:20>>*/ return _m_;
+           /*<<format.ml:406:20>>*/ return sentinal;
          case 3:
           return state[9] < (size$0 + caml_ml_string_length(before) | 0)
-                  ? (break_new_line(state, breaks, width$1), _m_)
-                  : (break_same_line(state, fits), _m_);
+                  ? (break_new_line(state, breaks, width$1), sentinal)
+                  : (break_same_line(state, fits), sentinal);
          case 4:
           return state[11]
-                  ? (break_same_line(state, fits), _m_)
+                  ? (break_same_line(state, fits), sentinal)
                   : state
                      [9]
                     < (size$0 + caml_ml_string_length(before) | 0)
-                    ? (break_new_line(state, breaks, width$1), _m_)
+                    ? (break_new_line(state, breaks, width$1), sentinal)
                     : ((state
                        [6]
                       - width$1
@@ -25008,11 +25018,11 @@
                       + off
                       | 0)
                       < state[10]
-                      ? (break_new_line(state, breaks, width$1), _m_)
-                      : (break_same_line(state, fits), _m_);
+                      ? (break_new_line(state, breaks, width$1), sentinal)
+                      : (break_same_line(state, fits), sentinal);
          default:
            /*<<format.ml:407:19>>*/ break_same_line(state, fits);
-           /*<<format.ml:407:19>>*/ return _m_;
+           /*<<format.ml:407:19>>*/ return sentinal;
        }
       case 2:
         /*<<format.ml:359:16>>*/ var
@@ -25021,7 +25031,7 @@
         insertion_point = state[6] - state[9] | 0,
          /*<<format.ml:359:16>>*/ match$8 =
            /*<<format.ml:359:16>>*/ caml_call1(Stdlib_Stack[7], state[3]);
-       if(! match$8)  /*<<format.ml:360:14>>*/ return _m_;
+       if(! match$8)  /*<<format.ml:360:14>>*/ return sentinal;
         /*<<format.ml:362:6>>*/ var
         tabs$0 = match$8[1][1],
          /*<<format.ml:362:6>>*/ match$9 = tabs$0[1];
@@ -25031,11 +25041,11 @@
          if(param$0){
           var tail = param$0[2], head = param$0[1];
           if(insertion_point > head){var param$0 = tail; continue;}
-          var _bN_ = head;
+          var _bM_ = head;
          }
          else
-          var _bN_ = first;
-         var tab = _bN_;
+          var _bM_ = first;
+         var tab = _bM_;
          break;
         }
        }
@@ -25045,10 +25055,10 @@
         /*<<format.ml:372:6>>*/ return 0 <= offset
                ? (break_same_line
                   (state, [0, cst$0, offset + n | 0, cst]),
-                 _m_)
+                 sentinal)
                : (break_new_line
                   (state, [0, cst$2, tab + off$0 | 0, cst$1], state[6]),
-                 _m_);
+                 sentinal);
       case 3:
        var
         ty = param[2],
@@ -25072,12 +25082,12 @@
           1 === ty ? 1 : state[9] < size$0 ? ty : 5;
         /*<<format.ml:336:4>>*/  /*<<format.ml:336:4>>*/ caml_call2
         (Stdlib_Stack[3], [0, box_type$1, width$2], state[2]);
-        /*<<format.ml:336:4>>*/ return _m_;
+        /*<<format.ml:336:4>>*/ return sentinal;
       case 4:
        var tbox = param[1];
         /*<<format.ml:342:4>>*/  /*<<format.ml:342:4>>*/ caml_call2
         (Stdlib_Stack[3], tbox, state[3]);
-        /*<<format.ml:342:4>>*/ return _m_;
+        /*<<format.ml:342:4>>*/ return sentinal;
       default:
         /*<<format.ml:414:18>>*/ var
         tag_name$0 = param[1],
@@ -25085,7 +25095,7 @@
            /*<<format.ml:414:18>>*/ caml_call1(state[24], tag_name$0);
         /*<<format.ml:415:5>>*/ pp_output_string(state, marker$0);
        caml_call2(Stdlib_Stack[3], tag_name$0, state[5]);
-       return _m_;
+       return sentinal;
     }
    }
    function advance_left(state){
@@ -25099,10 +25109,10 @@
       length = match$0[3],
       token = match$0[2],
       pending_count = state[13] - state[12] | 0,
-       /*<<format.ml:435:7>>*/ _bK_ = 0 <= size ? 1 : 0,
-       /*<<format.ml:435:7>>*/ _bL_ =
-        _bK_ || (state[9] <= pending_count ? 1 : 0);
-     if(! _bL_)  /*<<format.ml:435:7>>*/ return _bL_;
+       /*<<format.ml:435:7>>*/ _bJ_ = 0 <= size ? 1 : 0,
+       /*<<format.ml:435:7>>*/ _bK_ =
+        _bJ_ || (state[9] <= pending_count ? 1 : 0);
+     if(! _bK_)  /*<<format.ml:435:7>>*/ return _bK_;
       /*<<format.ml:436:6>>*/  /*<<format.ml:436:6>>*/ caml_call1
       (Stdlib_Queue[5], state[28]);
       /*<<format.ml:437:20>>*/  /*<<format.ml:437:20>>*/ var
@@ -25126,28 +25136,31 @@
      queue_elem = [0, unknown, _b_, 0];
      /*<<format.ml:464:2>>*/  /*<<format.ml:464:2>>*/ caml_call2
      (Stdlib_Stack[3], [0, -1, queue_elem], stack);
-     /*<<format.ml:464:2>>*/ return _m_;
+     /*<<format.ml:464:2>>*/ return sentinal;
     /*<<format.ml:464:50>>*/ }
    function set_size(state, ty){
      /*<<format.ml:476:2>>*/  /*<<format.ml:476:8>>*/ var
      match =  /*<<format.ml:476:8>>*/ caml_call1(Stdlib_Stack[7], state[1]);
-    if(! match)  /*<<format.ml:477:12>>*/ return _m_;
+    if(! match)  /*<<format.ml:477:12>>*/ return sentinal;
      /*<<format.ml:479:4>>*/ var
      match$0 = match[1],
      queue_elem = match$0[2],
      left_total = match$0[1],
       /*<<format.ml:479:4>>*/ size = queue_elem[1];
-    if(left_total < state[12]){initialize_scan_stack(state[1]); return _m_;}
-    var _bJ_ = queue_elem[2];
-    if(typeof _bJ_ !== "number")
-     switch(_bJ_[0]){
+    if(left_total < state[12]){
+     initialize_scan_stack(state[1]);
+     return sentinal;
+    }
+    var _bI_ = queue_elem[2];
+    if(typeof _bI_ !== "number")
+     switch(_bI_[0]){
        case 3:
         if(1 - ty){
          queue_elem[1] = state[13] + size | 0;
           /*<<format.ml:493:10>>*/  /*<<format.ml:493:10>>*/ caml_call1
           (Stdlib_Stack[5], state[1]);
         }
-         /*<<format.ml:493:10>>*/ return _m_;
+         /*<<format.ml:493:10>>*/ return sentinal;
        case 1:
        case 2:
         if(ty){
@@ -25155,9 +25168,9 @@
           /*<<format.ml:488:10>>*/  /*<<format.ml:488:10>>*/ caml_call1
           (Stdlib_Stack[5], state[1]);
         }
-         /*<<format.ml:488:10>>*/ return _m_;
+         /*<<format.ml:488:10>>*/ return sentinal;
      }
-     /*<<format.ml:497:8>>*/ return _m_;
+     /*<<format.ml:497:8>>*/ return sentinal;
     /*<<format.ml:497:10>>*/ }
    function scan_push(state, b, token){
      /*<<format.ml:503:2>>*/ pp_enqueue(state, token);
@@ -25175,26 +25188,26 @@
        /*<<format.ml:516:15>>*/ elem = [0, size, [3, indent, br_ty], 0];
       /*<<format.ml:517:4>>*/ return scan_push(state, 0, elem);
     }
-    var _bI_ = state[14] === state[15] ? 1 : 0;
-    if(! _bI_) return _bI_;
+    var _bH_ = state[14] === state[15] ? 1 : 0;
+    if(! _bH_) return _bH_;
     var s = state[16];
      /*<<format.ml:454:2>>*/ return enqueue_string_as
             (state, caml_ml_string_length(s), s);
     /*<<format.ml:519:45>>*/ }
    function pp_close_box(state, param){
-     /*<<format.ml:527:2>>*/ var _bG_ = 1 < state[14] ? 1 : 0;
-    if(_bG_){
+     /*<<format.ml:527:2>>*/ var _bF_ = 1 < state[14] ? 1 : 0;
+    if(_bF_){
      if(state[14] < state[15]){
        /*<<format.ml:531:6>>*/ pp_enqueue(state, [0, zero, 1, 0]);
        /*<<format.ml:532:6>>*/ set_size(state, 1);
        /*<<format.ml:532:27>>*/ set_size(state, 0);
      }
      state[14] = state[14] - 1 | 0;
-     var _bH_ = 0;
+     var _bG_ = 0;
     }
     else
-     var _bH_ = _bG_;
-    return _bH_;
+     var _bG_ = _bF_;
+    return _bG_;
     /*<<format.ml:535:5>>*/ }
    function pp_open_stag(state, tag_name){
      /*<<format.ml:540:2>>*/ if(state[22]){
@@ -25203,8 +25216,8 @@
       /*<<format.ml:543:4>>*/  /*<<format.ml:543:4>>*/ caml_call1
       (state[26], tag_name);
     }
-    var _bF_ = state[23];
-    if(! _bF_) return _bF_;
+    var _bE_ = state[23];
+    if(! _bE_) return _bE_;
      /*<<format.ml:546:16>>*/  /*<<format.ml:546:16>>*/ var
      token = [5, tag_name];
      /*<<format.ml:547:21>>*/ return pp_enqueue(state, [0, zero, token, 0]);
@@ -25212,8 +25225,8 @@
    function pp_close_stag(state, param){
      /*<<format.ml:552:2>>*/ if(state[23])
       /*<<format.ml:553:4>>*/ pp_enqueue(state, [0, zero, 5, 0]);
-    var _bD_ = state[22];
-    if(_bD_){
+    var _bC_ = state[22];
+    if(_bC_){
       /*<<format.ml:555:10>>*/  /*<<format.ml:555:10>>*/ var
       match =  /*<<format.ml:555:10>>*/ caml_call1(Stdlib_Stack[5], state[4]);
      if(match){
@@ -25221,11 +25234,11 @@
        /*<<format.ml:558:6>>*/ return  /*<<format.ml:558:6>>*/ caml_call1
               (state[27], tag_name);
      }
-     var _bE_ = 0;
+     var _bD_ = 0;
     }
     else
-     var _bE_ = _bD_;
-     /*<<format.ml:556:14>>*/ return _bE_;
+     var _bD_ = _bC_;
+     /*<<format.ml:556:14>>*/ return _bD_;
     /*<<format.ml:558:39>>*/ }
    function pp_set_print_tags(state, b){
      /*<<format.ml:560:32>>*/ state[22] = b;
@@ -25279,26 +25292,26 @@
      /*<<format.ml:523:28>>*/ return pp_open_box_gen(state, 0, 3);
     /*<<format.ml:600:23>>*/ }
    function pp_flush_queue(state, b){
-     /*<<format.ml:608:2>>*/ var _bB_ = state[4];
-    function _bC_(param){
+     /*<<format.ml:608:2>>*/ var _bA_ = state[4];
+    function _bB_(param){
       /*<<format.ml:603:23>>*/ return pp_close_stag(state, 0);
      /*<<format.ml:603:45>>*/ }
      /*<<format.ml:603:13>>*/  /*<<format.ml:603:13>>*/ caml_call2
-     (Stdlib_Stack[12], _bC_, _bB_);
+     (Stdlib_Stack[12], _bB_, _bA_);
      /*<<format.ml:610:4>>*/ for(;;){
      if(1 >= state[14]){
       state[13] = pp_infinity;
        /*<<format.ml:613:2>>*/ advance_left(state);
       if(b)  /*<<format.ml:614:12>>*/ pp_output_newline(state);
        /*<<format.ml:614:12>>*/ pp_rinit(state);
-       /*<<format.ml:614:12>>*/ return _m_;
+       /*<<format.ml:614:12>>*/ return sentinal;
      }
       /*<<format.ml:610:4>>*/ pp_close_box(state, 0);
     }
     /*<<format.ml:615:16>>*/ }
    function pp_print_as_size(state, size, s){
-     /*<<format.ml:625:2>>*/ var _bA_ = state[14] < state[15] ? 1 : 0;
-    return _bA_ ? enqueue_string_as(state, size, s) : _bA_;
+     /*<<format.ml:625:2>>*/ var _bz_ = state[14] < state[15] ? 1 : 0;
+    return _bz_ ? enqueue_string_as(state, size, s) : _bz_;
     /*<<format.ml:626:37>>*/ }
    function pp_print_as(state, isize, s){
      /*<<format.ml:630:2>>*/ return pp_print_as_size(state, isize, s);
@@ -25357,20 +25370,20 @@
             (state[18], 0);
     /*<<format.ml:673:51>>*/ }
    function pp_force_newline(state, param){
-     /*<<format.ml:678:2>>*/ var _bz_ = state[14] < state[15] ? 1 : 0;
-    return _bz_ ? enqueue_advance(state, [0, zero, 3, 0]) : _bz_;
+     /*<<format.ml:678:2>>*/ var _by_ = state[14] < state[15] ? 1 : 0;
+    return _by_ ? enqueue_advance(state, [0, zero, 3, 0]) : _by_;
     /*<<format.ml:679:78>>*/ }
    function pp_print_if_newline(state, param){
-     /*<<format.ml:684:2>>*/ var _by_ = state[14] < state[15] ? 1 : 0;
-    return _by_ ? enqueue_advance(state, [0, zero, 4, 0]) : _by_;
+     /*<<format.ml:684:2>>*/ var _bx_ = state[14] < state[15] ? 1 : 0;
+    return _bx_ ? enqueue_advance(state, [0, zero, 4, 0]) : _bx_;
     /*<<format.ml:686:61>>*/ }
    function pp_print_custom_break(state, fits, breaks){
      /*<<format.ml:692:2>>*/ var
      after = fits[3],
      width = fits[2],
      before = fits[1],
-     _bx_ = state[14] < state[15] ? 1 : 0;
-    if(! _bx_) return _bx_;
+     _bw_ = state[14] < state[15] ? 1 : 0;
+    if(! _bw_) return _bw_;
      /*<<format.ml:695:25>>*/ var
      size = - state[13] | 0,
       /*<<format.ml:695:25>>*/ token = [1, fits, breaks],
@@ -25393,33 +25406,33 @@
     /*<<format.ml:715:52>>*/ }
    function pp_open_tbox(state, param){
      /*<<format.ml:720:2>>*/ state[14] = state[14] + 1 | 0;
-    var _bw_ = state[14] < state[15] ? 1 : 0;
-    if(! _bw_) return _bw_;
+    var _bv_ = state[14] < state[15] ? 1 : 0;
+    if(! _bv_) return _bv_;
      /*<<format.ml:723:15>>*/  /*<<format.ml:723:15>>*/ var
      elem = [0, zero, [4, [0, [0, 0]]], 0];
      /*<<format.ml:724:4>>*/ return enqueue_advance(state, elem);
     /*<<format.ml:724:30>>*/ }
    function pp_close_tbox(state, param){
-     /*<<format.ml:729:2>>*/ var _bt_ = 1 < state[14] ? 1 : 0;
-    if(_bt_){
-     var _bu_ = state[14] < state[15] ? 1 : 0;
-     if(_bu_){
+     /*<<format.ml:729:2>>*/ var _bs_ = 1 < state[14] ? 1 : 0;
+    if(_bs_){
+     var _bt_ = state[14] < state[15] ? 1 : 0;
+     if(_bt_){
        /*<<format.ml:732:16>>*/  /*<<format.ml:732:16>>*/ var
        elem = [0, zero, 2, 0];
        /*<<format.ml:733:5>>*/ enqueue_advance(state, elem);
       state[14] = state[14] - 1 | 0;
-      var _bv_ = 0;
+      var _bu_ = 0;
      }
      else
-      var _bv_ = _bu_;
+      var _bu_ = _bt_;
     }
     else
-     var _bv_ = _bt_;
-    return _bv_;
+     var _bu_ = _bs_;
+    return _bu_;
     /*<<format.ml:735:5>>*/ }
    function pp_print_tbreak(state, width, offset){
-     /*<<format.ml:740:2>>*/ var _bs_ = state[14] < state[15] ? 1 : 0;
-    if(! _bs_) return _bs_;
+     /*<<format.ml:740:2>>*/ var _br_ = state[14] < state[15] ? 1 : 0;
+    if(! _br_) return _br_;
      /*<<format.ml:742:15>>*/ var
      size = - state[13] | 0,
       /*<<format.ml:742:15>>*/ elem = [0, size, [2, width, offset], width];
@@ -25429,17 +25442,17 @@
      /*<<format.ml:746:28>>*/ return pp_print_tbreak(state, 0, 0);
     /*<<format.ml:746:53>>*/ }
    function pp_set_tab(state, param){
-     /*<<format.ml:749:2>>*/ var _br_ = state[14] < state[15] ? 1 : 0;
-    if(! _br_) return _br_;
+     /*<<format.ml:749:2>>*/ var _bq_ = state[14] < state[15] ? 1 : 0;
+    if(! _bq_) return _bq_;
      /*<<format.ml:750:15>>*/  /*<<format.ml:750:15>>*/ var
      elem = [0, zero, 0, 0];
      /*<<format.ml:751:4>>*/ return enqueue_advance(state, elem);
     /*<<format.ml:751:30>>*/ }
    function pp_set_max_boxes(state, n){
      /*<<format.ml:761:31>>*/ var
-     _bp_ = 1 < n ? 1 : 0,
-     _bq_ = _bp_ ? (state[15] = n, 0) : _bp_;
-    return _bq_;
+     _bo_ = 1 < n ? 1 : 0,
+     _bp_ = _bo_ ? (state[15] = n, 0) : _bo_;
+    return _bp_;
     /*<<format.ml:761:68>>*/ }
    function pp_get_max_boxes(state, param){
      /*<<format.ml:764:32>>*/ return state[15];
@@ -25458,10 +25471,10 @@
      /*<<format.ml:775:2>>*/ return n < 1000000010 ? n : 1000000009;
     /*<<format.ml:775:49>>*/ }
    function pp_set_max_indent(state, n$0){
-     /*<<format.ml:791:2>>*/ var _bo_ = 1 < n$0 ? 1 : 0;
-    if(! _bo_) return _bo_;
-    var n$1 = state[6] - n$0 | 0, _bn_ = 1 <= n$1 ? 1 : 0;
+     /*<<format.ml:791:2>>*/ var _bn_ = 1 < n$0 ? 1 : 0;
     if(! _bn_) return _bn_;
+    var n$1 = state[6] - n$0 | 0, _bm_ = 1 <= n$1 ? 1 : 0;
+    if(! _bm_) return _bm_;
      /*<<format.ml:781:12>>*/  /*<<format.ml:781:12>>*/ var n = pp_limit(n$1);
     state[7] = n;
     state[8] = state[6] - state[7] | 0;
@@ -25471,19 +25484,19 @@
      /*<<format.ml:795:33>>*/ return state[8];
     /*<<format.ml:795:52>>*/ }
    function pp_set_margin(state, n){
-     /*<<format.ml:798:2>>*/ var _bl_ = 1 <= n ? 1 : 0;
-    if(! _bl_) return _bl_;
+     /*<<format.ml:798:2>>*/ var _bk_ = 1 <= n ? 1 : 0;
+    if(! _bk_) return _bk_;
      /*<<format.ml:799:12>>*/  /*<<format.ml:799:12>>*/ var n$0 = pp_limit(n);
     state[6] = n$0;
     if(state[8] <= state[6])
      var new_max_indent = state[8];
     else
       /*<<format.ml:808:15>>*/ var
-       /*<<format.ml:808:15>>*/ _bm_ =
+       /*<<format.ml:808:15>>*/ _bl_ =
          /*<<format.ml:808:15>>*/ caml_call2
          (Stdlib_Int[11], state[6] - state[7] | 0, state[6] / 2 | 0),
       new_max_indent =
-         /*<<format.ml:808:7>>*/ caml_call2(Stdlib_Int[11], _bm_, 1);
+         /*<<format.ml:808:7>>*/ caml_call2(Stdlib_Int[11], _bl_, 1);
      /*<<format.ml:811:4>>*/ return pp_set_max_indent(state, new_max_indent);
     /*<<format.ml:811:42>>*/ }
    function validate_geometry(param){
@@ -25514,11 +25527,11 @@
       /*<<format.ml:842:4>>*/ return pp_set_full_geometry(state, geometry);
      /*<<format.ml:840:28>>*/ var
      msg = match[1],
-      /*<<format.ml:840:28>>*/ _bk_ =
+      /*<<format.ml:840:28>>*/ _bj_ =
         /*<<format.ml:840:28>>*/ caml_call2
         (Stdlib[28], cst_Format_pp_set_geometry, msg);
      /*<<format.ml:840:4>>*/ throw  /*<<format.ml:840:4>>*/ caml_maybe_attach_backtrace
-           ([0, Stdlib[6], _bk_], 1);
+           ([0, Stdlib[6], _bj_], 1);
     /*<<format.ml:842:39>>*/ }
    function pp_safe_set_geometry(state, max_indent, margin){
      /*<<format.ml:845:2>>*/  /*<<format.ml:845:17>>*/ var
@@ -25571,8 +25584,8 @@
    function display_blanks(state, n){
      /*<<format.ml:896:2>>*/ var n$0 = n;
      /*<<format.ml:896:2>>*/ for(;;){
-     var _bj_ = 0 < n$0 ? 1 : 0;
-     if(! _bj_) return _bj_;
+     var _bi_ = 0 < n$0 ? 1 : 0;
+     if(! _bi_) return _bi_;
      if(80 >= n$0)
        /*<<format.ml:897:18>>*/ return  /*<<format.ml:897:18>>*/ caml_call3
               (state[17], blank_line, 0, n$0);
@@ -25592,9 +25605,9 @@
               (Stdlib[63], oc);
       /*<<format.ml:911:43>>*/ };
     state[19] =
-     function(_bi_){ /*<<?>>*/ return display_newline(state, _bi_);};
-    state[20] = function(_bh_){ /*<<?>>*/ return display_blanks(state, _bh_);};
-    state[21] = function(_bg_){ /*<<?>>*/ return display_blanks(state, _bg_);};
+     function(_bh_){ /*<<?>>*/ return display_newline(state, _bh_);};
+    state[20] = function(_bg_){ /*<<?>>*/ return display_blanks(state, _bg_);};
+    state[21] = function(_bf_){ /*<<?>>*/ return display_blanks(state, _bf_);};
     return 0;
     /*<<format.ml:914:45>>*/ }
    function default_pp_mark_open_tag(param){
@@ -25602,23 +25615,23 @@
       /*<<format.ml:924:9>>*/ return cst$10;
      /*<<format.ml:923:26>>*/ var
      s = param[2],
-      /*<<format.ml:923:26>>*/ _bf_ =
+      /*<<format.ml:923:26>>*/ _be_ =
         /*<<format.ml:923:26>>*/ caml_call2(Stdlib[28], s, cst$8);
      /*<<format.ml:923:26>>*/ return  /*<<format.ml:923:26>>*/ caml_call2
-            (Stdlib[28], cst$9, _bf_);
+            (Stdlib[28], cst$9, _be_);
     /*<<format.ml:924:11>>*/ }
    function default_pp_mark_close_tag(param){
      /*<<format.ml:925:32>>*/ if(param[1] !== String_tag)
       /*<<format.ml:927:9>>*/ return cst$13;
      /*<<format.ml:926:27>>*/ var
      s = param[2],
-      /*<<format.ml:926:27>>*/ _be_ =
+      /*<<format.ml:926:27>>*/ _bd_ =
         /*<<format.ml:926:27>>*/ caml_call2(Stdlib[28], s, cst$11);
      /*<<format.ml:926:27>>*/ return  /*<<format.ml:926:27>>*/ caml_call2
-            (Stdlib[28], cst$12, _be_);
+            (Stdlib[28], cst$12, _bd_);
     /*<<format.ml:927:11>>*/ }
-   function default_pp_print_open_tag(_bd_){ /*<<?>>*/ return 0;}
-   function default_pp_print_close_tag(_bc_){ /*<<?>>*/ return 0;}
+   function default_pp_print_open_tag(_bc_){ /*<<?>>*/ return 0;}
+   function default_pp_print_close_tag(_bb_){ /*<<?>>*/ return 0;}
    function pp_make_formatter(f, g, h, i, j){
      /*<<format.ml:936:17>>*/ var
       /*<<format.ml:936:17>>*/ pp_queue =
@@ -25632,19 +25645,19 @@
      /*<<format.ml:942:2>>*/  /*<<format.ml:942:2>>*/ caml_call2
      (Stdlib_Stack[3], [0, 1, sys_tok], scan_stack);
      /*<<format.ml:950:20>>*/ var
-     _a__ = Stdlib[19],
-      /*<<format.ml:950:20>>*/ _a$_ =
+     _a9_ = Stdlib[19],
+      /*<<format.ml:950:20>>*/ _a__ =
         /*<<format.ml:950:20>>*/ caml_call1(Stdlib_Stack[2], 0),
-      /*<<format.ml:949:19>>*/ _ba_ =
+      /*<<format.ml:949:19>>*/ _a$_ =
         /*<<format.ml:949:19>>*/ caml_call1(Stdlib_Stack[2], 0),
-      /*<<format.ml:948:20>>*/ _bb_ =
+      /*<<format.ml:948:20>>*/ _ba_ =
         /*<<format.ml:948:20>>*/ caml_call1(Stdlib_Stack[2], 0);
      /*<<format.ml:945:2>>*/ return [0,
             scan_stack,
              /*<<format.ml:947:22>>*/ caml_call1(Stdlib_Stack[2], 0),
-            _bb_,
             _ba_,
             _a$_,
+            _a__,
             78,
             10,
             68,
@@ -25654,7 +25667,7 @@
             1,
             1,
             1,
-            _a__,
+            _a9_,
             cst$14,
             f,
             g,
@@ -25674,30 +25687,30 @@
             (out_funs[1], out_funs[2], out_funs[3], out_funs[4], out_funs[5]);
     /*<<format.ml:984:23>>*/ }
    function make_formatter(output, flush){
-    function _a2_(_a9_){ /*<<?>>*/ return 0;}
-    function _a3_(_a8_){ /*<<?>>*/ return 0;}
+    function _a1_(_a8_){ /*<<?>>*/ return 0;}
+    function _a2_(_a7_){ /*<<?>>*/ return 0;}
      /*<<format.ml:990:12>>*/  /*<<format.ml:990:12>>*/ var
      ppf =
        pp_make_formatter
-        (output, flush, function(_a7_){ /*<<?>>*/ return 0;}, _a3_, _a2_);
-    ppf[19] = function(_a6_){ /*<<?>>*/ return display_newline(ppf, _a6_);};
-    ppf[20] = function(_a5_){ /*<<?>>*/ return display_blanks(ppf, _a5_);};
-    ppf[21] = function(_a4_){ /*<<?>>*/ return display_blanks(ppf, _a4_);};
+        (output, flush, function(_a6_){ /*<<?>>*/ return 0;}, _a2_, _a1_);
+    ppf[19] = function(_a5_){ /*<<?>>*/ return display_newline(ppf, _a5_);};
+    ppf[20] = function(_a4_){ /*<<?>>*/ return display_blanks(ppf, _a4_);};
+    ppf[21] = function(_a3_){ /*<<?>>*/ return display_blanks(ppf, _a3_);};
      /*<<format.ml:994:2>>*/ return ppf;
     /*<<format.ml:994:5>>*/ }
    function formatter_of_out_channel(oc){
-    function _a1_(param){
+    function _a0_(param){
       /*<<format.ml:999:50>>*/ return  /*<<format.ml:999:2>>*/ caml_call1
              (Stdlib[63], oc);
      /*<<format.ml:999:58>>*/ }
      /*<<format.ml:999:39>>*/ return make_formatter
-            ( /*<<format.ml:999:17>>*/ caml_call1(Stdlib[69], oc), _a1_);
+            ( /*<<format.ml:999:17>>*/ caml_call1(Stdlib[69], oc), _a0_);
     /*<<format.ml:999:59>>*/ }
    function formatter_of_buffer(b){
-     /*<<format.ml:1004:2>>*/ function _aZ_(_a0_){ /*<<?>>*/ return 0;}
+     /*<<format.ml:1004:2>>*/ function _aY_(_aZ_){ /*<<?>>*/ return 0;}
      /*<<format.ml:1004:42>>*/ return make_formatter
             ( /*<<format.ml:1004:17>>*/ caml_call1(Stdlib_Buffer[18], b),
-             _aZ_);
+             _aY_);
     /*<<format.ml:1004:48>>*/ }
    var pp_buffer_size = 512;
    function pp_make_buffer(param){
@@ -25728,9 +25741,9 @@
     (Stdlib_Domain[10][3], str_formatter_key, str_formatter);
     /*<<format.ml:1030:8>>*/ function buffered_out_string(key, str, ofs, len){
      /*<<format.ml:1033:2>>*/  /*<<format.ml:1033:23>>*/ var
-     _aY_ =  /*<<format.ml:1033:23>>*/ caml_call1(Stdlib_Domain[10][2], key);
+     _aX_ =  /*<<format.ml:1033:23>>*/ caml_call1(Stdlib_Domain[10][2], key);
      /*<<format.ml:1033:2>>*/ return  /*<<format.ml:1033:2>>*/ caml_call4
-            (Stdlib_Buffer[18], _aY_, str, ofs, len);
+            (Stdlib_Buffer[18], _aX_, str, ofs, len);
     /*<<format.ml:1033:55>>*/ }
    function buffered_out_flush(oc, key, param){
      /*<<format.ml:1036:2>>*/ var
@@ -25762,31 +25775,31 @@
     err_buf_key =
        /*<<format.ml:1044:18>>*/ caml_call2(Stdlib_Domain[10][1], 0, _i_);
    function _j_(param){
-    function _aH_(_aX_){ /*<<?>>*/ return 0;}
-    function _aI_(_aW_){ /*<<?>>*/ return 0;}
-    function _aJ_(_aV_){ /*<<?>>*/ return 0;}
-    var _aK_ = Stdlib[39];
-     /*<<format.ml:1049:6>>*/ function _aL_(_aU_){
-      /*<<?>>*/ return buffered_out_flush(_aK_, std_buf_key, _aU_);
+    function _aG_(_aW_){ /*<<?>>*/ return 0;}
+    function _aH_(_aV_){ /*<<?>>*/ return 0;}
+    function _aI_(_aU_){ /*<<?>>*/ return 0;}
+    var _aJ_ = Stdlib[39];
+     /*<<format.ml:1049:6>>*/ function _aK_(_aT_){
+      /*<<?>>*/ return buffered_out_flush(_aJ_, std_buf_key, _aT_);
     }
      /*<<format.ml:1048:4>>*/  /*<<format.ml:1048:4>>*/ var
      ppf =
        pp_make_formatter
-        (function(_aR_, _aS_, _aT_){
-           /*<<?>>*/ return buffered_out_string(std_buf_key, _aR_, _aS_, _aT_);
+        (function(_aQ_, _aR_, _aS_){
+           /*<<?>>*/ return buffered_out_string(std_buf_key, _aQ_, _aR_, _aS_);
          },
-         _aL_,
-         _aJ_,
+         _aK_,
          _aI_,
-         _aH_);
-    ppf[19] = function(_aQ_){ /*<<?>>*/ return display_newline(ppf, _aQ_);};
-    ppf[20] = function(_aP_){ /*<<?>>*/ return display_blanks(ppf, _aP_);};
-    ppf[21] = function(_aO_){ /*<<?>>*/ return display_blanks(ppf, _aO_);};
-     /*<<format.ml:1054:17>>*/ function _aM_(_aN_){
-      /*<<?>>*/ return pp_print_flush(ppf, _aN_);
+         _aH_,
+         _aG_);
+    ppf[19] = function(_aP_){ /*<<?>>*/ return display_newline(ppf, _aP_);};
+    ppf[20] = function(_aO_){ /*<<?>>*/ return display_blanks(ppf, _aO_);};
+    ppf[21] = function(_aN_){ /*<<?>>*/ return display_blanks(ppf, _aN_);};
+     /*<<format.ml:1054:17>>*/ function _aL_(_aM_){
+      /*<<?>>*/ return pp_print_flush(ppf, _aM_);
     }
      /*<<format.ml:1054:2>>*/  /*<<format.ml:1054:2>>*/ caml_call1
-     (Stdlib_Domain[6], _aM_);
+     (Stdlib_Domain[6], _aL_);
      /*<<format.ml:1054:2>>*/ return ppf;
     /*<<format.ml:1055:5>>*/ }
     /*<<format.ml:1046:24>>*/  /*<<format.ml:1046:24>>*/ var
@@ -25795,31 +25808,31 @@
     /*<<format.ml:1056:8>>*/  /*<<format.ml:1056:8>>*/ caml_call2
     (Stdlib_Domain[10][3], std_formatter_key, std_formatter);
    function _k_(param){
-    function _aq_(_aG_){ /*<<?>>*/ return 0;}
-    function _ar_(_aF_){ /*<<?>>*/ return 0;}
-    function _as_(_aE_){ /*<<?>>*/ return 0;}
-    var _at_ = Stdlib[40];
-     /*<<format.ml:1061:6>>*/ function _au_(_aD_){
-      /*<<?>>*/ return buffered_out_flush(_at_, err_buf_key, _aD_);
+    function _ap_(_aF_){ /*<<?>>*/ return 0;}
+    function _aq_(_aE_){ /*<<?>>*/ return 0;}
+    function _ar_(_aD_){ /*<<?>>*/ return 0;}
+    var _as_ = Stdlib[40];
+     /*<<format.ml:1061:6>>*/ function _at_(_aC_){
+      /*<<?>>*/ return buffered_out_flush(_as_, err_buf_key, _aC_);
     }
      /*<<format.ml:1060:4>>*/  /*<<format.ml:1060:4>>*/ var
      ppf =
        pp_make_formatter
-        (function(_aA_, _aB_, _aC_){
-           /*<<?>>*/ return buffered_out_string(err_buf_key, _aA_, _aB_, _aC_);
+        (function(_az_, _aA_, _aB_){
+           /*<<?>>*/ return buffered_out_string(err_buf_key, _az_, _aA_, _aB_);
          },
-         _au_,
-         _as_,
+         _at_,
          _ar_,
-         _aq_);
-    ppf[19] = function(_az_){ /*<<?>>*/ return display_newline(ppf, _az_);};
-    ppf[20] = function(_ay_){ /*<<?>>*/ return display_blanks(ppf, _ay_);};
-    ppf[21] = function(_ax_){ /*<<?>>*/ return display_blanks(ppf, _ax_);};
-     /*<<format.ml:1066:17>>*/ function _av_(_aw_){
-      /*<<?>>*/ return pp_print_flush(ppf, _aw_);
+         _aq_,
+         _ap_);
+    ppf[19] = function(_ay_){ /*<<?>>*/ return display_newline(ppf, _ay_);};
+    ppf[20] = function(_ax_){ /*<<?>>*/ return display_blanks(ppf, _ax_);};
+    ppf[21] = function(_aw_){ /*<<?>>*/ return display_blanks(ppf, _aw_);};
+     /*<<format.ml:1066:17>>*/ function _au_(_av_){
+      /*<<?>>*/ return pp_print_flush(ppf, _av_);
     }
      /*<<format.ml:1066:2>>*/  /*<<format.ml:1066:2>>*/ caml_call1
-     (Stdlib_Domain[6], _av_);
+     (Stdlib_Domain[6], _au_);
      /*<<format.ml:1066:2>>*/ return ppf;
     /*<<format.ml:1067:5>>*/ }
     /*<<format.ml:1058:24>>*/  /*<<format.ml:1058:24>>*/ var
@@ -25862,7 +25875,7 @@
             (stdbuf, str_formatter);
     /*<<format.ml:1089:45>>*/ }
    function make_synchronized_formatter(output, flush){
-    function _ao_(param){
+    function _an_(param){
       /*<<format.ml:1093:4>>*/ var
        /*<<format.ml:1093:14>>*/ buf =
          /*<<format.ml:1093:14>>*/ caml_call1
@@ -25871,12 +25884,12 @@
          /*<<format.ml:1094:18>>*/ caml_call1(Stdlib_Buffer[18], buf);
      function flush$0(param){
        /*<<format.ml:1096:6>>*/  /*<<format.ml:1096:37>>*/ var
-       _ap_ =  /*<<format.ml:1096:37>>*/ caml_call1(Stdlib_Buffer[7], buf);
+       _ao_ =  /*<<format.ml:1096:37>>*/ caml_call1(Stdlib_Buffer[7], buf);
        /*<<format.ml:1096:6>>*/  /*<<format.ml:1096:6>>*/ caml_call3
        (output,
          /*<<format.ml:1096:13>>*/ caml_call1(Stdlib_Buffer[2], buf),
         0,
-        _ap_);
+        _ao_);
        /*<<format.ml:1097:6>>*/  /*<<format.ml:1097:6>>*/ caml_call1
        (Stdlib_Buffer[8], buf);
        /*<<format.ml:1097:6>>*/ return  /*<<format.ml:1097:6>>*/ caml_call1
@@ -25885,15 +25898,15 @@
       /*<<format.ml:1100:4>>*/ return make_formatter(output$0, flush$0);
      /*<<format.ml:1100:33>>*/ }
      /*<<format.ml:1092:14>>*/ return  /*<<format.ml:1092:14>>*/ caml_call2
-            (Stdlib_Domain[10][1], 0, _ao_);
+            (Stdlib_Domain[10][1], 0, _an_);
     /*<<format.ml:1100:34>>*/ }
    function synchronized_formatter_of_out_(oc){
-    function _an_(param){
+    function _am_(param){
       /*<<format.ml:1103:63>>*/ return  /*<<format.ml:1103:2>>*/ caml_call1
              (Stdlib[63], oc);
      /*<<format.ml:1103:71>>*/ }
      /*<<format.ml:1103:52>>*/ return make_synchronized_formatter
-            ( /*<<format.ml:1103:30>>*/ caml_call1(Stdlib[69], oc), _an_);
+            ( /*<<format.ml:1103:30>>*/ caml_call1(Stdlib[69], oc), _am_);
     /*<<format.ml:1103:72>>*/ }
    function make_symbolic_output_buffer(param){ /*<<format.ml:1130:2>>*/ return [0, 0];
     /*<<format.ml:1130:35>>*/ }
@@ -25922,10 +25935,10 @@
                 /*<<format.ml:1152:48>>*/ caml_call3
                 (Stdlib_String[15], s, i, n)]);
     }
-     /*<<format.ml:1159:10>>*/ function g(_am_){
+     /*<<format.ml:1159:10>>*/ function g(_al_){
       /*<<format.ml:1148:4>>*/ return add_symbolic_output_item(sob, 0);
     }
-     /*<<format.ml:1160:10>>*/ function h(_al_){
+     /*<<format.ml:1160:10>>*/ function h(_ak_){
       /*<<format.ml:1150:4>>*/ return add_symbolic_output_item(sob, 1);
     }
      /*<<format.ml:1161:10>>*/ function i(n){
@@ -26312,8 +26325,8 @@
      /*<<format.ml:1285:31>>*/ }
     for(;;){
      if(right[1] === len){
-      var _ak_ = left[1] !== len ? 1 : 0;
-      return _ak_ ? flush(0) : _ak_;
+      var _aj_ = left[1] !== len ? 1 : 0;
+      return _aj_ ? flush(0) : _aj_;
      }
       /*<<format.ml:1288:10>>*/  /*<<format.ml:1288:10>>*/ var
       match =  /*<<format.ml:1288:10>>*/ runtime.caml_string_get(s, right[1]);
@@ -26335,7 +26348,7 @@
     else
      var
       none =
-        function(param, _aj_){
+        function(param, _ai_){
           /*<<format.ml:1300:41>>*/ return 0;
          /*<<format.ml:1300:43>>*/ };
      /*<<format.ml:1300:56>>*/ if(! param)
@@ -26434,56 +26447,56 @@
           var acc$1 = match[1];
            /*<<format.ml:1366:4>>*/ output_acc(ppf, p$0);
            /*<<format.ml:1367:43>>*/ var
-            /*<<format.ml:1367:43>>*/ _aa_ = compute_tag(output_acc, acc$1),
+            /*<<format.ml:1367:43>>*/ _$_ = compute_tag(output_acc, acc$1),
             /*<<format.ml:1367:24>>*/ match$0 =
               /*<<format.ml:1367:24>>*/ caml_call1
-              (CamlinternalFormat[20], _aa_),
+              (CamlinternalFormat[20], _$_),
            bty = match$0[2],
            indent = match$0[1];
            /*<<format.ml:1368:4>>*/ return pp_open_box_gen(ppf, indent, bty);
          case 2:
-          var _ab_ = acc[1];
-          if(typeof _ab_ !== "number" && 0 === _ab_[0]){
-           var _ac_ = _ab_[2];
-           if(typeof _ac_ !== "number" && 1 === _ac_[0]){
-            var s$0 = acc[2], size = _ac_[2], p$2 = _ab_[1];
+          var _aa_ = acc[1];
+          if(typeof _aa_ !== "number" && 0 === _aa_[0]){
+           var _ab_ = _aa_[2];
+           if(typeof _ab_ !== "number" && 1 === _ab_[0]){
+            var s$0 = acc[2], size = _ab_[2], p$2 = _aa_[1];
             break b;
            }
           }
-          var s = acc[2], p$1 = _ab_;
+          var s = acc[2], p$1 = _aa_;
           break a;
          case 3:
-          var _ad_ = acc[1];
-          if(typeof _ad_ !== "number" && 0 === _ad_[0]){
-           var _ae_ = _ad_[2];
-           if(typeof _ae_ !== "number" && 1 === _ae_[0]){
-            var c$0 = acc[2], size$0 = _ae_[2], p$4 = _ad_[1];
+          var _ac_ = acc[1];
+          if(typeof _ac_ !== "number" && 0 === _ac_[0]){
+           var _ad_ = _ac_[2];
+           if(typeof _ad_ !== "number" && 1 === _ad_[0]){
+            var c$0 = acc[2], size$0 = _ad_[2], p$4 = _ac_[1];
             break;
            }
           }
-          var c = acc[2], p$3 = _ad_;
+          var c = acc[2], p$3 = _ac_;
           break c;
          case 4:
-          var _af_ = acc[1];
-          if(typeof _af_ !== "number" && 0 === _af_[0]){
-           var _ag_ = _af_[2];
-           if(typeof _ag_ !== "number" && 1 === _ag_[0]){
-            var s$0 = acc[2], size = _ag_[2], p$2 = _af_[1];
+          var _ae_ = acc[1];
+          if(typeof _ae_ !== "number" && 0 === _ae_[0]){
+           var _af_ = _ae_[2];
+           if(typeof _af_ !== "number" && 1 === _af_[0]){
+            var s$0 = acc[2], size = _af_[2], p$2 = _ae_[1];
             break b;
            }
           }
-          var s = acc[2], p$1 = _af_;
+          var s = acc[2], p$1 = _ae_;
           break a;
          case 5:
-          var _ah_ = acc[1];
-          if(typeof _ah_ !== "number" && 0 === _ah_[0]){
-           var _ai_ = _ah_[2];
-           if(typeof _ai_ !== "number" && 1 === _ai_[0]){
-            var c$0 = acc[2], size$0 = _ai_[2], p$4 = _ah_[1];
+          var _ag_ = acc[1];
+          if(typeof _ag_ !== "number" && 0 === _ag_[0]){
+           var _ah_ = _ag_[2];
+           if(typeof _ah_ !== "number" && 1 === _ah_[0]){
+            var c$0 = acc[2], size$0 = _ah_[2], p$4 = _ag_[1];
             break;
            }
           }
-          var c = acc[2], p$3 = _ah_;
+          var c = acc[2], p$3 = _ag_;
           break c;
          case 6:
           var f$0 = acc[2], p$5 = acc[1];
@@ -26541,56 +26554,56 @@
           var acc$1 = match[1];
            /*<<format.ml:1401:4>>*/ strput_acc(ppf, p$0);
            /*<<format.ml:1402:43>>*/ var
-            /*<<format.ml:1402:43>>*/ _T_ = compute_tag(strput_acc, acc$1),
+            /*<<format.ml:1402:43>>*/ _S_ = compute_tag(strput_acc, acc$1),
             /*<<format.ml:1402:24>>*/ match$0 =
               /*<<format.ml:1402:24>>*/ caml_call1
-              (CamlinternalFormat[20], _T_),
+              (CamlinternalFormat[20], _S_),
            bty = match$0[2],
            indent = match$0[1];
            /*<<format.ml:1403:4>>*/ return pp_open_box_gen(ppf, indent, bty);
          case 2:
-          var _U_ = acc[1];
-          if(typeof _U_ !== "number" && 0 === _U_[0]){
-           var _V_ = _U_[2];
-           if(typeof _V_ !== "number" && 1 === _V_[0]){
-            var s$0 = acc[2], size = _V_[2], p$2 = _U_[1];
+          var _T_ = acc[1];
+          if(typeof _T_ !== "number" && 0 === _T_[0]){
+           var _U_ = _T_[2];
+           if(typeof _U_ !== "number" && 1 === _U_[0]){
+            var s$0 = acc[2], size = _U_[2], p$2 = _T_[1];
             break b;
            }
           }
-          var s = acc[2], p$1 = _U_;
+          var s = acc[2], p$1 = _T_;
           break a;
          case 3:
-          var _W_ = acc[1];
-          if(typeof _W_ !== "number" && 0 === _W_[0]){
-           var _X_ = _W_[2];
-           if(typeof _X_ !== "number" && 1 === _X_[0]){
-            var c$0 = acc[2], size$0 = _X_[2], p$4 = _W_[1];
+          var _V_ = acc[1];
+          if(typeof _V_ !== "number" && 0 === _V_[0]){
+           var _W_ = _V_[2];
+           if(typeof _W_ !== "number" && 1 === _W_[0]){
+            var c$0 = acc[2], size$0 = _W_[2], p$4 = _V_[1];
             break;
            }
           }
-          var c = acc[2], p$3 = _W_;
+          var c = acc[2], p$3 = _V_;
           break c;
          case 4:
-          var _Y_ = acc[1];
-          if(typeof _Y_ !== "number" && 0 === _Y_[0]){
-           var _Z_ = _Y_[2];
-           if(typeof _Z_ !== "number" && 1 === _Z_[0]){
-            var s$0 = acc[2], size = _Z_[2], p$2 = _Y_[1];
+          var _X_ = acc[1];
+          if(typeof _X_ !== "number" && 0 === _X_[0]){
+           var _Y_ = _X_[2];
+           if(typeof _Y_ !== "number" && 1 === _Y_[0]){
+            var s$0 = acc[2], size = _Y_[2], p$2 = _X_[1];
             break b;
            }
           }
-          var s = acc[2], p$1 = _Y_;
+          var s = acc[2], p$1 = _X_;
           break a;
          case 5:
-          var ___ = acc[1];
-          if(typeof ___ !== "number" && 0 === ___[0]){
-           var _$_ = ___[2];
-           if(typeof _$_ !== "number" && 1 === _$_[0]){
-            var c$0 = acc[2], size$0 = _$_[2], p$4 = ___[1];
+          var _Z_ = acc[1];
+          if(typeof _Z_ !== "number" && 0 === _Z_[0]){
+           var ___ = _Z_[2];
+           if(typeof ___ !== "number" && 1 === ___[0]){
+            var c$0 = acc[2], size$0 = ___[2], p$4 = _Z_[1];
             break;
            }
           }
-          var c = acc[2], p$3 = ___;
+          var c = acc[2], p$3 = _Z_;
           break c;
          case 6:
           var p$5 = acc[1];
@@ -26636,13 +26649,13 @@
    function kfprintf(k, ppf, param){
      /*<<format.ml:1420:2>>*/ var
      fmt = param[1],
-      /*<<format.ml:1420:2>>*/ _R_ = 0;
-    function _S_(acc){
+      /*<<format.ml:1420:2>>*/ _Q_ = 0;
+    function _R_(acc){
       /*<<format.ml:1421:16>>*/ output_acc(ppf, acc);
      return caml_call1(k, ppf);
      /*<<format.ml:1421:41>>*/ }
      /*<<format.ml:1420:2>>*/ return  /*<<format.ml:1420:2>>*/ caml_call3
-            (CamlinternalFormat[7], _S_, _R_, fmt);
+            (CamlinternalFormat[7], _R_, _Q_, fmt);
    }
    function ikfprintf(k, ppf, param){
     var fmt = param[1];
@@ -26652,47 +26665,47 @@
    function ifprintf(ppf, param){
      /*<<format.ml:1428:2>>*/ var
      fmt = param[1],
-      /*<<format.ml:1428:2>>*/ _O_ = 0;
-    function _P_(_Q_){ /*<<?>>*/ return 0;}
+      /*<<format.ml:1428:2>>*/ _N_ = 0;
+    function _O_(_P_){ /*<<?>>*/ return 0;}
      /*<<format.ml:1428:2>>*/ return  /*<<format.ml:1428:2>>*/ caml_call3
-            (CamlinternalFormat[8], _P_, _O_, fmt);
+            (CamlinternalFormat[8], _O_, _N_, fmt);
    }
    function fprintf(ppf){
-    function _L_(_N_){ /*<<?>>*/ return 0;}
-     /*<<format.ml:1430:18>>*/ return function(_M_){
-      /*<<?>>*/ return kfprintf(_L_, ppf, _M_);};
+    function _K_(_M_){ /*<<?>>*/ return 0;}
+     /*<<format.ml:1430:18>>*/ return function(_L_){
+      /*<<?>>*/ return kfprintf(_K_, ppf, _L_);};
     /*<<format.ml:1430:37>>*/ }
    function printf(param){
      /*<<format.ml:1433:2>>*/ var
      fmt = param[1],
-      /*<<format.ml:1433:2>>*/ _J_ = 0;
-    function _K_(acc){
+      /*<<format.ml:1433:2>>*/ _I_ = 0;
+    function _J_(acc){
       /*<<format.ml:1434:16>>*/ return output_acc
              ( /*<<format.ml:1434:27>>*/ caml_call1
                (Stdlib_Domain[10][2], std_formatter_key),
               acc);
      /*<<format.ml:1434:58>>*/ }
      /*<<format.ml:1433:2>>*/ return  /*<<format.ml:1433:2>>*/ caml_call3
-            (CamlinternalFormat[7], _K_, _J_, fmt);
+            (CamlinternalFormat[7], _J_, _I_, fmt);
    }
    function eprintf(param){
      /*<<format.ml:1438:2>>*/ var
      fmt = param[1],
-      /*<<format.ml:1438:2>>*/ _H_ = 0;
-    function _I_(acc){
+      /*<<format.ml:1438:2>>*/ _G_ = 0;
+    function _H_(acc){
       /*<<format.ml:1439:16>>*/ return output_acc
              ( /*<<format.ml:1439:27>>*/ caml_call1
                (Stdlib_Domain[10][2], err_formatter_key),
               acc);
      /*<<format.ml:1439:58>>*/ }
      /*<<format.ml:1438:2>>*/ return  /*<<format.ml:1438:2>>*/ caml_call3
-            (CamlinternalFormat[7], _I_, _H_, fmt);
+            (CamlinternalFormat[7], _H_, _G_, fmt);
    }
    function kdprintf(k, param){
      /*<<format.ml:1443:2>>*/ var
      fmt = param[1],
-      /*<<format.ml:1443:2>>*/ _F_ = 0;
-    function _G_(acc){
+      /*<<format.ml:1443:2>>*/ _E_ = 0;
+    function _F_(acc){
       /*<<format.ml:1444:16>>*/ return  /*<<format.ml:1444:18>>*/ caml_call1
              (k,
               function(ppf){
@@ -26700,7 +26713,7 @@
                /*<<format.ml:1444:48>>*/ });
      /*<<format.ml:1444:49>>*/ }
      /*<<format.ml:1443:2>>*/ return  /*<<format.ml:1443:2>>*/ caml_call3
-            (CamlinternalFormat[7], _G_, _F_, fmt);
+            (CamlinternalFormat[7], _F_, _E_, fmt);
    }
    function dprintf(fmt){
      /*<<format.ml:1447:18>>*/ return kdprintf
@@ -26758,44 +26771,44 @@
      /*<<format.ml:1481:11>>*/ var
       /*<<format.ml:1481:11>>*/ fs =
        pp_get_formatter_out_functions(std_formatter, 0),
-     _n_ = fs[5],
-     _o_ = fs[4],
-     _p_ = fs[3],
-     _q_ = Stdlib[39];
-     /*<<format.ml:1484:25>>*/ function _r_(_E_){
-      /*<<?>>*/ return buffered_out_flush(_q_, std_buf_key, _E_);
+     _m_ = fs[5],
+     _n_ = fs[4],
+     _o_ = fs[3],
+     _p_ = Stdlib[39];
+     /*<<format.ml:1484:25>>*/ function _q_(_D_){
+      /*<<?>>*/ return buffered_out_flush(_p_, std_buf_key, _D_);
     }
      /*<<format.ml:1482:2>>*/ pp_set_formatter_out_functions
      (std_formatter,
       [0,
-       function(_B_, _C_, _D_){
-         /*<<?>>*/ return buffered_out_string(std_buf_key, _B_, _C_, _D_);
+       function(_A_, _B_, _C_){
+         /*<<?>>*/ return buffered_out_string(std_buf_key, _A_, _B_, _C_);
        },
-       _r_,
-       _p_,
+       _q_,
        _o_,
-       _n_]);
+       _n_,
+       _m_]);
      /*<<format.ml:1486:11>>*/ var
       /*<<format.ml:1486:11>>*/ fs$0 =
        pp_get_formatter_out_functions(err_formatter, 0),
-     _s_ = fs$0[5],
-     _t_ = fs$0[4],
-     _u_ = fs$0[3],
-     _v_ = Stdlib[40];
-     /*<<format.ml:1489:25>>*/ function _w_(_A_){
-      /*<<?>>*/ return buffered_out_flush(_v_, err_buf_key, _A_);
+     _r_ = fs$0[5],
+     _s_ = fs$0[4],
+     _t_ = fs$0[3],
+     _u_ = Stdlib[40];
+     /*<<format.ml:1489:25>>*/ function _v_(_z_){
+      /*<<?>>*/ return buffered_out_flush(_u_, err_buf_key, _z_);
     }
      /*<<format.ml:1488:4>>*/ return pp_set_formatter_out_functions
             (err_formatter,
              [0,
-              function(_x_, _y_, _z_){
+              function(_w_, _x_, _y_){
                 /*<<?>>*/ return buffered_out_string
-                       (err_buf_key, _x_, _y_, _z_);
+                       (err_buf_key, _w_, _x_, _y_);
               },
-              _w_,
-              _u_,
+              _v_,
               _t_,
-              _s_]);
+              _s_,
+              _r_]);
     /*<<format.ml:1489:71>>*/ }
     /*<<format.ml:1479:9>>*/  /*<<format.ml:1479:9>>*/ caml_call1
     (Stdlib_Domain[5], _l_);
@@ -26996,7 +27009,7 @@
             : runtime.caml_call_gen(f, [a0, a1, a2, a3]);
    }
    var
-    _u_ = undefined,
+    sentinal = undefined,
     global_data = runtime.caml_get_global_data(),
     cst$3 = cst$5,
     cst$4 = cst$5,
@@ -27120,9 +27133,9 @@
      if(10 === c) ib[5] = ib[5] + 1 | 0;
       /*<<scanf.ml:171:6>>*/ return c;
     }
-    catch(_bc_){
-     var _bb_ = caml_wrap_exception(_bc_);
-     if(_bb_ !== Stdlib[12]) throw caml_maybe_attach_backtrace(_bb_, 0);
+    catch(_bb_){
+     var _ba_ = caml_wrap_exception(_bb_);
+     if(_ba_ !== Stdlib[12]) throw caml_maybe_attach_backtrace(_ba_, 0);
      ib[2] = null_char;
      ib[3] = 0;
      ib[1] = 1;
@@ -27215,8 +27228,8 @@
      /*<<scanf.ml:271:4>>*/ return create(1, next);
     /*<<scanf.ml:271:27>>*/ }
    var _a_ = 0;
-    /*<<scanf.ml:274:22>>*/ function from_function(_ba_){
-     /*<<?>>*/ return create(_a_, _ba_);
+    /*<<scanf.ml:274:22>>*/ function from_function(_a$_){
+     /*<<?>>*/ return create(_a_, _a$_);
    }
     /*<<scanf.ml:274:22>>*/  /*<<scanf.ml:274:22>>*/ var len = 1024;
    function scan_close_at_end(ic){
@@ -27263,12 +27276,12 @@
     return from_ic(scan_close_at_end, [1, fname, ic], ic);
     /*<<scanf.ml:371:53>>*/ }
    var _b_ = Stdlib[79];
-    /*<<scanf.ml:374:16>>*/ function open_in(_a$_){
-     /*<<?>>*/ return open_in_file(_b_, _a$_);
+    /*<<scanf.ml:374:16>>*/ function open_in(_a__){
+     /*<<?>>*/ return open_in_file(_b_, _a__);
    }
     /*<<scanf.ml:374:16>>*/  /*<<scanf.ml:374:16>>*/ var _c_ = Stdlib[80];
-    /*<<scanf.ml:375:20>>*/ function open_in_bin(_a__){
-     /*<<?>>*/ return open_in_file(_c_, _a__);
+    /*<<scanf.ml:375:20>>*/ function open_in_bin(_a9_){
+     /*<<?>>*/ return open_in_file(_c_, _a9_);
    }
    function from_channel(ic){
      /*<<scanf.ml:381:4>>*/ return from_ic(scan_raise_at_end, [0, ic], ic);
@@ -27331,15 +27344,15 @@
      /*<<scanf.ml:444:2>>*/ for(;;){
       /*<<scanf.ml:444:10>>*/ var
        /*<<scanf.ml:444:10>>*/ c = peek_char(ib),
-       /*<<scanf.ml:445:9>>*/ _a8_ = 1 - ib[1];
-     if(! _a8_)  /*<<scanf.ml:445:9>>*/ return _a8_;
-      /*<<scanf.ml:445:32>>*/  /*<<scanf.ml:445:32>>*/ var _a9_ = c - 9 | 0;
+       /*<<scanf.ml:445:9>>*/ _a7_ = 1 - ib[1];
+     if(! _a7_)  /*<<scanf.ml:445:9>>*/ return _a7_;
+      /*<<scanf.ml:445:32>>*/  /*<<scanf.ml:445:32>>*/ var _a8_ = c - 9 | 0;
      a:
      {
-      if(4 < _a9_ >>> 0){
-       if(23 === _a9_) break a;
+      if(4 < _a8_ >>> 0){
+       if(23 === _a8_) break a;
       }
-      else if(1 < _a9_ - 2 >>> 0) break a;
+      else if(1 < _a8_ - 2 >>> 0) break a;
        /*<<scanf.ml:449:11>>*/ return 0;
      }
       /*<<scanf.ml:448:6>>*/ invalidate_current_char(ib);
@@ -27385,23 +27398,23 @@
      /*<<scanf.ml:523:2>>*/ switch(conv){
       case 0:
         /*<<scanf.ml:529:29>>*/ var
-         /*<<scanf.ml:529:29>>*/ _a4_ = token_string(ib),
-        tok =  /*<<scanf.ml:529:22>>*/ caml_call2(Stdlib[28], cst_0b, _a4_);
+         /*<<scanf.ml:529:29>>*/ _a3_ = token_string(ib),
+        tok =  /*<<scanf.ml:529:22>>*/ caml_call2(Stdlib[28], cst_0b, _a3_);
        break;
       case 3:
         /*<<scanf.ml:527:29>>*/ var
-         /*<<scanf.ml:527:29>>*/ _a5_ = token_string(ib),
-        tok =  /*<<scanf.ml:527:22>>*/ caml_call2(Stdlib[28], cst_0o, _a5_);
+         /*<<scanf.ml:527:29>>*/ _a4_ = token_string(ib),
+        tok =  /*<<scanf.ml:527:22>>*/ caml_call2(Stdlib[28], cst_0o, _a4_);
        break;
       case 4:
         /*<<scanf.ml:526:29>>*/ var
-         /*<<scanf.ml:526:29>>*/ _a6_ = token_string(ib),
-        tok =  /*<<scanf.ml:526:22>>*/ caml_call2(Stdlib[28], cst_0u, _a6_);
+         /*<<scanf.ml:526:29>>*/ _a5_ = token_string(ib),
+        tok =  /*<<scanf.ml:526:22>>*/ caml_call2(Stdlib[28], cst_0u, _a5_);
        break;
       case 5:
         /*<<scanf.ml:528:29>>*/ var
-         /*<<scanf.ml:528:29>>*/ _a7_ = token_string(ib),
-        tok =  /*<<scanf.ml:528:22>>*/ caml_call2(Stdlib[28], cst_0x, _a7_);
+         /*<<scanf.ml:528:29>>*/ _a6_ = token_string(ib),
+        tok =  /*<<scanf.ml:528:22>>*/ caml_call2(Stdlib[28], cst_0x, _a6_);
        break;
       default: var tok = token_string(ib);
     }
@@ -27486,31 +27499,31 @@
    function is_binary_digit(param){
      /*<<scanf.ml:629:22>>*/ return 1 < param - 48 >>> 0 ? 0 : 1;
     /*<<scanf.ml:631:14>>*/ }
-    /*<<scanf.ml:634:22>>*/ function scan_binary_int(_a2_, _a3_){
-     /*<<?>>*/ return scan_digit_plus(cst_binary, is_binary_digit, _a2_, _a3_);
+    /*<<scanf.ml:634:22>>*/ function scan_binary_int(_a1_, _a2_){
+     /*<<?>>*/ return scan_digit_plus(cst_binary, is_binary_digit, _a1_, _a2_);
    }
    function is_octal_digit(param){
      /*<<scanf.ml:636:21>>*/ return 7 < param - 48 >>> 0 ? 0 : 1;
     /*<<scanf.ml:638:14>>*/ }
-    /*<<scanf.ml:641:21>>*/ function scan_octal_int(_a0_, _a1_){
-     /*<<?>>*/ return scan_digit_plus(cst_octal, is_octal_digit, _a0_, _a1_);
+    /*<<scanf.ml:641:21>>*/ function scan_octal_int(_aZ_, _a0_){
+     /*<<?>>*/ return scan_digit_plus(cst_octal, is_octal_digit, _aZ_, _a0_);
    }
    function is_hexa_digit(param){
      /*<<scanf.ml:643:20>>*/  /*<<scanf.ml:643:20>>*/ var
-     _aZ_ = param - 48 | 0;
+     _aY_ = param - 48 | 0;
     a:
     {
-     if(22 < _aZ_ >>> 0){
-      if(5 < _aZ_ - 49 >>> 0) break a;
+     if(22 < _aY_ >>> 0){
+      if(5 < _aY_ - 49 >>> 0) break a;
      }
-     else if(6 >= _aZ_ - 10 >>> 0) break a;
+     else if(6 >= _aY_ - 10 >>> 0) break a;
       /*<<scanf.ml:644:44>>*/ return 1;
     }
      /*<<scanf.ml:645:9>>*/ return 0;
     /*<<scanf.ml:645:14>>*/ }
-    /*<<scanf.ml:648:27>>*/ function scan_hexadecimal_int(_aX_, _aY_){
+    /*<<scanf.ml:648:27>>*/ function scan_hexadecimal_int(_aW_, _aX_){
      /*<<?>>*/ return scan_digit_plus
-            (cst_hexadecimal, is_hexa_digit, _aX_, _aY_);
+            (cst_hexadecimal, is_hexa_digit, _aW_, _aX_);
    }
    function scan_sign(width, ib){
      /*<<scanf.ml:654:2>>*/ var
@@ -27630,38 +27643,38 @@
       /*<<scanf.ml:785:2>>*/ len =
         /*<<scanf.ml:785:2>>*/ caml_ml_string_length(str),
       /*<<scanf.ml:786:14>>*/ width$0 = [0, width],
-      /*<<scanf.ml:787:2>>*/ _aU_ = len - 1 | 0,
-      /*<<scanf.ml:786:14>>*/ _aT_ = 0;
-    if(_aU_ >= 0){
-     var i = _aT_;
+      /*<<scanf.ml:787:2>>*/ _aT_ = len - 1 | 0,
+      /*<<scanf.ml:786:14>>*/ _aS_ = 0;
+    if(_aT_ >= 0){
+     var i = _aS_;
      for(;;){
        /*<<scanf.ml:788:12>>*/ var
         /*<<scanf.ml:788:12>>*/ c = peek_char(ib),
-        /*<<scanf.ml:789:22>>*/ _aV_ =
+        /*<<scanf.ml:789:22>>*/ _aU_ =
          lowercase( /*<<scanf.ml:789:32>>*/ caml_string_get(str, i));
-      if(lowercase(c) !== _aV_)
+      if(lowercase(c) !== _aU_)
         /*<<scanf.ml:789:45>>*/  /*<<scanf.ml:789:45>>*/ caml_call1(error, 0);
       if(0 === width$0[1])
         /*<<scanf.ml:790:23>>*/  /*<<scanf.ml:790:23>>*/ caml_call1(error, 0);
       width$0[1] = store_char(width$0[1], ib, c);
-       /*<<scanf.ml:787:2>>*/  /*<<scanf.ml:787:2>>*/ var _aW_ = i + 1 | 0;
-      if(_aU_ === i) break;
-      var i = _aW_;
+       /*<<scanf.ml:787:2>>*/  /*<<scanf.ml:787:2>>*/ var _aV_ = i + 1 | 0;
+      if(_aT_ === i) break;
+      var i = _aV_;
      }
     }
     return width$0[1];
     /*<<scanf.ml:793:8>>*/ }
    function scan_hex_float(width, precision, ib){
      /*<<scanf.ml:797:2>>*/ var
-     _aG_ = 0 === width ? 1 : 0,
-     _aH_ = _aG_ || end_of_input(ib);
-     /*<<scanf.ml:797:18>>*/ if(_aH_)
+     _aF_ = 0 === width ? 1 : 0,
+     _aG_ = _aF_ || end_of_input(ib);
+     /*<<scanf.ml:797:18>>*/ if(_aG_)
       /*<<scanf.ml:797:48>>*/ bad_hex_float(0);
      /*<<scanf.ml:798:14>>*/ var
       /*<<scanf.ml:798:14>>*/ width$0 = scan_sign(width, ib),
-     _aI_ = 0 === width$0 ? 1 : 0,
-     _aJ_ = _aI_ || end_of_input(ib);
-     /*<<scanf.ml:799:18>>*/ if(_aJ_)
+     _aH_ = 0 === width$0 ? 1 : 0,
+     _aI_ = _aH_ || end_of_input(ib);
+     /*<<scanf.ml:799:18>>*/ if(_aI_)
       /*<<scanf.ml:799:48>>*/ bad_hex_float(0);
      /*<<scanf.ml:800:8>>*/  /*<<scanf.ml:800:8>>*/ var c = peek_char(ib);
     a:
@@ -27673,9 +27686,9 @@
        if(32 <= switcher) break a;
         /*<<scanf.ml:830:16>>*/ var
          /*<<scanf.ml:830:16>>*/ width$1 = store_char(width$0, ib, c),
-        _aK_ = 0 === width$1 ? 1 : 0,
-        _aL_ = _aK_ || end_of_input(ib);
-        /*<<scanf.ml:831:20>>*/ if(_aL_)
+        _aJ_ = 0 === width$1 ? 1 : 0,
+        _aK_ = _aJ_ || end_of_input(ib);
+        /*<<scanf.ml:831:20>>*/ if(_aK_)
          /*<<scanf.ml:831:50>>*/ bad_hex_float(0);
         /*<<scanf.ml:831:50>>*/ return check_case_insensitive_string
                (width$1, ib, bad_hex_float, cst_an);
@@ -27686,24 +27699,24 @@
       if(48 === c){
         /*<<scanf.ml:802:16>>*/ var
          /*<<scanf.ml:802:16>>*/ width$3 = store_char(width$0, ib, c),
-        _aO_ = 0 === width$3 ? 1 : 0,
-        _aP_ = _aO_ || end_of_input(ib);
-        /*<<scanf.ml:803:20>>*/ if(_aP_)
+        _aN_ = 0 === width$3 ? 1 : 0,
+        _aO_ = _aN_ || end_of_input(ib);
+        /*<<scanf.ml:803:20>>*/ if(_aO_)
          /*<<scanf.ml:803:50>>*/ bad_hex_float(0);
         /*<<scanf.ml:804:16>>*/  /*<<scanf.ml:804:16>>*/ var
         width$4 =
           check_case_insensitive_string(width$3, ib, bad_hex_float, cst_x);
         /*<<scanf.ml:805:20>>*/ if(0 !== width$4 && ! end_of_input(ib)){
          /*<<scanf.ml:806:24>>*/  /*<<scanf.ml:806:24>>*/ var
-         _aQ_ = peek_char(ib) - 46 | 0;
+         _aP_ = peek_char(ib) - 46 | 0;
         b:
         {
          c:
          {
-          if(34 < _aQ_ >>> 0){
-           if(66 === _aQ_) break c;
+          if(34 < _aP_ >>> 0){
+           if(66 === _aP_) break c;
           }
-          else if(32 < _aQ_ - 1 >>> 0) break c;
+          else if(32 < _aP_ - 1 >>> 0) break c;
           var width$5 = scan_hexadecimal_int(width$4, ib);
           break b;
          }
@@ -27751,9 +27764,9 @@
             /*<<scanf.ml:827:17>>*/ return width$8;
            /*<<scanf.ml:824:24>>*/ var
             /*<<scanf.ml:824:24>>*/ width$9 = store_char(width$8, ib, c$1),
-           _aR_ = 0 === width$9 ? 1 : 0,
-           _aS_ = _aR_ || end_of_input(ib);
-           /*<<scanf.ml:825:28>>*/ if(_aS_)
+           _aQ_ = 0 === width$9 ? 1 : 0,
+           _aR_ = _aQ_ || end_of_input(ib);
+           /*<<scanf.ml:825:28>>*/ if(_aR_)
             /*<<scanf.ml:825:58>>*/ bad_hex_float(0);
            /*<<scanf.ml:825:58>>*/ return scan_optionally_signed_decimal
                   (width$9, ib);
@@ -27768,9 +27781,9 @@
      }
       /*<<scanf.ml:834:16>>*/ var
        /*<<scanf.ml:834:16>>*/ width$2 = store_char(width$0, ib, c),
-      _aM_ = 0 === width$2 ? 1 : 0,
-      _aN_ = _aM_ || end_of_input(ib);
-      /*<<scanf.ml:835:20>>*/ if(_aN_)
+      _aL_ = 0 === width$2 ? 1 : 0,
+      _aM_ = _aL_ || end_of_input(ib);
+      /*<<scanf.ml:835:20>>*/ if(_aM_)
        /*<<scanf.ml:835:50>>*/ bad_hex_float(0);
       /*<<scanf.ml:835:50>>*/ return check_case_insensitive_string
              (width$2, ib, bad_hex_float, cst_nfinity);
@@ -27779,14 +27792,14 @@
     /*<<scanf.ml:837:25>>*/ }
    function scan_caml_float_rest(width, precision, ib){
      /*<<scanf.ml:841:2>>*/ var
-     _aC_ = 0 === width ? 1 : 0,
-     _aD_ = _aC_ || end_of_input(ib);
-     /*<<scanf.ml:841:18>>*/ if(_aD_)  /*<<scanf.ml:841:48>>*/ bad_float(0);
+     _aB_ = 0 === width ? 1 : 0,
+     _aC_ = _aB_ || end_of_input(ib);
+     /*<<scanf.ml:841:18>>*/ if(_aC_)  /*<<scanf.ml:841:48>>*/ bad_float(0);
      /*<<scanf.ml:842:14>>*/ var
       /*<<scanf.ml:842:14>>*/ width$0 = scan_decimal_digit_star(width, ib),
-     _aE_ = 0 === width$0 ? 1 : 0,
-     _aF_ = _aE_ || end_of_input(ib);
-     /*<<scanf.ml:843:18>>*/ if(_aF_)  /*<<scanf.ml:843:48>>*/ bad_float(0);
+     _aD_ = 0 === width$0 ? 1 : 0,
+     _aE_ = _aD_ || end_of_input(ib);
+     /*<<scanf.ml:843:18>>*/ if(_aE_)  /*<<scanf.ml:843:48>>*/ bad_float(0);
      /*<<scanf.ml:844:10>>*/ var
       /*<<scanf.ml:844:10>>*/ c = peek_char(ib),
       /*<<scanf.ml:844:10>>*/ switcher = c - 69 | 0;
@@ -27810,22 +27823,22 @@
     /*<<scanf.ml:862:21>>*/ }
    function scan_caml_float(width, precision, ib){
      /*<<scanf.ml:866:2>>*/ var
-     _ao_ = 0 === width ? 1 : 0,
-     _ap_ = _ao_ || end_of_input(ib);
-     /*<<scanf.ml:866:18>>*/ if(_ap_)  /*<<scanf.ml:866:48>>*/ bad_float(0);
+     _an_ = 0 === width ? 1 : 0,
+     _ao_ = _an_ || end_of_input(ib);
+     /*<<scanf.ml:866:18>>*/ if(_ao_)  /*<<scanf.ml:866:48>>*/ bad_float(0);
      /*<<scanf.ml:867:14>>*/ var
       /*<<scanf.ml:867:14>>*/ width$0 = scan_sign(width, ib),
-     _aq_ = 0 === width$0 ? 1 : 0,
-     _ar_ = _aq_ || end_of_input(ib);
-     /*<<scanf.ml:868:18>>*/ if(_ar_)  /*<<scanf.ml:868:48>>*/ bad_float(0);
+     _ap_ = 0 === width$0 ? 1 : 0,
+     _aq_ = _ap_ || end_of_input(ib);
+     /*<<scanf.ml:868:18>>*/ if(_aq_)  /*<<scanf.ml:868:48>>*/ bad_float(0);
      /*<<scanf.ml:869:8>>*/  /*<<scanf.ml:869:8>>*/ var c = peek_char(ib);
     if(49 <= c){
      if(58 > c){
        /*<<scanf.ml:903:16>>*/ var
         /*<<scanf.ml:903:16>>*/ width$1 = store_char(width$0, ib, c),
-       _as_ = 0 === width$1 ? 1 : 0,
-       _at_ = _as_ || end_of_input(ib);
-       /*<<scanf.ml:904:20>>*/ if(_at_)  /*<<scanf.ml:904:50>>*/ bad_float(0);
+       _ar_ = 0 === width$1 ? 1 : 0,
+       _as_ = _ar_ || end_of_input(ib);
+       /*<<scanf.ml:904:20>>*/ if(_as_)  /*<<scanf.ml:904:50>>*/ bad_float(0);
        /*<<scanf.ml:904:50>>*/ return scan_caml_float_rest
               (width$1, precision, ib);
      }
@@ -27833,9 +27846,9 @@
     else if(48 <= c){
       /*<<scanf.ml:871:16>>*/ var
        /*<<scanf.ml:871:16>>*/ width$2 = store_char(width$0, ib, c),
-      _au_ = 0 === width$2 ? 1 : 0,
-      _av_ = _au_ || end_of_input(ib);
-      /*<<scanf.ml:872:20>>*/ if(_av_)  /*<<scanf.ml:872:50>>*/ bad_float(0);
+      _at_ = 0 === width$2 ? 1 : 0,
+      _au_ = _at_ || end_of_input(ib);
+      /*<<scanf.ml:872:20>>*/ if(_au_)  /*<<scanf.ml:872:50>>*/ bad_float(0);
       /*<<scanf.ml:873:10>>*/  /*<<scanf.ml:873:10>>*/ var
       c$0 = peek_char(ib);
      if(88 !== c$0 && 120 !== c$0)
@@ -27843,14 +27856,14 @@
               (width$2, precision, ib);
       /*<<scanf.ml:875:18>>*/ var
        /*<<scanf.ml:875:18>>*/ width$3 = store_char(width$2, ib, c$0),
-      _aw_ = 0 === width$3 ? 1 : 0,
-      _ax_ = _aw_ || end_of_input(ib);
-      /*<<scanf.ml:876:22>>*/ if(_ax_)  /*<<scanf.ml:876:52>>*/ bad_float(0);
+      _av_ = 0 === width$3 ? 1 : 0,
+      _aw_ = _av_ || end_of_input(ib);
+      /*<<scanf.ml:876:22>>*/ if(_aw_)  /*<<scanf.ml:876:52>>*/ bad_float(0);
       /*<<scanf.ml:877:18>>*/ var
        /*<<scanf.ml:877:18>>*/ width$4 = scan_hexadecimal_int(width$3, ib),
-      _ay_ = 0 === width$4 ? 1 : 0,
-      _az_ = _ay_ || end_of_input(ib);
-      /*<<scanf.ml:878:22>>*/ if(_az_)  /*<<scanf.ml:878:52>>*/ bad_float(0);
+      _ax_ = 0 === width$4 ? 1 : 0,
+      _ay_ = _ax_ || end_of_input(ib);
+      /*<<scanf.ml:878:22>>*/ if(_ay_)  /*<<scanf.ml:878:52>>*/ bad_float(0);
       /*<<scanf.ml:879:24>>*/ var
        /*<<scanf.ml:879:24>>*/ c$1 = peek_char(ib),
        /*<<scanf.ml:879:24>>*/ switcher = c$1 - 80 | 0;
@@ -27903,9 +27916,9 @@
       if(80 !== c$2 && 112 !== c$2)  /*<<scanf.ml:897:15>>*/ return width$8;
        /*<<scanf.ml:894:22>>*/ var
         /*<<scanf.ml:894:22>>*/ width$9 = store_char(width$8, ib, c$2),
-       _aA_ = 0 === width$9 ? 1 : 0,
-       _aB_ = _aA_ || end_of_input(ib);
-       /*<<scanf.ml:895:26>>*/ if(_aB_)
+       _az_ = 0 === width$9 ? 1 : 0,
+       _aA_ = _az_ || end_of_input(ib);
+       /*<<scanf.ml:895:26>>*/ if(_aA_)
         /*<<scanf.ml:895:56>>*/ bad_hex_float(0);
        /*<<scanf.ml:895:56>>*/ return scan_optionally_signed_decimal
               (width$9, ib);
@@ -27922,13 +27935,13 @@
       /*<<scanf.ml:923:7>>*/ if(ib[1])
        /*<<scanf.ml:923:28>>*/ return width$0;
      if(! stp){
-       /*<<scanf.ml:928:8>>*/  /*<<scanf.ml:928:8>>*/ var _an_ = c - 9 | 0;
+       /*<<scanf.ml:928:8>>*/  /*<<scanf.ml:928:8>>*/ var _am_ = c - 9 | 0;
       a:
       {
-       if(4 < _an_ >>> 0){
-        if(23 === _an_) break a;
+       if(4 < _am_ >>> 0){
+        if(23 === _am_) break a;
        }
-       else if(1 < _an_ - 2 >>> 0) break a;
+       else if(1 < _am_ - 2 >>> 0) break a;
         /*<<scanf.ml:930:20>>*/ var
          /*<<scanf.ml:930:20>>*/ width$2 = store_char(width$0, ib, c),
         width$0 = width$2;
@@ -27958,11 +27971,11 @@
                 (Stdlib_Printf[4], _f_, message))
             : c;
     /*<<scanf.ml:998:3>>*/ }
-    /*<<scanf.ml:1001:31>>*/ function check_next_char_for_char(_al_, _am_){
-     /*<<?>>*/ return check_next_char(cst_a_Char, _al_, _am_);
+    /*<<scanf.ml:1001:31>>*/ function check_next_char_for_char(_ak_, _al_){
+     /*<<?>>*/ return check_next_char(cst_a_Char, _ak_, _al_);
    }
-    /*<<scanf.ml:1002:33>>*/ function check_next_char_for_string(_aj_, _ak_){
-     /*<<?>>*/ return check_next_char(cst_a_String, _aj_, _ak_);
+    /*<<scanf.ml:1002:33>>*/ function check_next_char_for_string(_ai_, _aj_){
+     /*<<?>>*/ return check_next_char(cst_a_String, _ai_, _aj_);
    }
    function scan_backslash_char(width, ib){
      /*<<scanf.ml:1005:2>>*/  /*<<scanf.ml:1005:8>>*/ var
@@ -27988,16 +28001,16 @@
        b:
        {
         if(0 <= c && 255 >= c){
-         var _ah_ =  /*<<scanf.ml:963:2>>*/ caml_call1(Stdlib[29], c);
+         var _ag_ =  /*<<scanf.ml:963:2>>*/ caml_call1(Stdlib[29], c);
          break b;
         }
         var
-         _ah_ =
+         _ag_ =
            bad_input
             ( /*<<scanf.ml:961:6>>*/ caml_call4
               (Stdlib_Printf[4], _l_, c0, c1$0, c2$0));
        }
-        /*<<scanf.ml:1017:39>>*/ return store_char(width - 2 | 0, ib, _ah_);
+        /*<<scanf.ml:1017:39>>*/ return store_char(width - 2 | 0, ib, _ag_);
       }
        /*<<scanf.ml:1005:8>>*/  /*<<scanf.ml:1005:8>>*/ var
        switcher = c0 - 92 | 0;
@@ -28009,34 +28022,34 @@
             function(param){
               /*<<scanf.ml:1020:6>>*/ var
                /*<<scanf.ml:1020:14>>*/ c = next_char(ib),
-               /*<<scanf.ml:1020:14>>*/ _ai_ = c - 48 | 0;
+               /*<<scanf.ml:1020:14>>*/ _ah_ = c - 48 | 0;
              a:
              {
-              if(22 < _ai_ >>> 0){
-               if(5 < _ai_ - 49 >>> 0) break a;
+              if(22 < _ah_ >>> 0){
+               if(5 < _ah_ - 49 >>> 0) break a;
               }
-              else if(6 >= _ai_ - 10 >>> 0) break a;
+              else if(6 >= _ah_ - 10 >>> 0) break a;
                /*<<scanf.ml:1022:53>>*/ return c;
              }
               /*<<scanf.ml:1023:13>>*/ return bad_input_escape(c);
              /*<<scanf.ml:1023:31>>*/ },
            /*<<scanf.ml:1024:13>>*/ c1 = get_digit(0),
            /*<<scanf.ml:1025:13>>*/ c2 = get_digit(0),
-           /*<<scanf.ml:985:9>>*/ _ae_ = hexadecimal_value_of_char(c2),
-          c$0 = (16 * hexadecimal_value_of_char(c1) | 0) + _ae_ | 0;
+           /*<<scanf.ml:985:9>>*/ _ad_ = hexadecimal_value_of_char(c2),
+          c$0 = (16 * hexadecimal_value_of_char(c1) | 0) + _ad_ | 0;
          b:
          {
           if(0 <= c$0 && 255 >= c$0){
-           var _ag_ =  /*<<scanf.ml:989:2>>*/ caml_call1(Stdlib[29], c$0);
+           var _af_ =  /*<<scanf.ml:989:2>>*/ caml_call1(Stdlib[29], c$0);
            break b;
           }
           var
-           _ag_ =
+           _af_ =
              bad_input
               ( /*<<scanf.ml:988:6>>*/ caml_call3
                 (Stdlib_Printf[4], _m_, c1, c2));
          }
-          /*<<scanf.ml:1026:39>>*/ return store_char(width - 2 | 0, ib, _ag_);
+          /*<<scanf.ml:1026:39>>*/ return store_char(width - 2 | 0, ib, _af_);
         case 0:
         case 6:
         case 18:
@@ -28052,17 +28065,17 @@
        if(117 > c0)
         switch(c0 - 110 | 0){
           case 0:
-           var _af_ = 10; break b;
+           var _ae_ = 10; break b;
           case 4:
-           var _af_ = 13; break b;
+           var _ae_ = 13; break b;
           case 6:
-           var _af_ = 9; break b;
+           var _ae_ = 9; break b;
         }
       }
-      else if(98 === c0){var _af_ = 8; break b;}
-      var _af_ = c0;
+      else if(98 === c0){var _ae_ = 8; break b;}
+      var _ae_ = c0;
      }
-      /*<<scanf.ml:1007:33>>*/ return store_char(width, ib, _af_);
+      /*<<scanf.ml:1007:33>>*/ return store_char(width, ib, _ae_);
     }
      /*<<scanf.ml:1028:4>>*/ return bad_input_escape(c0);
     /*<<scanf.ml:1028:22>>*/ }
@@ -28080,24 +28093,24 @@
           check_next_char_for_string(width$1, ib);
        if(10 === match){
          /*<<scanf.ml:1071:26>>*/  /*<<scanf.ml:1071:26>>*/ var
-         _ac_ = ignore_char(width$1, ib);
+         _ab_ = ignore_char(width$1, ib);
          /*<<scanf.ml:1071:26>>*/ if(counter >= 50)
           /*<<scanf.ml:1071:26>>*/ return  /*<<scanf.ml:1071:26>>*/ caml_trampoline_return
-                 (skip_spaces, [0, _ac_]);
+                 (skip_spaces, [0, _ab_]);
         var counter$0 = counter + 1 | 0;
-         /*<<scanf.ml:1071:26>>*/ return skip_spaces(counter$0, _ac_);
+         /*<<scanf.ml:1071:26>>*/ return skip_spaces(counter$0, _ab_);
        }
        if(13 === match){
          /*<<scanf.ml:1070:27>>*/  /*<<scanf.ml:1070:27>>*/ var
          width$3 = ignore_char(width$1, ib);
         if(10 === check_next_char_for_string(width$3, ib)){
           /*<<scanf.ml:1076:26>>*/  /*<<scanf.ml:1076:26>>*/ var
-          _ad_ = ignore_char(width$3, ib);
+          _ac_ = ignore_char(width$3, ib);
           /*<<scanf.ml:1076:26>>*/ if(counter >= 50)
            /*<<scanf.ml:1076:26>>*/ return  /*<<scanf.ml:1076:26>>*/ caml_trampoline_return
-                  (skip_spaces, [0, _ad_]);
+                  (skip_spaces, [0, _ac_]);
          var counter$1 = counter + 1 | 0;
-          /*<<scanf.ml:1076:26>>*/ return skip_spaces(counter$1, _ad_);
+          /*<<scanf.ml:1076:26>>*/ return skip_spaces(counter$1, _ac_);
         }
          /*<<scanf.ml:1077:21>>*/ var
           /*<<scanf.ml:1077:21>>*/ width$5 = store_char(width$3, ib, 13),
@@ -28144,39 +28157,39 @@
       /*<<scanf.ml:1104:4>>*/ for(;;){
        /*<<scanf.ml:1104:12>>*/ var
         /*<<scanf.ml:1104:12>>*/ c = peek_char(ib),
-       ___ = 0 < i$0 ? 1 : 0;
-      if(___){
+       _Z_ = 0 < i$0 ? 1 : 0;
+      if(_Z_){
         /*<<scanf.ml:1105:20>>*/  /*<<scanf.ml:1105:20>>*/ var
-        _$_ = 1 - ib[1];
-       if(_$_)
+        ___ = 1 - ib[1];
+       if(___)
          /*<<scanf.ml:1106:7>>*/ var
-          /*<<scanf.ml:1106:7>>*/ _aa_ =
+          /*<<scanf.ml:1106:7>>*/ _$_ =
             /*<<scanf.ml:1106:7>>*/ caml_call2
             (CamlinternalFormat[1], char_set, c),
-          /*<<scanf.ml:1106:7>>*/ _ab_ = _aa_ ? c !== stp ? 1 : 0 : _aa_;
+          /*<<scanf.ml:1106:7>>*/ _aa_ = _$_ ? c !== stp ? 1 : 0 : _$_;
        else
-        var _ab_ = _$_;
+        var _aa_ = ___;
       }
       else
-       var _ab_ = ___;
-      if(! _ab_) return _ab_;
+       var _aa_ = _Z_;
+      if(! _aa_) return _aa_;
        /*<<scanf.ml:1108:14>>*/ store_char(Stdlib[19], ib, c);
       var i$1 = i$0 - 1 | 0, i$0 = i$1;
      }
      /*<<scanf.ml:1109:28>>*/ }
     if(! scan_indic){
       /*<<scanf.ml:1111:12>>*/ scan_chars(width, -1);
-      /*<<scanf.ml:1111:12>>*/ return _u_;
+      /*<<scanf.ml:1111:12>>*/ return sentinal;
     }
     var c = scan_indic[1];
      /*<<scanf.ml:1113:4>>*/ scan_chars(width, c);
-     /*<<scanf.ml:1114:11>>*/  /*<<scanf.ml:1114:11>>*/ var _Z_ = 1 - ib[1];
-    if(! _Z_)  /*<<scanf.ml:1114:11>>*/ return _Z_;
+     /*<<scanf.ml:1114:11>>*/  /*<<scanf.ml:1114:11>>*/ var _Y_ = 1 - ib[1];
+    if(! _Y_)  /*<<scanf.ml:1114:11>>*/ return _Y_;
      /*<<scanf.ml:1115:15>>*/  /*<<scanf.ml:1115:15>>*/ var
      ci = peek_char(ib);
     return c === ci
-            ? (invalidate_current_char(ib), _u_)
-            : (character_mismatch(c, ci), _u_);
+            ? (invalidate_current_char(ib), sentinal)
+            : (character_mismatch(c, ci), sentinal);
     /*<<scanf.ml:1118:34>>*/ }
    function scanf_bad_input(ib, x){
      /*<<?>>*/ if(x[1] === Scan_failure)
@@ -28253,17 +28266,17 @@
          /*<<scanf.ml:1195:44>>*/ var
          rest$13 = fmt$0[3],
          fmtty = fmt$0[2],
-          /*<<scanf.ml:1195:44>>*/ _W_ =
+          /*<<scanf.ml:1195:44>>*/ _V_ =
             /*<<scanf.ml:1195:44>>*/ caml_call1(CamlinternalFormat[21], fmtty),
-          /*<<scanf.ml:1195:33>>*/ _X_ =
+          /*<<scanf.ml:1195:33>>*/ _W_ =
             /*<<scanf.ml:1195:33>>*/ caml_call1
-            (CamlinternalFormatBasics[2], _W_);
+            (CamlinternalFormatBasics[2], _V_);
          /*<<scanf.ml:1195:5>>*/ if(counter >= 50)
           /*<<scanf.ml:1195:5>>*/ return  /*<<scanf.ml:1195:5>>*/ caml_trampoline_return
-                 (take_fmtty_format_readers$0, [0, k, _X_, rest$13]);
+                 (take_fmtty_format_readers$0, [0, k, _W_, rest$13]);
         var counter$0 = counter + 1 | 0;
          /*<<scanf.ml:1195:5>>*/ return take_fmtty_format_readers$0
-                (counter$0, k, _X_, rest$13);
+                (counter$0, k, _W_, rest$13);
        case 15:
         var rest$14 = fmt$0[1], fmt$0 = rest$14; break;
        case 16:
@@ -28271,11 +28284,11 @@
        case 17:
         var rest$16 = fmt$0[2], fmt$0 = rest$16; break;
        case 18:
-        var _Y_ = fmt$0[1];
-        if(0 === _Y_[0])
+        var _X_ = fmt$0[1];
+        if(0 === _X_[0])
           /*<<scanf.ml:1189:28>>*/ var
           rest$17 = fmt$0[2],
-          fmt$1 = _Y_[1][1],
+          fmt$1 = _X_[1][1],
            /*<<scanf.ml:1189:28>>*/ fmt$2 =
              /*<<scanf.ml:1189:28>>*/ caml_call2
              (CamlinternalFormatBasics[3], fmt$1, rest$17),
@@ -28283,7 +28296,7 @@
         else
           /*<<scanf.ml:1191:28>>*/ var
           rest$18 = fmt$0[2],
-          fmt$3 = _Y_[1][1],
+          fmt$3 = _X_[1][1],
            /*<<scanf.ml:1191:28>>*/ fmt$4 =
              /*<<scanf.ml:1191:28>>*/ caml_call2
              (CamlinternalFormatBasics[3], fmt$3, rest$18),
@@ -28393,11 +28406,11 @@
          rest = fmtty$0[3],
          ty2 = fmtty$0[2],
          ty1 = fmtty$0[1],
-          /*<<scanf.ml:1227:19>>*/ _V_ =
+          /*<<scanf.ml:1227:19>>*/ _U_ =
             /*<<scanf.ml:1227:19>>*/ caml_call1(CamlinternalFormat[21], ty1),
           /*<<scanf.ml:1227:13>>*/ ty =
             /*<<scanf.ml:1227:13>>*/ caml_call2
-            (CamlinternalFormat[22], _V_, ty2),
+            (CamlinternalFormat[22], _U_, ty2),
           /*<<scanf.ml:1228:32>>*/ fmtty$10 =
             /*<<scanf.ml:1228:32>>*/ caml_call2
             (CamlinternalFormatBasics[1], ty, rest),
@@ -28502,8 +28515,8 @@
              /*<<scanf.ml:1047:4>>*/  /*<<scanf.ml:1047:10>>*/ var
              c = check_next_char_for_char(width, ib);
             return 39 === c
-                    ? (ignore_char(width, ib), _u_)
-                    : (character_mismatch(39, c), _u_);
+                    ? (ignore_char(width, ib), sentinal)
+                    : (character_mismatch(39, c), sentinal);
             /*<<scanf.ml:1049:36>>*/ },
           /*<<scanf.ml:1035:10>>*/ c = checked_peek_char(ib);
         if(39 === c){
@@ -28544,11 +28557,11 @@
              /*<<scanf.ml:1280:4>>*/ return pad_prec_scanf
                     (ib, str_rest, readers, pad, 0, scan$0, token_string);
            case 18:
-            var _H_ = match[1];
-            if(0 === _H_[0]){
+            var _G_ = match[1];
+            if(0 === _G_[0]){
               /*<<scanf.ml:1282:4>>*/ var
               rest$3 = match[2],
-              fmt$1 = _H_[1][1],
+              fmt$1 = _G_[1][1],
                /*<<scanf.ml:1282:4>>*/ scan$1 =
                 function(width, param, ib){
                   /*<<scanf.ml:1282:26>>*/ return scan_string(_q_, width, ib);
@@ -28565,7 +28578,7 @@
             }
              /*<<scanf.ml:1286:4>>*/ var
              rest$4 = match[2],
-             fmt$2 = _H_[1][1],
+             fmt$2 = _G_[1][1],
               /*<<scanf.ml:1286:4>>*/ scan$2 =
                function(width, param, ib){
                  /*<<scanf.ml:1286:26>>*/ return scan_string(_r_, width, ib);
@@ -28742,7 +28755,7 @@
          rest$13 = fmt$0[2],
          pad$8 = fmt$0[1],
           /*<<scanf.ml:1320:4>>*/ scan$8 =
-           function(param, _U_, ib){
+           function(param, _T_, ib){
              /*<<scanf.ml:1320:22>>*/ var
               /*<<scanf.ml:1089:10>>*/ c = checked_peek_char(ib),
               /*<<scanf.ml:1090:2>>*/ m =
@@ -28768,10 +28781,10 @@
          /*<<scanf.ml:1341:16>>*/ var
          rest$15 = fmt$0[2],
          str$0 = fmt$0[1],
-          /*<<scanf.ml:1341:16>>*/ _I_ =
-           function(_T_){ /*<<?>>*/ return check_char(ib, _T_);};
+          /*<<scanf.ml:1341:16>>*/ _H_ =
+           function(_S_){ /*<<?>>*/ return check_char(ib, _S_);};
          /*<<scanf.ml:1341:4>>*/  /*<<scanf.ml:1341:4>>*/ caml_call2
-         (Stdlib_String[29], _I_, str$0);
+         (Stdlib_String[29], _H_, str$0);
         var fmt$0 = rest$15;
         break;
        case 12:
@@ -28787,10 +28800,10 @@
          s = token_string(ib);
          /*<<scanf.ml:1350:4>>*/ try{
           /*<<scanf.ml:1351:10>>*/ var
-           /*<<scanf.ml:1351:10>>*/ _J_ =
+           /*<<scanf.ml:1351:10>>*/ _I_ =
              /*<<scanf.ml:1351:10>>*/ caml_call2
              (CamlinternalFormat[14], s, fmtty),
-          fmt$3 = _J_;
+          fmt$3 = _I_;
         }
         catch(exn$0){
          var exn = caml_wrap_exception(exn$0);
@@ -28816,23 +28829,23 @@
              /*<<scanf.ml:1361:27>>*/ caml_call2
               (CamlinternalFormat[13], 0, s$0)
              [1],
-           /*<<scanf.ml:1375:36>>*/ _L_ =
+           /*<<scanf.ml:1375:36>>*/ _K_ =
              /*<<scanf.ml:1375:36>>*/ caml_call1
              (CamlinternalFormat[21], fmtty$0),
-           /*<<scanf.ml:1375:25>>*/ _M_ =
+           /*<<scanf.ml:1375:25>>*/ _L_ =
              /*<<scanf.ml:1375:25>>*/ caml_call1
-             (CamlinternalFormatBasics[2], _L_),
+             (CamlinternalFormatBasics[2], _K_),
            /*<<scanf.ml:1375:8>>*/ fmt$8 =
              /*<<scanf.ml:1375:8>>*/ caml_call2
-             (CamlinternalFormat[12], fmt$7, _M_),
-           /*<<scanf.ml:1374:24>>*/ _N_ =
+             (CamlinternalFormat[12], fmt$7, _L_),
+           /*<<scanf.ml:1374:24>>*/ _M_ =
              /*<<scanf.ml:1374:24>>*/ caml_call1
              (CamlinternalFormatBasics[2], fmtty$0),
-           /*<<scanf.ml:1374:8>>*/ _O_ =
+           /*<<scanf.ml:1374:8>>*/ _N_ =
              /*<<scanf.ml:1374:8>>*/ caml_call2
-             (CamlinternalFormat[12], fmt$6, _N_),
+             (CamlinternalFormat[12], fmt$6, _M_),
           fmt$5 = fmt$8,
-          fmt$4 = _O_;
+          fmt$4 = _N_;
         }
         catch(exn){
          var exn$0 = caml_wrap_exception(exn);
@@ -28840,9 +28853,9 @@
           throw caml_maybe_attach_backtrace(exn$0, 0);
          var
           msg$0 = exn$0[2],
-          _K_ = bad_input(msg$0),
-          fmt$5 = _K_[2],
-          fmt$4 = _K_[1];
+          _J_ = bad_input(msg$0),
+          fmt$5 = _J_[2],
+          fmt$4 = _J_[1];
         }
          /*<<scanf.ml:1378:4>>*/ return [0,
                 [0, fmt$4, s$0],
@@ -28861,19 +28874,19 @@
          /*<<scanf.ml:1401:32>>*/ var
          rest$19 = fmt$0[2],
          formatting_lit = fmt$0[1],
-          /*<<scanf.ml:1401:32>>*/ _P_ =
+          /*<<scanf.ml:1401:32>>*/ _O_ =
             /*<<scanf.ml:1401:32>>*/ caml_call1
             (CamlinternalFormat[17], formatting_lit),
-          /*<<scanf.ml:1401:16>>*/ _Q_ =
-           function(_S_){ /*<<?>>*/ return check_char(ib, _S_);};
+          /*<<scanf.ml:1401:16>>*/ _P_ =
+           function(_R_){ /*<<?>>*/ return check_char(ib, _R_);};
          /*<<scanf.ml:1401:4>>*/  /*<<scanf.ml:1401:4>>*/ caml_call2
-         (Stdlib_String[29], _Q_, _P_);
+         (Stdlib_String[29], _P_, _O_);
         var fmt$0 = rest$19;
         break;
        case 18:
-        var _R_ = fmt$0[1];
-        if(0 === _R_[0]){
-         var rest$20 = fmt$0[2], fmt$9 = _R_[1][1];
+        var _Q_ = fmt$0[1];
+        if(0 === _Q_[0]){
+         var rest$20 = fmt$0[2], fmt$9 = _Q_[1][1];
           /*<<scanf.ml:1404:4>>*/ check_char(ib, 64);
           /*<<scanf.ml:1404:23>>*/ check_char(ib, 123);
           /*<<scanf.ml:1405:18>>*/ var
@@ -28883,7 +28896,7 @@
           fmt$0 = fmt$10;
         }
         else{
-         var rest$21 = fmt$0[2], fmt$11 = _R_[1][1];
+         var rest$21 = fmt$0[2], fmt$11 = _Q_[1][1];
           /*<<scanf.ml:1407:4>>*/ check_char(ib, 64);
           /*<<scanf.ml:1407:23>>*/ check_char(ib, 91);
           /*<<scanf.ml:1408:18>>*/ var
@@ -28992,16 +29005,16 @@
        if(exc[1] !== Stdlib[6]) throw caml_maybe_attach_backtrace(exc, 0);
         /*<<scanf.ml:1470:45>>*/ var
         msg = exc[2],
-         /*<<scanf.ml:1470:45>>*/ _D_ =
+         /*<<scanf.ml:1470:45>>*/ _C_ =
            /*<<scanf.ml:1470:45>>*/ caml_call1(Stdlib_String[24], str),
-         /*<<scanf.ml:1470:45>>*/ _E_ =
-           /*<<scanf.ml:1470:45>>*/ caml_call2(Stdlib[28], _D_, cst$0),
-         /*<<scanf.ml:1470:27>>*/ _F_ =
-           /*<<scanf.ml:1470:27>>*/ caml_call2(Stdlib[28], cst_in_format, _E_),
-         /*<<scanf.ml:1470:20>>*/ _G_ =
-           /*<<scanf.ml:1470:20>>*/ caml_call2(Stdlib[28], msg, _F_);
+         /*<<scanf.ml:1470:45>>*/ _D_ =
+           /*<<scanf.ml:1470:45>>*/ caml_call2(Stdlib[28], _C_, cst$0),
+         /*<<scanf.ml:1470:27>>*/ _E_ =
+           /*<<scanf.ml:1470:27>>*/ caml_call2(Stdlib[28], cst_in_format, _D_),
+         /*<<scanf.ml:1470:20>>*/ _F_ =
+           /*<<scanf.ml:1470:20>>*/ caml_call2(Stdlib[28], msg, _E_);
         /*<<scanf.ml:1470:20>>*/ return  /*<<scanf.ml:1470:20>>*/ caml_call1
-               (Stdlib[1], _G_);
+               (Stdlib[1], _F_);
       }
        /*<<scanf.ml:1468:8>>*/ return  /*<<scanf.ml:1468:8>>*/ caml_call2
               (ef, ib, exc);
@@ -29032,15 +29045,15 @@
              fmt);
     /*<<scanf.ml:1477:35>>*/ }
    function kscanf_opt(ib, fmt){
-    function _B_(x){
+    function _A_(x){
       /*<<scanf.ml:1480:44>>*/ return [0, x];
      /*<<scanf.ml:1480:50>>*/ }
      /*<<scanf.ml:1480:2>>*/ return kscanf_gen
             (ib,
-             function(param, _C_){
+             function(param, _B_){
                /*<<scanf.ml:1480:28>>*/ return 0;
               /*<<scanf.ml:1480:32>>*/ },
-             _B_,
+             _A_,
              fmt);
     /*<<scanf.ml:1480:55>>*/ }
    function bscanf(ib, fmt){
@@ -29071,10 +29084,10 @@
      str = token_string(ib);
      /*<<scanf.ml:1504:4>>*/ try{
       /*<<scanf.ml:1505:10>>*/ var
-       /*<<scanf.ml:1505:10>>*/ _A_ =
+       /*<<scanf.ml:1505:10>>*/ _z_ =
          /*<<scanf.ml:1505:10>>*/ caml_call2
          (CamlinternalFormat[15], str, format),
-      fmt = _A_;
+      fmt = _z_;
     }
     catch(exn$0){
      var exn = caml_wrap_exception(exn$0);
@@ -29088,30 +29101,30 @@
      /*<<scanf.ml:1513:20>>*/ return bscanf_format(from_string(s), format, f);
     /*<<scanf.ml:1513:67>>*/ }
    function format_from_string(s, fmt){
-     /*<<scanf.ml:1517:2>>*/ function _x_(x){
+     /*<<scanf.ml:1517:2>>*/ function _w_(x){
       /*<<scanf.ml:1517:63>>*/ return x;
      /*<<scanf.ml:1517:64>>*/ }
      /*<<scanf.ml:1517:24>>*/ var
-      /*<<scanf.ml:1517:24>>*/ _y_ =
+      /*<<scanf.ml:1517:24>>*/ _x_ =
         /*<<scanf.ml:1517:24>>*/ caml_call1(Stdlib_String[24], s),
-      /*<<scanf.ml:1517:24>>*/ _z_ =
-        /*<<scanf.ml:1517:24>>*/ caml_call2(Stdlib[28], _y_, cst$1);
+      /*<<scanf.ml:1517:24>>*/ _y_ =
+        /*<<scanf.ml:1517:24>>*/ caml_call2(Stdlib[28], _x_, cst$1);
      /*<<scanf.ml:1517:53>>*/ return sscanf_format
-            ( /*<<scanf.ml:1517:16>>*/ caml_call2(Stdlib[28], cst$2, _z_),
+            ( /*<<scanf.ml:1517:16>>*/ caml_call2(Stdlib[28], cst$2, _y_),
              fmt,
-             _x_);
+             _w_);
     /*<<scanf.ml:1517:65>>*/ }
    function unescaped(s){
-     /*<<scanf.ml:1521:2>>*/ function _v_(x){
+     /*<<scanf.ml:1521:2>>*/ function _u_(x){
       /*<<scanf.ml:1521:44>>*/ return x;
      /*<<scanf.ml:1521:45>>*/ }
      /*<<scanf.ml:1521:17>>*/  /*<<scanf.ml:1521:17>>*/ var
-     _w_ =  /*<<scanf.ml:1521:17>>*/ caml_call2(Stdlib[28], s, cst$3);
+     _v_ =  /*<<scanf.ml:1521:17>>*/ caml_call2(Stdlib[28], s, cst$3);
      /*<<scanf.ml:1521:34>>*/ return  /*<<scanf.ml:1521:34>>*/ caml_call1
             (sscanf
-              ( /*<<scanf.ml:1521:9>>*/ caml_call2(Stdlib[28], cst$4, _w_),
+              ( /*<<scanf.ml:1521:9>>*/ caml_call2(Stdlib[28], cst$4, _v_),
                _t_),
-             _v_);
+             _u_);
     /*<<scanf.ml:1521:46>>*/ }
    var
     Stdlib_Scanf =
@@ -30476,7 +30489,7 @@
             : runtime.caml_call_gen(f, [a0, a1, a2]);
    }
    var
-    _d_ = undefined,
+    sentinal = undefined,
     global_data = runtime.caml_get_global_data(),
     Stdlib_List = global_data.Stdlib__List,
     Stdlib = global_data.Stdlib,
@@ -30495,7 +30508,7 @@
      /*<<ephemeron.ml:105:20>>*/  /*<<ephemeron.ml:105:20>>*/ var
      prng =
        [246,
-        function(_aN_){ /*<<?>>*/ return caml_call1(Stdlib_Random[15][2], 0);}];
+        function(_aM_){ /*<<?>>*/ return caml_call1(Stdlib_Random[15][2], 0);}];
     function create(opt, initial_size){
       /*<<ephemeron.ml:108:6>>*/ if(opt)
       var sth = opt[1], random = sth;
@@ -30506,17 +30519,17 @@
       /*<<ephemeron.ml:101:6>>*/ for(;;){
       if(initial_size > x && Stdlib_Sys[13] >= (x * 2 | 0)){var x$0 = x * 2 | 0, x = x$0; continue;}
        /*<<ephemeron.ml:109:6>>*/ if(random){
-       var _aL_ = runtime.caml_obj_tag(prng);
+       var _aK_ = runtime.caml_obj_tag(prng);
        a:
-       if(250 === _aL_)
-        var _aM_ = prng[1];
+       if(250 === _aK_)
+        var _aL_ = prng[1];
        else{
-        if(246 !== _aL_ && 244 !== _aL_){var _aM_ = prng; break a;}
-        var _aM_ = caml_call1(CamlinternalLazy[2], prng);
+        if(246 !== _aK_ && 244 !== _aK_){var _aL_ = prng; break a;}
+        var _aL_ = caml_call1(CamlinternalLazy[2], prng);
        }
        var
         seed =
-           /*<<ephemeron.ml:109:32>>*/ caml_call1(Stdlib_Random[15][4], _aM_);
+           /*<<ephemeron.ml:109:32>>*/ caml_call1(Stdlib_Random[15][4], _aL_);
       }
       else
        var seed = 0;
@@ -30531,16 +30544,16 @@
       /*<<ephemeron.ml:113:6>>*/ h[1] = 0;
       /*<<ephemeron.ml:115:6>>*/ var
       len = h[2].length - 1,
-       /*<<ephemeron.ml:115:6>>*/ _aJ_ = len - 1 | 0,
-      _aI_ = 0;
-     if(_aJ_ >= 0){
-      var i = _aI_;
+       /*<<ephemeron.ml:115:6>>*/ _aI_ = len - 1 | 0,
+      _aH_ = 0;
+     if(_aI_ >= 0){
+      var i = _aH_;
       for(;;){
         /*<<ephemeron.ml:116:8>>*/ caml_check_bound(h[2], i)[1 + i] = 0;
         /*<<ephemeron.ml:116:8>>*/  /*<<ephemeron.ml:116:8>>*/ var
-        _aK_ = i + 1 | 0;
-       if(_aJ_ === i) break;
-       var i = _aK_;
+        _aJ_ = i + 1 | 0;
+       if(_aI_ === i) break;
+       var i = _aJ_;
       }
      }
      return 0;
@@ -30557,11 +30570,11 @@
      /*<<ephemeron.ml:126:9>>*/ }
     function copy(h){
       /*<<ephemeron.ml:128:17>>*/ var
-      _aF_ = h[4],
-      _aG_ = h[3],
-       /*<<ephemeron.ml:128:33>>*/ _aH_ =
+      _aE_ = h[4],
+      _aF_ = h[3],
+       /*<<ephemeron.ml:128:33>>*/ _aG_ =
          /*<<ephemeron.ml:128:33>>*/ caml_call1(Stdlib_Array[6], h[2]);
-      /*<<ephemeron.ml:128:17>>*/ return [0, h[1], _aH_, _aG_, _aF_];
+      /*<<ephemeron.ml:128:17>>*/ return [0, h[1], _aG_, _aF_, _aE_];
      /*<<ephemeron.ml:128:52>>*/ }
     function key_index(h, hkey){
       /*<<ephemeron.ml:131:6>>*/ return hkey & (h[2].length - 1 - 1 | 0);
@@ -30581,16 +30594,16 @@
        var param$0 = rest;
       }
       /*<<ephemeron.ml:141:41>>*/ }
-     var d = h[2], _aD_ = d.length - 1 - 1 | 0, _aC_ = 0;
-     if(_aD_ >= 0){
-      var i = _aC_;
+     var d = h[2], _aC_ = d.length - 1 - 1 | 0, _aB_ = 0;
+     if(_aC_ >= 0){
+      var i = _aB_;
       for(;;){
         /*<<ephemeron.ml:145:8>>*/ d[1 + i] =
         do_bucket(caml_check_bound(d, i)[1 + i]);
         /*<<ephemeron.ml:145:8>>*/  /*<<ephemeron.ml:145:8>>*/ var
-        _aE_ = i + 1 | 0;
-       if(_aD_ === i) break;
-       var i = _aE_;
+        _aD_ = i + 1 | 0;
+       if(_aC_ === i) break;
+       var i = _aD_;
       }
      }
      return 0;
@@ -30602,9 +30615,9 @@
       nsize = osize * 2 | 0;
       /*<<ephemeron.ml:172:6>>*/ clean(h);
      var
-      _aw_ = nsize < Stdlib_Sys[13] ? 1 : 0,
-      _ax_ = _aw_ ? (osize >>> 1 | 0) <= h[1] ? 1 : 0 : _aw_;
-     if(_ax_){
+      _av_ = nsize < Stdlib_Sys[13] ? 1 : 0,
+      _aw_ = _av_ ? (osize >>> 1 | 0) <= h[1] ? 1 : 0 : _av_;
+     if(_aw_){
        /*<<ephemeron.ml:174:20>>*/  /*<<ephemeron.ml:174:20>>*/ var
        ndata =  /*<<ephemeron.ml:174:20>>*/ caml_make_vect(nsize, 0);
       h[2] = ndata;
@@ -30612,33 +30625,33 @@
        insert_bucket =
          function(param){
            /*<<ephemeron.ml:176:32>>*/ if(! param)
-            /*<<ephemeron.ml:177:21>>*/ return _d_;
+            /*<<ephemeron.ml:177:21>>*/ return sentinal;
           var rest = param[3], data = param[2], hkey = param[1];
            /*<<ephemeron.ml:179:14>>*/ insert_bucket(rest);
            /*<<ephemeron.ml:180:25>>*/  /*<<ephemeron.ml:180:25>>*/ var
            nidx = key_index(h, hkey);
            /*<<ephemeron.ml:181:14>>*/ ndata[1 + nidx] =
            [0, hkey, data, caml_check_bound(ndata, nidx)[1 + nidx]];
-           /*<<ephemeron.ml:181:14>>*/ return _d_;
+           /*<<ephemeron.ml:181:14>>*/ return sentinal;
           /*<<ephemeron.ml:181:60>>*/ },
-        /*<<ephemeron.ml:170:6>>*/ _az_ = osize - 1 | 0,
-        /*<<ephemeron.ml:182:8>>*/ _ay_ = 0;
-      if(_az_ >= 0){
-       var i = _ay_;
+        /*<<ephemeron.ml:170:6>>*/ _ay_ = osize - 1 | 0,
+        /*<<ephemeron.ml:182:8>>*/ _ax_ = 0;
+      if(_ay_ >= 0){
+       var i = _ax_;
        for(;;){
          /*<<ephemeron.ml:183:10>>*/ insert_bucket
          (caml_check_bound(odata, i)[1 + i]);
          /*<<ephemeron.ml:183:10>>*/  /*<<ephemeron.ml:183:10>>*/ var
-         _aB_ = i + 1 | 0;
-        if(_az_ === i) break;
-        var i = _aB_;
+         _aA_ = i + 1 | 0;
+        if(_ay_ === i) break;
+        var i = _aA_;
        }
       }
-      var _aA_ = 0;
+      var _az_ = 0;
      }
      else
-      var _aA_ = _ax_;
-     return _aA_;
+      var _az_ = _aw_;
+     return _az_;
      /*<<ephemeron.ml:185:9>>*/ }
     function add(h, key, info){
       /*<<ephemeron.ml:188:6>>*/ var
@@ -30651,8 +30664,8 @@
         [0, hkey, container, caml_check_bound(h[2], i)[1 + i]];
       /*<<ephemeron.ml:192:6>>*/ caml_check_bound(h[2], i)[1 + i] = bucket;
      h[1] = h[1] + 1 | 0;
-     var _av_ = h[2].length - 1 << 1 < h[1] ? 1 : 0;
-     return _av_ ? resize(h) : _av_;
+     var _au_ = h[2].length - 1 << 1 < h[1] ? 1 : 0;
+     return _au_ ? resize(h) : _au_;
      /*<<ephemeron.ml:194:57>>*/ }
     function remove(h, key){
       /*<<ephemeron.ml:197:6>>*/  /*<<ephemeron.ml:197:17>>*/ var
@@ -30680,17 +30693,17 @@
       /*<<ephemeron.ml:210:60>>*/ }
       /*<<ephemeron.ml:211:14>>*/ var
        /*<<ephemeron.ml:211:14>>*/ i = key_index(h, hkey),
-       /*<<ephemeron.ml:212:20>>*/ _au_ =
+       /*<<ephemeron.ml:212:20>>*/ _at_ =
         remove_bucket(caml_check_bound(h[2], i)[1 + i]);
-      /*<<ephemeron.ml:212:6>>*/ caml_check_bound(h[2], i)[1 + i] = _au_;
+      /*<<ephemeron.ml:212:6>>*/ caml_check_bound(h[2], i)[1 + i] = _at_;
       /*<<ephemeron.ml:212:6>>*/ return 0;
      /*<<ephemeron.ml:212:44>>*/ }
     function find(h, key){
       /*<<ephemeron.ml:239:6>>*/ var
        /*<<ephemeron.ml:239:17>>*/ hkey =
          /*<<ephemeron.ml:239:17>>*/ caml_call2(H[2], h[3], key),
-       /*<<ephemeron.ml:241:33>>*/ _at_ = key_index(h, hkey),
-      param = caml_check_bound(h[2], _at_)[1 + _at_];
+       /*<<ephemeron.ml:241:33>>*/ _as_ = key_index(h, hkey),
+      param = caml_check_bound(h[2], _as_)[1 + _as_];
      for(;;){
       if(! param)
         /*<<ephemeron.ml:220:10>>*/ throw  /*<<ephemeron.ml:220:10>>*/ caml_maybe_attach_backtrace
@@ -30716,8 +30729,8 @@
       /*<<ephemeron.ml:264:6>>*/ var
        /*<<ephemeron.ml:264:17>>*/ hkey =
          /*<<ephemeron.ml:264:17>>*/ caml_call2(H[2], h[3], key),
-       /*<<ephemeron.ml:266:37>>*/ _as_ = key_index(h, hkey),
-      param = caml_check_bound(h[2], _as_)[1 + _as_];
+       /*<<ephemeron.ml:266:37>>*/ _ar_ = key_index(h, hkey),
+      param = caml_check_bound(h[2], _ar_)[1 + _ar_];
      for(;;){
       if(! param)  /*<<ephemeron.ml:245:10>>*/ return 0;
       var hk = param[1], rest = param[3], c = param[2];
@@ -30765,9 +30778,9 @@
       }
       /*<<ephemeron.ml:284:29>>*/ }
       /*<<ephemeron.ml:285:29>>*/  /*<<ephemeron.ml:285:29>>*/ var
-      _ar_ = key_index(h, hkey);
+      _aq_ = key_index(h, hkey);
       /*<<ephemeron.ml:285:21>>*/ return find_in_bucket
-             (caml_check_bound(h[2], _ar_)[1 + _ar_]);
+             (caml_check_bound(h[2], _aq_)[1 + _aq_]);
      /*<<ephemeron.ml:285:46>>*/ }
     function replace(h, key, info){
       /*<<ephemeron.ml:289:6>>*/ var
@@ -30785,8 +30798,8 @@
        if(hkey === hk){
         if(!  /*<<ephemeron.ml:293:24>>*/ caml_call2(H[3], c, key)){
           /*<<ephemeron.ml:290:6>>*/  /*<<ephemeron.ml:290:6>>*/ var
-          _an_ =  /*<<ephemeron.ml:290:6>>*/ caml_call3(H[5], c, key, info);
-          /*<<ephemeron.ml:302:8>>*/ return _an_;
+          _am_ =  /*<<ephemeron.ml:290:6>>*/ caml_call3(H[5], c, key, info);
+          /*<<ephemeron.ml:302:8>>*/ return _am_;
         }
         var param = next;
        }
@@ -30794,23 +30807,23 @@
         var next$0 = param[3], param = next$0;
       }
      }
-     catch(_aq_){
-      var _ao_ = caml_wrap_exception(_aq_);
-      if(_ao_ !== Stdlib[8]) throw caml_maybe_attach_backtrace(_ao_, 0);
+     catch(_ap_){
+      var _an_ = caml_wrap_exception(_ap_);
+      if(_an_ !== Stdlib[8]) throw caml_maybe_attach_backtrace(_an_, 0);
        /*<<ephemeron.ml:304:24>>*/  /*<<ephemeron.ml:304:24>>*/ var
        container =  /*<<ephemeron.ml:304:24>>*/ caml_call2(H[1], key, info);
        /*<<ephemeron.ml:305:8>>*/ caml_check_bound(h[2], i)[1 + i] = [0, hkey, container, l];
       h[1] = h[1] + 1 | 0;
-      var _ap_ = h[2].length - 1 << 1 < h[1] ? 1 : 0;
-      return _ap_ ? resize(h) : _ap_;
+      var _ao_ = h[2].length - 1 << 1 < h[1] ? 1 : 0;
+      return _ao_ ? resize(h) : _ao_;
      }
      /*<<ephemeron.ml:307:59>>*/ }
     function mem(h, key){
       /*<<ephemeron.ml:310:6>>*/ var
        /*<<ephemeron.ml:310:17>>*/ hkey =
          /*<<ephemeron.ml:310:17>>*/ caml_call2(H[2], h[3], key),
-       /*<<ephemeron.ml:320:28>>*/ _am_ = key_index(h, hkey),
-      param = caml_check_bound(h[2], _am_)[1 + _am_];
+       /*<<ephemeron.ml:320:28>>*/ _al_ = key_index(h, hkey),
+      param = caml_check_bound(h[2], _al_)[1 + _al_];
       /*<<ephemeron.ml:311:30>>*/ for(;;){
       if(! param)  /*<<ephemeron.ml:313:10>>*/ return 0;
       var hk = param[1], rest = param[3], c = param[2];
@@ -30838,21 +30851,21 @@
      }
     }
     function stats(h){
-      /*<<ephemeron.ml:329:6>>*/ var _ag_ = h[2], _ah_ = 0;
-     function _ai_(m, b){
+      /*<<ephemeron.ml:329:6>>*/ var _af_ = h[2], _ag_ = 0;
+     function _ah_(m, b){
        /*<<ephemeron.ml:330:36>>*/  /*<<ephemeron.ml:330:46>>*/ var
-       _al_ = bucket_length(0, b);
+       _ak_ = bucket_length(0, b);
        /*<<ephemeron.ml:330:46>>*/ return  /*<<ephemeron.ml:330:46>>*/ caml_call2
-              (Stdlib_Int[11], m, _al_);
+              (Stdlib_Int[11], m, _ak_);
       /*<<ephemeron.ml:330:65>>*/ }
       /*<<ephemeron.ml:330:8>>*/ var
        /*<<ephemeron.ml:330:8>>*/ mbl =
          /*<<ephemeron.ml:330:8>>*/ caml_call3
-         (Stdlib_Array[15], _ai_, _ah_, _ag_),
+         (Stdlib_Array[15], _ah_, _ag_, _af_),
        /*<<ephemeron.ml:331:18>>*/ histo =
          /*<<ephemeron.ml:331:18>>*/ caml_make_vect(mbl + 1 | 0, 0),
-       /*<<ephemeron.ml:332:6>>*/ _aj_ = h[2];
-     function _ak_(b){
+       /*<<ephemeron.ml:332:6>>*/ _ai_ = h[2];
+     function _aj_(b){
        /*<<ephemeron.ml:334:11>>*/  /*<<ephemeron.ml:334:19>>*/ var
        l = bucket_length(0, b);
        /*<<ephemeron.ml:335:11>>*/ histo[1 + l] =
@@ -30860,7 +30873,7 @@
        /*<<ephemeron.ml:335:11>>*/ return 0;
       /*<<ephemeron.ml:335:37>>*/ }
       /*<<ephemeron.ml:332:6>>*/  /*<<ephemeron.ml:332:6>>*/ caml_call2
-      (Stdlib_Array[11], _ak_, _aj_);
+      (Stdlib_Array[11], _aj_, _ai_);
       /*<<ephemeron.ml:337:6>>*/ return [0, h[1], h[2].length - 1, mbl, histo];
      /*<<ephemeron.ml:340:34>>*/ }
     function bucket_length_alive(accu, param){
@@ -30878,22 +30891,22 @@
     function stats_alive(h){
       /*<<ephemeron.ml:349:6>>*/ var
        /*<<ephemeron.ml:349:17>>*/ size = [0, 0],
-       /*<<ephemeron.ml:350:6>>*/ _aa_ = h[2],
-      _ab_ = 0;
-     function _ac_(m, b){
+       /*<<ephemeron.ml:350:6>>*/ _$_ = h[2],
+      _aa_ = 0;
+     function _ab_(m, b){
        /*<<ephemeron.ml:352:22>>*/  /*<<ephemeron.ml:352:32>>*/ var
-       _af_ = bucket_length_alive(0, b);
+       _ae_ = bucket_length_alive(0, b);
        /*<<ephemeron.ml:352:32>>*/ return  /*<<ephemeron.ml:352:32>>*/ caml_call2
-              (Stdlib_Int[11], m, _af_);
+              (Stdlib_Int[11], m, _ae_);
       /*<<ephemeron.ml:352:57>>*/ }
       /*<<ephemeron.ml:351:8>>*/ var
        /*<<ephemeron.ml:351:8>>*/ mbl =
          /*<<ephemeron.ml:351:8>>*/ caml_call3
-         (Stdlib_Array[15], _ac_, _ab_, _aa_),
+         (Stdlib_Array[15], _ab_, _aa_, _$_),
        /*<<ephemeron.ml:354:18>>*/ histo =
          /*<<ephemeron.ml:354:18>>*/ caml_make_vect(mbl + 1 | 0, 0),
-       /*<<ephemeron.ml:355:6>>*/ _ad_ = h[2];
-     function _ae_(b){
+       /*<<ephemeron.ml:355:6>>*/ _ac_ = h[2];
+     function _ad_(b){
        /*<<ephemeron.ml:357:11>>*/  /*<<ephemeron.ml:357:19>>*/ var
        l = bucket_length_alive(0, b);
       size[1] = size[1] + l | 0;
@@ -30902,7 +30915,7 @@
        /*<<ephemeron.ml:359:11>>*/ return 0;
       /*<<ephemeron.ml:359:37>>*/ }
       /*<<ephemeron.ml:355:6>>*/  /*<<ephemeron.ml:355:6>>*/ caml_call2
-      (Stdlib_Array[11], _ae_, _ad_);
+      (Stdlib_Array[11], _ad_, _ac_);
       /*<<ephemeron.ml:361:6>>*/ return [0,
              size[1],
              h[2].length - 1,
@@ -30910,20 +30923,20 @@
              histo];
      /*<<ephemeron.ml:364:34>>*/ }
     function add_seq(tbl, i){
-     function _$_(param){
+     function ___(param){
        /*<<ephemeron.ml:367:15>>*/ var v = param[2], k = param[1];
        /*<<ephemeron.ml:367:29>>*/ return add(tbl, k, v);
       /*<<ephemeron.ml:367:41>>*/ }
       /*<<ephemeron.ml:367:6>>*/ return  /*<<ephemeron.ml:367:6>>*/ caml_call2
-             (Stdlib_Seq[4], _$_, i);
+             (Stdlib_Seq[4], ___, i);
      /*<<ephemeron.ml:367:43>>*/ }
     function replace_seq(tbl, i){
-     function ___(param){
+     function _Z_(param){
        /*<<ephemeron.ml:370:15>>*/ var v = param[2], k = param[1];
        /*<<ephemeron.ml:370:29>>*/ return replace(tbl, k, v);
       /*<<ephemeron.ml:370:45>>*/ }
       /*<<ephemeron.ml:370:6>>*/ return  /*<<ephemeron.ml:370:6>>*/ caml_call2
-             (Stdlib_Seq[4], ___, i);
+             (Stdlib_Seq[4], _Z_, i);
      /*<<ephemeron.ml:370:47>>*/ }
     function of_seq(i){
       /*<<ephemeron.ml:373:6>>*/  /*<<ephemeron.ml:373:16>>*/ var
@@ -30962,7 +30975,7 @@
    function set_key(t, k){
      /*<<ephemeron.ml:397:44>>*/  /*<<ephemeron.ml:397:44>>*/ caml_call3
      (Stdlib_Obj[24][5], t, 0, k);
-     /*<<ephemeron.ml:397:44>>*/ return _d_;
+     /*<<ephemeron.ml:397:44>>*/ return sentinal;
     /*<<ephemeron.ml:397:75>>*/ }
    function check_key(t){
      /*<<ephemeron.ml:398:39>>*/ return  /*<<ephemeron.ml:398:39>>*/ caml_call2
@@ -31048,10 +31061,10 @@
      replace_seq = include[15],
      clean = include[17],
      stats_alive = include[18],
-     _Z_ = include[1];
+     _Y_ = include[1];
     function create(sz){
       /*<<ephemeron.ml:448:20>>*/ return  /*<<ephemeron.ml:448:20>>*/ caml_call2
-             (_Z_, _a_, sz);
+             (_Y_, _a_, sz);
      /*<<ephemeron.ml:448:43>>*/ }
     function of_seq(i){
       /*<<ephemeron.ml:450:6>>*/  /*<<ephemeron.ml:450:16>>*/ var
@@ -31084,8 +31097,8 @@
      /*<<ephemeron.ml:459:18>>*/ return [0, 0];
     /*<<ephemeron.ml:459:24>>*/ }
    function add(b, k, d){
-     /*<<ephemeron.ml:460:20>>*/ var _Y_ = b[1];
-    b[1] = [0, make(k, d), _Y_];
+     /*<<ephemeron.ml:460:20>>*/ var _X_ = b[1];
+    b[1] = [0, make(k, d), _X_];
     return 0;
     /*<<ephemeron.ml:460:42>>*/ }
    function test_key(k, e){
@@ -31114,13 +31127,13 @@
     }
     /*<<ephemeron.ml:474:16>>*/ }
    function find(b, k){
-     /*<<ephemeron.ml:477:6>>*/ var _V_ = b[1];
-     /*<<ephemeron.ml:477:26>>*/ function _W_(_X_){
-      /*<<?>>*/ return test_key(k, _X_);
+     /*<<ephemeron.ml:477:6>>*/ var _U_ = b[1];
+     /*<<ephemeron.ml:477:26>>*/ function _V_(_W_){
+      /*<<?>>*/ return test_key(k, _W_);
     }
      /*<<ephemeron.ml:477:12>>*/  /*<<ephemeron.ml:477:12>>*/ var
      match =
-        /*<<ephemeron.ml:477:12>>*/ caml_call2(Stdlib_List[39], _W_, _V_);
+        /*<<ephemeron.ml:477:12>>*/ caml_call2(Stdlib_List[39], _V_, _U_);
     if(! match)  /*<<ephemeron.ml:479:16>>*/ return 0;
     var e = match[1];
      /*<<ephemeron.ml:478:18>>*/ return get_data(e);
@@ -31143,7 +31156,7 @@
    function set_key1(t, k){
      /*<<ephemeron.ml:495:4>>*/  /*<<ephemeron.ml:495:4>>*/ caml_call3
      (Stdlib_Obj[24][5], t, 0, k);
-     /*<<ephemeron.ml:495:4>>*/ return _d_;
+     /*<<ephemeron.ml:495:4>>*/ return sentinal;
     /*<<ephemeron.ml:495:35>>*/ }
    function get_key2(t){
      /*<<ephemeron.ml:498:49>>*/ return  /*<<ephemeron.ml:498:57>>*/ caml_call2
@@ -31152,7 +31165,7 @@
    function set_key2(t, k){
      /*<<ephemeron.ml:500:4>>*/  /*<<ephemeron.ml:500:4>>*/ caml_call3
      (Stdlib_Obj[24][5], t, 1, k);
-     /*<<ephemeron.ml:500:4>>*/ return _d_;
+     /*<<ephemeron.ml:500:4>>*/ return sentinal;
     /*<<ephemeron.ml:500:35>>*/ }
    function get_data$0(t){
      /*<<ephemeron.ml:503:48>>*/ return  /*<<ephemeron.ml:503:56>>*/ caml_call1
@@ -31197,11 +31210,11 @@
       /*<<ephemeron.ml:539:33>>*/ var
       k2 = param[2],
       k1 = param[1],
-       /*<<ephemeron.ml:539:33>>*/ _U_ =
+       /*<<ephemeron.ml:539:33>>*/ _T_ =
          /*<<ephemeron.ml:539:33>>*/ caml_call2(H2[2], seed, k2) * 65599 | 0;
       /*<<ephemeron.ml:539:8>>*/ return  /*<<ephemeron.ml:539:8>>*/ caml_call2
              (H1[2], seed, k1)
-            + _U_
+            + _T_
             | 0;
     }
     function equal(c, param){
@@ -31230,11 +31243,11 @@
     }
     function check_key(c){
       /*<<ephemeron.ml:551:24>>*/  /*<<ephemeron.ml:496:45>>*/ var
-      _T_ =  /*<<ephemeron.ml:496:45>>*/ caml_call2(Stdlib_Obj[24][7], c, 0);
-      /*<<ephemeron.ml:551:24>>*/ return _T_
+      _S_ =  /*<<ephemeron.ml:496:45>>*/ caml_call2(Stdlib_Obj[24][7], c, 0);
+      /*<<ephemeron.ml:551:24>>*/ return _S_
              ?  /*<<ephemeron.ml:501:45>>*/ caml_call2
                (Stdlib_Obj[24][7], c, 1)
-             : _T_;
+             : _S_;
      /*<<ephemeron.ml:551:52>>*/ }
      /*<<ephemeron.ml:530:28>>*/ return MakeSeeded
             ([0,
@@ -31253,13 +31266,13 @@
      /*<<ephemeron.ml:566:52>>*/ }
      /*<<ephemeron.ml:563:9>>*/ var
      equal$0 = H1[1],
-      /*<<ephemeron.ml:563:9>>*/ _R_ = [0, equal, seeded_hash];
+      /*<<ephemeron.ml:563:9>>*/ _Q_ = [0, equal, seeded_hash];
     function seeded_hash$0(seed, x){
       /*<<ephemeron.ml:561:43>>*/ return  /*<<ephemeron.ml:561:43>>*/ caml_call1
              (H1[2], x);
      /*<<ephemeron.ml:561:52>>*/ }
     var
-     include = MakeSeeded$1([0, equal$0, seeded_hash$0], _R_),
+     include = MakeSeeded$1([0, equal$0, seeded_hash$0], _Q_),
      clear = include[2],
      reset = include[3],
      copy = include[4],
@@ -31276,10 +31289,10 @@
      replace_seq = include[15],
      clean = include[17],
      stats_alive = include[18],
-     _S_ = include[1];
+     _R_ = include[1];
     function create(sz){
       /*<<ephemeron.ml:568:20>>*/ return  /*<<ephemeron.ml:568:20>>*/ caml_call2
-             (_S_, _b_, sz);
+             (_R_, _b_, sz);
      /*<<ephemeron.ml:568:43>>*/ }
     function of_seq(i){
       /*<<ephemeron.ml:570:6>>*/  /*<<ephemeron.ml:570:16>>*/ var
@@ -31312,8 +31325,8 @@
      /*<<ephemeron.ml:579:18>>*/ return [0, 0];
     /*<<ephemeron.ml:579:24>>*/ }
    function add$0(b, k1, k2, d){
-     /*<<ephemeron.ml:580:24>>*/ var _Q_ = b[1];
-    b[1] = [0, make$1(k1, k2, d), _Q_];
+     /*<<ephemeron.ml:580:24>>*/ var _P_ = b[1];
+    b[1] = [0, make$1(k1, k2, d), _P_];
     return 0;
     /*<<ephemeron.ml:580:50>>*/ }
    function test_keys(k1, k2, e){
@@ -31343,13 +31356,13 @@
     }
     /*<<ephemeron.ml:594:16>>*/ }
    function find$0(b, k1, k2){
-     /*<<ephemeron.ml:597:6>>*/ var _N_ = b[1];
-     /*<<ephemeron.ml:597:26>>*/ function _O_(_P_){
-      /*<<?>>*/ return test_keys(k1, k2, _P_);
+     /*<<ephemeron.ml:597:6>>*/ var _M_ = b[1];
+     /*<<ephemeron.ml:597:26>>*/ function _N_(_O_){
+      /*<<?>>*/ return test_keys(k1, k2, _O_);
     }
      /*<<ephemeron.ml:597:12>>*/  /*<<ephemeron.ml:597:12>>*/ var
      match =
-        /*<<ephemeron.ml:597:12>>*/ caml_call2(Stdlib_List[39], _O_, _N_);
+        /*<<ephemeron.ml:597:12>>*/ caml_call2(Stdlib_List[39], _N_, _M_);
     if(! match)  /*<<ephemeron.ml:599:16>>*/ return 0;
     var e = match[1];
      /*<<ephemeron.ml:598:18>>*/ return get_data$0(e);
@@ -31376,7 +31389,7 @@
    function set_key$0(t, n, k){
      /*<<ephemeron.ml:616:4>>*/  /*<<ephemeron.ml:616:4>>*/ caml_call3
      (Stdlib_Obj[24][5], t, n, k);
-     /*<<ephemeron.ml:616:4>>*/ return _d_;
+     /*<<ephemeron.ml:616:4>>*/ return sentinal;
     /*<<ephemeron.ml:616:35>>*/ }
    function get_data$1(t){
      /*<<ephemeron.ml:619:43>>*/ return  /*<<ephemeron.ml:619:51>>*/ caml_call1
@@ -31392,17 +31405,17 @@
       /*<<ephemeron.ml:625:14>>*/ eph = create$1(l);
      /*<<ephemeron.ml:626:4>>*/ set_data$1(eph, data);
      /*<<ephemeron.ml:626:4>>*/ var
-     _L_ = l - 1 | 0,
-      /*<<ephemeron.ml:626:4>>*/ _K_ = 0;
-    if(_L_ >= 0){
-     var i = _K_;
+     _K_ = l - 1 | 0,
+      /*<<ephemeron.ml:626:4>>*/ _J_ = 0;
+    if(_K_ >= 0){
+     var i = _J_;
      for(;;){
        /*<<ephemeron.ml:627:26>>*/ set_key$0
        (eph, i, caml_check_bound(keys, i)[1 + i]);
        /*<<ephemeron.ml:627:26>>*/  /*<<ephemeron.ml:627:26>>*/ var
-       _M_ = i + 1 | 0;
-      if(_L_ === i) break;
-      var i = _M_;
+       _L_ = i + 1 | 0;
+      if(_K_ === i) break;
+      var i = _L_;
      }
     }
      /*<<ephemeron.ml:628:4>>*/ return eph;
@@ -31415,10 +31428,10 @@
        /*<<ephemeron.ml:633:37>>*/ throw  /*<<ephemeron.ml:633:37>>*/ caml_maybe_attach_backtrace
              (Stdlib[3], 1);
       /*<<ephemeron.ml:631:12>>*/ var
-       /*<<ephemeron.ml:631:12>>*/ _G_ = l - 1 | 0,
-       /*<<ephemeron.ml:634:6>>*/ _F_ = 0;
-     if(_G_ >= 0){
-      var i = _F_;
+       /*<<ephemeron.ml:631:12>>*/ _F_ = l - 1 | 0,
+       /*<<ephemeron.ml:634:6>>*/ _E_ = 0;
+     if(_F_ >= 0){
+      var i = _E_;
       for(;;){
         /*<<ephemeron.ml:635:14>>*/  /*<<ephemeron.ml:635:14>>*/ var
         match = get_key$0(eph, i);
@@ -31430,19 +31443,19 @@
          /*<<ephemeron.ml:638:20>>*/ throw  /*<<ephemeron.ml:638:20>>*/ caml_maybe_attach_backtrace
                (Stdlib[3], 1);
         /*<<ephemeron.ml:634:6>>*/  /*<<ephemeron.ml:634:6>>*/ var
-        _I_ = i + 1 | 0;
-       if(_G_ === i) break;
-       var i = _I_;
+        _H_ = i + 1 | 0;
+       if(_F_ === i) break;
+       var i = _H_;
       }
      }
       /*<<ephemeron.ml:640:6>>*/  /*<<ephemeron.ml:640:6>>*/ var
-      _H_ = get_data$1(eph);
-      /*<<ephemeron.ml:640:6>>*/ return _H_;
+      _G_ = get_data$1(eph);
+      /*<<ephemeron.ml:640:6>>*/ return _G_;
     }
-    catch(_J_){
-     var _E_ = caml_wrap_exception(_J_);
-     if(_E_ === Stdlib[3])  /*<<ephemeron.ml:641:17>>*/ return 0;
-     throw caml_maybe_attach_backtrace(_E_, 0);
+    catch(_I_){
+     var _D_ = caml_wrap_exception(_I_);
+     if(_D_ === Stdlib[3])  /*<<ephemeron.ml:641:17>>*/ return 0;
+     throw caml_maybe_attach_backtrace(_D_, 0);
     }
     /*<<ephemeron.ml:641:21>>*/ }
    function MakeSeeded$2(H){
@@ -31451,17 +31464,17 @@
       c = create$1(k.length - 1);
       /*<<ephemeron.ml:649:8>>*/ set_data$1(c, d);
       /*<<ephemeron.ml:649:8>>*/ var
-      _C_ = k.length - 1 - 1 | 0,
-       /*<<ephemeron.ml:649:8>>*/ _B_ = 0;
-     if(_C_ >= 0){
-      var i = _B_;
+      _B_ = k.length - 1 - 1 | 0,
+       /*<<ephemeron.ml:649:8>>*/ _A_ = 0;
+     if(_B_ >= 0){
+      var i = _A_;
       for(;;){
         /*<<ephemeron.ml:651:10>>*/ set_key$0
         (c, i, caml_check_bound(k, i)[1 + i]);
         /*<<ephemeron.ml:651:10>>*/  /*<<ephemeron.ml:651:10>>*/ var
-        _D_ = i + 1 | 0;
-       if(_C_ === i) break;
-       var i = _D_;
+        _C_ = i + 1 | 0;
+       if(_B_ === i) break;
+       var i = _C_;
       }
      }
       /*<<ephemeron.ml:653:8>>*/ return c;
@@ -31469,22 +31482,22 @@
     function seeded_hash(seed, k){
       /*<<ephemeron.ml:655:8>>*/ var
        /*<<ephemeron.ml:655:16>>*/ h = [0, 0],
-      _x_ = k.length - 1 - 1 | 0,
-       /*<<ephemeron.ml:655:16>>*/ _w_ = 0;
-     if(_x_ >= 0){
-      var i = _w_;
+      _w_ = k.length - 1 - 1 | 0,
+       /*<<ephemeron.ml:655:16>>*/ _v_ = 0;
+     if(_w_ >= 0){
+      var i = _v_;
       for(;;){
         /*<<ephemeron.ml:657:34>>*/ var
-        _y_ = h[1],
-         /*<<ephemeron.ml:657:34>>*/ _z_ = caml_check_bound(k, i)[1 + i];
+        _x_ = h[1],
+         /*<<ephemeron.ml:657:34>>*/ _y_ = caml_check_bound(k, i)[1 + i];
        h[1] =
-        ( /*<<ephemeron.ml:657:15>>*/ caml_call2(H[2], seed, _z_) * 65599 | 0)
-        + _y_
+        ( /*<<ephemeron.ml:657:15>>*/ caml_call2(H[2], seed, _y_) * 65599 | 0)
+        + _x_
         | 0;
         /*<<ephemeron.ml:656:8>>*/  /*<<ephemeron.ml:656:8>>*/ var
-        _A_ = i + 1 | 0;
-       if(_x_ === i) break;
-       var i = _A_;
+        _z_ = i + 1 | 0;
+       if(_w_ === i) break;
+       var i = _z_;
       }
      }
      return h[1];
@@ -31504,9 +31517,9 @@
       if(! match)  /*<<ephemeron.ml:669:24>>*/ return 2;
        /*<<ephemeron.ml:671:29>>*/ var
        ki = match[1],
-        /*<<ephemeron.ml:671:29>>*/ _v_ = caml_check_bound(k, i)[1 + i];
+        /*<<ephemeron.ml:671:29>>*/ _u_ = caml_check_bound(k, i)[1 + i];
        /*<<ephemeron.ml:671:21>>*/ if
-       (!  /*<<ephemeron.ml:671:21>>*/ caml_call2(H[1], _v_, ki))
+       (!  /*<<ephemeron.ml:671:21>>*/ caml_call2(H[1], _u_, ki))
         /*<<ephemeron.ml:673:23>>*/ return 1;
        /*<<ephemeron.ml:672:23>>*/ var
         /*<<ephemeron.ml:672:23>>*/ i$0 = i - 1 | 0,
@@ -31517,17 +31530,17 @@
       /*<<ephemeron.ml:678:8>>*/  /*<<ephemeron.ml:621:40>>*/ caml_call1
       (Stdlib_Obj[24][12], c);
       /*<<ephemeron.ml:678:8>>*/ var
-      _t_ = k.length - 1 - 1 | 0,
-       /*<<ephemeron.ml:678:8>>*/ _s_ = 0;
-     if(_t_ >= 0){
-      var i = _s_;
+      _s_ = k.length - 1 - 1 | 0,
+       /*<<ephemeron.ml:678:8>>*/ _r_ = 0;
+     if(_s_ >= 0){
+      var i = _r_;
       for(;;){
         /*<<ephemeron.ml:680:10>>*/ set_key$0
         (c, i, caml_check_bound(k, i)[1 + i]);
         /*<<ephemeron.ml:680:10>>*/  /*<<ephemeron.ml:680:10>>*/ var
-        _u_ = i + 1 | 0;
-       if(_t_ === i) break;
-       var i = _u_;
+        _t_ = i + 1 | 0;
+       if(_s_ === i) break;
+       var i = _t_;
       }
      }
       /*<<ephemeron.ml:682:8>>*/ return set_data$1(c, d);
@@ -31537,19 +31550,19 @@
        /*<<ephemeron.ml:686:17>>*/ i$1 = length$1(c) - 1 | 0,
       i = i$1;
       /*<<ephemeron.ml:685:10>>*/ for(;;){
-      var _q_ = i < 0 ? 1 : 0;
-      if(_q_)
-       var _r_ = _q_;
+      var _p_ = i < 0 ? 1 : 0;
+      if(_p_)
+       var _q_ = _p_;
       else{
         /*<<ephemeron.ml:617:47>>*/  /*<<ephemeron.ml:617:47>>*/ var
-        _p_ =  /*<<ephemeron.ml:617:47>>*/ caml_call2(Stdlib_Obj[24][7], c, i);
-        /*<<ephemeron.ml:685:20>>*/ if(_p_){
+        _o_ =  /*<<ephemeron.ml:617:47>>*/ caml_call2(Stdlib_Obj[24][7], c, i);
+        /*<<ephemeron.ml:685:20>>*/ if(_o_){
         var i$0 = i - 1 | 0, i = i$0;
         continue;
        }
-       var _r_ = _p_;
+       var _q_ = _o_;
       }
-      return _r_;
+      return _q_;
      }
      /*<<ephemeron.ml:686:30>>*/ }
      /*<<ephemeron.ml:644:28>>*/ return MakeSeeded
@@ -31585,10 +31598,10 @@
      replace_seq = include[15],
      clean = include[17],
      stats_alive = include[18],
-     _o_ = include[1];
+     _n_ = include[1];
     function create(sz){
       /*<<ephemeron.ml:696:20>>*/ return  /*<<ephemeron.ml:696:20>>*/ caml_call2
-             (_o_, _c_, sz);
+             (_n_, _c_, sz);
      /*<<ephemeron.ml:696:43>>*/ }
     function of_seq(i){
       /*<<ephemeron.ml:698:6>>*/  /*<<ephemeron.ml:698:16>>*/ var
@@ -31621,8 +31634,8 @@
      /*<<ephemeron.ml:707:18>>*/ return [0, 0];
     /*<<ephemeron.ml:707:24>>*/ }
    function add$1(b, k, d){
-     /*<<ephemeron.ml:708:20>>*/ var _n_ = b[1];
-    b[1] = [0, make$3(k, d), _n_];
+     /*<<ephemeron.ml:708:20>>*/ var _m_ = b[1];
+    b[1] = [0, make$3(k, d), _m_];
     return 0;
     /*<<ephemeron.ml:708:42>>*/ }
    function test_keys$0(k, e){
@@ -31631,10 +31644,10 @@
        /*<<ephemeron.ml:712:43>>*/ throw  /*<<ephemeron.ml:712:43>>*/ caml_maybe_attach_backtrace
              (Stdlib[3], 1);
       /*<<ephemeron.ml:713:8>>*/ var
-      _j_ = k.length - 1 - 1 | 0,
-       /*<<ephemeron.ml:713:8>>*/ _i_ = 0;
-     if(_j_ >= 0){
-      var i = _i_;
+      _i_ = k.length - 1 - 1 | 0,
+       /*<<ephemeron.ml:713:8>>*/ _h_ = 0;
+     if(_i_ >= 0){
+      var i = _h_;
       for(;;){
         /*<<ephemeron.ml:714:16>>*/  /*<<ephemeron.ml:714:16>>*/ var
         match = get_key$0(e, i);
@@ -31642,9 +31655,9 @@
         var x = match[1];
         if(x === caml_check_bound(k, i)[1 + i]){
           /*<<ephemeron.ml:713:8>>*/  /*<<ephemeron.ml:713:8>>*/ var
-          _l_ = i + 1 | 0;
-         if(_j_ === i) break;
-         var i = _l_;
+          _k_ = i + 1 | 0;
+         if(_i_ === i) break;
+         var i = _k_;
          continue;
         }
        }
@@ -31652,13 +31665,13 @@
               (Stdlib[3], 1);
       }
      }
-      /*<<ephemeron.ml:718:8>>*/  /*<<ephemeron.ml:718:8>>*/ var _k_ = 1;
-      /*<<ephemeron.ml:718:8>>*/ return _k_;
+      /*<<ephemeron.ml:718:8>>*/  /*<<ephemeron.ml:718:8>>*/ var _j_ = 1;
+      /*<<ephemeron.ml:718:8>>*/ return _j_;
     }
-    catch(_m_){
-     var _h_ = caml_wrap_exception(_m_);
-     if(_h_ === Stdlib[3])  /*<<ephemeron.ml:719:19>>*/ return 0;
-     throw caml_maybe_attach_backtrace(_h_, 0);
+    catch(_l_){
+     var _g_ = caml_wrap_exception(_l_);
+     if(_g_ === Stdlib[3])  /*<<ephemeron.ml:719:19>>*/ return 0;
+     throw caml_maybe_attach_backtrace(_g_, 0);
     }
     /*<<ephemeron.ml:719:24>>*/ }
    function remove$1(b, k){
@@ -31678,13 +31691,13 @@
     }
     /*<<ephemeron.ml:728:16>>*/ }
    function find$1(b, k){
-     /*<<ephemeron.ml:731:6>>*/ var _e_ = b[1];
-     /*<<ephemeron.ml:731:26>>*/ function _f_(_g_){
-      /*<<?>>*/ return test_keys$0(k, _g_);
+     /*<<ephemeron.ml:731:6>>*/ var _d_ = b[1];
+     /*<<ephemeron.ml:731:26>>*/ function _e_(_f_){
+      /*<<?>>*/ return test_keys$0(k, _f_);
     }
      /*<<ephemeron.ml:731:12>>*/  /*<<ephemeron.ml:731:12>>*/ var
      match =
-        /*<<ephemeron.ml:731:12>>*/ caml_call2(Stdlib_List[39], _f_, _e_);
+        /*<<ephemeron.ml:731:12>>*/ caml_call2(Stdlib_List[39], _e_, _d_);
     if(! match)  /*<<ephemeron.ml:733:16>>*/ return 0;
     var e = match[1];
      /*<<ephemeron.ml:732:18>>*/ return get_data$1(e);
@@ -31771,7 +31784,7 @@
             : runtime.caml_call_gen(f, [a0, a1, a2, a3]);
    }
    var
-    _l_ = undefined,
+    sentinal = undefined,
     global_data = runtime.caml_get_global_data(),
     cst$18 = cst$19,
     cst$17 = cst$19,
@@ -31907,39 +31920,39 @@
     /*<<filename.ml:96:34>>*/ }
    function is_relative(n){
      /*<<filename.ml:97:22>>*/ var
-     _aI_ = caml_ml_string_length(n) < 1 ? 1 : 0,
-     _aJ_ =
-       _aI_
+     _aH_ = caml_ml_string_length(n) < 1 ? 1 : 0,
+     _aI_ =
+       _aH_
        || (47 !==  /*<<filename.ml:97:45>>*/ caml_string_get(n, 0) ? 1 : 0);
-    return _aJ_;
+    return _aI_;
     /*<<filename.ml:97:57>>*/ }
    function is_implicit(n){
      /*<<filename.ml:99:4>>*/  /*<<filename.ml:99:4>>*/ var
-     _aD_ = is_relative(n);
-     /*<<filename.ml:99:4>>*/ if(_aD_){
+     _aC_ = is_relative(n);
+     /*<<filename.ml:99:4>>*/ if(_aC_){
      var
-      _aE_ = caml_ml_string_length(n) < 2 ? 1 : 0,
-      _aF_ =
-        _aE_
+      _aD_ = caml_ml_string_length(n) < 2 ? 1 : 0,
+      _aE_ =
+        _aD_
         ||
           /*<<filename.ml:100:31>>*/ caml_string_notequal
           ( /*<<filename.ml:100:31>>*/ caml_call3(Stdlib_String[15], n, 0, 2),
            cst$27);
-      /*<<filename.ml:100:31>>*/ if(_aF_)
+      /*<<filename.ml:100:31>>*/ if(_aE_)
       var
-       _aG_ = caml_ml_string_length(n) < 3 ? 1 : 0,
-       _aH_ =
-         _aG_
+       _aF_ = caml_ml_string_length(n) < 3 ? 1 : 0,
+       _aG_ =
+         _aF_
          ||
            /*<<filename.ml:101:31>>*/ caml_string_notequal
            ( /*<<filename.ml:101:31>>*/ caml_call3(Stdlib_String[15], n, 0, 3),
             cst$28);
      else
-      var _aH_ = _aF_;
+      var _aG_ = _aE_;
     }
     else
-     var _aH_ = _aD_;
-     /*<<filename.ml:101:31>>*/ return _aH_;
+     var _aG_ = _aC_;
+     /*<<filename.ml:101:31>>*/ return _aG_;
     /*<<filename.ml:101:57>>*/ }
    function check_suffix(name, suff){
      /*<<filename.ml:103:4>>*/ return  /*<<filename.ml:103:4>>*/ caml_call2
@@ -31967,8 +31980,8 @@
         /*<<filename.ml:117:8>>*/ caml_sys_getenv("TMPDIR"),
      temp_dir_name = _k_;
    }
-   catch(_aC_){
-    var _a_ = caml_wrap_exception(_aC_);
+   catch(_aB_){
+    var _a_ = caml_wrap_exception(_aB_);
     if(_a_ !== Stdlib[8]) throw caml_maybe_attach_backtrace(_a_, 0);
     var temp_dir_name = cst_tmp;
    }
@@ -31980,10 +31993,10 @@
      /*<<filename.ml:19:2>>*/  /*<<filename.ml:19:2>>*/ caml_call2
      (Stdlib_Buffer[12], b, 39);
      /*<<filename.ml:19:2>>*/ var
-     _az_ = l - 1 | 0,
-      /*<<filename.ml:19:2>>*/ _ay_ = 0;
-    if(_az_ >= 0){
-     var i = _ay_;
+     _ay_ = l - 1 | 0,
+      /*<<filename.ml:19:2>>*/ _ax_ = 0;
+    if(_ay_ >= 0){
+     var i = _ax_;
      for(;;){
        /*<<filename.ml:21:7>>*/ if
        (39 ===  /*<<filename.ml:21:7>>*/ caml_string_get(s, i))
@@ -31991,14 +32004,14 @@
         (Stdlib_Buffer[16], b, quotequote);
       else{
         /*<<filename.ml:23:28>>*/  /*<<filename.ml:23:28>>*/ var
-        _aB_ =  /*<<filename.ml:23:28>>*/ caml_string_get(s, i);
+        _aA_ =  /*<<filename.ml:23:28>>*/ caml_string_get(s, i);
         /*<<filename.ml:23:9>>*/  /*<<filename.ml:23:9>>*/ caml_call2
-        (Stdlib_Buffer[12], b, _aB_);
+        (Stdlib_Buffer[12], b, _aA_);
       }
        /*<<filename.ml:23:9>>*/  /*<<filename.ml:23:9>>*/ var
-       _aA_ = i + 1 | 0;
-      if(_az_ === i) break;
-      var i = _aA_;
+       _az_ = i + 1 | 0;
+      if(_ay_ === i) break;
+      var i = _az_;
      }
     }
      /*<<filename.ml:25:2>>*/  /*<<filename.ml:25:2>>*/ caml_call2
@@ -32011,47 +32024,47 @@
      var f = stderr[1];
       /*<<filename.ml:123:51>>*/ if
       ( /*<<filename.ml:123:51>>*/ caml_equal(stderr, stdout))
-      var _an_ = cst_2_1;
+      var _am_ = cst_2_1;
      else
        /*<<filename.ml:125:61>>*/ var
-        /*<<filename.ml:125:61>>*/ _ax_ = quote(f),
-       _an_ =  /*<<filename.ml:125:53>>*/ caml_call2(Stdlib[28], cst_2, _ax_);
-     var _ao_ = _an_;
+        /*<<filename.ml:125:61>>*/ _aw_ = quote(f),
+       _am_ =  /*<<filename.ml:125:53>>*/ caml_call2(Stdlib[28], cst_2, _aw_);
+     var _an_ = _am_;
     }
     else
-     var _ao_ = cst$4;
+     var _an_ = cst$4;
     if(stdout)
       /*<<filename.ml:122:55>>*/ var
       f$0 = stdout[1],
-       /*<<filename.ml:122:55>>*/ _ap_ = quote(f$0),
-      _aq_ =  /*<<filename.ml:122:48>>*/ caml_call2(Stdlib[28], cst, _ap_);
+       /*<<filename.ml:122:55>>*/ _ao_ = quote(f$0),
+      _ap_ =  /*<<filename.ml:122:48>>*/ caml_call2(Stdlib[28], cst, _ao_);
     else
-     var _aq_ = cst$3;
+     var _ap_ = cst$3;
      /*<<filename.ml:122:6>>*/  /*<<filename.ml:122:6>>*/ var
-     _ar_ =  /*<<filename.ml:122:6>>*/ caml_call2(Stdlib[28], _aq_, _ao_);
+     _aq_ =  /*<<filename.ml:122:6>>*/ caml_call2(Stdlib[28], _ap_, _an_);
     if(stdin)
       /*<<filename.ml:121:55>>*/ var
       f$1 = stdin[1],
-       /*<<filename.ml:121:55>>*/ _as_ = quote(f$1),
-      _at_ =  /*<<filename.ml:121:48>>*/ caml_call2(Stdlib[28], cst$0, _as_);
+       /*<<filename.ml:121:55>>*/ _ar_ = quote(f$1),
+      _as_ =  /*<<filename.ml:121:48>>*/ caml_call2(Stdlib[28], cst$0, _ar_);
     else
-     var _at_ = cst$2;
+     var _as_ = cst$2;
      /*<<filename.ml:121:6>>*/ var
-      /*<<filename.ml:121:6>>*/ _au_ =
-        /*<<filename.ml:121:6>>*/ caml_call2(Stdlib[28], _at_, _ar_),
-      /*<<filename.ml:120:22>>*/ _av_ =
+      /*<<filename.ml:121:6>>*/ _at_ =
+        /*<<filename.ml:121:6>>*/ caml_call2(Stdlib[28], _as_, _aq_),
+      /*<<filename.ml:120:22>>*/ _au_ =
         /*<<filename.ml:120:22>>*/ caml_call2
         (Stdlib_List[19], quote, [0, cmd, args]),
-      /*<<filename.ml:120:4>>*/ _aw_ =
-        /*<<filename.ml:120:4>>*/ caml_call2(Stdlib_String[6], cst$1, _av_);
+      /*<<filename.ml:120:4>>*/ _av_ =
+        /*<<filename.ml:120:4>>*/ caml_call2(Stdlib_String[6], cst$1, _au_);
      /*<<filename.ml:121:6>>*/ return  /*<<filename.ml:121:6>>*/ caml_call2
-            (Stdlib[28], _aw_, _au_);
+            (Stdlib[28], _av_, _at_);
     /*<<filename.ml:125:69>>*/ }
-    /*<<filename.ml:126:17>>*/ function basename(_am_){
-     /*<<?>>*/ return generic_basename(is_dir_sep, current_dir_name, _am_);
+    /*<<filename.ml:126:17>>*/ function basename(_al_){
+     /*<<?>>*/ return generic_basename(is_dir_sep, current_dir_name, _al_);
    }
-    /*<<filename.ml:127:16>>*/ function dirname(_al_){
-     /*<<?>>*/ return generic_dirname(is_dir_sep, current_dir_name, _al_);
+    /*<<filename.ml:127:16>>*/ function dirname(_ak_){
+     /*<<?>>*/ return generic_dirname(is_dir_sep, current_dir_name, _ak_);
    }
     /*<<filename.ml:91:24>>*/  /*<<filename.ml:91:24>>*/ var
     Unix =
@@ -32074,96 +32087,96 @@
      /*<<filename.ml:135:23>>*/ var
       /*<<filename.ml:135:31>>*/ c =
         /*<<filename.ml:135:31>>*/ caml_string_get(s, i),
-     _ai_ = 47 === c ? 1 : 0;
-    if(_ai_)
-     var _aj_ = _ai_;
+     _ah_ = 47 === c ? 1 : 0;
+    if(_ah_)
+     var _ai_ = _ah_;
     else
-     var _ak_ = 92 === c ? 1 : 0, _aj_ = _ak_ || (58 === c ? 1 : 0);
-    return _aj_;
+     var _aj_ = 92 === c ? 1 : 0, _ai_ = _aj_ || (58 === c ? 1 : 0);
+    return _ai_;
     /*<<filename.ml:135:70>>*/ }
    function is_relative$0(n){
      /*<<filename.ml:137:4>>*/ var
-     _ac_ = caml_ml_string_length(n) < 1 ? 1 : 0,
-     _ad_ =
-       _ac_
+     _ab_ = caml_ml_string_length(n) < 1 ? 1 : 0,
+     _ac_ =
+       _ab_
        || (47 !==  /*<<filename.ml:137:28>>*/ caml_string_get(n, 0) ? 1 : 0);
-    if(_ad_){
+    if(_ac_){
      var
-      _ae_ = caml_ml_string_length(n) < 1 ? 1 : 0,
-      _af_ =
-        _ae_
+      _ad_ = caml_ml_string_length(n) < 1 ? 1 : 0,
+      _ae_ =
+        _ad_
         || (92 !==  /*<<filename.ml:138:31>>*/ caml_string_get(n, 0) ? 1 : 0);
-     if(_af_)
+     if(_ae_)
       var
-       _ag_ = caml_ml_string_length(n) < 2 ? 1 : 0,
-       _ah_ =
-         _ag_
+       _af_ = caml_ml_string_length(n) < 2 ? 1 : 0,
+       _ag_ =
+         _af_
          || (58 !==  /*<<filename.ml:139:31>>*/ caml_string_get(n, 1) ? 1 : 0);
      else
-      var _ah_ = _af_;
+      var _ag_ = _ae_;
     }
     else
-     var _ah_ = _ad_;
-    return _ah_;
+     var _ag_ = _ac_;
+    return _ag_;
     /*<<filename.ml:139:44>>*/ }
    function is_implicit$0(n){
      /*<<filename.ml:141:4>>*/  /*<<filename.ml:141:4>>*/ var
-     _V_ = is_relative$0(n);
-     /*<<filename.ml:141:4>>*/ if(_V_){
+     _U_ = is_relative$0(n);
+     /*<<filename.ml:141:4>>*/ if(_U_){
      var
-      _W_ = caml_ml_string_length(n) < 2 ? 1 : 0,
-      _X_ =
-        _W_
+      _V_ = caml_ml_string_length(n) < 2 ? 1 : 0,
+      _W_ =
+        _V_
         ||
           /*<<filename.ml:142:31>>*/ caml_string_notequal
           ( /*<<filename.ml:142:31>>*/ caml_call3(Stdlib_String[15], n, 0, 2),
            cst$27);
-      /*<<filename.ml:142:31>>*/ if(_X_){
+      /*<<filename.ml:142:31>>*/ if(_W_){
       var
-       _Y_ = caml_ml_string_length(n) < 2 ? 1 : 0,
-       _Z_ =
-         _Y_
+       _X_ = caml_ml_string_length(n) < 2 ? 1 : 0,
+       _Y_ =
+         _X_
          ||
            /*<<filename.ml:143:31>>*/ caml_string_notequal
            ( /*<<filename.ml:143:31>>*/ caml_call3(Stdlib_String[15], n, 0, 2),
             ".\\");
-       /*<<filename.ml:143:31>>*/ if(_Z_){
+       /*<<filename.ml:143:31>>*/ if(_Y_){
        var
-        ___ = caml_ml_string_length(n) < 3 ? 1 : 0,
-        _$_ =
-          ___
+        _Z_ = caml_ml_string_length(n) < 3 ? 1 : 0,
+        ___ =
+          _Z_
           ||
             /*<<filename.ml:144:31>>*/ caml_string_notequal
             ( /*<<filename.ml:144:31>>*/ caml_call3
               (Stdlib_String[15], n, 0, 3),
              cst$28);
-        /*<<filename.ml:144:31>>*/ if(_$_)
+        /*<<filename.ml:144:31>>*/ if(___)
         var
-         _aa_ = caml_ml_string_length(n) < 3 ? 1 : 0,
-         _ab_ =
-           _aa_
+         _$_ = caml_ml_string_length(n) < 3 ? 1 : 0,
+         _aa_ =
+           _$_
            ||
              /*<<filename.ml:145:31>>*/ caml_string_notequal
              ( /*<<filename.ml:145:31>>*/ caml_call3
                (Stdlib_String[15], n, 0, 3),
               "..\\");
        else
-        var _ab_ = _$_;
+        var _aa_ = ___;
       }
       else
-       var _ab_ = _Z_;
+       var _aa_ = _Y_;
      }
      else
-      var _ab_ = _X_;
+      var _aa_ = _W_;
     }
     else
-     var _ab_ = _V_;
-     /*<<filename.ml:145:31>>*/ return _ab_;
+     var _aa_ = _U_;
+     /*<<filename.ml:145:31>>*/ return _aa_;
     /*<<filename.ml:145:58>>*/ }
    function check_suffix$0(name, suff){
      /*<<filename.ml:147:3>>*/ var
-     _S_ = caml_ml_string_length(suff) <= caml_ml_string_length(name) ? 1 : 0;
-    if(_S_)
+     _R_ = caml_ml_string_length(suff) <= caml_ml_string_length(name) ? 1 : 0;
+    if(_R_)
       /*<<filename.ml:148:12>>*/ var
        /*<<filename.ml:148:12>>*/ s =
          /*<<filename.ml:148:12>>*/ caml_call3
@@ -32171,14 +32184,14 @@
           name,
           caml_ml_string_length(name) - caml_ml_string_length(suff) | 0,
           caml_ml_string_length(suff)),
-       /*<<filename.ml:150:31>>*/ _T_ =
+       /*<<filename.ml:150:31>>*/ _S_ =
          /*<<filename.ml:150:31>>*/ caml_call1(Stdlib_String[26], suff),
-      _U_ =
+      _T_ =
          /*<<filename.ml:150:4>>*/ caml_string_equal
-         ( /*<<filename.ml:150:4>>*/ caml_call1(Stdlib_String[26], s), _T_);
+         ( /*<<filename.ml:150:4>>*/ caml_call1(Stdlib_String[26], s), _S_);
     else
-     var _U_ = _S_;
-     /*<<filename.ml:150:4>>*/ return _U_;
+     var _T_ = _R_;
+     /*<<filename.ml:150:4>>*/ return _T_;
     /*<<filename.ml:150:59>>*/ }
    function chop_suffix_opt$0(suffix, filename){
      /*<<filename.ml:153:4>>*/ var
@@ -32189,11 +32202,11 @@
       /*<<filename.ml:155:14>>*/ r =
         /*<<filename.ml:155:14>>*/ caml_call3
         (Stdlib_String[15], filename, len_f - len_s | 0, len_s),
-      /*<<filename.ml:156:36>>*/ _R_ =
+      /*<<filename.ml:156:36>>*/ _Q_ =
         /*<<filename.ml:156:36>>*/ caml_call1(Stdlib_String[26], suffix);
      /*<<filename.ml:156:9>>*/ return  /*<<filename.ml:156:9>>*/ caml_string_equal
              ( /*<<filename.ml:156:9>>*/ caml_call1(Stdlib_String[26], r),
-              _R_)
+              _Q_)
             ? [0,
                /*<<filename.ml:157:13>>*/ caml_call3
                (Stdlib_String[15], filename, 0, len_f - len_s | 0)]
@@ -32205,8 +32218,8 @@
         /*<<filename.ml:165:8>>*/ caml_sys_getenv("TEMP"),
      temp_dir_name$0 = _j_;
    }
-   catch(_Q_){
-    var _b_ = caml_wrap_exception(_Q_);
+   catch(_P_){
+    var _b_ = caml_wrap_exception(_P_);
     if(_b_ !== Stdlib[8]) throw caml_maybe_attach_backtrace(_b_, 0);
     var temp_dir_name$0 = cst$5;
    }
@@ -32223,17 +32236,17 @@
       if(i$0 === l){
         /*<<filename.ml:171:20>>*/  /*<<filename.ml:171:20>>*/ caml_call2
         (Stdlib_Buffer[12], b, 34);
-        /*<<filename.ml:171:20>>*/ return _l_;
+        /*<<filename.ml:171:20>>*/ return sentinal;
       }
        /*<<filename.ml:172:12>>*/  /*<<filename.ml:172:12>>*/ var
        c =  /*<<filename.ml:172:12>>*/ caml_string_get(s, i$0);
       if(34 === c){
         /*<<filename.ml:173:16>>*/ loop_bs(0, i$0);
-        /*<<filename.ml:173:16>>*/ return _l_;
+        /*<<filename.ml:173:16>>*/ return sentinal;
       }
       if(92 === c){
         /*<<filename.ml:174:16>>*/ loop_bs(0, i$0);
-        /*<<filename.ml:174:16>>*/ return _l_;
+        /*<<filename.ml:174:16>>*/ return sentinal;
       }
        /*<<filename.ml:175:16>>*/  /*<<filename.ml:175:16>>*/ caml_call2
        (Stdlib_Buffer[12], b, c);
@@ -32249,7 +32262,7 @@
         /*<<filename.ml:178:8>>*/  /*<<filename.ml:178:8>>*/ caml_call2
         (Stdlib_Buffer[12], b, 34);
         /*<<filename.ml:178:8>>*/ add_bs(n$0);
-        /*<<filename.ml:178:8>>*/ return _l_;
+        /*<<filename.ml:178:8>>*/ return sentinal;
       }
        /*<<filename.ml:181:14>>*/  /*<<filename.ml:181:14>>*/ var
        match =  /*<<filename.ml:181:14>>*/ caml_string_get(s, i$0);
@@ -32258,12 +32271,12 @@
         /*<<filename.ml:182:34>>*/  /*<<filename.ml:182:34>>*/ caml_call2
         (Stdlib_Buffer[12], b, 34);
         /*<<filename.ml:182:34>>*/ loop(i$0 + 1 | 0);
-        /*<<filename.ml:182:34>>*/ return _l_;
+        /*<<filename.ml:182:34>>*/ return sentinal;
       }
       if(92 !== match){
         /*<<filename.ml:184:18>>*/ add_bs(n$0);
         /*<<filename.ml:184:18>>*/ loop(i$0);
-        /*<<filename.ml:184:18>>*/ return _l_;
+        /*<<filename.ml:184:18>>*/ return sentinal;
       }
        /*<<filename.ml:183:18>>*/ var
         /*<<filename.ml:183:18>>*/ i$1 = i$0 + 1 | 0,
@@ -32273,19 +32286,19 @@
      }
      /*<<filename.ml:185:9>>*/ }
     function add_bs(n){
-      /*<<filename.ml:186:19>>*/  /*<<filename.ml:186:19>>*/ var _O_ = 1;
+      /*<<filename.ml:186:19>>*/  /*<<filename.ml:186:19>>*/ var _N_ = 1;
      if(n >= 1){
-      var j = _O_;
+      var j = _N_;
       for(;;){
         /*<<filename.ml:186:38>>*/  /*<<filename.ml:186:38>>*/ caml_call2
         (Stdlib_Buffer[12], b, 92);
         /*<<filename.ml:186:38>>*/  /*<<filename.ml:186:38>>*/ var
-        _P_ = j + 1 | 0;
+        _O_ = j + 1 | 0;
        if(n === j) break;
-       var j = _P_;
+       var j = _O_;
       }
      }
-     return _l_;
+     return sentinal;
      /*<<filename.ml:186:66>>*/ }
      /*<<filename.ml:188:4>>*/ loop(0);
      /*<<filename.ml:188:4>>*/ return  /*<<filename.ml:188:4>>*/ caml_call1
@@ -32300,62 +32313,62 @@
       (!  /*<<filename.ml:224:12>>*/ caml_call2(Stdlib_String[14], f, 32))
        /*<<filename.ml:227:6>>*/ return f;
       /*<<filename.ml:225:13>>*/  /*<<filename.ml:225:13>>*/ var
-      _N_ =  /*<<filename.ml:225:13>>*/ caml_call2(Stdlib[28], f, cst$6);
+      _M_ =  /*<<filename.ml:225:13>>*/ caml_call2(Stdlib[28], f, cst$6);
       /*<<filename.ml:225:13>>*/ return  /*<<filename.ml:225:13>>*/ caml_call2
-             (Stdlib[28], cst$7, _N_);
+             (Stdlib[28], cst$7, _M_);
     }
      /*<<filename.ml:223:15>>*/  /*<<filename.ml:223:15>>*/ var
-     _M_ =
+     _L_ =
         /*<<filename.ml:223:15>>*/ caml_call2
         (Stdlib[28], cst_Filename_quote_command_bad, f);
      /*<<filename.ml:223:15>>*/ return  /*<<filename.ml:223:15>>*/ caml_call1
-            (Stdlib[2], _M_);
+            (Stdlib[2], _L_);
     /*<<filename.ml:227:7>>*/ }
    function quote_command$0(cmd, stdin, stdout, stderr, args){
      /*<<filename.ml:232:4>>*/ if(stderr){
      var f = stderr[1];
       /*<<filename.ml:240:43>>*/ if
       ( /*<<filename.ml:240:43>>*/ caml_equal(stderr, stdout))
-      var _y_ = cst_2_1$0;
+      var _x_ = cst_2_1$0;
      else
        /*<<filename.ml:242:53>>*/ var
-        /*<<filename.ml:242:53>>*/ _K_ = quote_cmd_filename(f),
-       _y_ =  /*<<filename.ml:242:45>>*/ caml_call2(Stdlib[28], cst_2$0, _K_);
-     var _z_ = _y_;
+        /*<<filename.ml:242:53>>*/ _J_ = quote_cmd_filename(f),
+       _x_ =  /*<<filename.ml:242:45>>*/ caml_call2(Stdlib[28], cst_2$0, _J_);
+     var _y_ = _x_;
     }
     else
-     var _z_ = cst$16;
-    var _A_ = [0, _z_, _c_];
+     var _y_ = cst$16;
+    var _z_ = [0, _y_, _c_];
     if(stdout)
       /*<<filename.ml:238:55>>*/ var
       f$0 = stdout[1],
-       /*<<filename.ml:238:55>>*/ _B_ = quote_cmd_filename(f$0),
-      _C_ =  /*<<filename.ml:238:48>>*/ caml_call2(Stdlib[28], cst$8, _B_);
+       /*<<filename.ml:238:55>>*/ _A_ = quote_cmd_filename(f$0),
+      _B_ =  /*<<filename.ml:238:48>>*/ caml_call2(Stdlib[28], cst$8, _A_);
     else
-     var _C_ = cst$15;
-    var _D_ = [0, _C_, _A_];
+     var _B_ = cst$15;
+    var _C_ = [0, _B_, _z_];
     if(stdin)
       /*<<filename.ml:237:55>>*/ var
       f$1 = stdin[1],
-       /*<<filename.ml:237:55>>*/ _E_ = quote_cmd_filename(f$1),
-      _F_ =  /*<<filename.ml:237:48>>*/ caml_call2(Stdlib[28], cst$9, _E_);
+       /*<<filename.ml:237:55>>*/ _D_ = quote_cmd_filename(f$1),
+      _E_ =  /*<<filename.ml:237:48>>*/ caml_call2(Stdlib[28], cst$9, _D_);
     else
-     var _F_ = cst$14;
+     var _E_ = cst$14;
      /*<<filename.ml:236:35>>*/ var
-      /*<<filename.ml:236:35>>*/ _H_ =
+      /*<<filename.ml:236:35>>*/ _G_ =
         /*<<filename.ml:236:35>>*/ caml_call2(Stdlib_List[19], quote$0, args),
       /*<<filename.ml:236:16>>*/ s =
-        /*<<filename.ml:236:16>>*/ caml_call2(Stdlib_String[6], cst$10, _H_),
+        /*<<filename.ml:236:16>>*/ caml_call2(Stdlib_String[6], cst$10, _G_),
       /*<<filename.ml:211:12>>*/ b =
         /*<<filename.ml:211:12>>*/ caml_call1
         (Stdlib_Buffer[1], caml_ml_string_length(s) + 20 | 0),
-     _G_ = [0, _F_, _D_];
-    function _x_(c){
+     _F_ = [0, _E_, _C_];
+    function _w_(c){
       /*<<filename.ml:214:8>>*/ a:
      {
       if(62 <= c){
-       var _L_ = c - 63 | 0;
-       if(60 < _L_ >>> 0){if(62 <= _L_) break a;} else if(31 !== _L_) break a;
+       var _K_ = c - 63 | 0;
+       if(60 < _K_ >>> 0){if(62 <= _K_) break a;} else if(31 !== _K_) break a;
       }
       else
        if(42 <= c){
@@ -32375,21 +32388,21 @@
              (Stdlib_Buffer[12], b, c);
      /*<<filename.ml:218:31>>*/ }
      /*<<filename.ml:212:4>>*/  /*<<filename.ml:212:4>>*/ caml_call2
-     (Stdlib_String[29], _x_, s);
+     (Stdlib_String[29], _w_, s);
      /*<<filename.ml:232:21>>*/ var
-     _I_ =
+     _H_ =
        [0,
         cst$11,
-        [0,  /*<<filename.ml:212:4>>*/ caml_call1(Stdlib_Buffer[2], b), _G_]],
-      /*<<filename.ml:232:21>>*/ _J_ =
-       [0, cst$12, [0, quote_cmd_filename(cmd), _I_]];
+        [0,  /*<<filename.ml:212:4>>*/ caml_call1(Stdlib_Buffer[2], b), _F_]],
+      /*<<filename.ml:232:21>>*/ _I_ =
+       [0, cst$12, [0, quote_cmd_filename(cmd), _H_]];
      /*<<filename.ml:232:21>>*/ return  /*<<filename.ml:232:21>>*/ caml_call2
-            (Stdlib_String[6], cst$13, _J_);
+            (Stdlib_String[6], cst$13, _I_);
     /*<<filename.ml:244:5>>*/ }
    function drive_and_path(s){
      /*<<filename.ml:252:4>>*/ var
-     _t_ = 2 <=  /*<<filename.ml:250:4>>*/ caml_ml_string_length(s) ? 1 : 0;
-    if(_t_){
+     _s_ = 2 <=  /*<<filename.ml:250:4>>*/ caml_ml_string_length(s) ? 1 : 0;
+    if(_s_){
       /*<<filename.ml:250:38>>*/  /*<<filename.ml:250:38>>*/ var
       param =  /*<<filename.ml:250:38>>*/ caml_string_get(s, 0);
      a:
@@ -32400,28 +32413,28 @@
         if(25 < param - 97 >>> 0) break b;
        }
        else if(65 > param) break b;
-       var _u_ = 1;
+       var _t_ = 1;
        break a;
       }
-      var _u_ = 0;
+      var _t_ = 0;
      }
       /*<<filename.ml:250:28>>*/  /*<<filename.ml:250:28>>*/ var
-      _v_ =
-        _u_
+      _u_ =
+        _t_
          ? 58 ===  /*<<filename.ml:250:47>>*/ caml_string_get(s, 1) ? 1 : 0
-         : _u_;
+         : _t_;
     }
     else
-     var _v_ = _t_;
-     /*<<filename.ml:252:7>>*/ if(! _v_)
+     var _u_ = _s_;
+     /*<<filename.ml:252:7>>*/ if(! _u_)
       /*<<filename.ml:254:9>>*/ return [0, cst$17, s];
      /*<<filename.ml:253:28>>*/  /*<<filename.ml:253:28>>*/ var
-     _w_ =
+     _v_ =
         /*<<filename.ml:253:28>>*/ caml_call3
         (Stdlib_String[15], s, 2, caml_ml_string_length(s) - 2 | 0);
      /*<<filename.ml:253:9>>*/ return [0,
              /*<<filename.ml:253:10>>*/ caml_call3(Stdlib_String[15], s, 0, 2),
-            _w_];
+            _v_];
     /*<<filename.ml:254:16>>*/ }
    function dirname$0(s){
      /*<<filename.ml:256:4>>*/ var
@@ -32455,11 +32468,11 @@
        quote_command$0,
        basename$0,
        dirname$0];
-    /*<<filename.ml:277:17>>*/ function basename$1(_s_){
-     /*<<?>>*/ return generic_basename(is_dir_sep$0, current_dir_name$1, _s_);
+    /*<<filename.ml:277:17>>*/ function basename$1(_r_){
+     /*<<?>>*/ return generic_basename(is_dir_sep$0, current_dir_name$1, _r_);
    }
-    /*<<filename.ml:278:16>>*/ function dirname$1(_r_){
-     /*<<?>>*/ return generic_dirname(is_dir_sep$0, current_dir_name$1, _r_);
+    /*<<filename.ml:278:16>>*/ function dirname$1(_q_){
+     /*<<?>>*/ return generic_dirname(is_dir_sep$0, current_dir_name$1, _q_);
    }
     /*<<filename.ml:264:26>>*/ var
      /*<<filename.ml:264:26>>*/ Cygwin =
@@ -32502,11 +32515,11 @@
      /*<<filename.ml:291:14>>*/ if
      (0 !== l && ! is_dir_sep$1(dirname, l - 1 | 0)){
       /*<<filename.ml:293:17>>*/  /*<<filename.ml:293:17>>*/ var
-      _q_ =
+      _p_ =
          /*<<filename.ml:293:17>>*/ caml_call2
          (Stdlib[28], dir_sep$2, filename);
       /*<<filename.ml:293:17>>*/ return  /*<<filename.ml:293:17>>*/ caml_call2
-             (Stdlib[28], dirname, _q_);
+             (Stdlib[28], dirname, _p_);
     }
      /*<<filename.ml:292:7>>*/ return  /*<<filename.ml:292:7>>*/ caml_call2
             (Stdlib[28], dirname, filename);
@@ -32609,7 +32622,7 @@
     /*<<filename.ml:338:71>>*/ }
     /*<<filename.ml:338:40>>*/ var
      /*<<filename.ml:338:40>>*/ _g_ =
-      [0, function(_p_){ /*<<?>>*/ return _p_;}],
+      [0, function(_o_){ /*<<?>>*/ return _o_;}],
      /*<<filename.ml:338:2>>*/ current_temp_dir_name =
        /*<<filename.ml:338:2>>*/ caml_call2(Stdlib_Domain[10][1], _g_, _f_);
    function set_temp_dir_name(s){
@@ -32649,17 +32662,17 @@
      }
     }
     /*<<filename.ml:351:15>>*/ }
-   function open_temp_file(opt, _n_, _m_, prefix, suffix){
+   function open_temp_file(opt, _m_, _l_, prefix, suffix){
      /*<<filename.ml:356:2>>*/ if(opt)
      var sth = opt[1], mode = sth;
     else
      var mode = _i_;
-     /*<<filename.ml:356:2>>*/ if(_n_)
-     var sth$0 = _n_[1], perms = sth$0;
+     /*<<filename.ml:356:2>>*/ if(_m_)
+     var sth$0 = _m_[1], perms = sth$0;
     else
      var perms = 384;
-     /*<<filename.ml:356:2>>*/ if(_m_)
-     var sth$1 = _m_[1], temp_dir = sth$1;
+     /*<<filename.ml:356:2>>*/ if(_l_)
+     var sth$1 = _l_[1], temp_dir = sth$1;
     else
      var
       temp_dir =
@@ -32671,12 +32684,12 @@
       name = temp_file_name(temp_dir, prefix, suffix);
       /*<<filename.ml:358:4>>*/ try{
        /*<<filename.ml:359:6>>*/  /*<<filename.ml:359:6>>*/ var
-       _o_ =
+       _n_ =
          [0,
           name,
            /*<<filename.ml:360:7>>*/ caml_call3
            (Stdlib[62], [0, 1, [0, 3, [0, 5, mode]]], perms, name)];
-       /*<<filename.ml:359:6>>*/ return _o_;
+       /*<<filename.ml:359:6>>*/ return _n_;
      }
      catch(e$0){
       var e = caml_wrap_exception(e$0);

From ca4642592ab4545d8d9fb9384d41f64ec2963f35 Mon Sep 17 00:00:00 2001
From: Micah Cantor <micahcantor01@gmail.com>
Date: Thu, 24 Aug 2023 22:13:59 -0500
Subject: [PATCH 065/112] omit sentinal fields in generated code

---
 compiler/lib/driver.ml                     | 32 ++++++++++++++++------
 compiler/lib/generate.ml                   | 21 +++++++++++---
 compiler/lib/generate.mli                  |  1 +
 compiler/lib/macro.ml                      |  2 +-
 compiler/lib/mlvalue.ml                    |  6 ++--
 compiler/lib/mlvalue.mli                   |  4 +--
 compiler/tests-compiler/global_deadcode.ml |  2 +-
 7 files changed, 47 insertions(+), 21 deletions(-)

diff --git a/compiler/lib/driver.ml b/compiler/lib/driver.ml
index f72320508e..3ae57b0298 100644
--- a/compiler/lib/driver.ml
+++ b/compiler/lib/driver.ml
@@ -104,15 +104,22 @@ let exact_calls profile p =
       | O3 -> false
       | O1 | O2 -> true
     in
-    if Config.Flag.globaldeadcode () then
+    if Config.Flag.globaldeadcode ()
+    then
       let p, sentinal = Deadcode_dgraph.add_sentinal p in
       let info = Global_flow.f ~fast p in
       let p = Deadcode_dgraph.f p sentinal info in
-      Specialize.f ~function_arity:(fun f -> Global_flow.function_arity info f) p
-    else 
+      let p =
+        Specialize.f ~function_arity:(fun f -> Global_flow.function_arity info f) p
+      in
+      p, Some sentinal
+    else
       let info = Global_flow.f ~fast p in
-      Specialize.f ~function_arity:(fun f -> Global_flow.function_arity info f) p
-  else p
+      let p =
+        Specialize.f ~function_arity:(fun f -> Global_flow.function_arity info f) p
+      in
+      p, None
+  else p, None
 
 let print p =
   if debug () then Code.Print.program (fun _ _ -> "") p;
@@ -181,7 +188,7 @@ let generate
     ~exported_runtime
     ~wrap_with_fun
     ~warn_on_unhandled_effect
-    ((p, live_vars), cps_calls) =
+    ((p, live_vars), cps_calls, sentinal) =
   if times () then Format.eprintf "Start Generation...@.";
   let should_export = should_export wrap_with_fun in
   Generate.f
@@ -191,6 +198,7 @@ let generate
     ~cps_calls
     ~should_export
     ~warn_on_unhandled_effect
+    ~sentinal
     d
 
 let debug_linker = Debug.find "linker"
@@ -585,8 +593,11 @@ let full ~standalone ~wrap_with_fun ~profile ~linkall ~source_map formatter d p
        | O2 -> o2
        | O3 -> o3)
     +> exact_calls profile
-    +> effects
-    +> map_fst (Generate_closure.f +> deadcode')
+    +> (fun (p, sentinal) ->
+         let p, cps_calls = effects p in
+         p, cps_calls, sentinal)
+    +> fun (p, cps_calls, sentinal) ->
+    deadcode' (Generate_closure.f p), cps_calls, sentinal
   in
   let emit =
     generate d ~exported_runtime ~wrap_with_fun ~warn_on_unhandled_effect:standalone
@@ -598,7 +609,10 @@ let full ~standalone ~wrap_with_fun ~profile ~linkall ~source_map formatter d p
   in
   if times () then Format.eprintf "Start Optimizing...@.";
   let t = Timer.make () in
-  let r = opt p in
+  let r : (Code.program * Deadcode.variable_uses) * Effects.cps_calls * Code.Var.t option
+      =
+    opt p
+  in
   let () = if times () then Format.eprintf " optimizations : %a@." Timer.print t in
   emit r
 
diff --git a/compiler/lib/generate.ml b/compiler/lib/generate.ml
index 845e7a3003..ef49532f53 100644
--- a/compiler/lib/generate.ml
+++ b/compiler/lib/generate.ml
@@ -285,12 +285,14 @@ module Ctx = struct
     ; should_export : bool
     ; effect_warning : bool ref
     ; cps_calls : Effects.cps_calls
+    ; sentinal : Var.t option
     }
 
   let initial
       ~warn_on_unhandled_effect
       ~exported_runtime
       ~should_export
+      ~sentinal
       blocks
       live
       cps_calls
@@ -304,6 +306,7 @@ module Ctx = struct
     ; should_export
     ; effect_warning = ref (not warn_on_unhandled_effect)
     ; cps_calls
+    ; sentinal
     }
 end
 
@@ -444,7 +447,7 @@ let rec constant_rec ~ctx x level instrs =
   | Float_array a ->
       ( Mlvalue.Array.make
           ~tag:Obj.double_array_tag
-          ~args:(Array.to_list (Array.map a ~f:float_const))
+          ~args:(Array.to_list (Array.map a ~f:(fun x -> J.Element (float_const x))))
       , instrs )
   | Int64 i ->
       let p =
@@ -490,9 +493,9 @@ let rec constant_rec ~ctx x level instrs =
                       let instrs =
                         (J.variable_declaration [ J.V v, (js, J.N) ], J.N) :: instrs
                       in
-                      J.EVar (J.V v) :: acc, instrs
-                  | _ -> js :: acc, instrs)
-            else List.rev l, instrs
+                      J.Element (J.EVar (J.V v)) :: acc, instrs
+                  | _ -> J.Element js :: acc, instrs)
+            else List.map ~f:(fun x -> J.Element x) (List.rev l), instrs
           in
           Mlvalue.Block.make ~tag ~args:l, instrs)
   | Int i -> int32 i, instrs
@@ -1035,6 +1038,14 @@ let rec translate_expr ctx queue loc x e level : _ * J.statement_list =
         List.fold_right
           ~f:(fun x (args, prop, queue) ->
             let (prop', cx), queue = access_queue queue x in
+            let cx =
+              match cx with
+              | J.EVar (J.V v) -> (
+                  match ctx.sentinal with
+                  | Some s -> if Var.equal v s then J.ElementHole else J.Element cx
+                  | None -> J.Element cx)
+              | _ -> J.Element cx
+            in
             cx :: args, or_p prop prop', queue)
           (Array.to_list a)
           ~init:([], const_p, queue)
@@ -1792,6 +1803,7 @@ let f
     ~cps_calls
     ~should_export
     ~warn_on_unhandled_effect
+    ~sentinal
     debug =
   let t' = Timer.make () in
   let share = Share.get ~cps_calls ~alias_prims:exported_runtime p in
@@ -1803,6 +1815,7 @@ let f
       ~warn_on_unhandled_effect
       ~exported_runtime
       ~should_export
+      ~sentinal
       p.blocks
       live_vars
       cps_calls
diff --git a/compiler/lib/generate.mli b/compiler/lib/generate.mli
index 66053fdc2c..ddb4854644 100644
--- a/compiler/lib/generate.mli
+++ b/compiler/lib/generate.mli
@@ -25,6 +25,7 @@ val f :
   -> cps_calls:Effects.cps_calls
   -> should_export:bool
   -> warn_on_unhandled_effect:bool
+  -> sentinal:Code.Var.t option
   -> Parse_bytecode.Debug.t
   -> Javascript.program
 
diff --git a/compiler/lib/macro.ml b/compiler/lib/macro.ml
index 8904d212ac..c9e9fb2047 100644
--- a/compiler/lib/macro.ml
+++ b/compiler/lib/macro.ml
@@ -47,7 +47,7 @@ class macro_mapper ~flags =
               let tag = Int32.to_int (J.Num.to_int32 tag) in
               let args =
                 List.map args ~f:(function
-                    | J.Arg e -> m#expression e
+                    | J.Arg e -> J.Element (m#expression e)
                     | J.ArgSpread _ -> assert false)
               in
               Mlvalue.Block.make ~tag ~args
diff --git a/compiler/lib/mlvalue.ml b/compiler/lib/mlvalue.ml
index 8b5de2ca7b..6752522408 100644
--- a/compiler/lib/mlvalue.ml
+++ b/compiler/lib/mlvalue.ml
@@ -35,10 +35,8 @@ let is_immediate e = type_of_is_number J.EqEqEq e
 
 module Block = struct
   let make ~tag ~args =
-    J.EArr
-      (List.map
-         ~f:(fun x -> J.Element x)
-         (J.ENum (J.Num.of_int32 (Int32.of_int tag)) :: args))
+    let tag_elt = J.Element (J.ENum (J.Num.of_int32 (Int32.of_int tag))) in
+    J.EArr (tag_elt :: args)
 
   let tag e = J.EAccess (e, ANormal, zero)
 
diff --git a/compiler/lib/mlvalue.mli b/compiler/lib/mlvalue.mli
index c0595eac3b..a4d847783b 100644
--- a/compiler/lib/mlvalue.mli
+++ b/compiler/lib/mlvalue.mli
@@ -18,7 +18,7 @@
  *)
 
 module Block : sig
-  val make : tag:int -> args:Javascript.expression list -> Javascript.expression
+  val make : tag:int -> args:Javascript.element list -> Javascript.expression
 
   val tag : Javascript.expression -> Javascript.expression
 
@@ -26,7 +26,7 @@ module Block : sig
 end
 
 module Array : sig
-  val make : tag:int -> args:Javascript.expression list -> Javascript.expression
+  val make : tag:int -> args:Javascript.element list -> Javascript.expression
 
   val length : Javascript.expression -> Javascript.expression
 
diff --git a/compiler/tests-compiler/global_deadcode.ml b/compiler/tests-compiler/global_deadcode.ml
index 899ce4f854..09eefa39a1 100644
--- a/compiler/tests-compiler/global_deadcode.ml
+++ b/compiler/tests-compiler/global_deadcode.ml
@@ -64,7 +64,7 @@ let%expect_test "Substitutes unused fields with undefined" =
   print_fun_decl program (Some "f");
   [%expect {|
     function f(b, x){
-     var t = b ? [0, 1, sentinal, x] : [0, 3, sentinal, 4], v = t[3], u = t[1];
+     var t = b ? [0, 1, , x] : [0, 3, , 4], v = t[3], u = t[1];
      return [0, u, v];
     }
     //end |}];

From a702c991278bce2d595d739fbd4b6098c0b621f2 Mon Sep 17 00:00:00 2001
From: Micah Cantor <micahcantor01@gmail.com>
Date: Sat, 26 Aug 2023 17:27:27 -0500
Subject: [PATCH 066/112] default off

---
 compiler/lib/config.ml            | 2 +-
 compiler/tests-compiler/gh1349.ml | 1 -
 compiler/tests-compiler/gh1354.ml | 3 ---
 3 files changed, 1 insertion(+), 5 deletions(-)

diff --git a/compiler/lib/config.ml b/compiler/lib/config.ml
index 9385a063ba..4d6ab7cc25 100644
--- a/compiler/lib/config.ml
+++ b/compiler/lib/config.ml
@@ -58,7 +58,7 @@ module Flag = struct
 
   let deadcode = o ~name:"deadcode" ~default:true
 
-  let globaldeadcode = o ~name:"globaldeadcode" ~default:true
+  let globaldeadcode = o ~name:"globaldeadcode" ~default:false
 
   let shortvar = o ~name:"shortvar" ~default:true
 
diff --git a/compiler/tests-compiler/gh1349.ml b/compiler/tests-compiler/gh1349.ml
index c385023520..aff3e46862 100644
--- a/compiler/tests-compiler/gh1349.ml
+++ b/compiler/tests-compiler/gh1349.ml
@@ -35,7 +35,6 @@ let%expect_test _ =
         (List.concat
            [ [ "--disable"; "inline" ]
            ; [ "--disable"; "deadcode" ]
-           ; [ "--disable"; "globaldeadcode" ]
            ; [ "--disable"; "staticeval" ]
            ; [ "--enable"; "shortvar" ]
            ; [ "--debug"; "shortvar" ]
diff --git a/compiler/tests-compiler/gh1354.ml b/compiler/tests-compiler/gh1354.ml
index 122686d07b..16789258ba 100644
--- a/compiler/tests-compiler/gh1354.ml
+++ b/compiler/tests-compiler/gh1354.ml
@@ -37,7 +37,6 @@ with Exit ->
         (List.concat
            [ [ "--disable"; "inline" ]
            ; [ "--disable"; "deadcode" ]
-           ; [ "--disable"; "globaldeadcode" ]
            ; [ "--disable"; "staticeval" ]
            ])
       prog
@@ -101,7 +100,6 @@ with Exit ->
         (List.concat
            [ [ "--disable"; "inline" ]
            ; [ "--disable"; "deadcode" ]
-           ; [ "--disable"; "globaldeadcode" ]
            ; [ "--disable"; "staticeval" ]
            ])
       prog
@@ -188,7 +186,6 @@ with Exit ->
         (List.concat
            [ [ "--disable"; "inline" ]
            ; [ "--disable"; "deadcode" ]
-           ; [ "--disable"; "globaldeadcode" ]
            ; [ "--disable"; "staticeval" ]
            ])
       prog

From 3cdfb6ff6a10cc85af0e5d440a0414d707a6d46e Mon Sep 17 00:00:00 2001
From: Micah Cantor <micahcantor01@gmail.com>
Date: Sun, 27 Aug 2023 16:54:13 -0500
Subject: [PATCH 067/112] promote changes from making default off

---
 compiler/tests-compiler/direct_calls.ml    |   4 +-
 compiler/tests-compiler/gh1007.ml          |  88 +--
 compiler/tests-compiler/global_deadcode.ml |  24 +-
 compiler/tests-full/stdlib.cma.expected.js | 829 ++++++++++-----------
 4 files changed, 434 insertions(+), 511 deletions(-)

diff --git a/compiler/tests-compiler/direct_calls.ml b/compiler/tests-compiler/direct_calls.ml
index e7c66cb85a..30fdcc82fd 100644
--- a/compiler/tests-compiler/direct_calls.ml
+++ b/compiler/tests-compiler/direct_calls.ml
@@ -57,7 +57,7 @@ let%expect_test "direct calls without --enable effects" =
   [%expect
     {|
     function test1(param){
-     function f(g, x){caml_call1(g, x); return sentinal;}
+     function f(g, x){return caml_call1(g, x);}
      var _d_ = 7;
      f(function(x){return x + 1 | 0;}, _d_);
      var _e_ = 4.;
@@ -66,7 +66,7 @@ let%expect_test "direct calls without --enable effects" =
     }
     //end
     function test2(param){
-     function f(g, x){caml_call1(g, x); return sentinal;}
+     function f(g, x){return caml_call1(g, x);}
      var _c_ = 7;
      f(function(x){return x + 1 | 0;}, _c_);
      f(function(x){return caml_call2(Stdlib[28], x, cst_a$0);}, cst_a);
diff --git a/compiler/tests-compiler/gh1007.ml b/compiler/tests-compiler/gh1007.ml
index 6379531de1..e4971515a8 100644
--- a/compiler/tests-compiler/gh1007.ml
+++ b/compiler/tests-compiler/gh1007.ml
@@ -366,29 +366,25 @@ let ()  = M.run ()
       var
        even =
          function(n){
-          if(2 >= n >>> 0)
-           switch(n){
-             case 0:
-              return sentinal;
-             case 1:
-              odd(0); return sentinal;
-             default: odd(1); return sentinal;
-           }
-          odd(n - 1 | 0);
-          return sentinal;
+          if(2 < n >>> 0) return 1 - (1 - odd(n - 1 | 0));
+          switch(n){
+            case 0:
+             return 1;
+            case 1:
+             return 1 - (1 - odd(0));
+            default: return 1 - (1 - odd(1));
+          }
          },
        odd =
          function(n){
-          if(2 >= n >>> 0)
-           switch(n){
-             case 0:
-              return sentinal;
-             case 1:
-              even(0); return sentinal;
-             default: even(1); return sentinal;
-           }
-          even(n - 1 | 0);
-          return sentinal;
+          if(2 < n >>> 0) return 1 - (1 - even(n - 1 | 0));
+          switch(n){
+            case 0:
+             return 0;
+            case 1:
+             return 1 - (1 - even(0));
+            default: return 1 - (1 - even(1));
+          }
          };
       even(i);
       var _a_ = i + 1 | 0;
@@ -460,36 +456,32 @@ let ()  = M.run ()
        closures =
          function(i){
           function even(n){
-           if(2 >= n >>> 0)
-            switch(n){
-              case 0:
-               var
-                f = function(param){return caml_call2(Stdlib_Printf[2], _b_, i);};
-               delayed[1] = [0, f, delayed[1]];
-               f(0);
-               return sentinal;
-              case 1:
-               odd(0); return sentinal;
-              default: odd(1); return sentinal;
-            }
-           odd(n - 1 | 0);
-           return sentinal;
+           if(2 < n >>> 0) return 1 - (1 - odd(n - 1 | 0));
+           switch(n){
+             case 0:
+              var
+               f = function(param){return caml_call2(Stdlib_Printf[2], _b_, i);};
+              delayed[1] = [0, f, delayed[1]];
+              f(0);
+              return 1;
+             case 1:
+              return 1 - (1 - odd(0));
+             default: return 1 - (1 - odd(1));
+           }
           }
           function odd(n){
-           if(2 >= n >>> 0)
-            switch(n){
-              case 0:
-               var
-                f = function(param){return caml_call2(Stdlib_Printf[2], _a_, i);};
-               delayed[1] = [0, f, delayed[1]];
-               f(0);
-               return sentinal;
-              case 1:
-               even(0); return sentinal;
-              default: even(1); return sentinal;
-            }
-           even(n - 1 | 0);
-           return sentinal;
+           if(2 < n >>> 0) return 1 - (1 - even(n - 1 | 0));
+           switch(n){
+             case 0:
+              var
+               f = function(param){return caml_call2(Stdlib_Printf[2], _a_, i);};
+              delayed[1] = [0, f, delayed[1]];
+              f(0);
+              return 0;
+             case 1:
+              return 1 - (1 - even(0));
+             default: return 1 - (1 - even(1));
+           }
           }
           var block = [0, even, odd];
           return block;
diff --git a/compiler/tests-compiler/global_deadcode.ml b/compiler/tests-compiler/global_deadcode.ml
index 09eefa39a1..3606f717ce 100644
--- a/compiler/tests-compiler/global_deadcode.ml
+++ b/compiler/tests-compiler/global_deadcode.ml
@@ -4,6 +4,7 @@ let%expect_test "Eliminates unused functions from functor" =
   let program =
     (* Create two instances of Set functor so compiler can't inline one implementation. *)
     compile_and_parse_whole_program
+    ~flags: ["--enable"; "globaldeadcode"]
       {|
       module Int_set = Set.Make (Int);;
       module String_set = Set.Make (String);;
@@ -49,9 +50,10 @@ let%expect_test "Eliminates unused functions from functor" =
   print_fun_decl program (Some "inter");
   [%expect {| not found |}]
 
-let%expect_test "Substitutes unused fields with undefined" =
+let%expect_test "Omit unused fields" =
   let program =
     compile_and_parse
+    ~flags:["--enable"; "globaldeadcode"]
       {|
       let f b x =
         let t = if b then (1, 2, x) else (3, x, 4) in
@@ -60,27 +62,11 @@ let%expect_test "Substitutes unused fields with undefined" =
       in print_int (fst (f true 1) + snd (f false 2))
       |}
   in 
-  (* Expect second field in each triple to be replaced by a sentinal variable. *)
+  (* Expect second field in each triple to be omitted. *)
   print_fun_decl program (Some "f");
   [%expect {|
     function f(b, x){
      var t = b ? [0, 1, , x] : [0, 3, , 4], v = t[3], u = t[1];
      return [0, u, v];
     }
-    //end |}];
-  (* And that variable is defined as `undefined` *)
-  print_var_decl program "sentinal";
-  [%expect {|
-    var sentinal = undefined;
-    //end |}]
-
-let%expect_test "Sets unused return value to undefined" =
-  let program =
-    compile_and_parse
-      {|
-
-      |}
-  in print_fun_decl program (Some "f");
-  [%expect {| not found |}];
-  print_var_decl program "__";
-  [%expect {| var __ = not found |}]
\ No newline at end of file
+    //end |}];
\ No newline at end of file
diff --git a/compiler/tests-full/stdlib.cma.expected.js b/compiler/tests-full/stdlib.cma.expected.js
index 8249793bfe..282f75cac5 100644
--- a/compiler/tests-full/stdlib.cma.expected.js
+++ b/compiler/tests-full/stdlib.cma.expected.js
@@ -1248,7 +1248,6 @@
             : runtime.caml_call_gen(f, [a0]);
    }
    var
-    sentinal = undefined,
     global_data = runtime.caml_get_global_data(),
     Stdlib = global_data.Stdlib,
     Assert_failure = global_data.Assert_failure,
@@ -1346,9 +1345,7 @@
      _d_ = 0 <= o ? 1 : 0,
      _e_ = _d_ ? o < length(e) ? 1 : 0 : _d_,
      _f_ = 1 - _e_;
-    return _f_
-            ? ( /*<<obj.ml:143:6>>*/ caml_call1(Stdlib[1], msg), sentinal)
-            : _f_;
+    return _f_ ?  /*<<obj.ml:143:6>>*/ caml_call1(Stdlib[1], msg) : _f_;
     /*<<obj.ml:143:21>>*/ }
    function get_key(e, o){
      /*<<obj.ml:147:4>>*/ raise_if_invalid_offset
@@ -4551,7 +4548,6 @@
             : runtime.caml_call_gen(f, [a0, a1]);
    }
    var
-    sentinal = undefined,
     global_data = runtime.caml_get_global_data(),
     Stdlib = global_data.Stdlib,
     Stdlib_Uchar = global_data.Stdlib__Uchar,
@@ -5381,17 +5377,13 @@
     /*<<bytes.ml:513:23>>*/ }
    function unsafe_set_uint16_le(b, i, x){
      /*<<bytes.ml:516:2>>*/ return Stdlib_Sys[11]
-            ? ( /*<<bytes.ml:517:7>>*/ caml_bytes_set16
-               (b, i, caml_bswap16(x)),
-              sentinal)
-            : ( /*<<bytes.ml:518:7>>*/ caml_bytes_set16(b, i, x), sentinal);
+            ?  /*<<bytes.ml:517:7>>*/ caml_bytes_set16(b, i, caml_bswap16(x))
+            :  /*<<bytes.ml:518:7>>*/ caml_bytes_set16(b, i, x);
     /*<<bytes.ml:518:33>>*/ }
    function unsafe_set_uint16_be(b, i, x){
      /*<<bytes.ml:521:2>>*/ return Stdlib_Sys[11]
-            ? ( /*<<bytes.ml:522:7>>*/ caml_bytes_set16(b, i, x), sentinal)
-            : ( /*<<bytes.ml:523:2>>*/ caml_bytes_set16
-               (b, i, caml_bswap16(x)),
-              sentinal);
+            ?  /*<<bytes.ml:522:7>>*/ caml_bytes_set16(b, i, x)
+            :  /*<<bytes.ml:523:2>>*/ caml_bytes_set16(b, i, caml_bswap16(x));
     /*<<bytes.ml:523:37>>*/ }
    function set_int16_le(b, i, x){
      /*<<bytes.ml:526:2>>*/ return Stdlib_Sys[11]
@@ -5649,7 +5641,7 @@
    function set_utf_8_uchar(b, i, u){
      /*<<bytes.ml:651:2>>*/ function set(_i_, _h_, _g_){
       /*<<?>>*/ caml_bytes_unsafe_set(_i_, _h_, _g_);
-     return sentinal;
+     return 0;
     }
      /*<<bytes.ml:652:2>>*/ var
       /*<<bytes.ml:652:2>>*/ max =
@@ -6863,7 +6855,6 @@
             : runtime.caml_call_gen(f, [a0, a1, a2]);
    }
     /*<<array.ml:37:20>>*/ var
-    sentinal = undefined,
     global_data = runtime.caml_get_global_data(),
     Stdlib_Seq = global_data.Stdlib__Seq,
     Assert_failure = global_data.Assert_failure,
@@ -7561,16 +7552,13 @@
      return 0;
      /*<<array.ml:368:8>>*/ }
     function sortto(srcofs, dst, dstofs, len){
-      /*<<array.ml:371:4>>*/ if(len <= 5){
-       /*<<array.ml:371:26>>*/ isortto(srcofs, dst, dstofs, len);
-       /*<<array.ml:371:26>>*/ return sentinal;
-     }
+      /*<<array.ml:371:4>>*/ if(len <= 5)
+       /*<<array.ml:371:26>>*/ return isortto(srcofs, dst, dstofs, len);
      var l1 = len / 2 | 0, l2 = len - l1 | 0;
       /*<<array.ml:374:6>>*/ sortto(srcofs + l1 | 0, dst, dstofs + l1 | 0, l2);
       /*<<array.ml:375:6>>*/ sortto(srcofs, a, srcofs + l2 | 0, l1);
-      /*<<array.ml:375:6>>*/ merge
-      (srcofs + l2 | 0, l1, dst, dstofs + l1 | 0, l2, dst, dstofs);
-      /*<<array.ml:375:6>>*/ return sentinal;
+      /*<<array.ml:375:6>>*/ return merge
+             (srcofs + l2 | 0, l1, dst, dstofs + l1 | 0, l2, dst, dstofs);
      /*<<array.ml:377:7>>*/ }
     var l = a.length - 1;
     if(l <= 5)  /*<<array.ml:380:22>>*/ return isortto(0, a, 0, l);
@@ -7718,7 +7706,6 @@
             : runtime.caml_call_gen(f, [a0, a1, a2]);
    }
    var
-    sentinal = undefined,
     global_data = runtime.caml_get_global_data(),
     Stdlib_Seq = global_data.Stdlib__Seq,
     Stdlib_List = global_data.Stdlib__List,
@@ -7884,9 +7871,7 @@
        _an_ = (ofs + len | 0) < 0 ? 1 : 0,
        _al_ = _an_ || (a.length - 1 < (ofs + len | 0) ? 1 : 0);
     }
-    return _al_
-            ? ( /*<<float.ml:185:6>>*/ caml_call1(Stdlib[1], msg), sentinal)
-            : _al_;
+    return _al_ ?  /*<<float.ml:185:6>>*/ caml_call1(Stdlib[1], msg) : _al_;
     /*<<float.ml:185:21>>*/ }
    function make(n, v){
      /*<<float.ml:188:4>>*/  /*<<float.ml:188:17>>*/ var
@@ -8427,16 +8412,13 @@
      return 0;
      /*<<float.ml:444:10>>*/ }
     function sortto(srcofs, dst, dstofs, len){
-      /*<<float.ml:447:6>>*/ if(len <= 5){
-       /*<<float.ml:447:28>>*/ isortto(srcofs, dst, dstofs, len);
-       /*<<float.ml:447:28>>*/ return sentinal;
-     }
+      /*<<float.ml:447:6>>*/ if(len <= 5)
+       /*<<float.ml:447:28>>*/ return isortto(srcofs, dst, dstofs, len);
      var l1 = len / 2 | 0, l2 = len - l1 | 0;
       /*<<float.ml:450:8>>*/ sortto(srcofs + l1 | 0, dst, dstofs + l1 | 0, l2);
       /*<<float.ml:451:8>>*/ sortto(srcofs, a, srcofs + l2 | 0, l1);
-      /*<<float.ml:451:8>>*/ merge
-      (srcofs + l2 | 0, l1, dst, dstofs + l1 | 0, l2, dst, dstofs);
-      /*<<float.ml:451:8>>*/ return sentinal;
+      /*<<float.ml:451:8>>*/ return merge
+             (srcofs + l2 | 0, l1, dst, dstofs + l1 | 0, l2, dst, dstofs);
      /*<<float.ml:453:9>>*/ }
     var l = a.length - 1;
     if(l <= 5)  /*<<float.ml:456:24>>*/ return isortto(0, a, 0, l);
@@ -9416,7 +9398,6 @@
             : runtime.caml_call_gen(f, [a0, a1, a2, a3, a4]);
    }
     /*<<parsing.ml:59:0>>*/ var
-    sentinal = undefined,
     global_data = runtime.caml_get_global_data(),
     Stdlib_Obj = global_data.Stdlib__Obj,
     Stdlib_Array = global_data.Stdlib__Array,
@@ -9469,7 +9450,7 @@
      (Stdlib_Array[8], env[4], 0, new_end, 0, oldsize);
     env[4] = new_end;
     env[5] = newsize;
-    return sentinal;
+    return 0;
     /*<<parsing.ml:122:28>>*/ }
    function clear_parser(param){
      /*<<parsing.ml:125:2>>*/  /*<<parsing.ml:125:2>>*/ caml_call4
@@ -12008,7 +11989,6 @@
             : runtime.caml_call_gen(f, [a0, a1, a2, a3, a4]);
    }
    var
-    sentinal = undefined,
     global_data = runtime.caml_get_global_data(),
     Stdlib_Bytes = global_data.Stdlib__Bytes,
     Stdlib_Sys = global_data.Stdlib__Sys,
@@ -12104,7 +12084,7 @@
        /*<<buffer.ml:99:2>>*/  /*<<buffer.ml:99:2>>*/ caml_call5
        (Stdlib_Bytes[11], b[1][1], 0, new_buffer, 0, b[2]);
       b[1] = [0, new_buffer, new_len[1]];
-      return sentinal;
+      return 0;
      }
      new_len[1] = 2 * new_len[1] | 0;
     }
@@ -12787,7 +12767,6 @@
             : runtime.caml_call_gen(f, [a0, a1, a2, a3, a4]);
    }
    var
-    sentinal = undefined,
     global_data = runtime.caml_get_global_data(),
     Stdlib_Mutex = global_data.Stdlib__Mutex,
     Stdlib_Condition = global_data.Stdlib__Condition,
@@ -12806,8 +12785,8 @@
    function create_dls(param){
      /*<<domain.ml:59:4>>*/  /*<<domain.ml:59:13>>*/ var
      st =  /*<<domain.ml:59:13>>*/ caml_make_vect(8, unique_value);
-     /*<<domain.ml:60:4>>*/  /*<<domain.ml:60:4>>*/ caml_domain_dls_set(st);
-     /*<<domain.ml:60:4>>*/ return sentinal;
+     /*<<domain.ml:60:4>>*/ return  /*<<domain.ml:60:4>>*/ caml_domain_dls_set
+            (st);
     /*<<domain.ml:60:20>>*/ }
     /*<<domain.ml:62:10>>*/ create_dls(0);
     /*<<domain.ml:66:20>>*/ var
@@ -12896,7 +12875,7 @@
      /*<<domain.ml:147:27>>*/ first_spawn_function =
       [0,
        function(param){
-         /*<<domain.ml:147:42>>*/ return sentinal;
+         /*<<domain.ml:147:42>>*/ return 0;
         /*<<domain.ml:147:44>>*/ }];
    function before_first_spawn(f){
      /*<<domain.ml:150:2>>*/ if
@@ -13132,7 +13111,6 @@
             : runtime.caml_call_gen(f, [a0, a1, a2, a3, a4]);
    }
    var
-    sentinal = undefined,
     global_data = runtime.caml_get_global_data(),
     cst$9 = "%{",
     cst$10 = "%}",
@@ -13459,14 +13437,14 @@
      /*<<camlinternalFormat.ml:28:2>>*/ var
      str_ind = c >>> 3 | 0,
      mask = 1 << (c & 7),
-      /*<<camlinternalFormat.ml:31:30>>*/ _dS_ =
+      /*<<camlinternalFormat.ml:31:30>>*/ _dU_ =
         /*<<camlinternalFormat.ml:31:30>>*/ runtime.caml_bytes_get
         (char_set, str_ind)
        | mask;
      /*<<camlinternalFormat.ml:30:2>>*/ return  /*<<camlinternalFormat.ml:30:2>>*/ caml_bytes_set
             (char_set,
              str_ind,
-              /*<<camlinternalFormat.ml:31:4>>*/ caml_call1(Stdlib[29], _dS_));
+              /*<<camlinternalFormat.ml:31:4>>*/ caml_call1(Stdlib[29], _dU_));
     /*<<camlinternalFormat.ml:31:69>>*/ }
    function freeze_char_set(char_set){
      /*<<camlinternalFormat.ml:34:2>>*/ return  /*<<camlinternalFormat.ml:34:2>>*/ caml_call1
@@ -13478,19 +13456,19 @@
      i = 0;
     for(;;){
       /*<<camlinternalFormat.ml:41:32>>*/  /*<<camlinternalFormat.ml:41:32>>*/ var
-      _dQ_ =
+      _dS_ =
          /*<<camlinternalFormat.ml:41:32>>*/ caml_string_get(char_set, i)
         ^ 255;
       /*<<camlinternalFormat.ml:40:4>>*/  /*<<camlinternalFormat.ml:40:4>>*/ caml_bytes_set
       (char_set$0,
        i,
-        /*<<camlinternalFormat.ml:41:6>>*/ caml_call1(Stdlib[29], _dQ_));
+        /*<<camlinternalFormat.ml:41:6>>*/ caml_call1(Stdlib[29], _dS_));
       /*<<camlinternalFormat.ml:40:4>>*/  /*<<camlinternalFormat.ml:40:4>>*/ var
-      _dR_ = i + 1 | 0;
+      _dT_ = i + 1 | 0;
      if(31 === i)
        /*<<camlinternalFormat.ml:43:2>>*/ return  /*<<camlinternalFormat.ml:43:2>>*/ caml_call1
               (Stdlib_Bytes[44], char_set$0);
-     var i = _dR_;
+     var i = _dT_;
     }
     /*<<camlinternalFormat.ml:43:34>>*/ }
    function is_in_char_set(char_set, c){
@@ -13550,11 +13528,11 @@
       case 6:
        var prec_opt = ign[2], pad_opt$5 = ign[1];
        if(prec_opt)
-        var ndec = prec_opt[1], _dP_ = [0, ndec];
+        var ndec = prec_opt[1], _dR_ = [0, ndec];
        else
-        var _dP_ = 0;
+        var _dR_ = 0;
         /*<<camlinternalFormat.ml:97:4>>*/ return [0,
-               [8, _a_, pad_of_pad_opt(pad_opt$5), _dP_, fmt]];
+               [8, _a_, pad_of_pad_opt(pad_opt$5), _dR_, fmt]];
       case 7:
        var pad_opt$6 = ign[1];
         /*<<camlinternalFormat.ml:101:4>>*/ return [0,
@@ -13587,8 +13565,9 @@
    function buffer_check_size(buf, overhead){
      /*<<camlinternalFormat.ml:260:2>>*/ var
      len = runtime.caml_ml_bytes_length(buf[2]),
-     min_len = buf[1] + overhead | 0;
-    if(len < min_len){
+     min_len = buf[1] + overhead | 0,
+     _dP_ = len < min_len ? 1 : 0;
+    if(_dP_){
       /*<<camlinternalFormat.ml:263:18>>*/ var
        /*<<camlinternalFormat.ml:263:18>>*/ new_len =
          /*<<camlinternalFormat.ml:263:18>>*/ caml_call2
@@ -13598,15 +13577,18 @@
       /*<<camlinternalFormat.ml:265:4>>*/  /*<<camlinternalFormat.ml:265:4>>*/ caml_call5
       (Stdlib_Bytes[11], buf[2], 0, new_str, 0, len);
      buf[2] = new_str;
+     var _dQ_ = 0;
     }
-    return sentinal;
+    else
+     var _dQ_ = _dP_;
+    return _dQ_;
     /*<<camlinternalFormat.ml:267:3>>*/ }
    function buffer_add_char(buf, c){
      /*<<camlinternalFormat.ml:271:2>>*/ buffer_check_size(buf, 1);
      /*<<camlinternalFormat.ml:272:2>>*/  /*<<camlinternalFormat.ml:272:2>>*/ caml_bytes_set
      (buf[2], buf[1], c);
     buf[1] = buf[1] + 1 | 0;
-    return sentinal;
+    return 0;
     /*<<camlinternalFormat.ml:273:24>>*/ }
    function buffer_add_string(buf, s){
      /*<<camlinternalFormat.ml:277:2>>*/ var
@@ -13615,7 +13597,7 @@
      /*<<camlinternalFormat.ml:279:2>>*/  /*<<camlinternalFormat.ml:279:2>>*/ caml_call5
      (Stdlib_String[48], s, 0, buf[2], buf[1], str_len);
     buf[1] = buf[1] + str_len | 0;
-    return sentinal;
+    return 0;
     /*<<camlinternalFormat.ml:280:30>>*/ }
    function buffer_contents(buf){
      /*<<camlinternalFormat.ml:284:2>>*/ return caml_call3
@@ -13671,74 +13653,68 @@
    function bprint_padty(buf, padty){
      /*<<camlinternalFormat.ml:374:29>>*/ switch(padty){
       case 0:
-        /*<<camlinternalFormat.ml:375:13>>*/ buffer_add_char(buf, 45);
-        /*<<camlinternalFormat.ml:375:13>>*/ return sentinal;
+        /*<<camlinternalFormat.ml:375:13>>*/ return buffer_add_char(buf, 45);
       case 1:
-        /*<<camlinternalFormat.ml:376:13>>*/ return sentinal;
+        /*<<camlinternalFormat.ml:376:13>>*/ return 0;
       default:
-        /*<<camlinternalFormat.ml:377:13>>*/ buffer_add_char(buf, 48);
-        /*<<camlinternalFormat.ml:377:13>>*/ return sentinal;
+        /*<<camlinternalFormat.ml:377:13>>*/ return buffer_add_char(buf, 48);
     }
     /*<<camlinternalFormat.ml:377:36>>*/ }
    function bprint_ignored_flag(buf, ign_flag){
      /*<<camlinternalFormat.ml:381:2>>*/ return ign_flag
-            ? (buffer_add_char(buf, 95), sentinal)
+            ? buffer_add_char(buf, 95)
             : ign_flag;
     /*<<camlinternalFormat.ml:381:42>>*/ }
    function bprint_pad_opt(buf, pad_opt){
      /*<<camlinternalFormat.ml:385:33>>*/ if(! pad_opt)
-      /*<<camlinternalFormat.ml:386:12>>*/ return sentinal;
+      /*<<camlinternalFormat.ml:386:12>>*/ return 0;
     var width = pad_opt[1];
-     /*<<camlinternalFormat.ml:387:40>>*/ buffer_add_string
-     (buf,
-       /*<<camlinternalFormat.ml:387:40>>*/ caml_call1(Stdlib_Int[12], width));
-     /*<<camlinternalFormat.ml:387:40>>*/ return sentinal;
+     /*<<camlinternalFormat.ml:387:40>>*/ return buffer_add_string
+            (buf,
+              /*<<camlinternalFormat.ml:387:40>>*/ caml_call1
+              (Stdlib_Int[12], width));
     /*<<camlinternalFormat.ml:387:61>>*/ }
    function bprint_padding(buf, pad){
      /*<<camlinternalFormat.ml:393:15>>*/ if(typeof pad === "number")
-      /*<<camlinternalFormat.ml:394:18>>*/ return sentinal;
+      /*<<camlinternalFormat.ml:394:18>>*/ return 0;
     if(0 === pad[0]){
      var n = pad[2], padty = pad[1];
       /*<<camlinternalFormat.ml:396:4>>*/ bprint_padty(buf, padty);
-      /*<<camlinternalFormat.ml:397:26>>*/ buffer_add_string
-      (buf,
-        /*<<camlinternalFormat.ml:397:26>>*/ caml_call1(Stdlib_Int[12], n));
-      /*<<camlinternalFormat.ml:397:26>>*/ return sentinal;
+      /*<<camlinternalFormat.ml:397:26>>*/ return buffer_add_string
+             (buf,
+               /*<<camlinternalFormat.ml:397:26>>*/ caml_call1
+               (Stdlib_Int[12], n));
     }
     var padty$0 = pad[1];
      /*<<camlinternalFormat.ml:399:4>>*/ bprint_padty(buf, padty$0);
-     /*<<camlinternalFormat.ml:399:4>>*/ buffer_add_char(buf, 42);
-     /*<<camlinternalFormat.ml:399:4>>*/ return sentinal;
+     /*<<camlinternalFormat.ml:399:4>>*/ return buffer_add_char(buf, 42);
     /*<<camlinternalFormat.ml:400:27>>*/ }
    function bprint_precision(buf, prec){
      /*<<camlinternalFormat.ml:404:18>>*/ if(typeof prec === "number")
-     return prec ? (buffer_add_string(buf, cst), sentinal) : sentinal;
+     return prec ? buffer_add_string(buf, cst) : 0;
     var n = prec[1];
      /*<<camlinternalFormat.ml:407:4>>*/ buffer_add_char(buf, 46);
-     /*<<camlinternalFormat.ml:408:26>>*/ buffer_add_string
-     (buf,
-       /*<<camlinternalFormat.ml:408:26>>*/ caml_call1(Stdlib_Int[12], n));
-     /*<<camlinternalFormat.ml:408:26>>*/ return sentinal;
+     /*<<camlinternalFormat.ml:408:26>>*/ return buffer_add_string
+            (buf,
+              /*<<camlinternalFormat.ml:408:26>>*/ caml_call1
+              (Stdlib_Int[12], n));
     /*<<camlinternalFormat.ml:410:30>>*/ }
    function bprint_iconv_flag(buf, iconv){
      /*<<camlinternalFormat.ml:415:34>>*/ switch(iconv){
       case 1:
       case 4:
-        /*<<camlinternalFormat.ml:416:23>>*/ buffer_add_char(buf, 43);
-        /*<<camlinternalFormat.ml:416:23>>*/ return sentinal;
+        /*<<camlinternalFormat.ml:416:23>>*/ return buffer_add_char(buf, 43);
       case 2:
       case 5:
-        /*<<camlinternalFormat.ml:417:23>>*/ buffer_add_char(buf, 32);
-        /*<<camlinternalFormat.ml:417:23>>*/ return sentinal;
+        /*<<camlinternalFormat.ml:417:23>>*/ return buffer_add_char(buf, 32);
       case 7:
       case 9:
       case 11:
       case 13:
       case 14:
       case 15:
-        /*<<camlinternalFormat.ml:419:6>>*/ buffer_add_char(buf, 35);
-        /*<<camlinternalFormat.ml:419:6>>*/ return sentinal;
-      default:  /*<<camlinternalFormat.ml:420:53>>*/ return sentinal;
+        /*<<camlinternalFormat.ml:419:6>>*/ return buffer_add_char(buf, 35);
+      default:  /*<<camlinternalFormat.ml:420:53>>*/ return 0;
     }
     /*<<camlinternalFormat.ml:420:55>>*/ }
    function bprint_altint_fmt(buf, ign_flag, iconv, pad, prec, c){
@@ -13748,9 +13724,8 @@
      /*<<camlinternalFormat.ml:436:2>>*/ bprint_padding(buf, pad);
      /*<<camlinternalFormat.ml:437:2>>*/ bprint_precision(buf, prec);
      /*<<camlinternalFormat.ml:438:2>>*/ buffer_add_char(buf, c);
-     /*<<camlinternalFormat.ml:439:22>>*/ buffer_add_char
-     (buf, char_of_iconv(iconv));
-     /*<<camlinternalFormat.ml:439:22>>*/ return sentinal;
+     /*<<camlinternalFormat.ml:439:22>>*/ return buffer_add_char
+            (buf, char_of_iconv(iconv));
     /*<<camlinternalFormat.ml:439:43>>*/ }
    function bprint_fconv_flag(buf, fconv){
      /*<<camlinternalFormat.ml:445:2>>*/ switch(fconv[1]){
@@ -13759,7 +13734,7 @@
         /*<<camlinternalFormat.ml:446:20>>*/ buffer_add_char(buf, 43); break;
       default:  /*<<camlinternalFormat.ml:447:20>>*/ buffer_add_char(buf, 32);
     }
-    return 8 <= fconv[2] ? (buffer_add_char(buf, 35), sentinal) : sentinal;
+    return 8 <= fconv[2] ? buffer_add_char(buf, 35) : 0;
     /*<<camlinternalFormat.ml:452:37>>*/ }
    function string_of_formatting_lit(formatting_lit){
      /*<<camlinternalFormat.ml:465:46>>*/ if
@@ -13798,8 +13773,8 @@
     /*<<camlinternalFormat.ml:475:43>>*/ }
    function bprint_char_literal(buf, chr){
      /*<<camlinternalFormat.ml:480:34>>*/ return 37 === chr
-            ? (buffer_add_string(buf, cst$8), sentinal)
-            : (buffer_add_char(buf, chr), sentinal);
+            ? buffer_add_string(buf, cst$8)
+            : buffer_add_char(buf, chr);
     /*<<camlinternalFormat.ml:482:32>>*/ }
    function bprint_string_literal(buf, str){
      /*<<camlinternalFormat.ml:486:2>>*/ var
@@ -13816,13 +13791,13 @@
       var i = _dN_;
      }
     }
-    return sentinal;
+    return 0;
     /*<<camlinternalFormat.ml:488:6>>*/ }
    function bprint_fmtty(buf, fmtty){
      /*<<camlinternalFormat.ml:496:17>>*/ var fmtty$0 = fmtty;
      /*<<camlinternalFormat.ml:496:17>>*/ for(;;){
      if(typeof fmtty$0 === "number")
-       /*<<camlinternalFormat.ml:521:20>>*/ return sentinal;
+       /*<<camlinternalFormat.ml:521:20>>*/ return 0;
      switch(fmtty$0[0]){
        case 0:
         var fmtty$1 = fmtty$0[1];
@@ -13920,7 +13895,7 @@
       ign_flag$0 = ign_flag;
       /*<<camlinternalFormat.ml:535:22>>*/ for(;;){
       if(typeof fmt$0 === "number")
-        /*<<camlinternalFormat.ml:636:23>>*/ return sentinal;
+        /*<<camlinternalFormat.ml:636:23>>*/ return 0;
       switch(fmt$0[0]){
         case 0:
          var rest = fmt$0[1];
@@ -14124,17 +14099,11 @@
                  /*<<camlinternalFormat.ml:358:31>>*/ caml_call1
                  (Stdlib[29], i);
              return 37 === c
-                     ? (buffer_add_char
-                        (buf, 37),
-                       buffer_add_char(buf, 37),
-                       sentinal)
+                     ? (buffer_add_char(buf, 37), buffer_add_char(buf, 37))
                      : 64
                        === c
-                       ? (buffer_add_char
-                          (buf, 37),
-                         buffer_add_char(buf, 64),
-                         sentinal)
-                       : (buffer_add_char(buf, c), sentinal);
+                       ? (buffer_add_char(buf, 37), buffer_add_char(buf, 64))
+                       : buffer_add_char(buf, c);
              /*<<camlinternalFormat.ml:361:35>>*/ };
           /*<<camlinternalFormat.ml:363:2>>*/ buffer_add_char(buf, 91);
           /*<<camlinternalFormat.ml:365:7>>*/ var
@@ -14414,12 +14383,12 @@
          _di_ =
            function(param){
              /*<<camlinternalFormat.ml:698:17>>*/ af(0);
-             /*<<camlinternalFormat.ml:698:39>>*/ return sentinal;
+             /*<<camlinternalFormat.ml:698:39>>*/ return 0;
             /*<<camlinternalFormat.ml:698:43>>*/ };
          /*<<camlinternalFormat.ml:697:4>>*/ return [0,
                 function(param){
                   /*<<camlinternalFormat.ml:697:17>>*/ fa(0);
-                  /*<<camlinternalFormat.ml:697:39>>*/ return sentinal;
+                  /*<<camlinternalFormat.ml:697:39>>*/ return 0;
                  /*<<camlinternalFormat.ml:697:43>>*/ },
                 _di_,
                 ed,
@@ -14435,12 +14404,12 @@
          _dj_ =
            function(param){
              /*<<camlinternalFormat.ml:703:17>>*/ af$0(0);
-             /*<<camlinternalFormat.ml:703:39>>*/ return sentinal;
+             /*<<camlinternalFormat.ml:703:39>>*/ return 0;
             /*<<camlinternalFormat.ml:703:43>>*/ };
          /*<<camlinternalFormat.ml:702:4>>*/ return [0,
                 function(param){
                   /*<<camlinternalFormat.ml:702:17>>*/ fa$0(0);
-                  /*<<camlinternalFormat.ml:702:39>>*/ return sentinal;
+                  /*<<camlinternalFormat.ml:702:39>>*/ return 0;
                  /*<<camlinternalFormat.ml:702:43>>*/ },
                 _dj_,
                 ed$0,
@@ -14456,12 +14425,12 @@
          _dk_ =
            function(param){
              /*<<camlinternalFormat.ml:708:17>>*/ af$1(0);
-             /*<<camlinternalFormat.ml:708:39>>*/ return sentinal;
+             /*<<camlinternalFormat.ml:708:39>>*/ return 0;
             /*<<camlinternalFormat.ml:708:43>>*/ };
          /*<<camlinternalFormat.ml:707:4>>*/ return [0,
                 function(param){
                   /*<<camlinternalFormat.ml:707:17>>*/ fa$1(0);
-                  /*<<camlinternalFormat.ml:707:39>>*/ return sentinal;
+                  /*<<camlinternalFormat.ml:707:39>>*/ return 0;
                  /*<<camlinternalFormat.ml:707:43>>*/ },
                 _dk_,
                 ed$1,
@@ -14477,12 +14446,12 @@
          _dl_ =
            function(param){
              /*<<camlinternalFormat.ml:713:17>>*/ af$2(0);
-             /*<<camlinternalFormat.ml:713:39>>*/ return sentinal;
+             /*<<camlinternalFormat.ml:713:39>>*/ return 0;
             /*<<camlinternalFormat.ml:713:43>>*/ };
          /*<<camlinternalFormat.ml:712:4>>*/ return [0,
                 function(param){
                   /*<<camlinternalFormat.ml:712:17>>*/ fa$2(0);
-                  /*<<camlinternalFormat.ml:712:39>>*/ return sentinal;
+                  /*<<camlinternalFormat.ml:712:39>>*/ return 0;
                  /*<<camlinternalFormat.ml:712:43>>*/ },
                 _dl_,
                 ed$2,
@@ -14498,12 +14467,12 @@
          _dm_ =
            function(param){
              /*<<camlinternalFormat.ml:723:17>>*/ af$3(0);
-             /*<<camlinternalFormat.ml:723:39>>*/ return sentinal;
+             /*<<camlinternalFormat.ml:723:39>>*/ return 0;
             /*<<camlinternalFormat.ml:723:43>>*/ };
          /*<<camlinternalFormat.ml:722:4>>*/ return [0,
                 function(param){
                   /*<<camlinternalFormat.ml:722:17>>*/ fa$3(0);
-                  /*<<camlinternalFormat.ml:722:39>>*/ return sentinal;
+                  /*<<camlinternalFormat.ml:722:39>>*/ return 0;
                  /*<<camlinternalFormat.ml:722:43>>*/ },
                 _dm_,
                 ed$3,
@@ -14519,12 +14488,12 @@
          _dn_ =
            function(param){
              /*<<camlinternalFormat.ml:718:17>>*/ af$4(0);
-             /*<<camlinternalFormat.ml:718:39>>*/ return sentinal;
+             /*<<camlinternalFormat.ml:718:39>>*/ return 0;
             /*<<camlinternalFormat.ml:718:43>>*/ };
          /*<<camlinternalFormat.ml:717:4>>*/ return [0,
                 function(param){
                   /*<<camlinternalFormat.ml:717:17>>*/ fa$4(0);
-                  /*<<camlinternalFormat.ml:717:39>>*/ return sentinal;
+                  /*<<camlinternalFormat.ml:717:39>>*/ return 0;
                  /*<<camlinternalFormat.ml:717:43>>*/ },
                 _dn_,
                 ed$4,
@@ -14540,12 +14509,12 @@
          _do_ =
            function(param){
              /*<<camlinternalFormat.ml:728:17>>*/ af$5(0);
-             /*<<camlinternalFormat.ml:728:39>>*/ return sentinal;
+             /*<<camlinternalFormat.ml:728:39>>*/ return 0;
             /*<<camlinternalFormat.ml:728:43>>*/ };
          /*<<camlinternalFormat.ml:727:4>>*/ return [0,
                 function(param){
                   /*<<camlinternalFormat.ml:727:17>>*/ fa$5(0);
-                  /*<<camlinternalFormat.ml:727:39>>*/ return sentinal;
+                  /*<<camlinternalFormat.ml:727:39>>*/ return 0;
                  /*<<camlinternalFormat.ml:727:43>>*/ },
                 _do_,
                 ed$5,
@@ -14561,12 +14530,12 @@
          _dp_ =
            function(param){
              /*<<camlinternalFormat.ml:733:17>>*/ af$6(0);
-             /*<<camlinternalFormat.ml:733:39>>*/ return sentinal;
+             /*<<camlinternalFormat.ml:733:39>>*/ return 0;
             /*<<camlinternalFormat.ml:733:43>>*/ };
          /*<<camlinternalFormat.ml:732:4>>*/ return [0,
                 function(param){
                   /*<<camlinternalFormat.ml:732:17>>*/ fa$6(0);
-                  /*<<camlinternalFormat.ml:732:39>>*/ return sentinal;
+                  /*<<camlinternalFormat.ml:732:39>>*/ return 0;
                  /*<<camlinternalFormat.ml:732:43>>*/ },
                 _dp_,
                 ed$6,
@@ -14582,12 +14551,12 @@
          _dq_ =
            function(param){
              /*<<camlinternalFormat.ml:766:17>>*/ af$7(0);
-             /*<<camlinternalFormat.ml:766:39>>*/ return sentinal;
+             /*<<camlinternalFormat.ml:766:39>>*/ return 0;
             /*<<camlinternalFormat.ml:766:43>>*/ };
          /*<<camlinternalFormat.ml:765:4>>*/ return [0,
                 function(param){
                   /*<<camlinternalFormat.ml:765:17>>*/ fa$7(0);
-                  /*<<camlinternalFormat.ml:765:39>>*/ return sentinal;
+                  /*<<camlinternalFormat.ml:765:39>>*/ return 0;
                  /*<<camlinternalFormat.ml:765:43>>*/ },
                 _dq_,
                 ed$7,
@@ -14612,25 +14581,25 @@
            function(param){
              /*<<camlinternalFormat.ml:775:17>>*/ jd(0);
              /*<<camlinternalFormat.ml:775:50>>*/ de$8(0);
-             /*<<camlinternalFormat.ml:775:61>>*/ return sentinal;
+             /*<<camlinternalFormat.ml:775:61>>*/ return 0;
             /*<<camlinternalFormat.ml:775:65>>*/ },
          _ds_ =
            function(param){
              /*<<camlinternalFormat.ml:774:17>>*/ ed$8(0);
              /*<<camlinternalFormat.ml:774:50>>*/ dj(0);
-             /*<<camlinternalFormat.ml:774:61>>*/ return sentinal;
+             /*<<camlinternalFormat.ml:774:61>>*/ return 0;
             /*<<camlinternalFormat.ml:774:65>>*/ },
          _dt_ =
            function(param){
              /*<<camlinternalFormat.ml:773:17>>*/ ga(0);
              /*<<camlinternalFormat.ml:773:50>>*/ af$8(0);
-             /*<<camlinternalFormat.ml:773:61>>*/ return sentinal;
+             /*<<camlinternalFormat.ml:773:61>>*/ return 0;
             /*<<camlinternalFormat.ml:773:65>>*/ };
          /*<<camlinternalFormat.ml:772:4>>*/ return [0,
                 function(param){
                   /*<<camlinternalFormat.ml:772:17>>*/ fa$8(0);
                   /*<<camlinternalFormat.ml:772:50>>*/ ag(0);
-                  /*<<camlinternalFormat.ml:772:61>>*/ return sentinal;
+                  /*<<camlinternalFormat.ml:772:61>>*/ return 0;
                  /*<<camlinternalFormat.ml:772:65>>*/ },
                 _dt_,
                 _ds_,
@@ -14647,12 +14616,12 @@
          _du_ =
            function(param){
              /*<<camlinternalFormat.ml:744:17>>*/ af$9(0);
-             /*<<camlinternalFormat.ml:744:39>>*/ return sentinal;
+             /*<<camlinternalFormat.ml:744:39>>*/ return 0;
             /*<<camlinternalFormat.ml:744:43>>*/ };
          /*<<camlinternalFormat.ml:743:4>>*/ return [0,
                 function(param){
                   /*<<camlinternalFormat.ml:743:17>>*/ fa$9(0);
-                  /*<<camlinternalFormat.ml:743:39>>*/ return sentinal;
+                  /*<<camlinternalFormat.ml:743:39>>*/ return 0;
                  /*<<camlinternalFormat.ml:743:43>>*/ },
                 _du_,
                 ed$9,
@@ -14669,12 +14638,12 @@
          _dv_ =
            function(param){
              /*<<camlinternalFormat.ml:739:17>>*/ af$10(0);
-             /*<<camlinternalFormat.ml:739:39>>*/ return sentinal;
+             /*<<camlinternalFormat.ml:739:39>>*/ return 0;
             /*<<camlinternalFormat.ml:739:43>>*/ };
          /*<<camlinternalFormat.ml:738:4>>*/ return [0,
                 function(param){
                   /*<<camlinternalFormat.ml:738:17>>*/ fa$10(0);
-                  /*<<camlinternalFormat.ml:738:39>>*/ return sentinal;
+                  /*<<camlinternalFormat.ml:738:39>>*/ return 0;
                  /*<<camlinternalFormat.ml:738:43>>*/ },
                 _dv_,
                 ed$10,
@@ -14691,12 +14660,12 @@
          _dw_ =
            function(param){
              /*<<camlinternalFormat.ml:749:17>>*/ af$11(0);
-             /*<<camlinternalFormat.ml:749:39>>*/ return sentinal;
+             /*<<camlinternalFormat.ml:749:39>>*/ return 0;
             /*<<camlinternalFormat.ml:749:43>>*/ };
          /*<<camlinternalFormat.ml:748:4>>*/ return [0,
                 function(param){
                   /*<<camlinternalFormat.ml:748:17>>*/ fa$11(0);
-                  /*<<camlinternalFormat.ml:748:39>>*/ return sentinal;
+                  /*<<camlinternalFormat.ml:748:39>>*/ return 0;
                  /*<<camlinternalFormat.ml:748:43>>*/ },
                 _dw_,
                 ed$11,
@@ -14713,22 +14682,22 @@
           /*<<camlinternalFormat.ml:753:4>>*/ _dx_ =
            function(param){
              /*<<camlinternalFormat.ml:756:17>>*/ de$12(0);
-             /*<<camlinternalFormat.ml:756:39>>*/ return sentinal;
+             /*<<camlinternalFormat.ml:756:39>>*/ return 0;
             /*<<camlinternalFormat.ml:756:43>>*/ },
          _dy_ =
            function(param){
              /*<<camlinternalFormat.ml:755:17>>*/ ed$12(0);
-             /*<<camlinternalFormat.ml:755:39>>*/ return sentinal;
+             /*<<camlinternalFormat.ml:755:39>>*/ return 0;
             /*<<camlinternalFormat.ml:755:43>>*/ },
          _dz_ =
            function(param){
              /*<<camlinternalFormat.ml:754:17>>*/ af$12(0);
-             /*<<camlinternalFormat.ml:754:39>>*/ return sentinal;
+             /*<<camlinternalFormat.ml:754:39>>*/ return 0;
             /*<<camlinternalFormat.ml:754:43>>*/ };
          /*<<camlinternalFormat.ml:753:4>>*/ return [0,
                 function(param){
                   /*<<camlinternalFormat.ml:753:17>>*/ fa$12(0);
-                  /*<<camlinternalFormat.ml:753:39>>*/ return sentinal;
+                  /*<<camlinternalFormat.ml:753:39>>*/ return 0;
                  /*<<camlinternalFormat.ml:753:43>>*/ },
                 _dz_,
                 _dy_,
@@ -14745,39 +14714,39 @@
           /*<<camlinternalFormat.ml:759:4>>*/ _dA_ =
            function(param){
              /*<<camlinternalFormat.ml:762:17>>*/ de$13(0);
-             /*<<camlinternalFormat.ml:762:39>>*/ return sentinal;
+             /*<<camlinternalFormat.ml:762:39>>*/ return 0;
             /*<<camlinternalFormat.ml:762:43>>*/ },
          _dB_ =
            function(param){
              /*<<camlinternalFormat.ml:761:17>>*/ ed$13(0);
-             /*<<camlinternalFormat.ml:761:39>>*/ return sentinal;
+             /*<<camlinternalFormat.ml:761:39>>*/ return 0;
             /*<<camlinternalFormat.ml:761:43>>*/ },
          _dC_ =
            function(param){
              /*<<camlinternalFormat.ml:760:17>>*/ af$13(0);
-             /*<<camlinternalFormat.ml:760:39>>*/ return sentinal;
+             /*<<camlinternalFormat.ml:760:39>>*/ return 0;
             /*<<camlinternalFormat.ml:760:43>>*/ };
          /*<<camlinternalFormat.ml:759:4>>*/ return [0,
                 function(param){
                   /*<<camlinternalFormat.ml:759:17>>*/ fa$13(0);
-                  /*<<camlinternalFormat.ml:759:39>>*/ return sentinal;
+                  /*<<camlinternalFormat.ml:759:39>>*/ return 0;
                  /*<<camlinternalFormat.ml:759:43>>*/ },
                 _dC_,
                 _dB_,
                 _dA_];
      }
      /*<<camlinternalFormat.ml:691:4>>*/ function _df_(param){
-      /*<<camlinternalFormat.ml:694:17>>*/ return sentinal;
+      /*<<camlinternalFormat.ml:694:17>>*/ return 0;
      /*<<camlinternalFormat.ml:694:21>>*/ }
     function _dg_(param){
-      /*<<camlinternalFormat.ml:693:17>>*/ return sentinal;
+      /*<<camlinternalFormat.ml:693:17>>*/ return 0;
      /*<<camlinternalFormat.ml:693:21>>*/ }
     function _dh_(param){
-      /*<<camlinternalFormat.ml:692:17>>*/ return sentinal;
+      /*<<camlinternalFormat.ml:692:17>>*/ return 0;
      /*<<camlinternalFormat.ml:692:21>>*/ }
      /*<<camlinternalFormat.ml:691:4>>*/ return [0,
             function(param){
-              /*<<camlinternalFormat.ml:691:17>>*/ return sentinal;
+              /*<<camlinternalFormat.ml:691:17>>*/ return 0;
              /*<<camlinternalFormat.ml:691:21>>*/ },
             _dh_,
             _dg_,
@@ -16422,7 +16391,7 @@
       /*<<camlinternalFormat.ml:1438:16>>*/  /*<<camlinternalFormat.ml:1438:16>>*/ caml_bytes_set
       (buf, pos[1], c);
      pos[1]++;
-     return sentinal;
+     return 0;
      /*<<camlinternalFormat.ml:1438:46>>*/ }
      /*<<camlinternalFormat.ml:1439:15>>*/ var
       /*<<camlinternalFormat.ml:1439:15>>*/ left =
@@ -18052,9 +18021,9 @@
     /*<<camlinternalFormat.ml:2018:62>>*/ }
    function make_padprec_fmt_ebb(pad, prec, fmt){
      /*<<camlinternalFormat.ml:2038:2>>*/ if(typeof prec === "number")
-     var match = prec ? [0, 1] : [0, 0];
+     var match = prec ? [0, 1, fmt] : [0, 0, fmt];
     else
-     var p = prec[1], match = [0, [0, p]];
+     var p = prec[1], match = [0, [0, p], fmt];
     var prec$0 = match[1];
      /*<<camlinternalFormat.ml:2039:2>>*/ if(typeof pad === "number")
       /*<<camlinternalFormat.ml:2040:26>>*/ return [0, 0, prec$0, fmt];
@@ -18076,9 +18045,8 @@
      /*<<camlinternalFormat.ml:2086:21>>*/ }
      /*<<camlinternalFormat.ml:2091:2>>*/ function unexpected_end_of_format
     (end_ind){
-      /*<<camlinternalFormat.ml:2092:4>>*/ invalid_format_message
-      (end_ind, cst_unexpected_end_of_format);
-      /*<<camlinternalFormat.ml:2092:4>>*/ return sentinal;
+      /*<<camlinternalFormat.ml:2092:4>>*/ return invalid_format_message
+             (end_ind, cst_unexpected_end_of_format);
      /*<<camlinternalFormat.ml:2093:32>>*/ }
     function invalid_format_without(str_ind, c, s){
       /*<<camlinternalFormat.ml:2104:4>>*/ return  /*<<camlinternalFormat.ml:2104:4>>*/ caml_call4
@@ -18589,9 +18557,8 @@
              create_char_set(0),
            add_char =
              function(c){
-               /*<<camlinternalFormat.ml:2721:6>>*/ add_in_char_set
-               (char_set, c);
-               /*<<camlinternalFormat.ml:2721:6>>*/ return sentinal;
+               /*<<camlinternalFormat.ml:2721:6>>*/ return add_in_char_set
+                      (char_set, c);
               /*<<camlinternalFormat.ml:2721:32>>*/ },
            add_range =
              function(c$0, c){
@@ -18608,7 +18575,7 @@
                 var i = _bd_;
                }
               }
-              return sentinal;
+              return 0;
               /*<<camlinternalFormat.ml:2726:10>>*/ },
            fail_single_percent =
              function(str_ind){
@@ -19349,7 +19316,7 @@
         (failwith_message(_C_), str, str_ind, _am_);
       }
       flag[1] = 1;
-      return sentinal;
+      return 0;
       /*<<camlinternalFormat.ml:2158:19>>*/ }
      var str_ind$0 = str_ind;
       /*<<camlinternalFormat.ml:2161:6>>*/ for(;;){
@@ -20056,7 +20023,6 @@
             : runtime.caml_call_gen(f, [a0, a1, a2, a3, a4, a5]);
    }
     /*<<arg.ml:50:0>>*/ var
-    sentinal = undefined,
     global_data = runtime.caml_get_global_data(),
     cst$6 = "\n",
     cst$3 = cst$7,
@@ -20217,9 +20183,8 @@
       /*<<arg.ml:86:8>>*/ return  /*<<arg.ml:86:8>>*/ caml_call5
              (Stdlib_Printf[5], buf, _b_, key, _av_, doc);
     }
-     /*<<arg.ml:108:29>>*/  /*<<arg.ml:108:29>>*/ caml_call2
-     (Stdlib_List[17], _at_, _as_);
-     /*<<arg.ml:108:29>>*/ return sentinal;
+     /*<<arg.ml:108:29>>*/ return  /*<<arg.ml:108:29>>*/ caml_call2
+            (Stdlib_List[17], _at_, _as_);
     /*<<arg.ml:108:48>>*/ }
    function usage_string(speclist, errmsg){
      /*<<arg.ml:112:2>>*/  /*<<arg.ml:112:10>>*/ var
@@ -20357,7 +20322,7 @@
            function(s, follow){
             function no_arg(param){
               /*<<arg.ml:178:10>>*/ if(! follow)
-               /*<<arg.ml:179:20>>*/ return sentinal;
+               /*<<arg.ml:179:20>>*/ return 0;
              var arg = follow[1];
               /*<<arg.ml:180:24>>*/ throw  /*<<arg.ml:180:24>>*/ caml_maybe_attach_backtrace
                     ([0, Stop, [1, s, arg, cst_no_argument]], 1);
@@ -20836,9 +20801,8 @@
      else
       var word$0 = word;
      words[1] = [0, word$0, words[1]];
-      /*<<arg.ml:390:2>>*/  /*<<arg.ml:390:2>>*/ caml_call1
-      (Stdlib_Buffer[8], buf);
-      /*<<arg.ml:390:2>>*/ return sentinal;
+      /*<<arg.ml:390:2>>*/ return  /*<<arg.ml:390:2>>*/ caml_call1
+             (Stdlib_Buffer[8], buf);
      /*<<arg.ml:394:20>>*/ }
      /*<<arg.ml:396:2>>*/ try{
      for(;;){
@@ -21552,7 +21516,6 @@
             : runtime.caml_call_gen(f, [a0, a1]);
    }
    var
-    sentinal = undefined,
     global_data = runtime.caml_get_global_data(),
     Stdlib_Printexc = global_data.Stdlib__Printexc,
     Stdlib = global_data.Stdlib,
@@ -21575,19 +21538,20 @@
       /*<<fun.ml:25:7>>*/ return 0;
      /*<<fun.ml:24:55>>*/ var
      exn = param[2],
-      /*<<fun.ml:24:55>>*/ _b_ =
+      /*<<fun.ml:24:55>>*/ _c_ =
         /*<<fun.ml:24:55>>*/ caml_call1(Stdlib_Printexc[1], exn);
      /*<<fun.ml:24:24>>*/ return [0,
              /*<<fun.ml:24:29>>*/ caml_call2
-             (Stdlib[28], cst_Fun_Finally_raised, _b_)];
+             (Stdlib[28], cst_Fun_Finally_raised, _c_)];
     /*<<fun.ml:25:11>>*/ }
     /*<<fun.ml:23:9>>*/  /*<<fun.ml:23:9>>*/ caml_call1
     (Stdlib_Printexc[9], _a_);
    function protect(finally$0, work){
     function finally_no_exn(param){
       /*<<fun.ml:29:4>>*/ try{
-       /*<<fun.ml:29:8>>*/  /*<<fun.ml:29:8>>*/ caml_call1(finally$0, 0);
-       /*<<fun.ml:29:8>>*/ return sentinal;
+       /*<<fun.ml:29:8>>*/  /*<<fun.ml:29:8>>*/ var
+       _b_ =  /*<<fun.ml:29:8>>*/ caml_call1(finally$0, 0);
+       /*<<fun.ml:29:8>>*/ return _b_;
      }
      catch(e$0){
        /*<<fun.ml:30:15>>*/ var
@@ -22045,7 +22009,6 @@
             : runtime.caml_call_gen(f, [a0, a1, a2]);
    }
    var
-    sentinal = undefined,
     global_data = runtime.caml_get_global_data(),
     Stdlib = global_data.Stdlib,
     Stdlib_Array = global_data.Stdlib__Array,
@@ -22104,11 +22067,9 @@
      /*<<bigarray.ml:73:4>>*/ c_layout = 0,
     fortran_layout = 1;
    function cloop(arr, idx, f, col, max){
-     /*<<bigarray.ml:104:4>>*/ if(col === idx.length - 1){
-      /*<<bigarray.ml:104:35>>*/  /*<<bigarray.ml:104:35>>*/ caml_ba_set_generic
-      (arr, idx,  /*<<bigarray.ml:104:47>>*/ caml_call1(f, idx));
-      /*<<bigarray.ml:104:35>>*/ return sentinal;
-    }
+     /*<<bigarray.ml:104:4>>*/ if(col === idx.length - 1)
+      /*<<bigarray.ml:104:35>>*/ return  /*<<bigarray.ml:104:35>>*/ caml_ba_set_generic
+             (arr, idx,  /*<<bigarray.ml:104:47>>*/ caml_call1(f, idx));
      /*<<bigarray.ml:105:27>>*/ var
       /*<<bigarray.ml:105:27>>*/ _am_ =
        caml_check_bound(max, col)[1 + col] - 1 | 0,
@@ -22124,14 +22085,12 @@
       var j = _an_;
      }
     }
-    return sentinal;
+    return 0;
     /*<<bigarray.ml:108:13>>*/ }
    function floop(arr, idx, f, col, max){
-     /*<<bigarray.ml:110:4>>*/ if(0 > col){
-      /*<<bigarray.ml:110:20>>*/  /*<<bigarray.ml:110:20>>*/ caml_ba_set_generic
-      (arr, idx,  /*<<bigarray.ml:110:32>>*/ caml_call1(f, idx));
-      /*<<bigarray.ml:110:20>>*/ return sentinal;
-    }
+     /*<<bigarray.ml:110:4>>*/ if(0 > col)
+      /*<<bigarray.ml:110:20>>*/ return  /*<<bigarray.ml:110:20>>*/ caml_ba_set_generic
+             (arr, idx,  /*<<bigarray.ml:110:32>>*/ caml_call1(f, idx));
      /*<<bigarray.ml:111:22>>*/ var
       /*<<bigarray.ml:111:22>>*/ _aj_ = caml_check_bound(max, col)[1 + col],
       /*<<bigarray.ml:111:9>>*/ _ai_ = 1;
@@ -22146,7 +22105,7 @@
       var j = _ak_;
      }
     }
-    return sentinal;
+    return 0;
     /*<<bigarray.ml:114:13>>*/ }
    function init(kind, layout, dims, f){
      /*<<bigarray.ml:116:4>>*/ var
@@ -24171,7 +24130,6 @@
             : runtime.caml_call_gen(f, [a0, a1, a2, a3, a4]);
    }
    var
-    sentinal = undefined,
     global_data = runtime.caml_get_global_data(),
     Stdlib = global_data.Stdlib,
     Stdlib_Sys = global_data.Stdlib__Sys,
@@ -24204,9 +24162,7 @@
      _T_ = 0 <= o ? 1 : 0,
      _U_ = _T_ ? o < length(e) ? 1 : 0 : _T_,
      _V_ = 1 - _U_;
-    return _V_
-            ? ( /*<<weak.ml:37:4>>*/ caml_call1(Stdlib[1], msg), sentinal)
-            : _V_;
+    return _V_ ?  /*<<weak.ml:37:4>>*/ caml_call1(Stdlib[1], msg) : _V_;
     /*<<weak.ml:37:20>>*/ }
    function set(e, o, x){
      /*<<weak.ml:42:2>>*/ raise_if_invalid_offset(e, o, cst_Weak_set);
@@ -24809,7 +24765,6 @@
             : runtime.caml_call_gen(f, [a0, a1, a2, a3]);
    }
    var
-    sentinal = undefined,
     global_data = runtime.caml_get_global_data(),
     cst$14 = ".",
     cst$11 = cst$15,
@@ -24857,27 +24812,25 @@
     /*<<format.ml:220:32>>*/ }
    var pp_infinity = 1000000010;
    function pp_output_string(state, s){
-     /*<<format.ml:251:31>>*/ caml_call3
-     (state[17], s, 0, caml_ml_string_length(s));
-    return sentinal;
+     /*<<format.ml:251:31>>*/ return caml_call3
+            (state[17], s, 0, caml_ml_string_length(s));
     /*<<format.ml:251:72>>*/ }
    function pp_output_newline(state){
-     /*<<format.ml:252:30>>*/  /*<<format.ml:252:30>>*/ caml_call1
-     (state[19], 0);
-     /*<<format.ml:252:30>>*/ return sentinal;
+     /*<<format.ml:252:30>>*/ return  /*<<format.ml:252:30>>*/ caml_call1
+            (state[19], 0);
     /*<<format.ml:252:53>>*/ }
    function format_pp_text(state, size, text){
      /*<<format.ml:258:2>>*/ state[9] = state[9] - size | 0;
      /*<<format.ml:259:2>>*/ pp_output_string(state, text);
     state[11] = 0;
-    return sentinal;
+    return 0;
     /*<<format.ml:260:31>>*/ }
    function format_string(state, s){
      /*<<format.ml:264:2>>*/  /*<<format.ml:264:5>>*/ var
-     _bN_ =  /*<<format.ml:264:5>>*/ runtime.caml_string_notequal(s, cst$16);
-     /*<<format.ml:264:5>>*/ return _bN_
-            ? (format_pp_text(state, caml_ml_string_length(s), s), sentinal)
-            : _bN_;
+     _bQ_ =  /*<<format.ml:264:5>>*/ runtime.caml_string_notequal(s, cst$16);
+     /*<<format.ml:264:5>>*/ return _bQ_
+            ? format_pp_text(state, caml_ml_string_length(s), s)
+            : _bQ_;
     /*<<format.ml:264:58>>*/ }
    function break_new_line(state, param, width){
     var after = param[3], offset = param[2], before = param[1];
@@ -24893,12 +24846,10 @@
     var n = state[10];
      /*<<format.ml:254:31>>*/  /*<<format.ml:254:31>>*/ caml_call1
      (state[21], n);
-     /*<<format.ml:276:2>>*/ format_string(state, after);
-     /*<<format.ml:276:2>>*/ return sentinal;
+     /*<<format.ml:276:2>>*/ return format_string(state, after);
    }
    function break_line(state, width){
-     /*<<format.ml:281:29>>*/ break_new_line(state, _a_, width);
-     /*<<format.ml:281:29>>*/ return sentinal;
+     /*<<format.ml:281:29>>*/ return break_new_line(state, _a_, width);
     /*<<format.ml:281:67>>*/ }
    function break_same_line(state, param){
     var after = param[3], width = param[2], before = param[1];
@@ -24906,8 +24857,7 @@
     state[9] = state[9] - width | 0;
      /*<<format.ml:253:31>>*/  /*<<format.ml:253:31>>*/ caml_call1
      (state[20], width);
-     /*<<format.ml:287:2>>*/ format_string(state, after);
-     /*<<format.ml:287:2>>*/ return sentinal;
+     /*<<format.ml:287:2>>*/ return format_string(state, after);
    }
    function format_pp_token(state, size$0, param){
      /*<<?>>*/ if(typeof param === "number")
@@ -24916,7 +24866,7 @@
          /*<<format.ml:348:16>>*/  /*<<format.ml:348:16>>*/ var
          match$3 =
             /*<<format.ml:348:16>>*/ caml_call1(Stdlib_Stack[7], state[3]);
-        if(! match$3)  /*<<format.ml:349:14>>*/ return sentinal;
+        if(! match$3)  /*<<format.ml:349:14>>*/ return 0;
          /*<<format.ml:351:6>>*/ var
          tabs = match$3[1][1],
           /*<<format.ml:351:6>>*/ add_tab =
@@ -24929,54 +24879,49 @@
                     : [0, x, add_tab(n, l)];
            };
         tabs[1] = add_tab(state[6] - state[9] | 0, tabs[1]);
-        return sentinal;
+        return 0;
        case 1:
          /*<<format.ml:339:4>>*/  /*<<format.ml:339:4>>*/ caml_call1
          (Stdlib_Stack[5], state[2]);
-         /*<<format.ml:339:4>>*/ return sentinal;
+         /*<<format.ml:339:4>>*/ return 0;
        case 2:
          /*<<format.ml:345:4>>*/  /*<<format.ml:345:4>>*/ caml_call1
          (Stdlib_Stack[5], state[3]);
-         /*<<format.ml:345:4>>*/ return sentinal;
+         /*<<format.ml:345:4>>*/ return 0;
        case 3:
          /*<<format.ml:378:16>>*/  /*<<format.ml:378:16>>*/ var
          match$4 =
             /*<<format.ml:378:16>>*/ caml_call1(Stdlib_Stack[7], state[2]);
-        if(match$4){
-         var width$0 = match$4[1][2];
-          /*<<format.ml:380:26>>*/ break_line(state, width$0);
-          /*<<format.ml:380:26>>*/ return sentinal;
-        }
-         /*<<format.ml:379:14>>*/ pp_output_newline(state);
-         /*<<format.ml:379:14>>*/ return sentinal;
+        if(! match$4)
+          /*<<format.ml:379:14>>*/ return pp_output_newline(state);
+        var width$0 = match$4[1][2];
+         /*<<format.ml:380:26>>*/ return break_line(state, width$0);
        case 4:
-        var _bL_ = state[10] !== (state[6] - state[9] | 0) ? 1 : 0;
-        if(! _bL_) return _bL_;
+        var _bO_ = state[10] !== (state[6] - state[9] | 0) ? 1 : 0;
+        if(! _bO_) return _bO_;
          /*<<format.ml:306:8>>*/  /*<<format.ml:306:8>>*/ var
          match$1 =
             /*<<format.ml:306:8>>*/ caml_call1(Stdlib_Queue[6], state[28]);
-        if(! match$1)  /*<<format.ml:307:12>>*/ return sentinal;
+        if(! match$1)  /*<<format.ml:307:12>>*/ return 0;
         var match$2 = match$1[1], size = match$2[1], length = match$2[3];
         state[12] = state[12] - length | 0;
         state[9] = state[9] + size | 0;
-        return sentinal;
+        return 0;
        default:
          /*<<format.ml:419:17>>*/  /*<<format.ml:419:17>>*/ var
          match$5 =
             /*<<format.ml:419:17>>*/ caml_call1(Stdlib_Stack[5], state[5]);
-        if(! match$5)  /*<<format.ml:420:15>>*/ return sentinal;
+        if(! match$5)  /*<<format.ml:420:15>>*/ return 0;
          /*<<format.ml:422:20>>*/ var
          tag_name = match$5[1],
           /*<<format.ml:422:20>>*/ marker =
             /*<<format.ml:422:20>>*/ caml_call1(state[25], tag_name);
-         /*<<format.ml:423:7>>*/ pp_output_string(state, marker);
-         /*<<format.ml:423:7>>*/ return sentinal;
+         /*<<format.ml:423:7>>*/ return pp_output_string(state, marker);
      }
     switch(param[0]){
       case 0:
        var s = param[1];
-        /*<<format.ml:323:4>>*/ format_pp_text(state, size$0, s);
-        /*<<format.ml:323:4>>*/ return sentinal;
+        /*<<format.ml:323:4>>*/ return format_pp_text(state, size$0, s);
       case 1:
         /*<<format.ml:388:4>>*/ var
         breaks = param[2],
@@ -24985,32 +24930,31 @@
         before = breaks[1],
          /*<<format.ml:389:16>>*/ match$6 =
            /*<<format.ml:389:16>>*/ caml_call1(Stdlib_Stack[7], state[2]);
-       if(! match$6)  /*<<format.ml:390:14>>*/ return sentinal;
+       if(! match$6)  /*<<format.ml:390:14>>*/ return 0;
        var
         match$7 = match$6[1],
         width$1 = match$7[2],
         box_type$0 = match$7[1];
         /*<<format.ml:392:6>>*/ switch(box_type$0){
          case 0:
-           /*<<format.ml:409:19>>*/ break_same_line(state, fits);
-           /*<<format.ml:409:19>>*/ return sentinal;
+           /*<<format.ml:409:19>>*/ return break_same_line(state, fits);
          case 1:
-           /*<<format.ml:408:19>>*/ break_new_line(state, breaks, width$1);
-           /*<<format.ml:408:19>>*/ return sentinal;
+           /*<<format.ml:408:19>>*/ return break_new_line
+                  (state, breaks, width$1);
          case 2:
-           /*<<format.ml:406:20>>*/ break_new_line(state, breaks, width$1);
-           /*<<format.ml:406:20>>*/ return sentinal;
+           /*<<format.ml:406:20>>*/ return break_new_line
+                  (state, breaks, width$1);
          case 3:
           return state[9] < (size$0 + caml_ml_string_length(before) | 0)
-                  ? (break_new_line(state, breaks, width$1), sentinal)
-                  : (break_same_line(state, fits), sentinal);
+                  ? break_new_line(state, breaks, width$1)
+                  : break_same_line(state, fits);
          case 4:
           return state[11]
-                  ? (break_same_line(state, fits), sentinal)
+                  ? break_same_line(state, fits)
                   : state
                      [9]
                     < (size$0 + caml_ml_string_length(before) | 0)
-                    ? (break_new_line(state, breaks, width$1), sentinal)
+                    ? break_new_line(state, breaks, width$1)
                     : ((state
                        [6]
                       - width$1
@@ -25018,11 +24962,10 @@
                       + off
                       | 0)
                       < state[10]
-                      ? (break_new_line(state, breaks, width$1), sentinal)
-                      : (break_same_line(state, fits), sentinal);
+                      ? break_new_line(state, breaks, width$1)
+                      : break_same_line(state, fits);
          default:
-           /*<<format.ml:407:19>>*/ break_same_line(state, fits);
-           /*<<format.ml:407:19>>*/ return sentinal;
+           /*<<format.ml:407:19>>*/ return break_same_line(state, fits);
        }
       case 2:
         /*<<format.ml:359:16>>*/ var
@@ -25031,7 +24974,7 @@
         insertion_point = state[6] - state[9] | 0,
          /*<<format.ml:359:16>>*/ match$8 =
            /*<<format.ml:359:16>>*/ caml_call1(Stdlib_Stack[7], state[3]);
-       if(! match$8)  /*<<format.ml:360:14>>*/ return sentinal;
+       if(! match$8)  /*<<format.ml:360:14>>*/ return 0;
         /*<<format.ml:362:6>>*/ var
         tabs$0 = match$8[1][1],
          /*<<format.ml:362:6>>*/ match$9 = tabs$0[1];
@@ -25041,11 +24984,11 @@
          if(param$0){
           var tail = param$0[2], head = param$0[1];
           if(insertion_point > head){var param$0 = tail; continue;}
-          var _bM_ = head;
+          var _bP_ = head;
          }
          else
-          var _bM_ = first;
-         var tab = _bM_;
+          var _bP_ = first;
+         var tab = _bP_;
          break;
         }
        }
@@ -25053,12 +24996,9 @@
         var tab = insertion_point;
        var offset = tab - insertion_point | 0;
         /*<<format.ml:372:6>>*/ return 0 <= offset
-               ? (break_same_line
-                  (state, [0, cst$0, offset + n | 0, cst]),
-                 sentinal)
-               : (break_new_line
-                  (state, [0, cst$2, tab + off$0 | 0, cst$1], state[6]),
-                 sentinal);
+               ? break_same_line(state, [0, cst$0, offset + n | 0, cst])
+               : break_new_line
+                 (state, [0, cst$2, tab + off$0 | 0, cst$1], state[6]);
       case 3:
        var
         ty = param[2],
@@ -25080,22 +25020,19 @@
         width$2 = state[9] - off$1 | 0,
          /*<<format.ml:331:4>>*/ box_type$1 =
           1 === ty ? 1 : state[9] < size$0 ? ty : 5;
-        /*<<format.ml:336:4>>*/  /*<<format.ml:336:4>>*/ caml_call2
-        (Stdlib_Stack[3], [0, box_type$1, width$2], state[2]);
-        /*<<format.ml:336:4>>*/ return sentinal;
+        /*<<format.ml:336:4>>*/ return  /*<<format.ml:336:4>>*/ caml_call2
+               (Stdlib_Stack[3], [0, box_type$1, width$2], state[2]);
       case 4:
        var tbox = param[1];
-        /*<<format.ml:342:4>>*/  /*<<format.ml:342:4>>*/ caml_call2
-        (Stdlib_Stack[3], tbox, state[3]);
-        /*<<format.ml:342:4>>*/ return sentinal;
+        /*<<format.ml:342:4>>*/ return  /*<<format.ml:342:4>>*/ caml_call2
+               (Stdlib_Stack[3], tbox, state[3]);
       default:
         /*<<format.ml:414:18>>*/ var
         tag_name$0 = param[1],
          /*<<format.ml:414:18>>*/ marker$0 =
            /*<<format.ml:414:18>>*/ caml_call1(state[24], tag_name$0);
         /*<<format.ml:415:5>>*/ pp_output_string(state, marker$0);
-       caml_call2(Stdlib_Stack[3], tag_name$0, state[5]);
-       return sentinal;
+       return caml_call2(Stdlib_Stack[3], tag_name$0, state[5]);
     }
    }
    function advance_left(state){
@@ -25109,10 +25046,10 @@
       length = match$0[3],
       token = match$0[2],
       pending_count = state[13] - state[12] | 0,
-       /*<<format.ml:435:7>>*/ _bJ_ = 0 <= size ? 1 : 0,
-       /*<<format.ml:435:7>>*/ _bK_ =
-        _bJ_ || (state[9] <= pending_count ? 1 : 0);
-     if(! _bK_)  /*<<format.ml:435:7>>*/ return _bK_;
+       /*<<format.ml:435:7>>*/ _bM_ = 0 <= size ? 1 : 0,
+       /*<<format.ml:435:7>>*/ _bN_ =
+        _bM_ || (state[9] <= pending_count ? 1 : 0);
+     if(! _bN_)  /*<<format.ml:435:7>>*/ return _bN_;
       /*<<format.ml:436:6>>*/  /*<<format.ml:436:6>>*/ caml_call1
       (Stdlib_Queue[5], state[28]);
       /*<<format.ml:437:20>>*/  /*<<format.ml:437:20>>*/ var
@@ -25134,43 +25071,48 @@
      (Stdlib_Stack[8], stack);
      /*<<format.ml:463:19>>*/  /*<<format.ml:463:19>>*/ var
      queue_elem = [0, unknown, _b_, 0];
-     /*<<format.ml:464:2>>*/  /*<<format.ml:464:2>>*/ caml_call2
-     (Stdlib_Stack[3], [0, -1, queue_elem], stack);
-     /*<<format.ml:464:2>>*/ return sentinal;
+     /*<<format.ml:464:2>>*/ return  /*<<format.ml:464:2>>*/ caml_call2
+            (Stdlib_Stack[3], [0, -1, queue_elem], stack);
     /*<<format.ml:464:50>>*/ }
    function set_size(state, ty){
      /*<<format.ml:476:2>>*/  /*<<format.ml:476:8>>*/ var
      match =  /*<<format.ml:476:8>>*/ caml_call1(Stdlib_Stack[7], state[1]);
-    if(! match)  /*<<format.ml:477:12>>*/ return sentinal;
+    if(! match)  /*<<format.ml:477:12>>*/ return 0;
      /*<<format.ml:479:4>>*/ var
      match$0 = match[1],
      queue_elem = match$0[2],
      left_total = match$0[1],
       /*<<format.ml:479:4>>*/ size = queue_elem[1];
-    if(left_total < state[12]){
-     initialize_scan_stack(state[1]);
-     return sentinal;
-    }
+    if(left_total < state[12]) return initialize_scan_stack(state[1]);
     var _bI_ = queue_elem[2];
     if(typeof _bI_ !== "number")
      switch(_bI_[0]){
        case 3:
-        if(1 - ty){
-         queue_elem[1] = state[13] + size | 0;
-          /*<<format.ml:493:10>>*/  /*<<format.ml:493:10>>*/ caml_call1
-          (Stdlib_Stack[5], state[1]);
-        }
-         /*<<format.ml:493:10>>*/ return sentinal;
+        var
+         _bK_ = 1 - ty,
+         _bL_ =
+           _bK_
+            ? (queue_elem
+               [1]
+              = state[13] + size | 0,
+               /*<<format.ml:493:10>>*/ caml_call1(Stdlib_Stack[5], state[1]),
+              0)
+            : _bK_;
+         /*<<format.ml:493:10>>*/ return _bL_;
        case 1:
        case 2:
-        if(ty){
-         queue_elem[1] = state[13] + size | 0;
-          /*<<format.ml:488:10>>*/  /*<<format.ml:488:10>>*/ caml_call1
-          (Stdlib_Stack[5], state[1]);
-        }
-         /*<<format.ml:488:10>>*/ return sentinal;
+        var
+         _bJ_ =
+           ty
+            ? (queue_elem
+               [1]
+              = state[13] + size | 0,
+               /*<<format.ml:488:10>>*/ caml_call1(Stdlib_Stack[5], state[1]),
+              0)
+            : ty;
+         /*<<format.ml:488:10>>*/ return _bJ_;
      }
-     /*<<format.ml:497:8>>*/ return sentinal;
+     /*<<format.ml:497:8>>*/ return 0;
     /*<<format.ml:497:10>>*/ }
    function scan_push(state, b, token){
      /*<<format.ml:503:2>>*/ pp_enqueue(state, token);
@@ -25303,8 +25245,7 @@
       state[13] = pp_infinity;
        /*<<format.ml:613:2>>*/ advance_left(state);
       if(b)  /*<<format.ml:614:12>>*/ pp_output_newline(state);
-       /*<<format.ml:614:12>>*/ pp_rinit(state);
-       /*<<format.ml:614:12>>*/ return sentinal;
+       /*<<format.ml:614:12>>*/ return pp_rinit(state);
      }
       /*<<format.ml:610:4>>*/ pp_close_box(state, 0);
     }
@@ -27009,7 +26950,6 @@
             : runtime.caml_call_gen(f, [a0, a1, a2, a3]);
    }
    var
-    sentinal = undefined,
     global_data = runtime.caml_get_global_data(),
     cst$3 = cst$5,
     cst$4 = cst$5,
@@ -28177,19 +28117,14 @@
       var i$1 = i$0 - 1 | 0, i$0 = i$1;
      }
      /*<<scanf.ml:1109:28>>*/ }
-    if(! scan_indic){
-      /*<<scanf.ml:1111:12>>*/ scan_chars(width, -1);
-      /*<<scanf.ml:1111:12>>*/ return sentinal;
-    }
+    if(! scan_indic)  /*<<scanf.ml:1111:12>>*/ return scan_chars(width, -1);
     var c = scan_indic[1];
      /*<<scanf.ml:1113:4>>*/ scan_chars(width, c);
      /*<<scanf.ml:1114:11>>*/  /*<<scanf.ml:1114:11>>*/ var _Y_ = 1 - ib[1];
     if(! _Y_)  /*<<scanf.ml:1114:11>>*/ return _Y_;
      /*<<scanf.ml:1115:15>>*/  /*<<scanf.ml:1115:15>>*/ var
      ci = peek_char(ib);
-    return c === ci
-            ? (invalidate_current_char(ib), sentinal)
-            : (character_mismatch(c, ci), sentinal);
+    return c === ci ? invalidate_current_char(ib) : character_mismatch(c, ci);
     /*<<scanf.ml:1118:34>>*/ }
    function scanf_bad_input(ib, x){
      /*<<?>>*/ if(x[1] === Scan_failure)
@@ -28515,8 +28450,8 @@
              /*<<scanf.ml:1047:4>>*/  /*<<scanf.ml:1047:10>>*/ var
              c = check_next_char_for_char(width, ib);
             return 39 === c
-                    ? (ignore_char(width, ib), sentinal)
-                    : (character_mismatch(39, c), sentinal);
+                    ? ignore_char(width, ib)
+                    : character_mismatch(39, c);
             /*<<scanf.ml:1049:36>>*/ },
           /*<<scanf.ml:1035:10>>*/ c = checked_peek_char(ib);
         if(39 === c){
@@ -30489,7 +30424,6 @@
             : runtime.caml_call_gen(f, [a0, a1, a2]);
    }
    var
-    sentinal = undefined,
     global_data = runtime.caml_get_global_data(),
     Stdlib_List = global_data.Stdlib__List,
     Stdlib = global_data.Stdlib,
@@ -30625,14 +30559,14 @@
        insert_bucket =
          function(param){
            /*<<ephemeron.ml:176:32>>*/ if(! param)
-            /*<<ephemeron.ml:177:21>>*/ return sentinal;
+            /*<<ephemeron.ml:177:21>>*/ return 0;
           var rest = param[3], data = param[2], hkey = param[1];
            /*<<ephemeron.ml:179:14>>*/ insert_bucket(rest);
            /*<<ephemeron.ml:180:25>>*/  /*<<ephemeron.ml:180:25>>*/ var
            nidx = key_index(h, hkey);
            /*<<ephemeron.ml:181:14>>*/ ndata[1 + nidx] =
            [0, hkey, data, caml_check_bound(ndata, nidx)[1 + nidx]];
-           /*<<ephemeron.ml:181:14>>*/ return sentinal;
+           /*<<ephemeron.ml:181:14>>*/ return 0;
           /*<<ephemeron.ml:181:60>>*/ },
         /*<<ephemeron.ml:170:6>>*/ _ay_ = osize - 1 | 0,
         /*<<ephemeron.ml:182:8>>*/ _ax_ = 0;
@@ -30973,9 +30907,8 @@
             (Stdlib_Obj[24][3], t, 0);
     /*<<ephemeron.ml:396:70>>*/ }
    function set_key(t, k){
-     /*<<ephemeron.ml:397:44>>*/  /*<<ephemeron.ml:397:44>>*/ caml_call3
-     (Stdlib_Obj[24][5], t, 0, k);
-     /*<<ephemeron.ml:397:44>>*/ return sentinal;
+     /*<<ephemeron.ml:397:44>>*/ return  /*<<ephemeron.ml:397:44>>*/ caml_call3
+            (Stdlib_Obj[24][5], t, 0, k);
     /*<<ephemeron.ml:397:75>>*/ }
    function check_key(t){
      /*<<ephemeron.ml:398:39>>*/ return  /*<<ephemeron.ml:398:39>>*/ caml_call2
@@ -31154,18 +31087,16 @@
             (Stdlib_Obj[24][3], t, 0);
     /*<<ephemeron.ml:493:77>>*/ }
    function set_key1(t, k){
-     /*<<ephemeron.ml:495:4>>*/  /*<<ephemeron.ml:495:4>>*/ caml_call3
-     (Stdlib_Obj[24][5], t, 0, k);
-     /*<<ephemeron.ml:495:4>>*/ return sentinal;
+     /*<<ephemeron.ml:495:4>>*/ return  /*<<ephemeron.ml:495:4>>*/ caml_call3
+            (Stdlib_Obj[24][5], t, 0, k);
     /*<<ephemeron.ml:495:35>>*/ }
    function get_key2(t){
      /*<<ephemeron.ml:498:49>>*/ return  /*<<ephemeron.ml:498:57>>*/ caml_call2
             (Stdlib_Obj[24][3], t, 1);
     /*<<ephemeron.ml:498:77>>*/ }
    function set_key2(t, k){
-     /*<<ephemeron.ml:500:4>>*/  /*<<ephemeron.ml:500:4>>*/ caml_call3
-     (Stdlib_Obj[24][5], t, 1, k);
-     /*<<ephemeron.ml:500:4>>*/ return sentinal;
+     /*<<ephemeron.ml:500:4>>*/ return  /*<<ephemeron.ml:500:4>>*/ caml_call3
+            (Stdlib_Obj[24][5], t, 1, k);
     /*<<ephemeron.ml:500:35>>*/ }
    function get_data$0(t){
      /*<<ephemeron.ml:503:48>>*/ return  /*<<ephemeron.ml:503:56>>*/ caml_call1
@@ -31387,9 +31318,8 @@
             (Stdlib_Obj[24][3], t, n);
     /*<<ephemeron.ml:614:78>>*/ }
    function set_key$0(t, n, k){
-     /*<<ephemeron.ml:616:4>>*/  /*<<ephemeron.ml:616:4>>*/ caml_call3
-     (Stdlib_Obj[24][5], t, n, k);
-     /*<<ephemeron.ml:616:4>>*/ return sentinal;
+     /*<<ephemeron.ml:616:4>>*/ return  /*<<ephemeron.ml:616:4>>*/ caml_call3
+            (Stdlib_Obj[24][5], t, n, k);
     /*<<ephemeron.ml:616:35>>*/ }
    function get_data$1(t){
      /*<<ephemeron.ml:619:43>>*/ return  /*<<ephemeron.ml:619:51>>*/ caml_call1
@@ -31762,6 +31692,8 @@
     caml_string_get = runtime.caml_string_get,
     caml_string_notequal = runtime.caml_string_notequal,
     caml_sys_getenv = runtime.caml_sys_getenv,
+    caml_trampoline = runtime.caml_trampoline,
+    caml_trampoline_return = runtime.caml_trampoline_return,
     caml_wrap_exception = runtime.caml_wrap_exception;
     /*<<?>>*/ function caml_call1(f, a0){
     return (f.l >= 0 ? f.l : f.l = f.length) == 1
@@ -31784,7 +31716,6 @@
             : runtime.caml_call_gen(f, [a0, a1, a2, a3]);
    }
    var
-    sentinal = undefined,
     global_data = runtime.caml_get_global_data(),
     cst$18 = cst$19,
     cst$17 = cst$19,
@@ -31920,39 +31851,39 @@
     /*<<filename.ml:96:34>>*/ }
    function is_relative(n){
      /*<<filename.ml:97:22>>*/ var
-     _aH_ = caml_ml_string_length(n) < 1 ? 1 : 0,
-     _aI_ =
-       _aH_
+     _aK_ = caml_ml_string_length(n) < 1 ? 1 : 0,
+     _aL_ =
+       _aK_
        || (47 !==  /*<<filename.ml:97:45>>*/ caml_string_get(n, 0) ? 1 : 0);
-    return _aI_;
+    return _aL_;
     /*<<filename.ml:97:57>>*/ }
    function is_implicit(n){
      /*<<filename.ml:99:4>>*/  /*<<filename.ml:99:4>>*/ var
-     _aC_ = is_relative(n);
-     /*<<filename.ml:99:4>>*/ if(_aC_){
+     _aF_ = is_relative(n);
+     /*<<filename.ml:99:4>>*/ if(_aF_){
      var
-      _aD_ = caml_ml_string_length(n) < 2 ? 1 : 0,
-      _aE_ =
-        _aD_
+      _aG_ = caml_ml_string_length(n) < 2 ? 1 : 0,
+      _aH_ =
+        _aG_
         ||
           /*<<filename.ml:100:31>>*/ caml_string_notequal
           ( /*<<filename.ml:100:31>>*/ caml_call3(Stdlib_String[15], n, 0, 2),
            cst$27);
-      /*<<filename.ml:100:31>>*/ if(_aE_)
+      /*<<filename.ml:100:31>>*/ if(_aH_)
       var
-       _aF_ = caml_ml_string_length(n) < 3 ? 1 : 0,
-       _aG_ =
-         _aF_
+       _aI_ = caml_ml_string_length(n) < 3 ? 1 : 0,
+       _aJ_ =
+         _aI_
          ||
            /*<<filename.ml:101:31>>*/ caml_string_notequal
            ( /*<<filename.ml:101:31>>*/ caml_call3(Stdlib_String[15], n, 0, 3),
             cst$28);
      else
-      var _aG_ = _aE_;
+      var _aJ_ = _aH_;
     }
     else
-     var _aG_ = _aC_;
-     /*<<filename.ml:101:31>>*/ return _aG_;
+     var _aJ_ = _aF_;
+     /*<<filename.ml:101:31>>*/ return _aJ_;
     /*<<filename.ml:101:57>>*/ }
    function check_suffix(name, suff){
      /*<<filename.ml:103:4>>*/ return  /*<<filename.ml:103:4>>*/ caml_call2
@@ -31980,8 +31911,8 @@
         /*<<filename.ml:117:8>>*/ caml_sys_getenv("TMPDIR"),
      temp_dir_name = _k_;
    }
-   catch(_aB_){
-    var _a_ = caml_wrap_exception(_aB_);
+   catch(_aE_){
+    var _a_ = caml_wrap_exception(_aE_);
     if(_a_ !== Stdlib[8]) throw caml_maybe_attach_backtrace(_a_, 0);
     var temp_dir_name = cst_tmp;
    }
@@ -31993,10 +31924,10 @@
      /*<<filename.ml:19:2>>*/  /*<<filename.ml:19:2>>*/ caml_call2
      (Stdlib_Buffer[12], b, 39);
      /*<<filename.ml:19:2>>*/ var
-     _ay_ = l - 1 | 0,
-      /*<<filename.ml:19:2>>*/ _ax_ = 0;
-    if(_ay_ >= 0){
-     var i = _ax_;
+     _aB_ = l - 1 | 0,
+      /*<<filename.ml:19:2>>*/ _aA_ = 0;
+    if(_aB_ >= 0){
+     var i = _aA_;
      for(;;){
        /*<<filename.ml:21:7>>*/ if
        (39 ===  /*<<filename.ml:21:7>>*/ caml_string_get(s, i))
@@ -32004,14 +31935,14 @@
         (Stdlib_Buffer[16], b, quotequote);
       else{
         /*<<filename.ml:23:28>>*/  /*<<filename.ml:23:28>>*/ var
-        _aA_ =  /*<<filename.ml:23:28>>*/ caml_string_get(s, i);
+        _aD_ =  /*<<filename.ml:23:28>>*/ caml_string_get(s, i);
         /*<<filename.ml:23:9>>*/  /*<<filename.ml:23:9>>*/ caml_call2
-        (Stdlib_Buffer[12], b, _aA_);
+        (Stdlib_Buffer[12], b, _aD_);
       }
        /*<<filename.ml:23:9>>*/  /*<<filename.ml:23:9>>*/ var
-       _az_ = i + 1 | 0;
-      if(_ay_ === i) break;
-      var i = _az_;
+       _aC_ = i + 1 | 0;
+      if(_aB_ === i) break;
+      var i = _aC_;
      }
     }
      /*<<filename.ml:25:2>>*/  /*<<filename.ml:25:2>>*/ caml_call2
@@ -32024,47 +31955,47 @@
      var f = stderr[1];
       /*<<filename.ml:123:51>>*/ if
       ( /*<<filename.ml:123:51>>*/ caml_equal(stderr, stdout))
-      var _am_ = cst_2_1;
+      var _ap_ = cst_2_1;
      else
        /*<<filename.ml:125:61>>*/ var
-        /*<<filename.ml:125:61>>*/ _aw_ = quote(f),
-       _am_ =  /*<<filename.ml:125:53>>*/ caml_call2(Stdlib[28], cst_2, _aw_);
-     var _an_ = _am_;
+        /*<<filename.ml:125:61>>*/ _az_ = quote(f),
+       _ap_ =  /*<<filename.ml:125:53>>*/ caml_call2(Stdlib[28], cst_2, _az_);
+     var _aq_ = _ap_;
     }
     else
-     var _an_ = cst$4;
+     var _aq_ = cst$4;
     if(stdout)
       /*<<filename.ml:122:55>>*/ var
       f$0 = stdout[1],
-       /*<<filename.ml:122:55>>*/ _ao_ = quote(f$0),
-      _ap_ =  /*<<filename.ml:122:48>>*/ caml_call2(Stdlib[28], cst, _ao_);
+       /*<<filename.ml:122:55>>*/ _ar_ = quote(f$0),
+      _as_ =  /*<<filename.ml:122:48>>*/ caml_call2(Stdlib[28], cst, _ar_);
     else
-     var _ap_ = cst$3;
+     var _as_ = cst$3;
      /*<<filename.ml:122:6>>*/  /*<<filename.ml:122:6>>*/ var
-     _aq_ =  /*<<filename.ml:122:6>>*/ caml_call2(Stdlib[28], _ap_, _an_);
+     _at_ =  /*<<filename.ml:122:6>>*/ caml_call2(Stdlib[28], _as_, _aq_);
     if(stdin)
       /*<<filename.ml:121:55>>*/ var
       f$1 = stdin[1],
-       /*<<filename.ml:121:55>>*/ _ar_ = quote(f$1),
-      _as_ =  /*<<filename.ml:121:48>>*/ caml_call2(Stdlib[28], cst$0, _ar_);
+       /*<<filename.ml:121:55>>*/ _au_ = quote(f$1),
+      _av_ =  /*<<filename.ml:121:48>>*/ caml_call2(Stdlib[28], cst$0, _au_);
     else
-     var _as_ = cst$2;
+     var _av_ = cst$2;
      /*<<filename.ml:121:6>>*/ var
-      /*<<filename.ml:121:6>>*/ _at_ =
-        /*<<filename.ml:121:6>>*/ caml_call2(Stdlib[28], _as_, _aq_),
-      /*<<filename.ml:120:22>>*/ _au_ =
+      /*<<filename.ml:121:6>>*/ _aw_ =
+        /*<<filename.ml:121:6>>*/ caml_call2(Stdlib[28], _av_, _at_),
+      /*<<filename.ml:120:22>>*/ _ax_ =
         /*<<filename.ml:120:22>>*/ caml_call2
         (Stdlib_List[19], quote, [0, cmd, args]),
-      /*<<filename.ml:120:4>>*/ _av_ =
-        /*<<filename.ml:120:4>>*/ caml_call2(Stdlib_String[6], cst$1, _au_);
+      /*<<filename.ml:120:4>>*/ _ay_ =
+        /*<<filename.ml:120:4>>*/ caml_call2(Stdlib_String[6], cst$1, _ax_);
      /*<<filename.ml:121:6>>*/ return  /*<<filename.ml:121:6>>*/ caml_call2
-            (Stdlib[28], _av_, _at_);
+            (Stdlib[28], _ay_, _aw_);
     /*<<filename.ml:125:69>>*/ }
-    /*<<filename.ml:126:17>>*/ function basename(_al_){
-     /*<<?>>*/ return generic_basename(is_dir_sep, current_dir_name, _al_);
+    /*<<filename.ml:126:17>>*/ function basename(_ao_){
+     /*<<?>>*/ return generic_basename(is_dir_sep, current_dir_name, _ao_);
    }
-    /*<<filename.ml:127:16>>*/ function dirname(_ak_){
-     /*<<?>>*/ return generic_dirname(is_dir_sep, current_dir_name, _ak_);
+    /*<<filename.ml:127:16>>*/ function dirname(_an_){
+     /*<<?>>*/ return generic_dirname(is_dir_sep, current_dir_name, _an_);
    }
     /*<<filename.ml:91:24>>*/  /*<<filename.ml:91:24>>*/ var
     Unix =
@@ -32087,96 +32018,96 @@
      /*<<filename.ml:135:23>>*/ var
       /*<<filename.ml:135:31>>*/ c =
         /*<<filename.ml:135:31>>*/ caml_string_get(s, i),
-     _ah_ = 47 === c ? 1 : 0;
-    if(_ah_)
-     var _ai_ = _ah_;
+     _ak_ = 47 === c ? 1 : 0;
+    if(_ak_)
+     var _al_ = _ak_;
     else
-     var _aj_ = 92 === c ? 1 : 0, _ai_ = _aj_ || (58 === c ? 1 : 0);
-    return _ai_;
+     var _am_ = 92 === c ? 1 : 0, _al_ = _am_ || (58 === c ? 1 : 0);
+    return _al_;
     /*<<filename.ml:135:70>>*/ }
    function is_relative$0(n){
      /*<<filename.ml:137:4>>*/ var
-     _ab_ = caml_ml_string_length(n) < 1 ? 1 : 0,
-     _ac_ =
-       _ab_
+     _ae_ = caml_ml_string_length(n) < 1 ? 1 : 0,
+     _af_ =
+       _ae_
        || (47 !==  /*<<filename.ml:137:28>>*/ caml_string_get(n, 0) ? 1 : 0);
-    if(_ac_){
+    if(_af_){
      var
-      _ad_ = caml_ml_string_length(n) < 1 ? 1 : 0,
-      _ae_ =
-        _ad_
+      _ag_ = caml_ml_string_length(n) < 1 ? 1 : 0,
+      _ah_ =
+        _ag_
         || (92 !==  /*<<filename.ml:138:31>>*/ caml_string_get(n, 0) ? 1 : 0);
-     if(_ae_)
+     if(_ah_)
       var
-       _af_ = caml_ml_string_length(n) < 2 ? 1 : 0,
-       _ag_ =
-         _af_
+       _ai_ = caml_ml_string_length(n) < 2 ? 1 : 0,
+       _aj_ =
+         _ai_
          || (58 !==  /*<<filename.ml:139:31>>*/ caml_string_get(n, 1) ? 1 : 0);
      else
-      var _ag_ = _ae_;
+      var _aj_ = _ah_;
     }
     else
-     var _ag_ = _ac_;
-    return _ag_;
+     var _aj_ = _af_;
+    return _aj_;
     /*<<filename.ml:139:44>>*/ }
    function is_implicit$0(n){
      /*<<filename.ml:141:4>>*/  /*<<filename.ml:141:4>>*/ var
-     _U_ = is_relative$0(n);
-     /*<<filename.ml:141:4>>*/ if(_U_){
+     _X_ = is_relative$0(n);
+     /*<<filename.ml:141:4>>*/ if(_X_){
      var
-      _V_ = caml_ml_string_length(n) < 2 ? 1 : 0,
-      _W_ =
-        _V_
+      _Y_ = caml_ml_string_length(n) < 2 ? 1 : 0,
+      _Z_ =
+        _Y_
         ||
           /*<<filename.ml:142:31>>*/ caml_string_notequal
           ( /*<<filename.ml:142:31>>*/ caml_call3(Stdlib_String[15], n, 0, 2),
            cst$27);
-      /*<<filename.ml:142:31>>*/ if(_W_){
+      /*<<filename.ml:142:31>>*/ if(_Z_){
       var
-       _X_ = caml_ml_string_length(n) < 2 ? 1 : 0,
-       _Y_ =
-         _X_
+       ___ = caml_ml_string_length(n) < 2 ? 1 : 0,
+       _$_ =
+         ___
          ||
            /*<<filename.ml:143:31>>*/ caml_string_notequal
            ( /*<<filename.ml:143:31>>*/ caml_call3(Stdlib_String[15], n, 0, 2),
             ".\\");
-       /*<<filename.ml:143:31>>*/ if(_Y_){
+       /*<<filename.ml:143:31>>*/ if(_$_){
        var
-        _Z_ = caml_ml_string_length(n) < 3 ? 1 : 0,
-        ___ =
-          _Z_
+        _aa_ = caml_ml_string_length(n) < 3 ? 1 : 0,
+        _ab_ =
+          _aa_
           ||
             /*<<filename.ml:144:31>>*/ caml_string_notequal
             ( /*<<filename.ml:144:31>>*/ caml_call3
               (Stdlib_String[15], n, 0, 3),
              cst$28);
-        /*<<filename.ml:144:31>>*/ if(___)
+        /*<<filename.ml:144:31>>*/ if(_ab_)
         var
-         _$_ = caml_ml_string_length(n) < 3 ? 1 : 0,
-         _aa_ =
-           _$_
+         _ac_ = caml_ml_string_length(n) < 3 ? 1 : 0,
+         _ad_ =
+           _ac_
            ||
              /*<<filename.ml:145:31>>*/ caml_string_notequal
              ( /*<<filename.ml:145:31>>*/ caml_call3
                (Stdlib_String[15], n, 0, 3),
               "..\\");
        else
-        var _aa_ = ___;
+        var _ad_ = _ab_;
       }
       else
-       var _aa_ = _Y_;
+       var _ad_ = _$_;
      }
      else
-      var _aa_ = _W_;
+      var _ad_ = _Z_;
     }
     else
-     var _aa_ = _U_;
-     /*<<filename.ml:145:31>>*/ return _aa_;
+     var _ad_ = _X_;
+     /*<<filename.ml:145:31>>*/ return _ad_;
     /*<<filename.ml:145:58>>*/ }
    function check_suffix$0(name, suff){
      /*<<filename.ml:147:3>>*/ var
-     _R_ = caml_ml_string_length(suff) <= caml_ml_string_length(name) ? 1 : 0;
-    if(_R_)
+     _U_ = caml_ml_string_length(suff) <= caml_ml_string_length(name) ? 1 : 0;
+    if(_U_)
       /*<<filename.ml:148:12>>*/ var
        /*<<filename.ml:148:12>>*/ s =
          /*<<filename.ml:148:12>>*/ caml_call3
@@ -32184,14 +32115,14 @@
           name,
           caml_ml_string_length(name) - caml_ml_string_length(suff) | 0,
           caml_ml_string_length(suff)),
-       /*<<filename.ml:150:31>>*/ _S_ =
+       /*<<filename.ml:150:31>>*/ _V_ =
          /*<<filename.ml:150:31>>*/ caml_call1(Stdlib_String[26], suff),
-      _T_ =
+      _W_ =
          /*<<filename.ml:150:4>>*/ caml_string_equal
-         ( /*<<filename.ml:150:4>>*/ caml_call1(Stdlib_String[26], s), _S_);
+         ( /*<<filename.ml:150:4>>*/ caml_call1(Stdlib_String[26], s), _V_);
     else
-     var _T_ = _R_;
-     /*<<filename.ml:150:4>>*/ return _T_;
+     var _W_ = _U_;
+     /*<<filename.ml:150:4>>*/ return _W_;
     /*<<filename.ml:150:59>>*/ }
    function chop_suffix_opt$0(suffix, filename){
      /*<<filename.ml:153:4>>*/ var
@@ -32202,11 +32133,11 @@
       /*<<filename.ml:155:14>>*/ r =
         /*<<filename.ml:155:14>>*/ caml_call3
         (Stdlib_String[15], filename, len_f - len_s | 0, len_s),
-      /*<<filename.ml:156:36>>*/ _Q_ =
+      /*<<filename.ml:156:36>>*/ _T_ =
         /*<<filename.ml:156:36>>*/ caml_call1(Stdlib_String[26], suffix);
      /*<<filename.ml:156:9>>*/ return  /*<<filename.ml:156:9>>*/ caml_string_equal
              ( /*<<filename.ml:156:9>>*/ caml_call1(Stdlib_String[26], r),
-              _Q_)
+              _T_)
             ? [0,
                /*<<filename.ml:157:13>>*/ caml_call3
                (Stdlib_String[15], filename, 0, len_f - len_s | 0)]
@@ -32218,8 +32149,8 @@
         /*<<filename.ml:165:8>>*/ caml_sys_getenv("TEMP"),
      temp_dir_name$0 = _j_;
    }
-   catch(_P_){
-    var _b_ = caml_wrap_exception(_P_);
+   catch(_S_){
+    var _b_ = caml_wrap_exception(_S_);
     if(_b_ !== Stdlib[8]) throw caml_maybe_attach_backtrace(_b_, 0);
     var temp_dir_name$0 = cst$5;
    }
@@ -32230,23 +32161,44 @@
         /*<<filename.ml:168:12>>*/ caml_call1(Stdlib_Buffer[1], l + 20 | 0);
      /*<<filename.ml:169:4>>*/  /*<<filename.ml:169:4>>*/ caml_call2
      (Stdlib_Buffer[12], b, 34);
-    function loop(i){
+    function add_bs(n){
+      /*<<filename.ml:186:19>>*/  /*<<filename.ml:186:19>>*/ var _Q_ = 1;
+     if(n >= 1){
+      var j = _Q_;
+      for(;;){
+        /*<<filename.ml:186:38>>*/  /*<<filename.ml:186:38>>*/ caml_call2
+        (Stdlib_Buffer[12], b, 92);
+        /*<<filename.ml:186:38>>*/  /*<<filename.ml:186:38>>*/ var
+        _R_ = j + 1 | 0;
+       if(n === j) break;
+       var j = _R_;
+      }
+     }
+     return 0;
+     /*<<filename.ml:186:66>>*/ }
+    function loop$0(counter, i){
       /*<<filename.ml:171:6>>*/ var i$0 = i;
       /*<<filename.ml:171:6>>*/ for(;;){
-      if(i$0 === l){
-        /*<<filename.ml:171:20>>*/  /*<<filename.ml:171:20>>*/ caml_call2
-        (Stdlib_Buffer[12], b, 34);
-        /*<<filename.ml:171:20>>*/ return sentinal;
-      }
+      if(i$0 === l)
+        /*<<filename.ml:171:20>>*/ return  /*<<filename.ml:171:20>>*/ caml_call2
+               (Stdlib_Buffer[12], b, 34);
        /*<<filename.ml:172:12>>*/  /*<<filename.ml:172:12>>*/ var
        c =  /*<<filename.ml:172:12>>*/ caml_string_get(s, i$0);
       if(34 === c){
-        /*<<filename.ml:173:16>>*/ loop_bs(0, i$0);
-        /*<<filename.ml:173:16>>*/ return sentinal;
+       var _O_ = 0;
+        /*<<filename.ml:173:16>>*/ if(counter >= 50)
+         /*<<filename.ml:173:16>>*/ return  /*<<filename.ml:173:16>>*/ caml_trampoline_return
+                (loop_bs, [0, _O_, i$0]);
+       var counter$1 = counter + 1 | 0;
+        /*<<filename.ml:173:16>>*/ return loop_bs(counter$1, _O_, i$0);
       }
       if(92 === c){
-        /*<<filename.ml:174:16>>*/ loop_bs(0, i$0);
-        /*<<filename.ml:174:16>>*/ return sentinal;
+       var _P_ = 0;
+        /*<<filename.ml:174:16>>*/ if(counter >= 50)
+         /*<<filename.ml:174:16>>*/ return  /*<<filename.ml:174:16>>*/ caml_trampoline_return
+                (loop_bs, [0, _P_, i$0]);
+       var counter$0 = counter + 1 | 0;
+        /*<<filename.ml:174:16>>*/ return loop_bs(counter$0, _P_, i$0);
       }
        /*<<filename.ml:175:16>>*/  /*<<filename.ml:175:16>>*/ caml_call2
        (Stdlib_Buffer[12], b, c);
@@ -32255,14 +32207,13 @@
        i$0 = i$1;
      }
      /*<<filename.ml:175:48>>*/ }
-    function loop_bs(n, i){
+    function loop_bs(counter, n, i){
       /*<<filename.ml:177:6>>*/ var n$0 = n, i$0 = i;
       /*<<filename.ml:177:6>>*/ for(;;){
       if(i$0 === l){
         /*<<filename.ml:178:8>>*/  /*<<filename.ml:178:8>>*/ caml_call2
         (Stdlib_Buffer[12], b, 34);
-        /*<<filename.ml:178:8>>*/ add_bs(n$0);
-        /*<<filename.ml:178:8>>*/ return sentinal;
+        /*<<filename.ml:178:8>>*/ return add_bs(n$0);
       }
        /*<<filename.ml:181:14>>*/  /*<<filename.ml:181:14>>*/ var
        match =  /*<<filename.ml:181:14>>*/ caml_string_get(s, i$0);
@@ -32270,13 +32221,21 @@
         /*<<filename.ml:182:18>>*/ add_bs((2 * n$0 | 0) + 1 | 0);
         /*<<filename.ml:182:34>>*/  /*<<filename.ml:182:34>>*/ caml_call2
         (Stdlib_Buffer[12], b, 34);
-        /*<<filename.ml:182:34>>*/ loop(i$0 + 1 | 0);
-        /*<<filename.ml:182:34>>*/ return sentinal;
+        /*<<filename.ml:182:34>>*/  /*<<filename.ml:182:34>>*/ var
+        _N_ = i$0 + 1 | 0;
+        /*<<filename.ml:182:34>>*/ if(counter >= 50)
+         /*<<filename.ml:182:34>>*/ return  /*<<filename.ml:182:34>>*/ caml_trampoline_return
+                (loop$0, [0, _N_]);
+       var counter$1 = counter + 1 | 0;
+        /*<<filename.ml:182:34>>*/ return loop$0(counter$1, _N_);
       }
       if(92 !== match){
         /*<<filename.ml:184:18>>*/ add_bs(n$0);
-        /*<<filename.ml:184:18>>*/ loop(i$0);
-        /*<<filename.ml:184:18>>*/ return sentinal;
+        /*<<filename.ml:184:18>>*/ if(counter >= 50)
+         /*<<filename.ml:184:18>>*/ return  /*<<filename.ml:184:18>>*/ caml_trampoline_return
+                (loop$0, [0, i$0]);
+       var counter$0 = counter + 1 | 0;
+        /*<<filename.ml:184:18>>*/ return loop$0(counter$0, i$0);
       }
        /*<<filename.ml:183:18>>*/ var
         /*<<filename.ml:183:18>>*/ i$1 = i$0 + 1 | 0,
@@ -32285,21 +32244,7 @@
        i$0 = i$1;
      }
      /*<<filename.ml:185:9>>*/ }
-    function add_bs(n){
-      /*<<filename.ml:186:19>>*/  /*<<filename.ml:186:19>>*/ var _N_ = 1;
-     if(n >= 1){
-      var j = _N_;
-      for(;;){
-        /*<<filename.ml:186:38>>*/  /*<<filename.ml:186:38>>*/ caml_call2
-        (Stdlib_Buffer[12], b, 92);
-        /*<<filename.ml:186:38>>*/  /*<<filename.ml:186:38>>*/ var
-        _O_ = j + 1 | 0;
-       if(n === j) break;
-       var j = _O_;
-      }
-     }
-     return sentinal;
-     /*<<filename.ml:186:66>>*/ }
+    function loop(i){ /*<<?>>*/ return caml_trampoline(loop$0(0, i));}
      /*<<filename.ml:188:4>>*/ loop(0);
      /*<<filename.ml:188:4>>*/ return  /*<<filename.ml:188:4>>*/ caml_call1
             (Stdlib_Buffer[2], b);

From f0d95068e5a373f1ba2a54990ea5b2e4753c00d5 Mon Sep 17 00:00:00 2001
From: Micah Cantor <micahcantor01@gmail.com>
Date: Sat, 16 Sep 2023 23:25:03 -0500
Subject: [PATCH 068/112] change name to global deadcode

---
 compiler/lib/{deadcode_dgraph.ml => global_deadcode.ml}   | 0
 compiler/lib/{deadcode_dgraph.mli => global_deadcode.mli} | 0
 2 files changed, 0 insertions(+), 0 deletions(-)
 rename compiler/lib/{deadcode_dgraph.ml => global_deadcode.ml} (100%)
 rename compiler/lib/{deadcode_dgraph.mli => global_deadcode.mli} (100%)

diff --git a/compiler/lib/deadcode_dgraph.ml b/compiler/lib/global_deadcode.ml
similarity index 100%
rename from compiler/lib/deadcode_dgraph.ml
rename to compiler/lib/global_deadcode.ml
diff --git a/compiler/lib/deadcode_dgraph.mli b/compiler/lib/global_deadcode.mli
similarity index 100%
rename from compiler/lib/deadcode_dgraph.mli
rename to compiler/lib/global_deadcode.mli

From c8c7c53350932db213daa8a686bedd2ccad0a52d Mon Sep 17 00:00:00 2001
From: Micah Cantor <micahcantor01@gmail.com>
Date: Sat, 16 Sep 2023 23:39:50 -0500
Subject: [PATCH 069/112] format

---
 compiler/lib/global_deadcode.ml | 47 ++++++++++++++++++---------------
 1 file changed, 25 insertions(+), 22 deletions(-)

diff --git a/compiler/lib/global_deadcode.ml b/compiler/lib/global_deadcode.ml
index 7eb8f8944c..3af5e1edf4 100644
--- a/compiler/lib/global_deadcode.ml
+++ b/compiler/lib/global_deadcode.ml
@@ -35,14 +35,14 @@ let times = Debug.find "times"
 
 (** Definition of a variable [x]. *)
 type def =
-  | Expr of expr (** [x] is defined by an expression. *)
-  | Param (** [x] is a block or closure parameter. *)
+  | Expr of expr  (** [x] is defined by an expression. *)
+  | Param  (** [x] is a block or closure parameter. *)
 
 (** Liveness of a variable [x], forming a lattice structure. *)
 type live =
-  | Top (** [x] is live and not a block. *)
-  | Live of IntSet.t (** [x] is a live block with a (non-empty) set of live fields. *)
-  | Dead (** [x] is dead. *)
+  | Top  (** [x] is live and not a block. *)
+  | Live of IntSet.t  (** [x] is a live block with a (non-empty) set of live fields. *)
+  | Dead  (** [x] is dead. *)
 
 module G = Dgraph.Make_Imperative (Var) (Var.ISet) (Var.Tbl)
 
@@ -85,16 +85,16 @@ let definitions nv prog =
         block.body)
     prog.blocks;
   defs
-  
+
 let variable_may_escape x (global_info : Global_flow.info) =
   match global_info.info_variable_may_escape.(Var.idx x) with
   | Escape | Escape_constant -> true
   | No -> false
 
-(** Type of variable usage. *)  
+(** Type of variable usage. *)
 type usage_kind =
-  | Compute (** variable y is used to compute x *)
-  | Propagate (** values of y propagate to x *)
+  | Compute  (** variable y is used to compute x *)
+  | Propagate  (** values of y propagate to x *)
 
 (** Compute the adjacency list for the dependency graph of given program. An edge between
     variables [x] and [y] is marked [Compute] if [x] is used in the definition of [y]. It is marked
@@ -136,7 +136,9 @@ let usages nv prog (global_info : Global_flow.info) : usage_kind Var.Map.t array
                 | _ -> ())
               known);
         add_use Compute x f;
-        List.iter ~f:(fun a -> if variable_may_escape a global_info then add_use Compute x a) args
+        List.iter
+          ~f:(fun a -> if variable_may_escape a global_info then add_use Compute x a)
+          args
     | Block (_, vars, _) -> Array.iter ~f:(add_use Compute x) vars
     | Field (z, _) -> add_use Compute x z
     | Constant _ -> ()
@@ -166,8 +168,7 @@ let usages nv prog (global_info : Global_flow.info) : usage_kind Var.Map.t array
       | Cond (_, cont1, cont2) ->
           add_cont_deps cont1;
           add_cont_deps cont2
-      | Switch (_, a) ->
-          Array.iter ~f:add_cont_deps a;
+      | Switch (_, a) -> Array.iter ~f:add_cont_deps a
       | Pushtrap (cont, _, cont_h, _) ->
           add_cont_deps cont;
           add_cont_deps cont_h
@@ -219,16 +220,19 @@ let liveness nv prog pure_funs (global_info : Global_flow.info) =
   in
   let live_instruction i =
     match i with
-    | Let (_x, e) ->
+    | Let (_x, e) -> (
         if not (pure_expr pure_funs e)
-        then (
+        then
           let vars = expr_vars e in
-          Var.ISet.iter add_top vars;)
-        else (match e with
-          | Apply { f; args; _} ->
+          Var.ISet.iter add_top vars
+        else
+          match e with
+          | Apply { f; args; _ } ->
               add_top f;
-              List.iter ~f:(fun x -> if variable_may_escape x global_info then add_top x) args
-          | _ -> ()) 
+              List.iter
+                ~f:(fun x -> if variable_may_escape x global_info then add_top x)
+                args
+          | _ -> ())
     | Assign (_, _) -> ()
     | Set_field (x, i, y) ->
         add_live x i;
@@ -263,7 +267,7 @@ let variables deps =
     that uses [x]. *)
 let propagate uses defs live_vars live_table x =
   let idx = Var.idx x in
-  (** Variable [y] uses [x] either in its definition ([Compute]) or as a closure/block parameter
+  (* Variable [y] uses [x] either in its definition ([Compute]) or as a closure/block parameter
       ([Propagate]). In the latter case, the contribution is simply the liveness of [y]. In the former,
        the contribution depends on the liveness of [y] and its definition. *)
   let contribution y usage_kind =
@@ -377,8 +381,7 @@ let zero prog sentinal live_table =
         | Raise (_, _) | Stop -> last
         | Branch cont -> Branch (zero_cont cont)
         | Cond (x, cont1, cont2) -> Cond (x, zero_cont cont1, zero_cont cont2)
-        | Switch (x, a) ->
-            Switch (x, Array.map ~f:zero_cont a)
+        | Switch (x, a) -> Switch (x, Array.map ~f:zero_cont a)
         | Pushtrap (cont1, x, cont2, pcs) ->
             Pushtrap (zero_cont cont1, x, zero_cont cont2, pcs)
         | Poptrap cont -> Poptrap (zero_cont cont)

From 4df539962d03ca39c01162184dbfcbe8c0d0fafd Mon Sep 17 00:00:00 2001
From: Micah Cantor <micahcantor01@gmail.com>
Date: Sat, 16 Sep 2023 23:40:24 -0500
Subject: [PATCH 070/112] Change expr_vars to use Var.Set

---
 compiler/lib/global_deadcode.ml | 30 ++++++++++++++++--------------
 1 file changed, 16 insertions(+), 14 deletions(-)

diff --git a/compiler/lib/global_deadcode.ml b/compiler/lib/global_deadcode.ml
index 3af5e1edf4..d79d6ae7b1 100644
--- a/compiler/lib/global_deadcode.ml
+++ b/compiler/lib/global_deadcode.ml
@@ -178,23 +178,25 @@ let usages nv prog (global_info : Global_flow.info) : usage_kind Var.Map.t array
 
 (** Return the set of variables used in a given expression *)
 let expr_vars e =
-  let vars = Var.ISet.empty () in
-  (match e with
+  let vars = Var.Set.empty in
+  match e with
   | Apply { f; args; _ } ->
-      Var.ISet.add vars f;
-      List.iter ~f:(Var.ISet.add vars) args
-  | Block (_, params, _) -> Array.iter ~f:(Var.ISet.add vars) params
-  | Field (z, _) -> Var.ISet.add vars z
-  | Constant _ -> ()
-  | Closure (params, _) -> List.iter ~f:(Var.ISet.add vars) params
+      let vars = Var.Set.add f vars in
+      List.fold_left ~f:(fun acc x -> Var.Set.add x acc) ~init:vars args
+  | Block (_, params, _) ->
+      Array.fold_left ~f:(fun acc x -> Var.Set.add x acc) ~init:vars params
+  | Field (z, _) -> Var.Set.add z vars
+  | Constant _ -> vars
+  | Closure (params, _) ->
+      List.fold_left ~f:(fun acc x -> Var.Set.add x acc) ~init:vars params
   | Prim (_, args) ->
-      List.iter
-        ~f:(fun v ->
+      List.fold_left
+        ~f:(fun acc v ->
           match v with
-          | Pv v -> Var.ISet.add vars v
-          | Pc _ -> ())
-        args);
-  vars
+          | Pv v -> Var.Set.add v vars
+          | Pc _ -> acc)
+        ~init:vars
+        args
 
 (** Compute the initial liveness of each variable in the program. 
 

From 075c6f34c5e4794524e23fa14f99f8fa0acd9f1f Mon Sep 17 00:00:00 2001
From: Micah Cantor <micahcantor01@gmail.com>
Date: Sat, 16 Sep 2023 23:48:03 -0500
Subject: [PATCH 071/112] fix live_instruction, remove zero cont, contribution
 case

---
 compiler/lib/global_deadcode.ml | 32 ++++++--------------------------
 1 file changed, 6 insertions(+), 26 deletions(-)

diff --git a/compiler/lib/global_deadcode.ml b/compiler/lib/global_deadcode.ml
index d79d6ae7b1..8e5708e978 100644
--- a/compiler/lib/global_deadcode.ml
+++ b/compiler/lib/global_deadcode.ml
@@ -222,12 +222,11 @@ let liveness nv prog pure_funs (global_info : Global_flow.info) =
   in
   let live_instruction i =
     match i with
-    | Let (_x, e) -> (
+    | Let (_x, e) ->
         if not (pure_expr pure_funs e)
-        then
+        then (
           let vars = expr_vars e in
-          Var.ISet.iter add_top vars
-        else
+          Var.Set.iter add_top vars;
           match e with
           | Apply { f; args; _ } ->
               add_top f;
@@ -235,6 +234,7 @@ let liveness nv prog pure_funs (global_info : Global_flow.info) =
                 ~f:(fun x -> if variable_may_escape x global_info then add_top x)
                 args
           | _ -> ())
+        else ()
     | Assign (_, _) -> ()
     | Set_field (x, i, y) ->
         add_live x i;
@@ -289,6 +289,7 @@ let propagate uses defs live_vars live_table x =
                     if Var.equal v x && IntSet.mem i fields then found := true)
                   vars;
                 if !found then Top else Dead
+            | Expr (Field (_, i)) -> Live (IntSet.singleton i)
             | _ -> Top)
         (* If y is top and y is a field access, x depends only on that field *)
         | Top -> (
@@ -334,25 +335,10 @@ let zero prog sentinal live_table =
     | _ -> true
   in
   let zero_var x = if is_live x then x else sentinal in
-  let zero_cont ((pc, args) : cont) =
-    match Addr.Map.find_opt pc prog.blocks with
-    | Some block ->
-        let args =
-          List.map2
-            ~f:(fun param arg -> if is_live param then arg else sentinal)
-            block.params
-            args
-        in
-        pc, args
-    | None -> pc, args
-  in
   let zero_instr instr =
     match instr with
     | Let (x, e) -> (
         match e with
-        | Closure (args, cont) ->
-            let cont = zero_cont cont in
-            Let (x, Closure (args, cont))
         | Block (start, vars, is_array) -> (
             match Var.Tbl.get live_table x with
             | Live fields ->
@@ -380,13 +366,7 @@ let zero prog sentinal live_table =
       let last =
         match last with
         | Return x -> Return (zero_var x)
-        | Raise (_, _) | Stop -> last
-        | Branch cont -> Branch (zero_cont cont)
-        | Cond (x, cont1, cont2) -> Cond (x, zero_cont cont1, zero_cont cont2)
-        | Switch (x, a) -> Switch (x, Array.map ~f:zero_cont a)
-        | Pushtrap (cont1, x, cont2, pcs) ->
-            Pushtrap (zero_cont cont1, x, zero_cont cont2, pcs)
-        | Poptrap cont -> Poptrap (zero_cont cont)
+        | _ -> last
       in
       last, loc
     in

From a343dc9a6d11d4ab4159f399980168b81aadc082 Mon Sep 17 00:00:00 2001
From: Micah Cantor <micahcantor01@gmail.com>
Date: Sat, 16 Sep 2023 23:53:50 -0500
Subject: [PATCH 072/112] re-organize redundant call

---
 compiler/lib/driver.ml | 28 +++++++++++++---------------
 1 file changed, 13 insertions(+), 15 deletions(-)

diff --git a/compiler/lib/driver.ml b/compiler/lib/driver.ml
index f87753c2ac..2b44cb0aea 100644
--- a/compiler/lib/driver.ml
+++ b/compiler/lib/driver.ml
@@ -104,21 +104,19 @@ let exact_calls profile p =
       | O3 -> false
       | O1 | O2 -> true
     in
-    if Config.Flag.globaldeadcode ()
-    then
-      let p, sentinal = Global_deadcode.add_sentinal p in
-      let info = Global_flow.f ~fast p in
-      let p = Global_deadcode.f p sentinal info in
-      let p =
-        Specialize.f ~function_arity:(fun f -> Global_flow.function_arity info f) p
-      in
-      p, Some sentinal
-    else
-      let info = Global_flow.f ~fast p in
-      let p =
-        Specialize.f ~function_arity:(fun f -> Global_flow.function_arity info f) p
-      in
-      p, None
+    let p, info, sentinal =
+      if Config.Flag.globaldeadcode ()
+      then
+        let p, sentinal = Global_deadcode.add_sentinal p in
+        let info = Global_flow.f ~fast p in
+        let p = Global_deadcode.f p sentinal info in
+        p, info, Some sentinal
+      else
+        let info = Global_flow.f ~fast p in
+        p, info, None
+    in
+    let p = Specialize.f ~function_arity:(fun f -> Global_flow.function_arity info f) p in
+    p, Some sentinal
   else p, None
 
 let print p =

From 3523cf5255adf23663866b8af2464cf0a59618fe Mon Sep 17 00:00:00 2001
From: Micah Cantor <micahcantor01@gmail.com>
Date: Sun, 17 Sep 2023 00:16:33 -0500
Subject: [PATCH 073/112] don't generate dead return exprs

---
 compiler/lib/generate.ml | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/compiler/lib/generate.ml b/compiler/lib/generate.ml
index ef49532f53..0b3ad9327f 100644
--- a/compiler/lib/generate.ml
+++ b/compiler/lib/generate.ml
@@ -1594,7 +1594,12 @@ and compile_conditional st queue ~fall_through last scope_stack : _ * _ =
     match last with
     | Return x ->
         let (_px, cx), queue = access_queue queue x in
-        true, flush_all queue [ J.Return_statement (Some cx), loc ]
+        let return_expr = 
+          match st.ctx.sentinal with
+            | Some sentinal when Var.equal sentinal x -> None
+            | _ -> Some cx
+        in
+        true, flush_all queue [ J.Return_statement return_expr, loc ]
     | Raise (x, k) ->
         let (_px, cx), queue = access_queue queue x in
         true, flush_all queue (throw_statement st.ctx cx k loc)

From adacd59ed8ddea9f149221c1174410b3ae5e0e1f Mon Sep 17 00:00:00 2001
From: Micah Cantor <micahcantor01@gmail.com>
Date: Sun, 17 Sep 2023 00:16:39 -0500
Subject: [PATCH 074/112] fix type error

---
 compiler/lib/driver.ml | 7 ++-----
 1 file changed, 2 insertions(+), 5 deletions(-)

diff --git a/compiler/lib/driver.ml b/compiler/lib/driver.ml
index 2b44cb0aea..62d47b86b2 100644
--- a/compiler/lib/driver.ml
+++ b/compiler/lib/driver.ml
@@ -116,7 +116,7 @@ let exact_calls profile p =
         p, info, None
     in
     let p = Specialize.f ~function_arity:(fun f -> Global_flow.function_arity info f) p in
-    p, Some sentinal
+    p, sentinal
   else p, None
 
 let print p =
@@ -607,10 +607,7 @@ let full ~standalone ~wrap_with_fun ~profile ~linkall ~source_map formatter d p
   in
   if times () then Format.eprintf "Start Optimizing...@.";
   let t = Timer.make () in
-  let r : (Code.program * Deadcode.variable_uses) * Effects.cps_calls * Code.Var.t option
-      =
-    opt p
-  in
+  let r = opt p in
   let () = if times () then Format.eprintf " optimizations : %a@." Timer.print t in
   emit r
 

From 3d656ebe8d64f36499aea178dbc7d876aa5c62fd Mon Sep 17 00:00:00 2001
From: Micah Cantor <micahcantor01@gmail.com>
Date: Sun, 17 Sep 2023 00:23:33 -0500
Subject: [PATCH 075/112] refactor array compact

---
 compiler/lib/global_deadcode.ml | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/compiler/lib/global_deadcode.ml b/compiler/lib/global_deadcode.ml
index 8e5708e978..e9e55085f5 100644
--- a/compiler/lib/global_deadcode.ml
+++ b/compiler/lib/global_deadcode.ml
@@ -325,9 +325,7 @@ let zero prog sentinal live_table =
     while !i >= 0 && Var.equal vars.(!i) sentinal do
       i := !i - 1
     done;
-    let compacted = Array.make (!i + 1) sentinal in
-    Array.blit ~src:vars ~src_pos:0 ~dst:compacted ~dst_pos:0 ~len:(!i + 1);
-    compacted
+    Array.sub vars ~pos:0 ~len:(!i + 1)
   in
   let is_live v =
     match Var.Tbl.get live_table v with

From 58640303562f2f6680fdbaa0fe3f70c0ef5bd1e9 Mon Sep 17 00:00:00 2001
From: Micah Cantor <micahcantor01@gmail.com>
Date: Sun, 17 Sep 2023 10:17:56 -0500
Subject: [PATCH 076/112] move debug info before zeroing

---
 compiler/lib/global_deadcode.ml | 17 +++++++++--------
 1 file changed, 9 insertions(+), 8 deletions(-)

diff --git a/compiler/lib/global_deadcode.ml b/compiler/lib/global_deadcode.ml
index e9e55085f5..f6d98daa81 100644
--- a/compiler/lib/global_deadcode.ml
+++ b/compiler/lib/global_deadcode.ml
@@ -430,15 +430,16 @@ let f p sentinal global_info =
   (* Propagate liveness to dependencies *)
   let vars = variables uses in
   let live_table = solver vars uses defs live_vars in
+  (* Print debug info *)
+  if debug ()
+    then (
+      Code.Print.program (fun _ _ -> "") p;
+      Print.print_liveness live_vars;
+      Print.print_uses uses;
+      Print.print_live_tbl live_table;
+      Format.eprintf "After Elimination:\n";
+      Code.Print.program (fun _ _ -> "") p);
   (* Zero out dead fields *)
   let p = zero p sentinal live_table in
-  if debug ()
-  then (
-    Code.Print.program (fun _ _ -> "") p;
-    Print.print_liveness live_vars;
-    Print.print_uses uses;
-    Print.print_live_tbl live_table;
-    Format.eprintf "After Elimination:\n";
-    Code.Print.program (fun _ _ -> "") p);
   if times () then Format.eprintf "  deadcode dgraph.: %a@." Timer.print t;
   p

From 8e9f0c243b5dfbc727284260c76ddba6d34a553b Mon Sep 17 00:00:00 2001
From: Micah Cantor <micahcantor01@gmail.com>
Date: Sun, 17 Sep 2023 10:24:19 -0500
Subject: [PATCH 077/112] more descriptive sentinal name

---
 compiler/lib/driver.ml    | 22 +++++++++++-----------
 compiler/lib/generate.ml  | 14 +++++++-------
 compiler/lib/generate.mli |  2 +-
 3 files changed, 19 insertions(+), 19 deletions(-)

diff --git a/compiler/lib/driver.ml b/compiler/lib/driver.ml
index 62d47b86b2..f5b0d5003c 100644
--- a/compiler/lib/driver.ml
+++ b/compiler/lib/driver.ml
@@ -104,19 +104,19 @@ let exact_calls profile p =
       | O3 -> false
       | O1 | O2 -> true
     in
-    let p, info, sentinal =
+    let p, info, deadcode_sentinal =
       if Config.Flag.globaldeadcode ()
       then
-        let p, sentinal = Global_deadcode.add_sentinal p in
+        let p, deadcode_sentinal = Global_deadcode.add_sentinal p in
         let info = Global_flow.f ~fast p in
-        let p = Global_deadcode.f p sentinal info in
-        p, info, Some sentinal
+        let p = Global_deadcode.f p deadcode_sentinal info in
+        p, info, Some deadcode_sentinal
       else
         let info = Global_flow.f ~fast p in
         p, info, None
     in
     let p = Specialize.f ~function_arity:(fun f -> Global_flow.function_arity info f) p in
-    p, sentinal
+    p, deadcode_sentinal
   else p, None
 
 let print p =
@@ -186,7 +186,7 @@ let generate
     ~exported_runtime
     ~wrap_with_fun
     ~warn_on_unhandled_effect
-    ((p, live_vars), cps_calls, sentinal) =
+    ((p, live_vars), cps_calls, deadcode_sentinal) =
   if times () then Format.eprintf "Start Generation...@.";
   let should_export = should_export wrap_with_fun in
   Generate.f
@@ -196,7 +196,7 @@ let generate
     ~cps_calls
     ~should_export
     ~warn_on_unhandled_effect
-    ~sentinal
+    ~deadcode_sentinal
     d
 
 let debug_linker = Debug.find "linker"
@@ -591,11 +591,11 @@ let full ~standalone ~wrap_with_fun ~profile ~linkall ~source_map formatter d p
        | O2 -> o2
        | O3 -> o3)
     +> exact_calls profile
-    +> (fun (p, sentinal) ->
+    +> (fun (p, deadcode_sentinal) ->
          let p, cps_calls = effects p in
-         p, cps_calls, sentinal)
-    +> fun (p, cps_calls, sentinal) ->
-    deadcode' (Generate_closure.f p), cps_calls, sentinal
+         p, cps_calls, deadcode_sentinal)
+    +> fun (p, cps_calls, deadcode_sentinal) ->
+    deadcode' (Generate_closure.f p), cps_calls, deadcode_sentinal
   in
   let emit =
     generate d ~exported_runtime ~wrap_with_fun ~warn_on_unhandled_effect:standalone
diff --git a/compiler/lib/generate.ml b/compiler/lib/generate.ml
index 0b3ad9327f..493721acef 100644
--- a/compiler/lib/generate.ml
+++ b/compiler/lib/generate.ml
@@ -285,14 +285,14 @@ module Ctx = struct
     ; should_export : bool
     ; effect_warning : bool ref
     ; cps_calls : Effects.cps_calls
-    ; sentinal : Var.t option
+    ; deadcode_sentinal : Var.t option
     }
 
   let initial
       ~warn_on_unhandled_effect
       ~exported_runtime
       ~should_export
-      ~sentinal
+      ~deadcode_sentinal
       blocks
       live
       cps_calls
@@ -306,7 +306,7 @@ module Ctx = struct
     ; should_export
     ; effect_warning = ref (not warn_on_unhandled_effect)
     ; cps_calls
-    ; sentinal
+    ; deadcode_sentinal
     }
 end
 
@@ -1041,7 +1041,7 @@ let rec translate_expr ctx queue loc x e level : _ * J.statement_list =
             let cx =
               match cx with
               | J.EVar (J.V v) -> (
-                  match ctx.sentinal with
+                  match ctx.deadcode_sentinal with
                   | Some s -> if Var.equal v s then J.ElementHole else J.Element cx
                   | None -> J.Element cx)
               | _ -> J.Element cx
@@ -1595,7 +1595,7 @@ and compile_conditional st queue ~fall_through last scope_stack : _ * _ =
     | Return x ->
         let (_px, cx), queue = access_queue queue x in
         let return_expr = 
-          match st.ctx.sentinal with
+          match st.ctx.deadcode_sentinal with
             | Some sentinal when Var.equal sentinal x -> None
             | _ -> Some cx
         in
@@ -1808,7 +1808,7 @@ let f
     ~cps_calls
     ~should_export
     ~warn_on_unhandled_effect
-    ~sentinal
+    ~deadcode_sentinal
     debug =
   let t' = Timer.make () in
   let share = Share.get ~cps_calls ~alias_prims:exported_runtime p in
@@ -1820,7 +1820,7 @@ let f
       ~warn_on_unhandled_effect
       ~exported_runtime
       ~should_export
-      ~sentinal
+      ~deadcode_sentinal
       p.blocks
       live_vars
       cps_calls
diff --git a/compiler/lib/generate.mli b/compiler/lib/generate.mli
index ddb4854644..6a0df32259 100644
--- a/compiler/lib/generate.mli
+++ b/compiler/lib/generate.mli
@@ -25,7 +25,7 @@ val f :
   -> cps_calls:Effects.cps_calls
   -> should_export:bool
   -> warn_on_unhandled_effect:bool
-  -> sentinal:Code.Var.t option
+  -> deadcode_sentinal:Code.Var.t option
   -> Parse_bytecode.Debug.t
   -> Javascript.program
 

From 266221e88f53338cc07a5b0f013163978c6b1b62 Mon Sep 17 00:00:00 2001
From: Micah Cantor <micahcantor01@gmail.com>
Date: Sun, 17 Sep 2023 10:50:15 -0500
Subject: [PATCH 078/112] add omit return value test

---
 compiler/tests-compiler/global_deadcode.ml | 20 +++++++++++++++++++-
 1 file changed, 19 insertions(+), 1 deletion(-)

diff --git a/compiler/tests-compiler/global_deadcode.ml b/compiler/tests-compiler/global_deadcode.ml
index 3606f717ce..211f9bea2f 100644
--- a/compiler/tests-compiler/global_deadcode.ml
+++ b/compiler/tests-compiler/global_deadcode.ml
@@ -69,4 +69,22 @@ let%expect_test "Omit unused fields" =
      var t = b ? [0, 1, , x] : [0, 3, , 4], v = t[3], u = t[1];
      return [0, u, v];
     }
-    //end |}];
\ No newline at end of file
+    //end |}]
+
+let%expect_test "Omit unused return expressions" =
+  let program =
+    compile_and_parse
+    ~flags:["--enable"; "globaldeadcode"]
+      {|
+      let f x =
+        print_int x; 
+        x + 1
+      in 
+      ignore (f 5 + f 6)
+      |}
+  in 
+  (* Expect return value of f to be omitted. *)
+  print_fun_decl program (Some "f");
+  [%expect "
+    function f(x){caml_call1(Stdlib[44], x); return;}
+    //end"];
\ No newline at end of file

From 9ab2476a25d2fe8c055af90c57ef0b0a753e9270 Mon Sep 17 00:00:00 2001
From: Micah Cantor <micahcantor01@gmail.com>
Date: Wed, 20 Sep 2023 14:21:49 -0500
Subject: [PATCH 079/112] refactor driver final deadcode call

---
 compiler/lib/driver.ml | 8 ++------
 1 file changed, 2 insertions(+), 6 deletions(-)

diff --git a/compiler/lib/driver.ml b/compiler/lib/driver.ml
index f5b0d5003c..1b0bad697d 100644
--- a/compiler/lib/driver.ml
+++ b/compiler/lib/driver.ml
@@ -186,7 +186,7 @@ let generate
     ~exported_runtime
     ~wrap_with_fun
     ~warn_on_unhandled_effect
-    ((p, live_vars), cps_calls, deadcode_sentinal) =
+    (((p, live_vars), cps_calls), deadcode_sentinal)  =
   if times () then Format.eprintf "Start Generation...@.";
   let should_export = should_export wrap_with_fun in
   Generate.f
@@ -591,11 +591,7 @@ let full ~standalone ~wrap_with_fun ~profile ~linkall ~source_map formatter d p
        | O2 -> o2
        | O3 -> o3)
     +> exact_calls profile
-    +> (fun (p, deadcode_sentinal) ->
-         let p, cps_calls = effects p in
-         p, cps_calls, deadcode_sentinal)
-    +> fun (p, cps_calls, deadcode_sentinal) ->
-    deadcode' (Generate_closure.f p), cps_calls, deadcode_sentinal
+    +> map_fst (effects +> map_fst (Generate_closure.f +> deadcode'))
   in
   let emit =
     generate d ~exported_runtime ~wrap_with_fun ~warn_on_unhandled_effect:standalone

From d44390fe2292f06d49313425d689f3b4fae41f54 Mon Sep 17 00:00:00 2001
From: Micah Cantor <micahcantor01@gmail.com>
Date: Mon, 2 Oct 2023 15:38:28 -0500
Subject: [PATCH 080/112] rearrange debug output

---
 compiler/lib/global_deadcode.ml | 17 ++++++++++-------
 1 file changed, 10 insertions(+), 7 deletions(-)

diff --git a/compiler/lib/global_deadcode.ml b/compiler/lib/global_deadcode.ml
index f6d98daa81..80be156174 100644
--- a/compiler/lib/global_deadcode.ml
+++ b/compiler/lib/global_deadcode.ml
@@ -432,14 +432,17 @@ let f p sentinal global_info =
   let live_table = solver vars uses defs live_vars in
   (* Print debug info *)
   if debug ()
-    then (
-      Code.Print.program (fun _ _ -> "") p;
-      Print.print_liveness live_vars;
-      Print.print_uses uses;
-      Print.print_live_tbl live_table;
-      Format.eprintf "After Elimination:\n";
-      Code.Print.program (fun _ _ -> "") p);
+  then (
+    Format.eprintf "Before Zeroing:\n";
+    Code.Print.program (fun _ _ -> "") p;
+    Print.print_liveness live_vars;
+    Print.print_uses uses;
+    Print.print_live_tbl live_table);
   (* Zero out dead fields *)
   let p = zero p sentinal live_table in
+  if debug ()
+  then (
+    Format.printf "After Zeroing:\n";
+    Code.Print.program (fun _ _ -> "") p);
   if times () then Format.eprintf "  deadcode dgraph.: %a@." Timer.print t;
   p

From 238b5dee9c01120a4d1a55e821efe6d57fda51b6 Mon Sep 17 00:00:00 2001
From: Micah Cantor <micahcantor01@gmail.com>
Date: Mon, 2 Oct 2023 15:42:03 -0500
Subject: [PATCH 081/112] remove clojure parameters from expr_vars

---
 compiler/lib/global_deadcode.ml   |     4 +-
 compiler/tests-full/stdlib.cma.js | 34020 ++++++++++++++++++++++++++++
 testing/dead_field.js             |    29 +
 3 files changed, 34050 insertions(+), 3 deletions(-)
 create mode 100644 compiler/tests-full/stdlib.cma.js
 create mode 100644 testing/dead_field.js

diff --git a/compiler/lib/global_deadcode.ml b/compiler/lib/global_deadcode.ml
index 80be156174..f40a3981c5 100644
--- a/compiler/lib/global_deadcode.ml
+++ b/compiler/lib/global_deadcode.ml
@@ -186,9 +186,6 @@ let expr_vars e =
   | Block (_, params, _) ->
       Array.fold_left ~f:(fun acc x -> Var.Set.add x acc) ~init:vars params
   | Field (z, _) -> Var.Set.add z vars
-  | Constant _ -> vars
-  | Closure (params, _) ->
-      List.fold_left ~f:(fun acc x -> Var.Set.add x acc) ~init:vars params
   | Prim (_, args) ->
       List.fold_left
         ~f:(fun acc v ->
@@ -197,6 +194,7 @@ let expr_vars e =
           | Pc _ -> acc)
         ~init:vars
         args
+  | Constant _ | Closure (_, _) -> vars
 
 (** Compute the initial liveness of each variable in the program. 
 
diff --git a/compiler/tests-full/stdlib.cma.js b/compiler/tests-full/stdlib.cma.js
new file mode 100644
index 0000000000..e3d09981e8
--- /dev/null
+++ b/compiler/tests-full/stdlib.cma.js
@@ -0,0 +1,34020 @@
+// Generated by js_of_ocaml
+//# buildInfo:effects=false, kind=cma, use-js-string=true, version=5.4.0+git-5.3.0-128-g266221e88f-dirty
+
+//# unitInfo: Provides: CamlinternalFormatBasics
+(function
+  (globalThis){
+   "use strict";
+   var runtime = globalThis.jsoo_runtime;
+   function erase_rel(param){
+     /*<<camlinternalFormatBasics.ml:528:8>>*/ if(typeof param === "number")
+      /*<<camlinternalFormatBasics.ml:562:20>>*/ return 0;
+    switch(param[0]){
+      case 0:
+       var rest = param[1];
+        /*<<camlinternalFormatBasics.ml:533:4>>*/ return [0, erase_rel(rest)];
+      case 1:
+       var rest$0 = param[1];
+        /*<<camlinternalFormatBasics.ml:535:4>>*/ return [1,
+               erase_rel(rest$0)];
+      case 2:
+       var rest$1 = param[1];
+        /*<<camlinternalFormatBasics.ml:537:4>>*/ return [2,
+               erase_rel(rest$1)];
+      case 3:
+       var rest$2 = param[1];
+        /*<<camlinternalFormatBasics.ml:539:4>>*/ return [3,
+               erase_rel(rest$2)];
+      case 4:
+       var rest$3 = param[1];
+        /*<<camlinternalFormatBasics.ml:543:4>>*/ return [4,
+               erase_rel(rest$3)];
+      case 5:
+       var rest$4 = param[1];
+        /*<<camlinternalFormatBasics.ml:541:4>>*/ return [5,
+               erase_rel(rest$4)];
+      case 6:
+       var rest$5 = param[1];
+        /*<<camlinternalFormatBasics.ml:545:4>>*/ return [6,
+               erase_rel(rest$5)];
+      case 7:
+       var rest$6 = param[1];
+        /*<<camlinternalFormatBasics.ml:547:4>>*/ return [7,
+               erase_rel(rest$6)];
+      case 8:
+       var rest$7 = param[2], ty = param[1];
+        /*<<camlinternalFormatBasics.ml:549:4>>*/ return [8,
+               ty,
+               erase_rel(rest$7)];
+      case 9:
+       var rest$8 = param[3], ty1 = param[1];
+        /*<<camlinternalFormatBasics.ml:551:4>>*/ return [9,
+               ty1,
+               ty1,
+               erase_rel(rest$8)];
+      case 10:
+       var rest$9 = param[1];
+        /*<<camlinternalFormatBasics.ml:553:4>>*/ return [10,
+               erase_rel(rest$9)];
+      case 11:
+       var rest$10 = param[1];
+        /*<<camlinternalFormatBasics.ml:555:4>>*/ return [11,
+               erase_rel(rest$10)];
+      case 12:
+       var rest$11 = param[1];
+        /*<<camlinternalFormatBasics.ml:557:4>>*/ return [12,
+               erase_rel(rest$11)];
+      case 13:
+       var rest$12 = param[1];
+        /*<<camlinternalFormatBasics.ml:559:4>>*/ return [13,
+               erase_rel(rest$12)];
+      default:
+       var rest$13 = param[1];
+        /*<<camlinternalFormatBasics.ml:561:4>>*/ return [14,
+               erase_rel(rest$13)];
+    }
+    /*<<camlinternalFormatBasics.ml:562:32>>*/ }
+   function concat_fmtty(fmtty1, fmtty2){
+     /*<<camlinternalFormatBasics.ml:590:21>>*/ if(typeof fmtty1 === "number")
+      /*<<camlinternalFormatBasics.ml:621:20>>*/ return fmtty2;
+    switch(fmtty1[0]){
+      case 0:
+       var rest = fmtty1[1];
+        /*<<camlinternalFormatBasics.ml:592:4>>*/ return [0,
+               concat_fmtty(rest, fmtty2)];
+      case 1:
+       var rest$0 = fmtty1[1];
+        /*<<camlinternalFormatBasics.ml:594:4>>*/ return [1,
+               concat_fmtty(rest$0, fmtty2)];
+      case 2:
+       var rest$1 = fmtty1[1];
+        /*<<camlinternalFormatBasics.ml:596:4>>*/ return [2,
+               concat_fmtty(rest$1, fmtty2)];
+      case 3:
+       var rest$2 = fmtty1[1];
+        /*<<camlinternalFormatBasics.ml:598:4>>*/ return [3,
+               concat_fmtty(rest$2, fmtty2)];
+      case 4:
+       var rest$3 = fmtty1[1];
+        /*<<camlinternalFormatBasics.ml:600:4>>*/ return [4,
+               concat_fmtty(rest$3, fmtty2)];
+      case 5:
+       var rest$4 = fmtty1[1];
+        /*<<camlinternalFormatBasics.ml:602:4>>*/ return [5,
+               concat_fmtty(rest$4, fmtty2)];
+      case 6:
+       var rest$5 = fmtty1[1];
+        /*<<camlinternalFormatBasics.ml:604:4>>*/ return [6,
+               concat_fmtty(rest$5, fmtty2)];
+      case 7:
+       var rest$6 = fmtty1[1];
+        /*<<camlinternalFormatBasics.ml:606:4>>*/ return [7,
+               concat_fmtty(rest$6, fmtty2)];
+      case 8:
+       var rest$7 = fmtty1[2], ty = fmtty1[1];
+        /*<<camlinternalFormatBasics.ml:618:4>>*/ return [8,
+               ty,
+               concat_fmtty(rest$7, fmtty2)];
+      case 9:
+       var rest$8 = fmtty1[3], ty2 = fmtty1[2], ty1 = fmtty1[1];
+        /*<<camlinternalFormatBasics.ml:620:4>>*/ return [9,
+               ty1,
+               ty2,
+               concat_fmtty(rest$8, fmtty2)];
+      case 10:
+       var rest$9 = fmtty1[1];
+        /*<<camlinternalFormatBasics.ml:608:4>>*/ return [10,
+               concat_fmtty(rest$9, fmtty2)];
+      case 11:
+       var rest$10 = fmtty1[1];
+        /*<<camlinternalFormatBasics.ml:610:4>>*/ return [11,
+               concat_fmtty(rest$10, fmtty2)];
+      case 12:
+       var rest$11 = fmtty1[1];
+        /*<<camlinternalFormatBasics.ml:612:4>>*/ return [12,
+               concat_fmtty(rest$11, fmtty2)];
+      case 13:
+       var rest$12 = fmtty1[1];
+        /*<<camlinternalFormatBasics.ml:614:4>>*/ return [13,
+               concat_fmtty(rest$12, fmtty2)];
+      default:
+       var rest$13 = fmtty1[1];
+        /*<<camlinternalFormatBasics.ml:616:4>>*/ return [14,
+               concat_fmtty(rest$13, fmtty2)];
+    }
+    /*<<camlinternalFormatBasics.ml:621:26>>*/ }
+   function concat_fmt(fmt1, fmt2){
+     /*<<camlinternalFormatBasics.ml:631:17>>*/ if(typeof fmt1 === "number")
+      /*<<camlinternalFormatBasics.ml:690:4>>*/ return fmt2;
+    switch(fmt1[0]){
+      case 0:
+       var rest = fmt1[1];
+        /*<<camlinternalFormatBasics.ml:649:4>>*/ return [0,
+               concat_fmt(rest, fmt2)];
+      case 1:
+       var rest$0 = fmt1[1];
+        /*<<camlinternalFormatBasics.ml:651:4>>*/ return [1,
+               concat_fmt(rest$0, fmt2)];
+      case 2:
+       var rest$1 = fmt1[2], pad = fmt1[1];
+        /*<<camlinternalFormatBasics.ml:633:4>>*/ return [2,
+               pad,
+               concat_fmt(rest$1, fmt2)];
+      case 3:
+       var rest$2 = fmt1[2], pad$0 = fmt1[1];
+        /*<<camlinternalFormatBasics.ml:635:4>>*/ return [3,
+               pad$0,
+               concat_fmt(rest$2, fmt2)];
+      case 4:
+       var rest$3 = fmt1[4], prec = fmt1[3], pad$1 = fmt1[2], iconv = fmt1[1];
+        /*<<camlinternalFormatBasics.ml:638:4>>*/ return [4,
+               iconv,
+               pad$1,
+               prec,
+               concat_fmt(rest$3, fmt2)];
+      case 5:
+       var
+        rest$4 = fmt1[4],
+        prec$0 = fmt1[3],
+        pad$2 = fmt1[2],
+        iconv$0 = fmt1[1];
+        /*<<camlinternalFormatBasics.ml:640:4>>*/ return [5,
+               iconv$0,
+               pad$2,
+               prec$0,
+               concat_fmt(rest$4, fmt2)];
+      case 6:
+       var
+        rest$5 = fmt1[4],
+        prec$1 = fmt1[3],
+        pad$3 = fmt1[2],
+        iconv$1 = fmt1[1];
+        /*<<camlinternalFormatBasics.ml:642:4>>*/ return [6,
+               iconv$1,
+               pad$3,
+               prec$1,
+               concat_fmt(rest$5, fmt2)];
+      case 7:
+       var
+        rest$6 = fmt1[4],
+        prec$2 = fmt1[3],
+        pad$4 = fmt1[2],
+        iconv$2 = fmt1[1];
+        /*<<camlinternalFormatBasics.ml:644:4>>*/ return [7,
+               iconv$2,
+               pad$4,
+               prec$2,
+               concat_fmt(rest$6, fmt2)];
+      case 8:
+       var
+        rest$7 = fmt1[4],
+        prec$3 = fmt1[3],
+        pad$5 = fmt1[2],
+        fconv = fmt1[1];
+        /*<<camlinternalFormatBasics.ml:646:4>>*/ return [8,
+               fconv,
+               pad$5,
+               prec$3,
+               concat_fmt(rest$7, fmt2)];
+      case 9:
+       var rest$8 = fmt1[2], pad$6 = fmt1[1];
+        /*<<camlinternalFormatBasics.ml:653:4>>*/ return [9,
+               pad$6,
+               concat_fmt(rest$8, fmt2)];
+      case 10:
+       var rest$9 = fmt1[1];
+        /*<<camlinternalFormatBasics.ml:663:4>>*/ return [10,
+               concat_fmt(rest$9, fmt2)];
+      case 11:
+       var rest$10 = fmt1[2], str = fmt1[1];
+        /*<<camlinternalFormatBasics.ml:666:4>>*/ return [11,
+               str,
+               concat_fmt(rest$10, fmt2)];
+      case 12:
+       var rest$11 = fmt1[2], chr = fmt1[1];
+        /*<<camlinternalFormatBasics.ml:668:4>>*/ return [12,
+               chr,
+               concat_fmt(rest$11, fmt2)];
+      case 13:
+       var rest$12 = fmt1[3], fmtty = fmt1[2], pad$7 = fmt1[1];
+        /*<<camlinternalFormatBasics.ml:671:4>>*/ return [13,
+               pad$7,
+               fmtty,
+               concat_fmt(rest$12, fmt2)];
+      case 14:
+       var rest$13 = fmt1[3], fmtty$0 = fmt1[2], pad$8 = fmt1[1];
+        /*<<camlinternalFormatBasics.ml:673:4>>*/ return [14,
+               pad$8,
+               fmtty$0,
+               concat_fmt(rest$13, fmt2)];
+      case 15:
+       var rest$14 = fmt1[1];
+        /*<<camlinternalFormatBasics.ml:655:4>>*/ return [15,
+               concat_fmt(rest$14, fmt2)];
+      case 16:
+       var rest$15 = fmt1[1];
+        /*<<camlinternalFormatBasics.ml:657:4>>*/ return [16,
+               concat_fmt(rest$15, fmt2)];
+      case 17:
+       var rest$16 = fmt1[2], fmting_lit = fmt1[1];
+        /*<<camlinternalFormatBasics.ml:685:4>>*/ return [17,
+               fmting_lit,
+               concat_fmt(rest$16, fmt2)];
+      case 18:
+       var rest$17 = fmt1[2], fmting_gen = fmt1[1];
+        /*<<camlinternalFormatBasics.ml:687:4>>*/ return [18,
+               fmting_gen,
+               concat_fmt(rest$17, fmt2)];
+      case 19:
+       var rest$18 = fmt1[1];
+        /*<<camlinternalFormatBasics.ml:661:4>>*/ return [19,
+               concat_fmt(rest$18, fmt2)];
+      case 20:
+       var rest$19 = fmt1[3], char_set = fmt1[2], width_opt = fmt1[1];
+        /*<<camlinternalFormatBasics.ml:676:4>>*/ return [20,
+               width_opt,
+               char_set,
+               concat_fmt(rest$19, fmt2)];
+      case 21:
+       var rest$20 = fmt1[2], counter = fmt1[1];
+        /*<<camlinternalFormatBasics.ml:678:4>>*/ return [21,
+               counter,
+               concat_fmt(rest$20, fmt2)];
+      case 22:
+       var rest$21 = fmt1[1];
+        /*<<camlinternalFormatBasics.ml:680:4>>*/ return [22,
+               concat_fmt(rest$21, fmt2)];
+      case 23:
+       var rest$22 = fmt1[2], ign = fmt1[1];
+        /*<<camlinternalFormatBasics.ml:682:4>>*/ return [23,
+               ign,
+               concat_fmt(rest$22, fmt2)];
+      default:
+       var rest$23 = fmt1[3], f = fmt1[2], arity = fmt1[1];
+        /*<<camlinternalFormatBasics.ml:659:4>>*/ return [24,
+               arity,
+               f,
+               concat_fmt(rest$23, fmt2)];
+    }
+    /*<<camlinternalFormatBasics.ml:690:8>>*/ }
+   var CamlinternalFormatBasics = [0, concat_fmtty, erase_rel, concat_fmt];
+   runtime.caml_register_global
+    (0, CamlinternalFormatBasics, "CamlinternalFormatBasics");
+   return;
+   /*<<?>>*/ }
+  (globalThis));
+
+//# unitInfo: Provides: Stdlib
+//# unitInfo: Requires: Assert_failure, CamlinternalFormatBasics, Division_by_zero, End_of_file, Failure, Invalid_argument, Match_failure, Not_found, Out_of_memory, Stack_overflow, Sys_blocked_io, Sys_error, Undefined_recursive_module
+(function
+  (globalThis){
+   "use strict";
+   var
+    runtime = globalThis.jsoo_runtime,
+    cst_false$0 = "false",
+    cst_true$0 = "true",
+    caml_atomic_cas = runtime.caml_atomic_cas,
+    caml_atomic_load = runtime.caml_atomic_load,
+    caml_blit_string = runtime.caml_blit_string,
+    caml_create_bytes = runtime.caml_create_bytes,
+    caml_float_of_string = runtime.caml_float_of_string,
+    caml_int64_float_of_bits = runtime.caml_int64_float_of_bits,
+    caml_int_of_string = runtime.caml_int_of_string,
+    caml_maybe_attach_backtrace = runtime.caml_maybe_attach_backtrace,
+    caml_ml_bytes_length = runtime.caml_ml_bytes_length,
+    caml_ml_channel_size = runtime.caml_ml_channel_size,
+    caml_ml_channel_size_64 = runtime.caml_ml_channel_size_64,
+    caml_ml_close_channel = runtime.caml_ml_close_channel,
+    caml_ml_flush = runtime.caml_ml_flush,
+    caml_ml_input = runtime.caml_ml_input,
+    caml_ml_input_char = runtime.caml_ml_input_char,
+    caml_ml_open_descriptor_in = runtime.caml_ml_open_descriptor_in,
+    caml_ml_open_descriptor_out = runtime.caml_ml_open_descriptor_out,
+    caml_ml_output = runtime.caml_ml_output,
+    caml_ml_output_bytes = runtime.caml_ml_output_bytes,
+    caml_ml_output_char = runtime.caml_ml_output_char,
+    caml_ml_set_binary_mode = runtime.caml_ml_set_binary_mode,
+    caml_ml_set_channel_name = runtime.caml_ml_set_channel_name,
+    caml_ml_string_length = runtime.caml_ml_string_length,
+    caml_string_notequal = runtime.caml_string_notequal,
+    caml_string_of_bytes = runtime.caml_string_of_bytes,
+    caml_sys_open = runtime.caml_sys_open,
+    caml_wrap_exception = runtime.caml_wrap_exception;
+    /*<<?>>*/ function caml_call1(f, a0){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 1
+            ? f(a0)
+            : runtime.caml_call_gen(f, [a0]);
+   }
+    /*<<?>>*/ function caml_call2(f, a0, a1){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 2
+            ? f(a0, a1)
+            : runtime.caml_call_gen(f, [a0, a1]);
+   }
+   var
+    global_data = runtime.caml_get_global_data(),
+    cst$0 = "%,",
+    cst = ".",
+    CamlinternalFormatBasics = global_data.CamlinternalFormatBasics,
+    Invalid_argument = global_data.Invalid_argument,
+    Failure = global_data.Failure,
+    Match_failure = global_data.Match_failure,
+    Assert_failure = global_data.Assert_failure,
+    Not_found = global_data.Not_found,
+    Out_of_memory = global_data.Out_of_memory,
+    Stack_overflow = global_data.Stack_overflow,
+    Sys_error = global_data.Sys_error,
+    End_of_file = global_data.End_of_file,
+    Division_by_zero = global_data.Division_by_zero,
+    Sys_blocked_io = global_data.Sys_blocked_io,
+    Undefined_recursive_module = global_data.Undefined_recursive_module,
+    cst_really_input = "really_input",
+    cst_input = "input",
+    _l_ = [0, 0, [0, 6, 0]],
+    _k_ = [0, 0, [0, 7, 0]],
+    cst_output_substring = "output_substring",
+    cst_output = "output",
+    _j_ = [0, 1, [0, 3, [0, 4, [0, 6, 0]]]],
+    _i_ = [0, 1, [0, 3, [0, 4, [0, 7, 0]]]],
+    _g_ = [0, 1],
+    _h_ = [0, 0],
+    cst_bool_of_string = "bool_of_string",
+    cst_true = cst_true$0,
+    cst_false = cst_false$0,
+    cst_char_of_int = "char_of_int",
+    cst_Stdlib_Exit = "Stdlib.Exit",
+    _a_ = runtime.caml_int64_create_lo_mi_hi(0, 0, 32752),
+    _b_ = runtime.caml_int64_create_lo_mi_hi(0, 0, 65520),
+    _c_ = runtime.caml_int64_create_lo_mi_hi(1, 0, 32752),
+    _d_ = runtime.caml_int64_create_lo_mi_hi(16777215, 16777215, 32751),
+    _e_ = runtime.caml_int64_create_lo_mi_hi(0, 0, 16),
+    _f_ = runtime.caml_int64_create_lo_mi_hi(0, 0, 15536);
+   function failwith(s){
+     /*<<stdlib.ml:29:17>>*/ throw  /*<<stdlib.ml:29:17>>*/ caml_maybe_attach_backtrace
+           ([0, Failure, s], 1);
+    /*<<stdlib.ml:29:33>>*/ }
+   function invalid_arg(s){
+     /*<<stdlib.ml:30:20>>*/ throw  /*<<stdlib.ml:30:20>>*/ caml_maybe_attach_backtrace
+           ([0, Invalid_argument, s], 1);
+    /*<<stdlib.ml:30:45>>*/ }
+    /*<<stdlib.ml:32:0>>*/  /*<<stdlib.ml:32:0>>*/ var
+    Exit = [248, cst_Stdlib_Exit, runtime.caml_fresh_oo_id(0)];
+   function min(x, y){
+     /*<<stdlib.ml:74:14>>*/ return  /*<<stdlib.ml:74:17>>*/ runtime.caml_lessequal
+             (x, y)
+            ? x
+            : y;
+    /*<<stdlib.ml:74:37>>*/ }
+   function max(x, y){
+     /*<<stdlib.ml:75:14>>*/ return  /*<<stdlib.ml:75:17>>*/ runtime.caml_greaterequal
+             (x, y)
+            ? x
+            : y;
+    /*<<stdlib.ml:75:37>>*/ }
+   function abs(x){
+     /*<<stdlib.ml:98:12>>*/ return 0 <= x ? x : - x | 0;
+    /*<<stdlib.ml:98:36>>*/ }
+   function lnot(x){
+     /*<<stdlib.ml:104:13>>*/ return x ^ -1;
+    /*<<stdlib.ml:104:24>>*/ }
+    /*<<stdlib.ml:180:2>>*/ var
+     /*<<stdlib.ml:180:2>>*/ infinity =
+       /*<<stdlib.ml:180:2>>*/ caml_int64_float_of_bits(_a_),
+     /*<<stdlib.ml:182:2>>*/ neg_infinity =
+       /*<<stdlib.ml:182:2>>*/ caml_int64_float_of_bits(_b_),
+     /*<<stdlib.ml:184:2>>*/ nan =
+       /*<<stdlib.ml:184:2>>*/ caml_int64_float_of_bits(_c_),
+     /*<<stdlib.ml:186:2>>*/ max_float =
+       /*<<stdlib.ml:186:2>>*/ caml_int64_float_of_bits(_d_),
+     /*<<stdlib.ml:188:2>>*/ min_float =
+       /*<<stdlib.ml:188:2>>*/ caml_int64_float_of_bits(_e_),
+     /*<<stdlib.ml:190:2>>*/ epsilon_float =
+       /*<<stdlib.ml:190:2>>*/ caml_int64_float_of_bits(_f_),
+    max_int = 2147483647,
+    min_int = -2147483648;
+   function symbol(s1, s2){
+     /*<<stdlib.ml:213:2>>*/ var
+     l1 = caml_ml_string_length(s1),
+     l2 = caml_ml_string_length(s2),
+      /*<<stdlib.ml:214:10>>*/ s =
+        /*<<stdlib.ml:214:10>>*/ caml_create_bytes(l1 + l2 | 0);
+     /*<<stdlib.ml:215:2>>*/  /*<<stdlib.ml:215:2>>*/ caml_blit_string
+     (s1, 0, s, 0, l1);
+     /*<<stdlib.ml:216:2>>*/  /*<<stdlib.ml:216:2>>*/ caml_blit_string
+     (s2, 0, s, l1, l2);
+    return caml_string_of_bytes(s);
+    /*<<stdlib.ml:217:26>>*/ }
+   function char_of_int(n){
+     /*<<stdlib.ml:224:2>>*/ if(0 <= n && 255 >= n)
+      /*<<stdlib.ml:224:58>>*/ return n;
+     /*<<stdlib.ml:224:27>>*/ return invalid_arg(cst_char_of_int);
+    /*<<stdlib.ml:224:78>>*/ }
+   function string_of_bool(b){
+     /*<<stdlib.ml:254:2>>*/ return b ? cst_true : cst_false;
+    /*<<stdlib.ml:254:31>>*/ }
+   function bool_of_string(param){
+     /*<<stdlib.ml:255:21>>*/ return caml_string_notequal(param, cst_false$0)
+            ? caml_string_notequal
+               (param, cst_true$0)
+              ? invalid_arg(cst_bool_of_string)
+              : 1
+            : 0;
+    /*<<stdlib.ml:258:37>>*/ }
+   function bool_of_string_opt(param){
+     /*<<stdlib.ml:260:25>>*/ return caml_string_notequal(param, cst_false$0)
+            ? caml_string_notequal(param, cst_true$0) ? 0 : _g_
+            : _h_;
+    /*<<stdlib.ml:263:13>>*/ }
+   function string_of_int(n){
+     /*<<stdlib.ml:266:2>>*/ return "" + n;
+    /*<<stdlib.ml:266:19>>*/ }
+   function int_of_string_opt(s){
+     /*<<stdlib.ml:272:2>>*/ try{
+      /*<<stdlib.ml:272:6>>*/  /*<<stdlib.ml:272:6>>*/ var
+      _B_ = [0,  /*<<stdlib.ml:272:11>>*/ caml_int_of_string(s)];
+      /*<<stdlib.ml:272:6>>*/ return _B_;
+    }
+    catch(_C_){
+     var _A_ = caml_wrap_exception(_C_);
+     if(_A_[1] === Failure)  /*<<stdlib.ml:273:20>>*/ return 0;
+     throw caml_maybe_attach_backtrace(_A_, 0);
+    }
+    /*<<stdlib.ml:273:24>>*/ }
+   function valid_float_lexem(s){
+     /*<<stdlib.ml:278:2>>*/ var l = caml_ml_string_length(s), i = 0;
+     /*<<stdlib.ml:280:4>>*/ for(;;){
+     if(l <= i)  /*<<stdlib.ml:280:19>>*/ return symbol(s, cst);
+      /*<<stdlib.ml:281:10>>*/  /*<<stdlib.ml:281:10>>*/ var
+      match =  /*<<stdlib.ml:281:10>>*/ runtime.caml_string_get(s, i);
+     a:
+     {
+      if(48 <= match){if(58 > match) break a;} else if(45 === match) break a;
+       /*<<stdlib.ml:279:2>>*/ return s;
+     }
+      /*<<stdlib.ml:282:26>>*/ var
+       /*<<stdlib.ml:282:26>>*/ i$0 = i + 1 | 0,
+      i = i$0;
+    }
+    /*<<stdlib.ml:285:8>>*/ }
+   function string_of_float(f){
+     /*<<stdlib.ml:287:24>>*/ return valid_float_lexem
+            ( /*<<stdlib.ml:287:42>>*/ runtime.caml_format_float("%.12g", f));
+    /*<<stdlib.ml:287:66>>*/ }
+   function float_of_string_opt(s){
+     /*<<stdlib.ml:293:2>>*/ try{
+      /*<<stdlib.ml:293:6>>*/  /*<<stdlib.ml:293:6>>*/ var
+      _y_ = [0,  /*<<stdlib.ml:293:11>>*/ caml_float_of_string(s)];
+      /*<<stdlib.ml:293:6>>*/ return _y_;
+    }
+    catch(_z_){
+     var _x_ = caml_wrap_exception(_z_);
+     if(_x_[1] === Failure)  /*<<stdlib.ml:294:20>>*/ return 0;
+     throw caml_maybe_attach_backtrace(_x_, 0);
+    }
+    /*<<stdlib.ml:294:24>>*/ }
+   function symbol$0(l1, l2){
+     /*<<stdlib.ml:299:2>>*/ if(! l1)  /*<<stdlib.ml:300:10>>*/ return l2;
+    var tl = l1[2], hd = l1[1];
+     /*<<stdlib.ml:301:16>>*/ return [0, hd, symbol$0(tl, l2)];
+    /*<<stdlib.ml:301:31>>*/ }
+    /*<<stdlib.ml:312:12>>*/ var
+     /*<<stdlib.ml:312:12>>*/ stdin =
+       /*<<stdlib.ml:312:12>>*/ caml_ml_open_descriptor_in(0),
+     /*<<stdlib.ml:313:13>>*/ stdout =
+       /*<<stdlib.ml:313:13>>*/ caml_ml_open_descriptor_out(1),
+     /*<<stdlib.ml:314:13>>*/ stderr =
+       /*<<stdlib.ml:314:13>>*/ caml_ml_open_descriptor_out(2);
+   function open_out_gen(mode, perm, name){
+     /*<<stdlib.ml:329:2>>*/  /*<<stdlib.ml:329:10>>*/ var
+     c =
+        /*<<stdlib.ml:329:10>>*/ caml_ml_open_descriptor_out
+        ( /*<<stdlib.ml:329:29>>*/ caml_sys_open(name, mode, perm));
+     /*<<stdlib.ml:330:2>>*/  /*<<stdlib.ml:330:2>>*/ caml_ml_set_channel_name
+     (c, name);
+     /*<<stdlib.ml:330:2>>*/ return c;
+    /*<<stdlib.ml:331:3>>*/ }
+   function open_out(name){
+     /*<<stdlib.ml:334:2>>*/ return open_out_gen(_i_, 438, name);
+    /*<<stdlib.ml:334:74>>*/ }
+   function open_out_bin(name){
+     /*<<stdlib.ml:337:2>>*/ return open_out_gen(_j_, 438, name);
+    /*<<stdlib.ml:337:76>>*/ }
+   function flush_all(param){
+     /*<<stdlib.ml:345:2>>*/ var
+     param$0 =  /*<<stdlib.ml:354:10>>*/ runtime.caml_ml_out_channels_list(0);
+     /*<<stdlib.ml:345:17>>*/ for(;;){
+     if(! param$0)  /*<<stdlib.ml:346:12>>*/ return 0;
+     var l = param$0[2], a = param$0[1];
+      /*<<stdlib.ml:348:8>>*/ try{
+       /*<<stdlib.ml:349:12>>*/  /*<<stdlib.ml:349:12>>*/ caml_ml_flush(a);
+     }
+     catch(_w_){
+      var _v_ = caml_wrap_exception(_w_);
+      if(_v_[1] !== Sys_error) throw caml_maybe_attach_backtrace(_v_, 0);
+     }
+     var param$0 = l;
+    }
+    /*<<stdlib.ml:354:32>>*/ }
+   function output_bytes(oc, s){
+     /*<<stdlib.ml:364:2>>*/ return  /*<<stdlib.ml:364:2>>*/ caml_ml_output_bytes
+            (oc, s, 0, caml_ml_bytes_length(s));
+    /*<<stdlib.ml:364:39>>*/ }
+   function output_string(oc, s){
+     /*<<stdlib.ml:367:2>>*/ return  /*<<stdlib.ml:367:2>>*/ caml_ml_output
+            (oc, s, 0, caml_ml_string_length(s));
+    /*<<stdlib.ml:367:47>>*/ }
+   function output(oc, s, ofs, len){
+     /*<<stdlib.ml:370:2>>*/ if
+     (0 <= ofs && 0 <= len && (caml_ml_bytes_length(s) - len | 0) >= ofs)
+      /*<<stdlib.ml:372:7>>*/ return  /*<<stdlib.ml:372:7>>*/ caml_ml_output_bytes
+             (oc, s, ofs, len);
+     /*<<stdlib.ml:371:7>>*/ return invalid_arg(cst_output);
+    /*<<stdlib.ml:372:33>>*/ }
+   function output_substring(oc, s, ofs, len){
+     /*<<stdlib.ml:375:2>>*/ if
+     (0 <= ofs && 0 <= len && (caml_ml_string_length(s) - len | 0) >= ofs)
+      /*<<stdlib.ml:377:7>>*/ return  /*<<stdlib.ml:377:7>>*/ caml_ml_output
+             (oc, s, ofs, len);
+     /*<<stdlib.ml:376:7>>*/ return invalid_arg(cst_output_substring);
+    /*<<stdlib.ml:377:40>>*/ }
+   function output_value(chan, v){
+     /*<<stdlib.ml:384:26>>*/ return  /*<<stdlib.ml:384:26>>*/ runtime.caml_output_value
+            (chan, v, 0);
+    /*<<stdlib.ml:384:54>>*/ }
+   function close_out(oc){
+     /*<<stdlib.ml:390:19>>*/  /*<<stdlib.ml:390:19>>*/ caml_ml_flush(oc);
+     /*<<stdlib.ml:390:29>>*/ return  /*<<stdlib.ml:390:29>>*/ caml_ml_close_channel
+            (oc);
+    /*<<stdlib.ml:390:49>>*/ }
+   function close_out_noerr(oc){
+     /*<<stdlib.ml:392:2>>*/ try{
+      /*<<stdlib.ml:392:7>>*/  /*<<stdlib.ml:392:7>>*/ caml_ml_flush(oc);
+    }
+    catch(_u_){}
+     /*<<stdlib.ml:393:2>>*/ try{
+      /*<<stdlib.ml:393:7>>*/  /*<<stdlib.ml:393:7>>*/ var
+      _s_ =  /*<<stdlib.ml:393:7>>*/ caml_ml_close_channel(oc);
+      /*<<stdlib.ml:393:7>>*/ return _s_;
+    }
+    catch(_t_){ /*<<stdlib.ml:393:38>>*/ return 0;}
+    /*<<stdlib.ml:393:41>>*/ }
+   function open_in_gen(mode, perm, name){
+     /*<<stdlib.ml:403:2>>*/  /*<<stdlib.ml:403:10>>*/ var
+     c =
+        /*<<stdlib.ml:403:10>>*/ caml_ml_open_descriptor_in
+        ( /*<<stdlib.ml:403:28>>*/ caml_sys_open(name, mode, perm));
+     /*<<stdlib.ml:404:2>>*/  /*<<stdlib.ml:404:2>>*/ caml_ml_set_channel_name
+     (c, name);
+     /*<<stdlib.ml:404:2>>*/ return c;
+    /*<<stdlib.ml:405:3>>*/ }
+   function open_in(name){
+     /*<<stdlib.ml:408:2>>*/ return open_in_gen(_k_, 0, name);
+    /*<<stdlib.ml:408:45>>*/ }
+   function open_in_bin(name){
+     /*<<stdlib.ml:411:2>>*/ return open_in_gen(_l_, 0, name);
+    /*<<stdlib.ml:411:47>>*/ }
+   function input(ic, s, ofs, len){
+     /*<<stdlib.ml:419:2>>*/ if
+     (0 <= ofs && 0 <= len && (caml_ml_bytes_length(s) - len | 0) >= ofs)
+      /*<<stdlib.ml:421:7>>*/ return  /*<<stdlib.ml:421:7>>*/ caml_ml_input
+             (ic, s, ofs, len);
+     /*<<stdlib.ml:420:7>>*/ return invalid_arg(cst_input);
+    /*<<stdlib.ml:421:32>>*/ }
+   function unsafe_really_input(ic, s, ofs, len){
+     /*<<stdlib.ml:424:2>>*/ var ofs$0 = ofs, len$0 = len;
+     /*<<stdlib.ml:424:2>>*/ for(;;){
+     if(0 >= len$0)  /*<<stdlib.ml:424:19>>*/ return 0;
+      /*<<stdlib.ml:425:12>>*/  /*<<stdlib.ml:425:12>>*/ var
+      r =  /*<<stdlib.ml:425:12>>*/ caml_ml_input(ic, s, ofs$0, len$0);
+      /*<<stdlib.ml:426:4>>*/ if(0 === r)
+       /*<<stdlib.ml:427:9>>*/ throw  /*<<stdlib.ml:427:9>>*/ caml_maybe_attach_backtrace
+             (End_of_file, 1);
+     var
+      len$1 = len$0 - r | 0,
+      ofs$1 = ofs$0 + r | 0,
+      ofs$0 = ofs$1,
+      len$0 = len$1;
+    }
+    /*<<stdlib.ml:429:5>>*/ }
+   function really_input(ic, s, ofs, len){
+     /*<<stdlib.ml:432:2>>*/ if
+     (0 <= ofs && 0 <= len && (caml_ml_bytes_length(s) - len | 0) >= ofs)
+      /*<<stdlib.ml:434:7>>*/ return unsafe_really_input(ic, s, ofs, len);
+     /*<<stdlib.ml:433:7>>*/ return invalid_arg(cst_really_input);
+    /*<<stdlib.ml:434:39>>*/ }
+   function really_input_string(ic, len){
+     /*<<stdlib.ml:437:2>>*/  /*<<stdlib.ml:437:10>>*/ var
+     s =  /*<<stdlib.ml:437:10>>*/ caml_create_bytes(len);
+     /*<<stdlib.ml:438:2>>*/ really_input(ic, s, 0, len);
+    return caml_string_of_bytes(s);
+    /*<<stdlib.ml:439:26>>*/ }
+   function input_line(chan){
+     /*<<stdlib.ml:444:2>>*/ function build_result(buf, pos, param){
+     var pos$0 = pos, param$0 = param;
+     for(;;){
+      if(! param$0)  /*<<stdlib.ml:445:10>>*/ return buf;
+       /*<<stdlib.ml:447:6>>*/ var
+       tl = param$0[2],
+       hd = param$0[1],
+        /*<<stdlib.ml:447:6>>*/ len =
+          /*<<stdlib.ml:447:6>>*/ caml_ml_bytes_length(hd);
+       /*<<stdlib.ml:448:6>>*/  /*<<stdlib.ml:448:6>>*/ runtime.caml_blit_bytes
+       (hd, 0, buf, pos$0 - len | 0, len);
+      var pos$1 = pos$0 - len | 0, pos$0 = pos$1, param$0 = tl;
+     }
+    }
+    var accu = 0, len = 0;
+     /*<<stdlib.ml:451:4>>*/ for(;;){
+      /*<<stdlib.ml:451:12>>*/  /*<<stdlib.ml:451:12>>*/ var
+      n =  /*<<stdlib.ml:451:12>>*/ runtime.caml_ml_input_scan_line(chan);
+      /*<<stdlib.ml:452:4>>*/ if(0 === n){
+      if(! accu)
+        /*<<stdlib.ml:454:14>>*/ throw  /*<<stdlib.ml:454:14>>*/ caml_maybe_attach_backtrace
+              (End_of_file, 1);
+      var
+       _r_ =
+         build_result
+          ( /*<<stdlib.ml:455:27>>*/ caml_create_bytes(len), len, accu);
+     }
+     else{
+      if(0 >= n){
+        /*<<stdlib.ml:465:16>>*/  /*<<stdlib.ml:465:16>>*/ var
+        beg =  /*<<stdlib.ml:465:16>>*/ caml_create_bytes(- n | 0);
+        /*<<stdlib.ml:466:12>>*/  /*<<stdlib.ml:466:12>>*/ caml_ml_input
+        (chan, beg, 0, - n | 0);
+        /*<<stdlib.ml:467:11>>*/ var
+        len$1 = len - n | 0,
+         /*<<stdlib.ml:467:11>>*/ accu$0 = [0, beg, accu],
+        accu = accu$0,
+        len = len$1;
+       continue;
+      }
+       /*<<stdlib.ml:457:16>>*/  /*<<stdlib.ml:457:16>>*/ var
+       res =  /*<<stdlib.ml:457:16>>*/ caml_create_bytes(n - 1 | 0);
+       /*<<stdlib.ml:458:13>>*/  /*<<stdlib.ml:458:13>>*/ caml_ml_input
+       (chan, res, 0, n - 1 | 0);
+       /*<<stdlib.ml:459:13>>*/  /*<<stdlib.ml:459:13>>*/ caml_ml_input_char
+       (chan);
+      if(accu)
+       var
+        len$0 = (len + n | 0) - 1 | 0,
+        _r_ =
+          build_result
+           ( /*<<stdlib.ml:463:27>>*/ caml_create_bytes(len$0),
+            len$0,
+            [0, res, accu]);
+      else
+       var _r_ = res;
+     }
+      /*<<stdlib.ml:469:28>>*/ return  /*<<stdlib.ml:469:28>>*/ caml_string_of_bytes
+             (_r_);
+    }
+    /*<<stdlib.ml:469:39>>*/ }
+   function close_in_noerr(ic){
+     /*<<stdlib.ml:478:24>>*/ try{
+      /*<<stdlib.ml:478:29>>*/  /*<<stdlib.ml:478:29>>*/ var
+      _p_ =  /*<<stdlib.ml:478:29>>*/ caml_ml_close_channel(ic);
+      /*<<stdlib.ml:478:29>>*/ return _p_;
+    }
+    catch(_q_){ /*<<stdlib.ml:478:51>>*/ return 0;}
+    /*<<stdlib.ml:478:54>>*/ }
+   function print_char(c){
+     /*<<stdlib.ml:484:19>>*/ return  /*<<stdlib.ml:484:19>>*/ caml_ml_output_char
+            (stdout, c);
+    /*<<stdlib.ml:484:39>>*/ }
+   function print_string(s){
+     /*<<stdlib.ml:485:21>>*/ return output_string(stdout, s);
+    /*<<stdlib.ml:485:43>>*/ }
+   function print_bytes(s){
+     /*<<stdlib.ml:486:20>>*/ return output_bytes(stdout, s);
+    /*<<stdlib.ml:486:41>>*/ }
+   function print_int(i){
+     /*<<stdlib.ml:487:18>>*/ return output_string(stdout, "" + i);
+    /*<<stdlib.ml:487:56>>*/ }
+   function print_float(f){
+     /*<<stdlib.ml:488:20>>*/ return output_string(stdout, string_of_float(f));
+    /*<<stdlib.ml:488:60>>*/ }
+   function print_endline(s){
+     /*<<stdlib.ml:490:2>>*/ output_string(stdout, s);
+     /*<<stdlib.ml:490:26>>*/  /*<<stdlib.ml:490:26>>*/ caml_ml_output_char
+     (stdout, 10);
+     /*<<stdlib.ml:490:51>>*/ return  /*<<stdlib.ml:490:51>>*/ caml_ml_flush
+            (stdout);
+    /*<<stdlib.ml:490:63>>*/ }
+   function print_newline(param){
+     /*<<stdlib.ml:491:23>>*/  /*<<stdlib.ml:491:23>>*/ caml_ml_output_char
+     (stdout, 10);
+     /*<<stdlib.ml:491:48>>*/ return  /*<<stdlib.ml:491:48>>*/ caml_ml_flush
+            (stdout);
+    /*<<stdlib.ml:491:60>>*/ }
+   function prerr_char(c){
+     /*<<stdlib.ml:495:19>>*/ return  /*<<stdlib.ml:495:19>>*/ caml_ml_output_char
+            (stderr, c);
+    /*<<stdlib.ml:495:39>>*/ }
+   function prerr_string(s){
+     /*<<stdlib.ml:496:21>>*/ return output_string(stderr, s);
+    /*<<stdlib.ml:496:43>>*/ }
+   function prerr_bytes(s){
+     /*<<stdlib.ml:497:20>>*/ return output_bytes(stderr, s);
+    /*<<stdlib.ml:497:41>>*/ }
+   function prerr_int(i){
+     /*<<stdlib.ml:498:18>>*/ return output_string(stderr, "" + i);
+    /*<<stdlib.ml:498:56>>*/ }
+   function prerr_float(f){
+     /*<<stdlib.ml:499:20>>*/ return output_string(stderr, string_of_float(f));
+    /*<<stdlib.ml:499:60>>*/ }
+   function prerr_endline(s){
+     /*<<stdlib.ml:501:2>>*/ output_string(stderr, s);
+     /*<<stdlib.ml:501:26>>*/  /*<<stdlib.ml:501:26>>*/ caml_ml_output_char
+     (stderr, 10);
+     /*<<stdlib.ml:501:51>>*/ return  /*<<stdlib.ml:501:51>>*/ caml_ml_flush
+            (stderr);
+    /*<<stdlib.ml:501:63>>*/ }
+   function prerr_newline(param){
+     /*<<stdlib.ml:502:23>>*/  /*<<stdlib.ml:502:23>>*/ caml_ml_output_char
+     (stderr, 10);
+     /*<<stdlib.ml:502:48>>*/ return  /*<<stdlib.ml:502:48>>*/ caml_ml_flush
+            (stderr);
+    /*<<stdlib.ml:502:60>>*/ }
+   function read_line(param){
+     /*<<stdlib.ml:506:19>>*/  /*<<stdlib.ml:506:19>>*/ caml_ml_flush(stdout);
+     /*<<stdlib.ml:312:12>>*/ return input_line(stdin);
+    /*<<stdlib.ml:506:49>>*/ }
+   function read_int(param){
+     /*<<stdlib.ml:507:18>>*/ return  /*<<stdlib.ml:507:18>>*/ caml_int_of_string
+            (read_line(0));
+    /*<<stdlib.ml:507:44>>*/ }
+   function read_int_opt(param){
+     /*<<stdlib.ml:508:22>>*/ return int_of_string_opt(read_line(0));
+    /*<<stdlib.ml:508:52>>*/ }
+   function read_float(param){
+     /*<<stdlib.ml:509:20>>*/ return  /*<<stdlib.ml:509:20>>*/ caml_float_of_string
+            (read_line(0));
+    /*<<stdlib.ml:509:48>>*/ }
+   function read_float_opt(param){
+     /*<<stdlib.ml:510:24>>*/ return float_of_string_opt(read_line(0));
+    /*<<stdlib.ml:510:56>>*/ }
+   function string_of_format(param){
+    var str = param[2];
+     /*<<stdlib.ml:536:44>>*/ return str;
+   }
+   function symbol$1(param, _n_){
+     /*<<stdlib.ml:544:10>>*/ var
+     str2 = _n_[2],
+     fmt2 = _n_[1],
+     str1 = param[2],
+     fmt1 = param[1],
+      /*<<stdlib.ml:544:10>>*/ _o_ = symbol(str1, symbol(cst$0, str2));
+     /*<<stdlib.ml:543:2>>*/ return [0,
+             /*<<stdlib.ml:543:10>>*/ caml_call2
+             (CamlinternalFormatBasics[3], fmt1, fmt2),
+            _o_];
+   }
+    /*<<stdlib.ml:557:20>>*/  /*<<stdlib.ml:557:20>>*/ var
+    exit_function = [0, flush_all];
+   function at_exit(f){
+     /*<<stdlib.ml:561:2>>*/ for(;;){
+      /*<<stdlib.ml:561:21>>*/ var
+       /*<<stdlib.ml:561:21>>*/ f_yet_to_run = [0, 1],
+       /*<<stdlib.ml:562:2>>*/ old_exit =
+         /*<<stdlib.ml:562:2>>*/ caml_atomic_load(exit_function),
+      new_exit$0 =
+        function(f_yet_to_run, old_exit){
+         function new_exit(param){
+           /*<<stdlib.ml:564:4>>*/ if(caml_atomic_cas(f_yet_to_run, 1, 0))
+            /*<<stdlib.ml:564:59>>*/  /*<<stdlib.ml:564:59>>*/ caml_call1
+            (f, 0);
+           /*<<stdlib.ml:564:59>>*/ return  /*<<stdlib.ml:564:59>>*/ caml_call1
+                  (old_exit, 0);
+          /*<<stdlib.ml:565:15>>*/ }
+         return new_exit;
+        },
+      new_exit = new_exit$0(f_yet_to_run, old_exit),
+      success = caml_atomic_cas(exit_function, old_exit, new_exit),
+       /*<<stdlib.ml:568:2>>*/ _m_ = 1 - success;
+     if(! _m_)  /*<<stdlib.ml:568:2>>*/ return _m_;
+    }
+    /*<<stdlib.ml:568:31>>*/ }
+    /*<<stdlib.ml:570:30>>*/  /*<<stdlib.ml:570:30>>*/ var
+    do_domain_local_at_exit =
+      [0,
+       function(param){
+         /*<<stdlib.ml:570:45>>*/ return 0;
+        /*<<stdlib.ml:570:47>>*/ }];
+   function do_at_exit(param){
+     /*<<stdlib.ml:573:2>>*/  /*<<stdlib.ml:573:2>>*/ caml_call1
+     (do_domain_local_at_exit[1], 0);
+     /*<<stdlib.ml:573:2>>*/ return  /*<<stdlib.ml:573:2>>*/ caml_call1
+            (caml_atomic_load(exit_function), 0);
+    /*<<stdlib.ml:574:31>>*/ }
+   function exit(retcode){
+     /*<<stdlib.ml:577:2>>*/ do_at_exit(0);
+     /*<<stdlib.ml:578:2>>*/ return  /*<<stdlib.ml:578:2>>*/ runtime.caml_sys_exit
+            (retcode);
+    /*<<stdlib.ml:578:18>>*/ }
+    /*<<stdlib.ml:580:8>>*/  /*<<stdlib.ml:580:8>>*/ runtime.caml_register_named_value
+    ("Pervasives.do_at_exit", do_at_exit);
+   var
+    Stdlib =
+      [0,
+       invalid_arg,
+       failwith,
+       Exit,
+       Match_failure,
+       Assert_failure,
+       Invalid_argument,
+       Failure,
+       Not_found,
+       Out_of_memory,
+       Stack_overflow,
+       Sys_error,
+       End_of_file,
+       Division_by_zero,
+       Sys_blocked_io,
+       Undefined_recursive_module,
+       min,
+       max,
+       abs,
+       max_int,
+       min_int,
+       lnot,
+       infinity,
+       neg_infinity,
+       nan,
+       max_float,
+       min_float,
+       epsilon_float,
+       symbol,
+       char_of_int,
+       string_of_bool,
+       bool_of_string_opt,
+       bool_of_string,
+       string_of_int,
+       int_of_string_opt,
+       string_of_float,
+       float_of_string_opt,
+       symbol$0,
+       stdin,
+       stdout,
+       stderr,
+       print_char,
+       print_string,
+       print_bytes,
+       print_int,
+       print_float,
+       print_endline,
+       print_newline,
+       prerr_char,
+       prerr_string,
+       prerr_bytes,
+       prerr_int,
+       prerr_float,
+       prerr_endline,
+       prerr_newline,
+       read_line,
+       read_int_opt,
+       read_int,
+       read_float_opt,
+       read_float,
+       open_out,
+       open_out_bin,
+       open_out_gen,
+       caml_ml_flush,
+       flush_all,
+       caml_ml_output_char,
+       output_string,
+       output_bytes,
+       output,
+       output_substring,
+       caml_ml_output_char,
+       runtime.caml_ml_output_int,
+       output_value,
+       runtime.caml_ml_seek_out,
+       runtime.caml_ml_pos_out,
+       caml_ml_channel_size,
+       close_out,
+       close_out_noerr,
+       caml_ml_set_binary_mode,
+       open_in,
+       open_in_bin,
+       open_in_gen,
+       caml_ml_input_char,
+       input_line,
+       input,
+       really_input,
+       really_input_string,
+       caml_ml_input_char,
+       runtime.caml_ml_input_int,
+       runtime.caml_input_value,
+       runtime.caml_ml_seek_in,
+       runtime.caml_ml_pos_in,
+       caml_ml_channel_size,
+       caml_ml_close_channel,
+       close_in_noerr,
+       caml_ml_set_binary_mode,
+       [0,
+        runtime.caml_ml_seek_out_64,
+        runtime.caml_ml_pos_out_64,
+        caml_ml_channel_size_64,
+        runtime.caml_ml_seek_in_64,
+        runtime.caml_ml_pos_in_64,
+        caml_ml_channel_size_64],
+       string_of_format,
+       symbol$1,
+       exit,
+       at_exit,
+       valid_float_lexem,
+       unsafe_really_input,
+       do_at_exit,
+       do_domain_local_at_exit];
+   runtime.caml_register_global(45, Stdlib, "Stdlib");
+   return;
+   /*<<?>>*/ }
+  (globalThis));
+
+//# unitInfo: Provides: Stdlib__Either
+(function(globalThis){
+   "use strict";
+   var runtime = globalThis.jsoo_runtime;
+    /*<<?>>*/ function caml_call1(f, a0){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 1
+            ? f(a0)
+            : runtime.caml_call_gen(f, [a0]);
+   }
+    /*<<?>>*/ function caml_call2(f, a0, a1){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 2
+            ? f(a0, a1)
+            : runtime.caml_call_gen(f, [a0, a1]);
+   }
+   function left(v){
+     /*<<either.ml:18:13>>*/ return [0, v];
+    /*<<either.ml:18:19>>*/ }
+   function right(v){
+     /*<<either.ml:19:14>>*/ return [1, v];
+    /*<<either.ml:19:21>>*/ }
+   function is_left(param){
+     /*<<either.ml:21:14>>*/ return 0 === param[0] ? 1 : 0;
+    /*<<either.ml:23:18>>*/ }
+   function is_right(param){
+     /*<<either.ml:25:15>>*/ return 0 === param[0] ? 0 : 1;
+    /*<<either.ml:27:17>>*/ }
+   function find_left(param){
+     /*<<either.ml:29:16>>*/ if(0 !== param[0])
+      /*<<either.ml:31:13>>*/ return 0;
+    var v = param[1];
+     /*<<either.ml:30:12>>*/ return [0, v];
+    /*<<either.ml:31:17>>*/ }
+   function find_right(param){
+     /*<<either.ml:33:17>>*/ if(0 === param[0])
+      /*<<either.ml:34:12>>*/ return 0;
+    var v = param[1];
+     /*<<either.ml:35:13>>*/ return [0, v];
+    /*<<either.ml:35:19>>*/ }
+   function map_left(f, e){
+     /*<<?>>*/ if(0 !== e[0])  /*<<either.ml:39:18>>*/ return e;
+    var v = e[1];
+     /*<<either.ml:38:12>>*/ return [0,
+             /*<<either.ml:38:17>>*/ caml_call1(f, v)];
+   }
+   function map_right(f, e){
+     /*<<?>>*/ if(0 === e[0])  /*<<either.ml:42:17>>*/ return e;
+    var v = e[1];
+     /*<<either.ml:43:13>>*/ return [1,
+             /*<<either.ml:43:19>>*/ caml_call1(f, v)];
+   }
+   function map(left, right, param){
+     /*<<?>>*/ if(0 === param[0]){
+     var v = param[1];
+      /*<<either.ml:46:12>>*/ return [0,
+              /*<<either.ml:46:17>>*/ caml_call1(left, v)];
+    }
+    var v$0 = param[1];
+     /*<<either.ml:47:13>>*/ return [1,
+             /*<<either.ml:47:19>>*/ caml_call1(right, v$0)];
+   }
+   function fold(left, right, param){
+     /*<<?>>*/ if(0 === param[0]){
+     var v = param[1];
+      /*<<either.ml:50:12>>*/ return  /*<<either.ml:50:12>>*/ caml_call1
+             (left, v);
+    }
+    var v$0 = param[1];
+     /*<<either.ml:51:13>>*/ return  /*<<either.ml:51:13>>*/ caml_call1
+            (right, v$0);
+   }
+   function equal(left, right, e1, e2){
+     /*<<either.ml:57:31>>*/ if(0 === e1[0]){
+     var v1 = e1[1];
+     if(0 === e2[0]){
+      var v2 = e2[1];
+       /*<<either.ml:58:22>>*/ return  /*<<either.ml:58:22>>*/ caml_call2
+              (left, v1, v2);
+     }
+    }
+    else{
+     var v1$0 = e1[1];
+     if(0 !== e2[0]){
+      var v2$0 = e2[1];
+       /*<<either.ml:59:24>>*/ return  /*<<either.ml:59:24>>*/ caml_call2
+              (right, v1$0, v2$0);
+     }
+    }
+     /*<<either.ml:60:39>>*/ return 0;
+    /*<<either.ml:60:44>>*/ }
+   function compare(left, right, e1, e2){
+     /*<<either.ml:62:33>>*/ if(0 === e1[0]){
+     var v1 = e1[1];
+     if(0 !== e2[0])  /*<<either.ml:65:21>>*/ return -1;
+     var v2 = e2[1];
+      /*<<either.ml:63:22>>*/ return  /*<<either.ml:63:22>>*/ caml_call2
+             (left, v1, v2);
+    }
+    var v1$0 = e1[1];
+    if(0 === e2[0])  /*<<either.ml:66:21>>*/ return 1;
+    var v2$0 = e2[1];
+     /*<<either.ml:64:24>>*/ return  /*<<either.ml:64:24>>*/ caml_call2
+            (right, v1$0, v2$0);
+    /*<<either.ml:66:22>>*/ }
+   var
+    Stdlib_Either =
+      [0,
+       left,
+       right,
+       is_left,
+       is_right,
+       find_left,
+       find_right,
+       map_left,
+       map_right,
+       map,
+       fold,
+       fold,
+       fold,
+       equal,
+       compare];
+   runtime.caml_register_global(0, Stdlib_Either, "Stdlib__Either");
+   return;
+   /*<<?>>*/ }
+  (globalThis));
+
+//# unitInfo: Provides: Stdlib__Sys
+//# unitInfo: Requires: Stdlib
+(function
+  (globalThis){
+   "use strict";
+    /*<<sys.ml.in:36:22>>*/ var
+    runtime = globalThis.jsoo_runtime,
+    caml_maybe_attach_backtrace = runtime.caml_maybe_attach_backtrace,
+    caml_wrap_exception = runtime.caml_wrap_exception,
+    global_data = runtime.caml_get_global_data(),
+    ocaml_version = "5.0.0",
+    ocaml_release = [0, 5, 0, 0, 0],
+    Stdlib = global_data.Stdlib,
+     /*<<sys.ml.in:36:22>>*/ executable_name =
+       /*<<sys.ml.in:36:22>>*/ runtime.caml_sys_executable_name(0),
+    os_type =  /*<<sys.ml.in:37:22>>*/ runtime.caml_sys_get_config(0)[1],
+    backend_type = [0, "js_of_ocaml"],
+    unix = runtime.caml_sys_const_ostype_unix(0),
+    win32 = runtime.caml_sys_const_ostype_win32(0),
+    cygwin = runtime.caml_sys_const_ostype_cygwin(0),
+    max_array_length = runtime.caml_sys_const_max_wosize(0),
+    max_floatarray_length = max_array_length / 2 | 0,
+    max_string_length = (4 * max_array_length | 0) - 1 | 0,
+    cst_Stdlib_Sys_Break = "Stdlib.Sys.Break",
+    big_endian = 0,
+    word_size = 32,
+    int_size = 32;
+   function getenv_opt(s){
+     /*<<sys.ml.in:59:2>>*/ try{
+      /*<<sys.ml.in:59:6>>*/  /*<<sys.ml.in:59:6>>*/ var
+      _d_ = [0,  /*<<sys.ml.in:59:11>>*/ runtime.caml_sys_getenv(s)];
+      /*<<sys.ml.in:59:6>>*/ return _d_;
+    }
+    catch(_e_){
+     var _c_ = caml_wrap_exception(_e_);
+     if(_c_ === Stdlib[8])  /*<<sys.ml.in:60:20>>*/ return 0;
+     throw caml_maybe_attach_backtrace(_c_, 0);
+    }
+    /*<<sys.ml.in:60:24>>*/ }
+    /*<<sys.ml.in:71:18>>*/  /*<<sys.ml.in:71:18>>*/ var interactive = [0, 0];
+   function set_signal(sig_num, sig_beh){ /*<<sys.ml.in:81:33>>*/ return 0;
+    /*<<sys.ml.in:81:63>>*/ }
+    /*<<sys.ml.in:112:0>>*/ var
+     /*<<sys.ml.in:112:0>>*/ Break =
+      [248, cst_Stdlib_Sys_Break, runtime.caml_fresh_oo_id(0)],
+    sigabrt = -1,
+    sigalrm = -2,
+    sigfpe = -3,
+    sighup = -4,
+    sigill = -5,
+    sigint = -6,
+    sigkill = -7,
+    sigpipe = -8,
+    sigquit = -9,
+    sigsegv = -10,
+    sigterm = -11,
+    sigusr1 = -12,
+    sigusr2 = -13,
+    sigchld = -14,
+    sigcont = -15,
+    sigstop = -16,
+    sigtstp = -17,
+    sigttin = -18,
+    sigttou = -19,
+    sigvtalrm = -20,
+    sigprof = -21,
+    sigbus = -22,
+    sigpoll = -23,
+    sigsys = -24,
+    sigtrap = -25,
+    sigurg = -26,
+    sigxcpu = -27,
+    sigxfsz = -28;
+   function catch_break(on){
+     /*<<sys.ml.in:115:2>>*/ return on ? 0 : 0;
+    /*<<sys.ml.in:118:36>>*/ }
+   var development_version = 0;
+   function Make(_b_, _a_){ /*<<sys.ml.in:162:70>>*/ return [0, 1];}
+    /*<<sys.ml.in:154:21>>*/ var
+     /*<<sys.ml.in:154:21>>*/ Immediate64 = [0, Make],
+    Stdlib_Sys =
+      [0,
+       executable_name,
+       getenv_opt,
+       interactive,
+       os_type,
+       backend_type,
+       unix,
+       win32,
+       cygwin,
+       word_size,
+       int_size,
+       big_endian,
+       max_string_length,
+       max_array_length,
+       max_floatarray_length,
+       set_signal,
+       sigabrt,
+       sigalrm,
+       sigfpe,
+       sighup,
+       sigill,
+       sigint,
+       sigkill,
+       sigpipe,
+       sigquit,
+       sigsegv,
+       sigterm,
+       sigusr1,
+       sigusr2,
+       sigchld,
+       sigcont,
+       sigstop,
+       sigtstp,
+       sigttin,
+       sigttou,
+       sigvtalrm,
+       sigprof,
+       sigbus,
+       sigpoll,
+       sigsys,
+       sigtrap,
+       sigurg,
+       sigxcpu,
+       sigxfsz,
+       Break,
+       catch_break,
+       ocaml_version,
+       development_version,
+       ocaml_release,
+       runtime.caml_ml_enable_runtime_warnings,
+       runtime.caml_ml_runtime_warnings_enabled,
+       Immediate64];
+   runtime.caml_register_global(4, Stdlib_Sys, "Stdlib__Sys");
+   return;
+   /*<<?>>*/ }
+  (globalThis));
+
+//# unitInfo: Provides: Stdlib__Obj
+//# unitInfo: Requires: Assert_failure, Stdlib, Stdlib__Sys
+(function
+  (globalThis){
+   "use strict";
+   var
+    runtime = globalThis.jsoo_runtime,
+    cst_Obj_extension_constructor$1 = "Obj.extension_constructor",
+    caml_maybe_attach_backtrace = runtime.caml_maybe_attach_backtrace,
+    caml_obj_tag = runtime.caml_obj_tag;
+    /*<<?>>*/ function caml_call1(f, a0){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 1
+            ? f(a0)
+            : runtime.caml_call_gen(f, [a0]);
+   }
+   var
+    global_data = runtime.caml_get_global_data(),
+    Stdlib = global_data.Stdlib,
+    Assert_failure = global_data.Assert_failure,
+    Stdlib_Sys = global_data.Stdlib__Sys,
+    cst_Obj_Ephemeron_blit_key = "Obj.Ephemeron.blit_key",
+    cst_Obj_Ephemeron_check_key = "Obj.Ephemeron.check_key",
+    cst_Obj_Ephemeron_unset_key = "Obj.Ephemeron.unset_key",
+    cst_Obj_Ephemeron_set_key = "Obj.Ephemeron.set_key",
+    cst_Obj_Ephemeron_get_key_copy = "Obj.Ephemeron.get_key_copy",
+    cst_Obj_Ephemeron_get_key = "Obj.Ephemeron.get_key",
+    cst_Obj_Ephemeron_create = "Obj.Ephemeron.create",
+    cst_Obj_extension_constructor$0 = cst_Obj_extension_constructor$1,
+    cst_Obj_extension_constructor = cst_Obj_extension_constructor$1,
+    _a_ = [0, "obj.ml", 97, 4];
+   function is_block(a){
+     /*<<obj.ml:26:34>>*/ return 1 - (typeof a === "number" ? 1 : 0);
+    /*<<obj.ml:26:48>>*/ }
+   var
+    double_field = runtime.caml_array_get,
+    set_double_field = runtime.caml_array_set,
+    first_non_constant_constructor = 0,
+    last_non_constant_constructor_ = 243,
+    forcing_tag = 244,
+    cont_tag = 245,
+    lazy_tag = 246,
+    closure_tag = 247,
+    object_tag = 248,
+    infix_tag = 249,
+    forward_tag = 250,
+    no_scan_tag = 251,
+    abstract_tag = 251,
+    string_tag = 252,
+    double_tag = 253,
+    double_array_tag = 254,
+    custom_tag = 255,
+    int_tag = 1000,
+    out_of_heap_tag = 1001,
+    unaligned_tag = 1002;
+   function info(obj){
+     /*<<obj.ml:97:4>>*/ if( /*<<obj.ml:97:12>>*/ caml_obj_tag(obj) !== 247)
+      /*<<obj.ml:97:4>>*/ throw  /*<<obj.ml:97:4>>*/ caml_maybe_attach_backtrace
+            ([0, Assert_failure, _a_], 1);
+     /*<<obj.ml:98:16>>*/ var
+      /*<<obj.ml:98:16>>*/ info =
+        /*<<obj.ml:98:16>>*/ runtime.caml_obj_raw_field(obj, 1),
+     arity = 64 === Stdlib_Sys[9] ? info >> 56 : info >> 24,
+      /*<<obj.ml:92:13>>*/ start_env = info << 8 >>> 9 | 0;
+     /*<<obj.ml:93:4>>*/ return [0, arity, start_env];
+    /*<<obj.ml:98:33>>*/ }
+   function of_val(x){
+     /*<<obj.ml:105:4>>*/ a:
+    {
+     if
+      (is_block(x)
+       &&  /*<<obj.ml:107:25>>*/ caml_obj_tag(x) !== 248 && 1 <= x.length - 1){var slot = x[1]; break a;}
+     var slot = x;
+    }
+    a:
+    {
+     if(is_block(slot) &&  /*<<obj.ml:111:28>>*/ caml_obj_tag(slot) === 248){var name = slot[1]; break a;}
+     var
+      name =
+         /*<<obj.ml:112:11>>*/ caml_call1
+         (Stdlib[1], cst_Obj_extension_constructor$0);
+    }
+    return  /*<<obj.ml:114:9>>*/ caml_obj_tag(name) === 252
+            ? slot
+            :  /*<<obj.ml:115:11>>*/ caml_call1
+              (Stdlib[1], cst_Obj_extension_constructor);
+    /*<<obj.ml:115:50>>*/ }
+   function name(slot){
+     /*<<obj.ml:118:5>>*/ return slot[1];
+    /*<<obj.ml:118:30>>*/ }
+   function id(slot){
+     /*<<obj.ml:121:5>>*/ return slot[2];
+    /*<<obj.ml:121:30>>*/ }
+    /*<<obj.ml:102:0>>*/ var
+     /*<<obj.ml:102:0>>*/ Extension_constructor = [0, of_val, name, id],
+    max_ephe_length = Stdlib_Sys[13] - 2 | 0;
+   function create(l){
+     /*<<obj.ml:135:4>>*/ var
+     _g_ = 0 <= l ? 1 : 0,
+     _h_ = _g_ ? l <= max_ephe_length ? 1 : 0 : _g_;
+    if(1 - _h_)
+      /*<<obj.ml:136:6>>*/  /*<<obj.ml:136:6>>*/ caml_call1
+      (Stdlib[1], cst_Obj_Ephemeron_create);
+     /*<<obj.ml:137:4>>*/ return  /*<<obj.ml:137:4>>*/ runtime.caml_ephe_create
+            (l);
+    /*<<obj.ml:137:12>>*/ }
+   function length(x){
+     /*<<obj.ml:139:17>>*/ return x.length - 1 - 2 | 0;
+    /*<<obj.ml:139:49>>*/ }
+   function raise_if_invalid_offset(e, o, msg){
+     /*<<obj.ml:142:4>>*/ var
+     _d_ = 0 <= o ? 1 : 0,
+     _e_ = _d_ ? o < length(e) ? 1 : 0 : _d_,
+     _f_ = 1 - _e_;
+    return _f_ ?  /*<<obj.ml:143:6>>*/ caml_call1(Stdlib[1], msg) : _f_;
+    /*<<obj.ml:143:21>>*/ }
+   function get_key(e, o){
+     /*<<obj.ml:147:4>>*/ raise_if_invalid_offset
+     (e, o, cst_Obj_Ephemeron_get_key);
+     /*<<obj.ml:148:4>>*/ return  /*<<obj.ml:148:4>>*/ runtime.caml_ephe_get_key
+            (e, o);
+    /*<<obj.ml:148:15>>*/ }
+   function get_key_copy(e, o){
+     /*<<obj.ml:152:4>>*/ raise_if_invalid_offset
+     (e, o, cst_Obj_Ephemeron_get_key_copy);
+     /*<<obj.ml:153:4>>*/ return  /*<<obj.ml:153:4>>*/ runtime.caml_ephe_get_key_copy
+            (e, o);
+    /*<<obj.ml:153:20>>*/ }
+   function set_key(e, o, x){
+     /*<<obj.ml:157:4>>*/ raise_if_invalid_offset
+     (e, o, cst_Obj_Ephemeron_set_key);
+     /*<<obj.ml:158:4>>*/ return  /*<<obj.ml:158:4>>*/ runtime.caml_ephe_set_key
+            (e, o, x);
+    /*<<obj.ml:158:17>>*/ }
+   function unset_key(e, o){
+     /*<<obj.ml:162:4>>*/ raise_if_invalid_offset
+     (e, o, cst_Obj_Ephemeron_unset_key);
+     /*<<obj.ml:163:4>>*/ return  /*<<obj.ml:163:4>>*/ runtime.caml_ephe_unset_key
+            (e, o);
+    /*<<obj.ml:163:17>>*/ }
+   function check_key(e, o){
+     /*<<obj.ml:167:4>>*/ raise_if_invalid_offset
+     (e, o, cst_Obj_Ephemeron_check_key);
+     /*<<obj.ml:168:4>>*/ return  /*<<obj.ml:168:4>>*/ runtime.caml_ephe_check_key
+            (e, o);
+    /*<<obj.ml:168:17>>*/ }
+   function blit_key(e1, o1, e2, o2, l){
+     /*<<obj.ml:174:4>>*/ if
+     (0 <= l
+      &&
+       0 <= o1
+       && (length(e1) - l | 0) >= o1 && 0 <= o2 && (length(e2) - l | 0) >= o2){
+     var
+      _b_ = 0 !== l ? 1 : 0,
+      _c_ =
+        _b_
+         ?  /*<<obj.ml:177:24>>*/ runtime.caml_ephe_blit_key
+           (e1, o1, e2, o2, l)
+         : _b_;
+      /*<<obj.ml:177:24>>*/ return _c_;
+    }
+     /*<<obj.ml:176:9>>*/ return  /*<<obj.ml:176:9>>*/ caml_call1
+            (Stdlib[1], cst_Obj_Ephemeron_blit_key);
+    /*<<obj.ml:177:46>>*/ }
+   var
+    Stdlib_Obj =
+      [0,
+       is_block,
+       double_field,
+       set_double_field,
+       first_non_constant_constructor,
+       last_non_constant_constructor_,
+       forcing_tag,
+       cont_tag,
+       lazy_tag,
+       closure_tag,
+       object_tag,
+       infix_tag,
+       forward_tag,
+       no_scan_tag,
+       abstract_tag,
+       string_tag,
+       double_tag,
+       double_array_tag,
+       custom_tag,
+       int_tag,
+       out_of_heap_tag,
+       unaligned_tag,
+       [0, info],
+       Extension_constructor,
+       [0,
+        create,
+        length,
+        get_key,
+        get_key_copy,
+        set_key,
+        unset_key,
+        check_key,
+        blit_key,
+        runtime.caml_ephe_get_data,
+        runtime.caml_ephe_get_data_copy,
+        runtime.caml_ephe_set_data,
+        runtime.caml_ephe_unset_data,
+        runtime.caml_ephe_check_data,
+        runtime.caml_ephe_blit_data,
+        max_ephe_length]];
+   runtime.caml_register_global(13, Stdlib_Obj, "Stdlib__Obj");
+   return;
+   /*<<?>>*/ }
+  (globalThis));
+
+//# unitInfo: Provides: Stdlib__Atomic
+(function(globalThis){
+   "use strict";
+   var
+    runtime = globalThis.jsoo_runtime,
+    caml_atomic_exchange = runtime.caml_atomic_exchange,
+    caml_atomic_fetch_add = runtime.caml_atomic_fetch_add;
+   function set(r, x){
+     /*<<atomic.ml:24:14>>*/ caml_atomic_exchange(r, x);
+    return 0;
+    /*<<atomic.ml:24:35>>*/ }
+   function incr(r){
+     /*<<atomic.ml:25:13>>*/ caml_atomic_fetch_add(r, 1);
+    return 0;
+    /*<<atomic.ml:25:39>>*/ }
+   function decr(r){
+     /*<<atomic.ml:26:13>>*/ caml_atomic_fetch_add(r, -1);
+    return 0;
+    /*<<atomic.ml:26:42>>*/ }
+   var
+    _a_ = caml_atomic_fetch_add,
+    _b_ = runtime.caml_atomic_cas,
+    _c_ = caml_atomic_exchange,
+    _d_ = runtime.caml_atomic_load,
+    Stdlib_Atomic =
+      [0,
+       function(_e_){ /*<<atomic.ml:17:0>>*/ return [0, _e_];},
+       _d_,
+       set,
+       _c_,
+       _b_,
+       _a_,
+       incr,
+       decr];
+   runtime.caml_register_global(0, Stdlib_Atomic, "Stdlib__Atomic");
+   return;
+   /*<<?>>*/ }
+  (globalThis));
+
+//# unitInfo: Provides: CamlinternalLazy
+//# unitInfo: Requires: Stdlib, Stdlib__Obj
+(function
+  (globalThis){
+   "use strict";
+   var
+    runtime = globalThis.jsoo_runtime,
+    caml_lazy_update_to_forward = runtime.caml_lazy_update_to_forward,
+    caml_maybe_attach_backtrace = runtime.caml_maybe_attach_backtrace,
+    caml_wrap_exception = runtime.caml_wrap_exception;
+    /*<<?>>*/ function caml_call1(f, a0){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 1
+            ? f(a0)
+            : runtime.caml_call_gen(f, [a0]);
+   }
+    /*<<camlinternalLazy.ml:20:0>>*/ var
+    global_data = runtime.caml_get_global_data(),
+    Stdlib_Obj = global_data.Stdlib__Obj,
+     /*<<camlinternalLazy.ml:20:0>>*/ Undefined =
+      [248, "CamlinternalLazy.Undefined", runtime.caml_fresh_oo_id(0)];
+   function force_gen_lazy_block(only_val, blk){
+     /*<<camlinternalLazy.ml:72:2>>*/ if
+     (0
+      !==
+        /*<<camlinternalLazy.ml:72:8>>*/ runtime.caml_lazy_update_to_forcing
+        (blk))
+      /*<<camlinternalLazy.ml:75:9>>*/ throw  /*<<camlinternalLazy.ml:75:9>>*/ caml_maybe_attach_backtrace
+            (Undefined, 1);
+    if(only_val){
+      /*<<camlinternalLazy.ml:61:25>>*/  /*<<camlinternalLazy.ml:61:25>>*/ var
+      closure$0 = blk[1];
+      /*<<camlinternalLazy.ml:62:2>>*/ blk[1] = 0;
+      /*<<camlinternalLazy.ml:63:15>>*/  /*<<camlinternalLazy.ml:63:15>>*/ var
+      result$0 =  /*<<camlinternalLazy.ml:63:15>>*/ caml_call1(closure$0, 0);
+      /*<<camlinternalLazy.ml:64:2>>*/ blk[1] = result$0;
+      /*<<camlinternalLazy.ml:65:2>>*/  /*<<camlinternalLazy.ml:65:2>>*/ caml_lazy_update_to_forward
+      (blk);
+      /*<<camlinternalLazy.ml:65:2>>*/ return result$0;
+    }
+     /*<<camlinternalLazy.ml:46:25>>*/  /*<<camlinternalLazy.ml:46:25>>*/ var
+     closure = blk[1];
+     /*<<camlinternalLazy.ml:47:2>>*/ blk[1] = 0;
+     /*<<camlinternalLazy.ml:47:2>>*/ try{
+      /*<<camlinternalLazy.ml:49:17>>*/  /*<<camlinternalLazy.ml:49:17>>*/ var
+      result =  /*<<camlinternalLazy.ml:49:17>>*/ caml_call1(closure, 0);
+      /*<<camlinternalLazy.ml:50:4>>*/ blk[1] = result;
+      /*<<camlinternalLazy.ml:51:4>>*/  /*<<camlinternalLazy.ml:51:4>>*/ caml_lazy_update_to_forward
+      (blk);
+      /*<<camlinternalLazy.ml:51:4>>*/ return result;
+    }
+    catch(e$0){
+     var e = caml_wrap_exception(e$0);
+      /*<<camlinternalLazy.ml:54:4>>*/ blk[1] =
+      function(param){
+        /*<<camlinternalLazy.ml:54:43>>*/ throw  /*<<camlinternalLazy.ml:54:43>>*/ caml_maybe_attach_backtrace
+              (e, 0);
+       /*<<camlinternalLazy.ml:54:50>>*/ };
+      /*<<camlinternalLazy.ml:55:4>>*/  /*<<camlinternalLazy.ml:55:4>>*/ runtime.caml_lazy_reset_to_lazy
+      (blk);
+      /*<<camlinternalLazy.ml:56:4>>*/ throw  /*<<camlinternalLazy.ml:56:4>>*/ caml_maybe_attach_backtrace
+            (e, 0);
+    }
+    /*<<camlinternalLazy.ml:75:24>>*/ }
+   function force_lazy_block(blk){
+     /*<<camlinternalLazy.ml:78:27>>*/ return force_gen_lazy_block(0, blk);
+    /*<<camlinternalLazy.ml:78:67>>*/ }
+   function force_gen(only_val, lzv){
+     /*<<camlinternalLazy.ml:93:2>>*/  /*<<camlinternalLazy.ml:99:10>>*/ var
+     t =  /*<<camlinternalLazy.ml:99:10>>*/ runtime.caml_obj_tag(lzv);
+    if(t === Stdlib_Obj[12])
+      /*<<camlinternalLazy.ml:101:13>>*/ return lzv[1];
+    if(t === Stdlib_Obj[6])
+      /*<<camlinternalLazy.ml:103:35>>*/ throw  /*<<camlinternalLazy.ml:103:35>>*/ caml_maybe_attach_backtrace
+            (Undefined, 1);
+    return t !== Stdlib_Obj[8] ? lzv : force_gen_lazy_block(only_val, lzv);
+    /*<<camlinternalLazy.ml:105:41>>*/ }
+   var CamlinternalLazy = [0, Undefined, force_lazy_block, force_gen];
+   runtime.caml_register_global(2, CamlinternalLazy, "CamlinternalLazy");
+   return;
+   /*<<?>>*/ }
+  (globalThis));
+
+//# unitInfo: Provides: Stdlib__Lazy
+//# unitInfo: Requires: CamlinternalLazy, Stdlib, Stdlib__Obj
+(function
+  (globalThis){
+   "use strict";
+   var runtime = globalThis.jsoo_runtime, caml_obj_tag = runtime.caml_obj_tag;
+    /*<<?>>*/ function caml_call1(f, a0){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 1
+            ? f(a0)
+            : runtime.caml_call_gen(f, [a0]);
+   }
+    /*<<?>>*/ function caml_call2(f, a0, a1){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 2
+            ? f(a0, a1)
+            : runtime.caml_call_gen(f, [a0, a1]);
+   }
+   var
+    global_data = runtime.caml_get_global_data(),
+    CamlinternalLazy = global_data.CamlinternalLazy,
+    Stdlib_Obj = global_data.Stdlib__Obj,
+    Undefined = CamlinternalLazy[1];
+   function force_val(l){
+     /*<<lazy.ml:56:18>>*/ return  /*<<lazy.ml:56:18>>*/ caml_call2
+            (CamlinternalLazy[3], 1, l);
+    /*<<lazy.ml:56:61>>*/ }
+   function from_fun(f){
+     /*<<lazy.ml:59:2>>*/  /*<<lazy.ml:59:10>>*/ var
+     x =  /*<<lazy.ml:59:10>>*/ runtime.caml_obj_block(Stdlib_Obj[8], 1);
+     /*<<lazy.ml:60:2>>*/ x[1] = f;
+     /*<<lazy.ml:60:2>>*/ return x;
+    /*<<lazy.ml:61:22>>*/ }
+   function from_val(v){
+     /*<<lazy.ml:64:2>>*/  /*<<lazy.ml:64:10>>*/ var
+     t =  /*<<lazy.ml:64:10>>*/ caml_obj_tag(v);
+    if
+     (t !== Stdlib_Obj[12]
+      && t !== Stdlib_Obj[8] && t !== Stdlib_Obj[6] && t !== Stdlib_Obj[16])
+      /*<<lazy.ml:69:5>>*/ return v;
+     /*<<lazy.ml:66:52>>*/ return  /*<<lazy.ml:66:52>>*/ runtime.caml_lazy_make_forward
+            (v);
+    /*<<lazy.ml:70:5>>*/ }
+   function is_val(l){
+     /*<<lazy.ml:72:26>>*/  /*<<lazy.ml:72:26>>*/ var _i_ = Stdlib_Obj[8];
+     /*<<lazy.ml:72:26>>*/ return  /*<<lazy.ml:72:26>>*/ caml_obj_tag(l)
+            !== _i_
+            ? 1
+            : 0;
+    /*<<lazy.ml:72:62>>*/ }
+   function map(f, x){
+     /*<<lazy.ml:75:2>>*/ return [246,
+            function(_f_){
+             var _g_ = caml_obj_tag(x);
+             a:
+             if(250 === _g_)
+              var _h_ = x[1];
+             else{
+              if(246 !== _g_ && 244 !== _g_){var _h_ = x; break a;}
+              var _h_ = caml_call1(CamlinternalLazy[2], x);
+             }
+              /*<<lazy.ml:75:10>>*/ return  /*<<lazy.ml:75:10>>*/ caml_call1
+                     (f, _h_);
+            }];
+    /*<<lazy.ml:75:20>>*/ }
+   function map_val(f, x){
+     /*<<lazy.ml:78:2>>*/ if(! is_val(x))
+      /*<<lazy.ml:80:12>>*/ return [246,
+             function(_c_){
+              var _d_ = caml_obj_tag(x);
+              a:
+              if(250 === _d_)
+               var _e_ = x[1];
+              else{
+               if(246 !== _d_ && 244 !== _d_){var _e_ = x; break a;}
+               var _e_ = caml_call1(CamlinternalLazy[2], x);
+              }
+               /*<<lazy.ml:80:15>>*/ return  /*<<lazy.ml:80:15>>*/ caml_call1
+                      (f, _e_);
+             }];
+    var _a_ = caml_obj_tag(x);
+    a:
+    if(250 === _a_)
+     var _b_ = x[1];
+    else{
+     if(246 !== _a_ && 244 !== _a_){var _b_ = x; break a;}
+     var _b_ = caml_call1(CamlinternalLazy[2], x);
+    }
+     /*<<lazy.ml:79:16>>*/ return from_val
+            ( /*<<lazy.ml:79:16>>*/ caml_call1(f, _b_));
+    /*<<lazy.ml:80:25>>*/ }
+   var
+    Stdlib_Lazy =
+      [0, Undefined, map, is_val, from_val, map_val, from_fun, force_val];
+   runtime.caml_register_global(2, Stdlib_Lazy, "Stdlib__Lazy");
+   return;
+   /*<<?>>*/ }
+  (globalThis));
+
+//# unitInfo: Provides: Stdlib__Seq
+//# unitInfo: Requires: Assert_failure, CamlinternalLazy, Stdlib, Stdlib__Atomic, Stdlib__Lazy
+(function
+  (globalThis){
+   "use strict";
+   var
+    runtime = globalThis.jsoo_runtime,
+    caml_maybe_attach_backtrace = runtime.caml_maybe_attach_backtrace;
+    /*<<?>>*/ function caml_call1(f, a0){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 1
+            ? f(a0)
+            : runtime.caml_call_gen(f, [a0]);
+   }
+    /*<<?>>*/ function caml_call2(f, a0, a1){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 2
+            ? f(a0, a1)
+            : runtime.caml_call_gen(f, [a0, a1]);
+   }
+    /*<<?>>*/ function caml_call3(f, a0, a1, a2){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 3
+            ? f(a0, a1, a2)
+            : runtime.caml_call_gen(f, [a0, a1, a2]);
+   }
+   var
+    global_data = runtime.caml_get_global_data(),
+    Assert_failure = global_data.Assert_failure,
+    Stdlib_Atomic = global_data.Stdlib__Atomic,
+    CamlinternalLazy = global_data.CamlinternalLazy,
+    Stdlib = global_data.Stdlib,
+    Stdlib_Lazy = global_data.Stdlib__Lazy,
+    _a_ = [0, "seq.ml", 596, 4],
+    cst_Seq_drop = "Seq.drop",
+    cst_Seq_take = "Seq.take",
+    cst_Seq_init = "Seq.init",
+    cst_Stdlib_Seq_Forced_twice = "Stdlib.Seq.Forced_twice";
+   function empty(param){
+     /*<<seq.ml:24:15>>*/ return 0;
+    /*<<seq.ml:24:18>>*/ }
+   function return$0(x, param){
+     /*<<seq.ml:26:18>>*/ return [0, x, empty];
+    /*<<seq.ml:26:33>>*/ }
+   function cons(x, next, param){
+     /*<<seq.ml:28:21>>*/ return [0, x, next];
+    /*<<seq.ml:28:35>>*/ }
+   function append(seq1, seq2, param){
+     /*<<seq.ml:31:2>>*/  /*<<seq.ml:31:8>>*/ var
+     match =  /*<<seq.ml:31:8>>*/ caml_call1(seq1, 0);
+    if(! match)
+      /*<<seq.ml:32:11>>*/ return  /*<<seq.ml:32:11>>*/ caml_call1(seq2, 0);
+    var next = match[2], x = match[1];
+     /*<<seq.ml:33:22>>*/ return [0,
+            x,
+            function(_aM_){ /*<<?>>*/ return append(next, seq2, _aM_);}];
+    /*<<seq.ml:33:48>>*/ }
+   function map(f, seq, param){
+     /*<<seq.ml:35:23>>*/  /*<<seq.ml:35:29>>*/ var
+     match =  /*<<seq.ml:35:29>>*/ caml_call1(seq, 0);
+    if(! match)  /*<<seq.ml:36:11>>*/ return 0;
+    var next = match[2], x = match[1];
+     /*<<seq.ml:37:33>>*/ function _aK_(_aL_){
+      /*<<?>>*/ return map(f, next, _aL_);
+    }
+     /*<<seq.ml:37:22>>*/ return [0,
+             /*<<seq.ml:37:28>>*/ caml_call1(f, x),
+            _aK_];
+    /*<<seq.ml:37:44>>*/ }
+   function filter_map(f, seq, param){
+     /*<<seq.ml:39:30>>*/ var seq$0 = seq;
+     /*<<seq.ml:39:30>>*/ for(;;){
+      /*<<seq.ml:39:36>>*/  /*<<seq.ml:39:36>>*/ var
+      match =  /*<<seq.ml:39:36>>*/ caml_call1(seq$0, 0);
+     if(! match)  /*<<seq.ml:40:11>>*/ return 0;
+      /*<<seq.ml:42:12>>*/ var
+      next = match[2],
+      x = match[1],
+       /*<<seq.ml:42:12>>*/ match$0 =  /*<<seq.ml:42:12>>*/ caml_call1(f, x);
+     if(match$0){
+      var y = match$0[1];
+       /*<<seq.ml:44:20>>*/ return [0,
+              y,
+              function(_aJ_){ /*<<?>>*/ return filter_map(f, next, _aJ_);}];
+     }
+     var seq$0 = next;
+    }
+    /*<<seq.ml:44:47>>*/ }
+   function filter(f, seq, param){
+     /*<<seq.ml:46:26>>*/ var seq$0 = seq;
+     /*<<seq.ml:46:26>>*/ for(;;){
+      /*<<seq.ml:46:32>>*/  /*<<seq.ml:46:32>>*/ var
+      match =  /*<<seq.ml:46:32>>*/ caml_call1(seq$0, 0);
+     if(! match)  /*<<seq.ml:47:11>>*/ return 0;
+     var next = match[2], x = match[1];
+      /*<<seq.ml:49:9>>*/ if( /*<<seq.ml:49:9>>*/ caml_call1(f, x))
+       /*<<seq.ml:50:11>>*/ return [0,
+              x,
+              function(_aI_){ /*<<?>>*/ return filter(f, next, _aI_);}];
+     var seq$0 = next;
+    }
+    /*<<seq.ml:51:27>>*/ }
+   function concat(seq, param){
+     /*<<seq.ml:53:24>>*/  /*<<seq.ml:53:30>>*/ var
+     match =  /*<<seq.ml:53:30>>*/ caml_call1(seq, 0);
+    if(! match)  /*<<seq.ml:54:11>>*/ return 0;
+    var next = match[2], x = match[1], _aG_ = 0;
+     /*<<seq.ml:56:5>>*/ return append
+            (x, function(_aH_){ /*<<?>>*/ return concat(next, _aH_);}, _aG_);
+    /*<<seq.ml:56:30>>*/ }
+   function flat_map(f, seq, param){
+     /*<<seq.ml:58:28>>*/  /*<<seq.ml:58:34>>*/ var
+     match =  /*<<seq.ml:58:34>>*/ caml_call1(seq, 0);
+    if(! match)  /*<<seq.ml:59:11>>*/ return 0;
+    var next = match[2], x = match[1], _aD_ = 0;
+     /*<<seq.ml:61:17>>*/ function _aE_(_aF_){
+      /*<<?>>*/ return flat_map(f, next, _aF_);
+    }
+     /*<<seq.ml:61:4>>*/ return append
+            ( /*<<seq.ml:61:11>>*/ caml_call1(f, x), _aE_, _aD_);
+    /*<<seq.ml:61:37>>*/ }
+   function fold_left(f, acc, seq){
+     /*<<seq.ml:66:2>>*/ var acc$0 = acc, seq$0 = seq;
+     /*<<seq.ml:66:2>>*/ for(;;){
+      /*<<seq.ml:66:8>>*/  /*<<seq.ml:66:8>>*/ var
+      match =  /*<<seq.ml:66:8>>*/ caml_call1(seq$0, 0);
+     if(! match)  /*<<seq.ml:67:13>>*/ return acc$0;
+      /*<<seq.ml:69:18>>*/ var
+      next = match[2],
+      x = match[1],
+       /*<<seq.ml:69:18>>*/ acc$1 =
+         /*<<seq.ml:69:18>>*/ caml_call2(f, acc$0, x),
+      acc$0 = acc$1,
+      seq$0 = next;
+    }
+    /*<<seq.ml:70:28>>*/ }
+   function iter(f, seq){
+     /*<<seq.ml:73:2>>*/ var seq$0 = seq;
+     /*<<seq.ml:73:2>>*/ for(;;){
+      /*<<seq.ml:73:8>>*/  /*<<seq.ml:73:8>>*/ var
+      match =  /*<<seq.ml:73:8>>*/ caml_call1(seq$0, 0);
+     if(! match)  /*<<seq.ml:74:13>>*/ return 0;
+     var next = match[2], x = match[1];
+      /*<<seq.ml:76:8>>*/  /*<<seq.ml:76:8>>*/ caml_call1(f, x);
+     var seq$0 = next;
+    }
+    /*<<seq.ml:77:19>>*/ }
+   function unfold(f, u, param){
+     /*<<seq.ml:80:2>>*/  /*<<seq.ml:80:8>>*/ var
+     match =  /*<<seq.ml:80:8>>*/ caml_call1(f, u);
+    if(! match)  /*<<seq.ml:81:12>>*/ return 0;
+    var match$0 = match[1], u$0 = match$0[2], x = match$0[1];
+     /*<<seq.ml:82:20>>*/ return [0,
+            x,
+            function(_aC_){ /*<<?>>*/ return unfold(f, u$0, _aC_);}];
+    /*<<seq.ml:82:41>>*/ }
+   function is_empty(xs){
+     /*<<seq.ml:85:2>>*/ return  /*<<seq.ml:85:8>>*/ caml_call1(xs, 0) ? 0 : 1;
+    /*<<seq.ml:89:11>>*/ }
+   function uncons(xs){
+     /*<<seq.ml:92:2>>*/  /*<<seq.ml:92:8>>*/ var
+     match =  /*<<seq.ml:92:8>>*/ caml_call1(xs, 0);
+    if(! match)  /*<<seq.ml:96:6>>*/ return 0;
+    var xs$0 = match[2], x = match[1];
+     /*<<seq.ml:94:6>>*/ return [0, [0, x, xs$0]];
+    /*<<seq.ml:96:10>>*/ }
+   function length(xs$1){
+     /*<<seq.ml:108:2>>*/ var accu = 0, xs = xs$1;
+     /*<<seq.ml:101:2>>*/ for(;;){
+      /*<<seq.ml:101:8>>*/  /*<<seq.ml:101:8>>*/ var
+      match =  /*<<seq.ml:101:8>>*/ caml_call1(xs, 0);
+     if(! match)  /*<<seq.ml:103:6>>*/ return accu;
+      /*<<seq.ml:105:6>>*/ var
+      xs$0 = match[2],
+       /*<<seq.ml:105:6>>*/ accu$0 = accu + 1 | 0,
+      accu = accu$0,
+      xs = xs$0;
+    }
+    /*<<seq.ml:108:17>>*/ }
+   function iteri(f, xs$1){
+     /*<<seq.ml:119:2>>*/ var i = 0, xs = xs$1;
+     /*<<seq.ml:111:2>>*/ for(;;){
+      /*<<seq.ml:111:8>>*/  /*<<seq.ml:111:8>>*/ var
+      match =  /*<<seq.ml:111:8>>*/ caml_call1(xs, 0);
+     if(! match)  /*<<seq.ml:113:6>>*/ return 0;
+     var xs$0 = match[2], x = match[1];
+      /*<<seq.ml:115:6>>*/  /*<<seq.ml:115:6>>*/ caml_call2(f, i, x);
+     var i$0 = i + 1 | 0, i = i$0, xs = xs$0;
+    }
+    /*<<seq.ml:119:18>>*/ }
+   function fold_lefti(f, accu$1, xs$1){
+     /*<<seq.ml:130:2>>*/ var accu = accu$1, i = 0, xs = xs$1;
+     /*<<seq.ml:122:2>>*/ for(;;){
+      /*<<seq.ml:122:8>>*/  /*<<seq.ml:122:8>>*/ var
+      match =  /*<<seq.ml:122:8>>*/ caml_call1(xs, 0);
+     if(! match)  /*<<seq.ml:124:6>>*/ return accu;
+      /*<<seq.ml:126:17>>*/ var
+      xs$0 = match[2],
+      x = match[1],
+       /*<<seq.ml:126:17>>*/ accu$0 =
+         /*<<seq.ml:126:17>>*/ caml_call3(f, accu, i, x),
+       /*<<seq.ml:127:6>>*/ i$0 = i + 1 | 0,
+      accu = accu$0,
+      i = i$0,
+      xs = xs$0;
+    }
+    /*<<seq.ml:130:28>>*/ }
+   function for_all(p, xs){
+     /*<<seq.ml:133:2>>*/ var xs$0 = xs;
+     /*<<seq.ml:133:2>>*/ for(;;){
+      /*<<seq.ml:133:8>>*/  /*<<seq.ml:133:8>>*/ var
+      match =  /*<<seq.ml:133:8>>*/ caml_call1(xs$0, 0);
+     if(! match)  /*<<seq.ml:135:6>>*/ return 1;
+      /*<<seq.ml:137:6>>*/ var
+      xs$1 = match[2],
+      x = match[1],
+       /*<<seq.ml:137:6>>*/ _aB_ =  /*<<seq.ml:137:6>>*/ caml_call1(p, x);
+      /*<<seq.ml:137:6>>*/ if(! _aB_)  /*<<seq.ml:137:6>>*/ return _aB_;
+     var xs$0 = xs$1;
+    }
+    /*<<seq.ml:137:25>>*/ }
+   function exists(p, xs){
+     /*<<seq.ml:140:2>>*/ var xs$0 = xs;
+     /*<<seq.ml:140:2>>*/ for(;;){
+      /*<<seq.ml:140:8>>*/  /*<<seq.ml:140:8>>*/ var
+      match =  /*<<seq.ml:140:8>>*/ caml_call1(xs$0, 0);
+     if(! match)  /*<<seq.ml:142:6>>*/ return 0;
+      /*<<seq.ml:144:6>>*/ var
+      xs$1 = match[2],
+      x = match[1],
+       /*<<seq.ml:144:6>>*/ _aA_ =  /*<<seq.ml:144:6>>*/ caml_call1(p, x);
+      /*<<seq.ml:144:6>>*/ if(_aA_)  /*<<seq.ml:144:6>>*/ return _aA_;
+     var xs$0 = xs$1;
+    }
+    /*<<seq.ml:144:24>>*/ }
+   function find(p, xs){
+     /*<<seq.ml:147:2>>*/ var xs$0 = xs;
+     /*<<seq.ml:147:2>>*/ for(;;){
+      /*<<seq.ml:147:8>>*/  /*<<seq.ml:147:8>>*/ var
+      match =  /*<<seq.ml:147:8>>*/ caml_call1(xs$0, 0);
+     if(! match)  /*<<seq.ml:149:6>>*/ return 0;
+     var xs$1 = match[2], x = match[1];
+      /*<<seq.ml:151:9>>*/ if( /*<<seq.ml:151:9>>*/ caml_call1(p, x))
+       /*<<seq.ml:151:18>>*/ return [0, x];
+     var xs$0 = xs$1;
+    }
+    /*<<seq.ml:151:39>>*/ }
+   function find_map(f, xs){
+     /*<<seq.ml:154:2>>*/ var xs$0 = xs;
+     /*<<seq.ml:154:2>>*/ for(;;){
+      /*<<seq.ml:154:8>>*/  /*<<seq.ml:154:8>>*/ var
+      match =  /*<<seq.ml:154:8>>*/ caml_call1(xs$0, 0);
+     if(! match)  /*<<seq.ml:156:6>>*/ return 0;
+      /*<<seq.ml:158:12>>*/ var
+      xs$1 = match[2],
+      x = match[1],
+       /*<<seq.ml:158:12>>*/ result =  /*<<seq.ml:158:12>>*/ caml_call1(f, x);
+     if(result)  /*<<seq.ml:162:10>>*/ return result;
+     var xs$0 = xs$1;
+    }
+    /*<<seq.ml:162:16>>*/ }
+   function iter2(f, xs, ys){
+     /*<<seq.ml:172:2>>*/ var xs$0 = xs, ys$0 = ys;
+     /*<<seq.ml:172:2>>*/ for(;;){
+      /*<<seq.ml:172:8>>*/  /*<<seq.ml:172:8>>*/ var
+      match =  /*<<seq.ml:172:8>>*/ caml_call1(xs$0, 0);
+     if(! match)  /*<<seq.ml:174:6>>*/ return 0;
+      /*<<seq.ml:176:12>>*/ var
+      xs$1 = match[2],
+      x = match[1],
+       /*<<seq.ml:176:12>>*/ match$0 =
+         /*<<seq.ml:176:12>>*/ caml_call1(ys$0, 0);
+     if(! match$0)  /*<<seq.ml:178:10>>*/ return 0;
+     var ys$1 = match$0[2], y = match$0[1];
+      /*<<seq.ml:180:10>>*/  /*<<seq.ml:180:10>>*/ caml_call2(f, x, y);
+     var xs$0 = xs$1, ys$0 = ys$1;
+    }
+    /*<<seq.ml:181:23>>*/ }
+   function fold_left2(f, accu, xs, ys){
+     /*<<seq.ml:184:2>>*/ var accu$0 = accu, xs$0 = xs, ys$0 = ys;
+     /*<<seq.ml:184:2>>*/ for(;;){
+      /*<<seq.ml:184:8>>*/  /*<<seq.ml:184:8>>*/ var
+      match =  /*<<seq.ml:184:8>>*/ caml_call1(xs$0, 0);
+     if(! match)  /*<<seq.ml:186:6>>*/ return accu$0;
+      /*<<seq.ml:188:12>>*/ var
+      xs$1 = match[2],
+      x = match[1],
+       /*<<seq.ml:188:12>>*/ match$0 =
+         /*<<seq.ml:188:12>>*/ caml_call1(ys$0, 0);
+     if(! match$0)  /*<<seq.ml:190:10>>*/ return accu$0;
+      /*<<seq.ml:192:21>>*/ var
+      ys$1 = match$0[2],
+      y = match$0[1],
+       /*<<seq.ml:192:21>>*/ accu$1 =
+         /*<<seq.ml:192:21>>*/ caml_call3(f, accu$0, x, y),
+      accu$0 = accu$1,
+      xs$0 = xs$1,
+      ys$0 = ys$1;
+    }
+    /*<<seq.ml:193:33>>*/ }
+   function for_all2(f, xs, ys){
+     /*<<seq.ml:196:2>>*/ var xs$0 = xs, ys$0 = ys;
+     /*<<seq.ml:196:2>>*/ for(;;){
+      /*<<seq.ml:196:8>>*/  /*<<seq.ml:196:8>>*/ var
+      match =  /*<<seq.ml:196:8>>*/ caml_call1(xs$0, 0);
+     if(! match)  /*<<seq.ml:198:6>>*/ return 1;
+      /*<<seq.ml:200:12>>*/ var
+      xs$1 = match[2],
+      x = match[1],
+       /*<<seq.ml:200:12>>*/ match$0 =
+         /*<<seq.ml:200:12>>*/ caml_call1(ys$0, 0);
+     if(! match$0)  /*<<seq.ml:202:10>>*/ return 1;
+      /*<<seq.ml:204:10>>*/ var
+      ys$1 = match$0[2],
+      y = match$0[1],
+       /*<<seq.ml:204:10>>*/ _az_ =  /*<<seq.ml:204:10>>*/ caml_call2(f, x, y);
+      /*<<seq.ml:204:10>>*/ if(! _az_)  /*<<seq.ml:204:10>>*/ return _az_;
+     var xs$0 = xs$1, ys$0 = ys$1;
+    }
+    /*<<seq.ml:204:35>>*/ }
+   function exists2(f, xs, ys){
+     /*<<seq.ml:207:2>>*/ var xs$0 = xs, ys$0 = ys;
+     /*<<seq.ml:207:2>>*/ for(;;){
+      /*<<seq.ml:207:8>>*/  /*<<seq.ml:207:8>>*/ var
+      match =  /*<<seq.ml:207:8>>*/ caml_call1(xs$0, 0);
+     if(! match)  /*<<seq.ml:209:6>>*/ return 0;
+      /*<<seq.ml:211:12>>*/ var
+      xs$1 = match[2],
+      x = match[1],
+       /*<<seq.ml:211:12>>*/ match$0 =
+         /*<<seq.ml:211:12>>*/ caml_call1(ys$0, 0);
+     if(! match$0)  /*<<seq.ml:213:10>>*/ return 0;
+      /*<<seq.ml:215:10>>*/ var
+      ys$1 = match$0[2],
+      y = match$0[1],
+       /*<<seq.ml:215:10>>*/ _ay_ =  /*<<seq.ml:215:10>>*/ caml_call2(f, x, y);
+      /*<<seq.ml:215:10>>*/ if(_ay_)  /*<<seq.ml:215:10>>*/ return _ay_;
+     var xs$0 = xs$1, ys$0 = ys$1;
+    }
+    /*<<seq.ml:215:34>>*/ }
+   function equal(eq, xs, ys){
+     /*<<seq.ml:218:2>>*/ var xs$0 = xs, ys$0 = ys;
+     /*<<seq.ml:218:2>>*/ for(;;){
+      /*<<seq.ml:218:8>>*/ var
+       /*<<seq.ml:218:8>>*/ match =  /*<<seq.ml:218:8>>*/ caml_call1(xs$0, 0),
+       /*<<seq.ml:218:14>>*/ match$0 =
+         /*<<seq.ml:218:14>>*/ caml_call1(ys$0, 0);
+     if(match){
+      if(match$0){
+        /*<<seq.ml:222:6>>*/ var
+        ys$1 = match$0[2],
+        y = match$0[1],
+        xs$1 = match[2],
+        x = match[1],
+         /*<<seq.ml:222:6>>*/ _ax_ =
+           /*<<seq.ml:222:6>>*/ caml_call2(eq, x, y);
+        /*<<seq.ml:222:6>>*/ if(! _ax_)  /*<<seq.ml:222:6>>*/ return _ax_;
+       var xs$0 = xs$1, ys$0 = ys$1;
+       continue;
+      }
+     }
+     else if(! match$0)  /*<<seq.ml:220:6>>*/ return 1;
+      /*<<seq.ml:225:6>>*/ return 0;
+    }
+    /*<<seq.ml:225:11>>*/ }
+   function compare(cmp, xs, ys){
+     /*<<seq.ml:228:2>>*/ var xs$0 = xs, ys$0 = ys;
+     /*<<seq.ml:228:2>>*/ for(;;){
+      /*<<seq.ml:228:8>>*/ var
+       /*<<seq.ml:228:8>>*/ match =  /*<<seq.ml:228:8>>*/ caml_call1(xs$0, 0),
+       /*<<seq.ml:228:14>>*/ match$0 =
+         /*<<seq.ml:228:14>>*/ caml_call1(ys$0, 0);
+     if(! match) return match$0 ? -1 : 0;
+     var xs$1 = match[2], x = match[1];
+     if(! match$0)  /*<<seq.ml:237:6>>*/ return 1;
+      /*<<seq.ml:232:14>>*/ var
+      ys$1 = match$0[2],
+      y = match$0[1],
+       /*<<seq.ml:232:14>>*/ c =  /*<<seq.ml:232:14>>*/ caml_call2(cmp, x, y);
+      /*<<seq.ml:233:6>>*/ if(0 !== c)  /*<<seq.ml:233:21>>*/ return c;
+     var xs$0 = xs$1, ys$0 = ys$1;
+    }
+    /*<<seq.ml:237:8>>*/ }
+   function init_aux(f, i, j, param){
+     /*<<seq.ml:244:2>>*/ if(i >= j)  /*<<seq.ml:248:4>>*/ return 0;
+    var _au_ = i + 1 | 0;
+     /*<<seq.ml:245:15>>*/ function _av_(_aw_){
+      /*<<?>>*/ return init_aux(f, _au_, j, _aw_);
+    }
+     /*<<seq.ml:244:16>>*/ return [0,
+             /*<<seq.ml:245:10>>*/ caml_call1(f, i),
+            _av_];
+    /*<<seq.ml:248:7>>*/ }
+   function init(n, f){
+     /*<<seq.ml:251:2>>*/ if(0 > n)
+      /*<<seq.ml:252:4>>*/ return  /*<<seq.ml:252:4>>*/ caml_call1
+             (Stdlib[1], cst_Seq_init);
+    var _as_ = 0;
+     /*<<seq.ml:254:4>>*/ return function(_at_){
+      /*<<?>>*/ return init_aux(f, _as_, n, _at_);};
+    /*<<seq.ml:254:18>>*/ }
+   function repeat(x, param){
+     /*<<seq.ml:257:2>>*/ return [0,
+            x,
+            function(_ar_){ /*<<?>>*/ return repeat(x, _ar_);}];
+    /*<<seq.ml:257:20>>*/ }
+   function forever(f, param){
+     /*<<seq.ml:260:13>>*/ function _ap_(_aq_){
+      /*<<?>>*/ return forever(f, _aq_);
+    }
+     /*<<seq.ml:260:2>>*/ return [0,
+             /*<<seq.ml:260:8>>*/ caml_call1(f, 0),
+            _ap_];
+    /*<<seq.ml:260:23>>*/ }
+   function cycle_nonempty(xs, param){
+     /*<<seq.ml:267:2>>*/  /*<<seq.ml:267:2>>*/ var _an_ = 0;
+     /*<<seq.ml:267:2>>*/ return append
+            (xs,
+             function(_ao_){ /*<<?>>*/ return cycle_nonempty(xs, _ao_);},
+             _an_);
+    /*<<seq.ml:267:34>>*/ }
+   function cycle(xs, param){
+     /*<<seq.ml:275:2>>*/  /*<<seq.ml:275:8>>*/ var
+     match =  /*<<seq.ml:275:8>>*/ caml_call1(xs, 0);
+    if(! match)  /*<<seq.ml:277:6>>*/ return 0;
+    var xs$0 = match[2], x = match[1];
+     /*<<seq.ml:279:26>>*/ function _ak_(_am_){
+      /*<<?>>*/ return cycle_nonempty(xs, _am_);
+    }
+     /*<<seq.ml:279:6>>*/ return [0,
+            x,
+            function(_al_){ /*<<?>>*/ return append(xs$0, _ak_, _al_);}];
+    /*<<seq.ml:279:46>>*/ }
+   function iterate1(f, x, param){
+     /*<<seq.ml:286:2>>*/  /*<<seq.ml:286:10>>*/ var
+     y =  /*<<seq.ml:286:10>>*/ caml_call1(f, x);
+     /*<<seq.ml:287:2>>*/ return [0,
+            y,
+            function(_aj_){ /*<<?>>*/ return iterate1(f, y, _aj_);}];
+    /*<<seq.ml:287:24>>*/ }
+   function iterate(f, x){
+     /*<<seq.ml:299:9>>*/ function _ag_(_ai_){
+      /*<<?>>*/ return iterate1(f, x, _ai_);
+    }
+     /*<<seq.ml:299:9>>*/ return function(_ah_){
+      /*<<?>>*/ return [0, x, _ag_];};
+    /*<<seq.ml:299:23>>*/ }
+   function mapi_aux(f, i, xs, param){
+     /*<<seq.ml:304:2>>*/  /*<<seq.ml:304:8>>*/ var
+     match =  /*<<seq.ml:304:8>>*/ caml_call1(xs, 0);
+    if(! match)  /*<<seq.ml:306:6>>*/ return 0;
+     /*<<seq.ml:308:6>>*/ var
+     xs$0 = match[2],
+     x = match[1],
+      /*<<seq.ml:308:6>>*/ _ad_ = i + 1 | 0;
+     /*<<seq.ml:308:19>>*/ function _ae_(_af_){
+      /*<<?>>*/ return mapi_aux(f, _ad_, xs$0, _af_);
+    }
+     /*<<seq.ml:308:6>>*/ return [0,
+             /*<<seq.ml:308:12>>*/ caml_call2(f, i, x),
+            _ae_];
+    /*<<seq.ml:308:39>>*/ }
+   function mapi(f, xs){
+     /*<<seq.ml:311:2>>*/ var _ab_ = 0;
+     /*<<seq.ml:311:2>>*/ return function(_ac_){
+      /*<<?>>*/ return mapi_aux(f, _ab_, xs, _ac_);};
+    /*<<seq.ml:311:17>>*/ }
+   function tail_scan(f, s, xs, param){
+     /*<<seq.ml:320:2>>*/  /*<<seq.ml:320:8>>*/ var
+     match =  /*<<seq.ml:320:8>>*/ caml_call1(xs, 0);
+    if(! match)  /*<<seq.ml:322:6>>*/ return 0;
+     /*<<seq.ml:324:14>>*/ var
+     xs$0 = match[2],
+     x = match[1],
+      /*<<seq.ml:324:14>>*/ s$0 =  /*<<seq.ml:324:14>>*/ caml_call2(f, s, x);
+     /*<<seq.ml:325:6>>*/ return [0,
+            s$0,
+            function(_aa_){ /*<<?>>*/ return tail_scan(f, s$0, xs$0, _aa_);}];
+    /*<<seq.ml:325:32>>*/ }
+   function scan(f, s, xs){
+     /*<<seq.ml:328:9>>*/ function _Z_(_$_){
+      /*<<?>>*/ return tail_scan(f, s, xs, _$_);
+    }
+     /*<<seq.ml:328:9>>*/ return function(___){
+      /*<<?>>*/ return [0, s, _Z_];};
+    /*<<seq.ml:328:27>>*/ }
+   function take_aux(n, xs){
+     /*<<seq.ml:334:2>>*/ return 0 === n
+            ? empty
+            : function
+             (param){
+               /*<<seq.ml:338:6>>*/  /*<<seq.ml:338:12>>*/ var
+               match =  /*<<seq.ml:338:12>>*/ caml_call1(xs, 0);
+              if(! match)  /*<<seq.ml:340:10>>*/ return 0;
+              var xs$0 = match[2], x = match[1];
+               /*<<seq.ml:342:10>>*/ return [0, x, take_aux(n - 1 | 0, xs$0)];
+              /*<<seq.ml:342:37>>*/ };
+    /*<<seq.ml:342:37>>*/ }
+   function take(n, xs){
+     /*<<seq.ml:345:2>>*/ if(n < 0)
+      /*<<seq.ml:345:16>>*/  /*<<seq.ml:345:16>>*/ caml_call1
+      (Stdlib[1], cst_Seq_take);
+     /*<<seq.ml:345:16>>*/ return take_aux(n, xs);
+    /*<<seq.ml:346:15>>*/ }
+   function drop(n, xs){
+     /*<<seq.ml:367:2>>*/ return 0 <= n
+            ? 0
+              === n
+              ? xs
+              : function
+               (param){
+                 /*<<seq.ml:372:6>>*/ var n$0 = n, xs$0 = xs;
+                 /*<<seq.ml:353:2>>*/ for(;;){
+                  /*<<seq.ml:353:8>>*/  /*<<seq.ml:353:8>>*/ var
+                  match =  /*<<seq.ml:353:8>>*/ caml_call1(xs$0, 0);
+                 if(! match)  /*<<seq.ml:355:6>>*/ return 0;
+                  /*<<seq.ml:357:6>>*/ var
+                  xs$1 = match[2],
+                   /*<<seq.ml:357:6>>*/ n$1 = n$0 - 1 | 0;
+                  /*<<seq.ml:358:6>>*/ if(0 === n$1)
+                   /*<<seq.ml:359:8>>*/ return  /*<<seq.ml:359:8>>*/ caml_call1
+                          (xs$1, 0);
+                 var n$0 = n$1, xs$0 = xs$1;
+                }
+                /*<<seq.ml:372:21>>*/ }
+            :  /*<<seq.ml:367:16>>*/ caml_call1(Stdlib[1], cst_Seq_drop);
+    /*<<seq.ml:372:21>>*/ }
+   function take_while(p, xs, param){
+     /*<<seq.ml:375:2>>*/  /*<<seq.ml:375:8>>*/ var
+     match =  /*<<seq.ml:375:8>>*/ caml_call1(xs, 0);
+    if(! match)  /*<<seq.ml:377:6>>*/ return 0;
+    var xs$0 = match[2], x = match[1];
+     /*<<seq.ml:379:9>>*/ return  /*<<seq.ml:379:9>>*/ caml_call1(p, x)
+            ? [0,
+              x,
+              function(_Y_){ /*<<?>>*/ return take_while(p, xs$0, _Y_);}]
+            : 0;
+    /*<<seq.ml:379:52>>*/ }
+   function drop_while(p, xs, param){
+     /*<<seq.ml:382:2>>*/ var xs$0 = xs;
+     /*<<seq.ml:382:2>>*/ for(;;){
+      /*<<seq.ml:382:8>>*/  /*<<seq.ml:382:8>>*/ var
+      node =  /*<<seq.ml:382:8>>*/ caml_call1(xs$0, 0);
+     if(! node)  /*<<seq.ml:384:6>>*/ return 0;
+     var xs$1 = node[2], x = node[1];
+      /*<<seq.ml:386:9>>*/ if(!  /*<<seq.ml:386:9>>*/ caml_call1(p, x))
+       /*<<seq.ml:386:42>>*/ return node;
+     var xs$0 = xs$1;
+    }
+    /*<<seq.ml:386:46>>*/ }
+   function group(eq, xs, param){
+     /*<<seq.ml:389:2>>*/  /*<<seq.ml:389:8>>*/ var
+     match =  /*<<seq.ml:389:8>>*/ caml_call1(xs, 0);
+    if(! match)  /*<<seq.ml:391:6>>*/ return 0;
+     /*<<seq.ml:393:64>>*/ var
+     xs$0 = match[2],
+     x = match[1],
+      /*<<seq.ml:393:64>>*/ _P_ =  /*<<seq.ml:393:64>>*/ caml_call1(eq, x);
+     /*<<seq.ml:393:52>>*/ function _Q_(_X_){
+      /*<<?>>*/ return drop_while(_P_, xs$0, _X_);
+    }
+     /*<<seq.ml:393:43>>*/ function _R_(_W_){
+      /*<<?>>*/ return group(eq, _Q_, _W_);
+    }
+     /*<<seq.ml:393:31>>*/  /*<<seq.ml:393:31>>*/ var
+     _S_ =  /*<<seq.ml:393:31>>*/ caml_call1(eq, x);
+     /*<<seq.ml:393:19>>*/ function _T_(_V_){
+      /*<<?>>*/ return take_while(_S_, xs$0, _V_);
+    }
+     /*<<seq.ml:393:6>>*/ return [0,
+            function(_U_){ /*<<?>>*/ return [0, x, _T_];},
+            _R_];
+    /*<<seq.ml:393:75>>*/ }
+    /*<<seq.ml:395:0>>*/ var
+     /*<<seq.ml:395:0>>*/ Forced_twice =
+      [248, cst_Stdlib_Seq_Forced_twice, runtime.caml_fresh_oo_id(0)],
+     /*<<seq.ml:395:0>>*/ to_lazy = Stdlib_Lazy[6];
+   function failure(param){
+     /*<<seq.ml:421:6>>*/ throw  /*<<seq.ml:421:6>>*/ caml_maybe_attach_backtrace
+           (Forced_twice, 1);
+    /*<<seq.ml:421:24>>*/ }
+   function memoize(xs){
+    function s$0(param){
+      /*<<seq.ml:440:4>>*/  /*<<seq.ml:440:10>>*/ var
+      match =  /*<<seq.ml:440:10>>*/ caml_call1(xs, 0);
+     if(! match)  /*<<seq.ml:442:8>>*/ return 0;
+     var xs$0 = match[2], x = match[1];
+      /*<<seq.ml:444:8>>*/ return [0, x, memoize(xs$0)];
+     /*<<seq.ml:444:28>>*/ }
+     /*<<seq.ml:414:14>>*/  /*<<seq.ml:414:14>>*/ var
+     s =  /*<<seq.ml:414:14>>*/ caml_call1(to_lazy, s$0);
+     /*<<seq.ml:414:14>>*/ return function(_O_){
+     var _N_ = runtime.caml_obj_tag(s);
+     if(250 === _N_) return s[1];
+     if(246 !== _N_ && 244 !== _N_)  /*<<seq.ml:409:14>>*/ return s;
+      /*<<seq.ml:409:14>>*/ return  /*<<seq.ml:409:14>>*/ caml_call1
+             (CamlinternalLazy[2], s);};
+    /*<<seq.ml:445:3>>*/ }
+   function once(xs){
+    function f(param){
+      /*<<seq.ml:449:4>>*/  /*<<seq.ml:449:10>>*/ var
+      match =  /*<<seq.ml:449:10>>*/ caml_call1(xs, 0);
+     if(! match)  /*<<seq.ml:451:8>>*/ return 0;
+     var xs$0 = match[2], x = match[1];
+      /*<<seq.ml:453:8>>*/ return [0, x, once(xs$0)];
+     /*<<seq.ml:453:25>>*/ }
+     /*<<seq.ml:428:17>>*/  /*<<seq.ml:428:17>>*/ var
+     action =  /*<<seq.ml:428:17>>*/ caml_call1(Stdlib_Atomic[1], f);
+     /*<<seq.ml:429:4>>*/ return function(param){
+      /*<<seq.ml:433:6>>*/  /*<<seq.ml:433:14>>*/ var
+      f =  /*<<seq.ml:433:14>>*/ caml_call2(Stdlib_Atomic[4], action, failure);
+      /*<<seq.ml:434:6>>*/ return  /*<<seq.ml:434:6>>*/ caml_call1(f, 0); /*<<seq.ml:434:9>>*/ };
+    /*<<seq.ml:454:3>>*/ }
+   function zip(xs, ys, param){
+     /*<<seq.ml:458:2>>*/  /*<<seq.ml:458:8>>*/ var
+     match =  /*<<seq.ml:458:8>>*/ caml_call1(xs, 0);
+    if(! match)  /*<<seq.ml:460:6>>*/ return 0;
+     /*<<seq.ml:462:12>>*/ var
+     xs$0 = match[2],
+     x = match[1],
+      /*<<seq.ml:462:12>>*/ match$0 =  /*<<seq.ml:462:12>>*/ caml_call1(ys, 0);
+    if(! match$0)  /*<<seq.ml:464:10>>*/ return 0;
+    var ys$0 = match$0[2], y = match$0[1];
+     /*<<seq.ml:466:10>>*/ return [0,
+            [0, x, y],
+            function(_M_){ /*<<?>>*/ return zip(xs$0, ys$0, _M_);}];
+    /*<<seq.ml:466:34>>*/ }
+   function map2(f, xs, ys, param){
+     /*<<seq.ml:469:2>>*/  /*<<seq.ml:469:8>>*/ var
+     match =  /*<<seq.ml:469:8>>*/ caml_call1(xs, 0);
+    if(! match)  /*<<seq.ml:471:6>>*/ return 0;
+     /*<<seq.ml:473:12>>*/ var
+     xs$0 = match[2],
+     x = match[1],
+      /*<<seq.ml:473:12>>*/ match$0 =  /*<<seq.ml:473:12>>*/ caml_call1(ys, 0);
+    if(! match$0)  /*<<seq.ml:475:10>>*/ return 0;
+    var ys$0 = match$0[2], y = match$0[1];
+     /*<<seq.ml:477:23>>*/ function _K_(_L_){
+      /*<<?>>*/ return map2(f, xs$0, ys$0, _L_);
+    }
+     /*<<seq.ml:477:10>>*/ return [0,
+             /*<<seq.ml:477:16>>*/ caml_call2(f, x, y),
+            _K_];
+    /*<<seq.ml:477:36>>*/ }
+   function interleave(xs, ys, param){
+     /*<<seq.ml:480:2>>*/  /*<<seq.ml:480:8>>*/ var
+     match =  /*<<seq.ml:480:8>>*/ caml_call1(xs, 0);
+    if(! match)
+      /*<<seq.ml:482:6>>*/ return  /*<<seq.ml:482:6>>*/ caml_call1(ys, 0);
+    var xs$0 = match[2], x = match[1];
+     /*<<seq.ml:484:6>>*/ return [0,
+            x,
+            function(_J_){ /*<<?>>*/ return interleave(ys, xs$0, _J_);}];
+    /*<<seq.ml:484:32>>*/ }
+   function sorted_merge1(cmp, x, xs, y, ys){
+     /*<<seq.ml:513:2>>*/ return 0
+            <  /*<<seq.ml:513:5>>*/ caml_call2(cmp, x, y)
+            ? [0,
+              y,
+              function(_H_){
+                /*<<seq.ml:499:8>>*/  /*<<seq.ml:499:8>>*/ var
+                match =  /*<<seq.ml:499:8>>*/ caml_call1(ys, 0);
+               if(! match)  /*<<seq.ml:501:6>>*/ return [0, x, xs];
+               var ys$0 = match[2], y = match[1];
+                /*<<seq.ml:503:6>>*/ return sorted_merge1(cmp, x, xs, y, ys$0);
+              }]
+            : [0,
+              x,
+              function(_I_){
+                /*<<seq.ml:506:8>>*/  /*<<seq.ml:506:8>>*/ var
+                match =  /*<<seq.ml:506:8>>*/ caml_call1(xs, 0);
+               if(! match)  /*<<seq.ml:508:6>>*/ return [0, y, ys];
+               var xs$0 = match[2], x = match[1];
+                /*<<seq.ml:510:6>>*/ return sorted_merge1(cmp, x, xs$0, y, ys);
+              }];
+    /*<<seq.ml:516:40>>*/ }
+   function sorted_merge(cmp, xs, ys, param){
+     /*<<seq.ml:519:2>>*/ var
+      /*<<seq.ml:519:8>>*/ match =  /*<<seq.ml:519:8>>*/ caml_call1(xs, 0),
+      /*<<seq.ml:519:14>>*/ match$0 =  /*<<seq.ml:519:14>>*/ caml_call1(ys, 0);
+    if(match){
+     if(match$0){
+      var ys$0 = match$0[2], y = match$0[1], xs$0 = match[2], x = match[1];
+       /*<<seq.ml:526:8>>*/ return sorted_merge1(cmp, x, xs$0, y, ys$0);
+     }
+     var c = match;
+    }
+    else{if(! match$0)  /*<<seq.ml:521:8>>*/ return 0; var c = match$0;}
+     /*<<seq.ml:524:8>>*/ return c;
+    /*<<seq.ml:526:35>>*/ }
+   function map_fst(xys, param){
+     /*<<seq.ml:530:2>>*/  /*<<seq.ml:530:8>>*/ var
+     match =  /*<<seq.ml:530:8>>*/ caml_call1(xys, 0);
+    if(! match)  /*<<seq.ml:532:6>>*/ return 0;
+    var xys$0 = match[2], x = match[1][1];
+     /*<<seq.ml:534:6>>*/ return [0,
+            x,
+            function(_G_){ /*<<?>>*/ return map_fst(xys$0, _G_);}];
+    /*<<seq.ml:534:27>>*/ }
+   function map_snd(xys, param){
+     /*<<seq.ml:537:2>>*/  /*<<seq.ml:537:8>>*/ var
+     match =  /*<<seq.ml:537:8>>*/ caml_call1(xys, 0);
+    if(! match)  /*<<seq.ml:539:6>>*/ return 0;
+    var xys$0 = match[2], y = match[1][2];
+     /*<<seq.ml:541:6>>*/ return [0,
+            y,
+            function(_F_){ /*<<?>>*/ return map_snd(xys$0, _F_);}];
+    /*<<seq.ml:541:27>>*/ }
+   function unzip(xys){
+     /*<<seq.ml:544:15>>*/ function _C_(_E_){
+      /*<<?>>*/ return map_snd(xys, _E_);
+    }
+     /*<<seq.ml:544:2>>*/ return [0,
+            function(_D_){ /*<<?>>*/ return map_fst(xys, _D_);},
+            _C_];
+    /*<<seq.ml:544:26>>*/ }
+   function filter_map_find_left_map(f, xs, param){
+     /*<<seq.ml:553:2>>*/ var xs$0 = xs;
+     /*<<seq.ml:553:2>>*/ for(;;){
+      /*<<seq.ml:553:8>>*/  /*<<seq.ml:553:8>>*/ var
+      match =  /*<<seq.ml:553:8>>*/ caml_call1(xs$0, 0);
+     if(! match)  /*<<seq.ml:555:6>>*/ return 0;
+      /*<<seq.ml:557:12>>*/ var
+      xs$1 = match[2],
+      x = match[1],
+       /*<<seq.ml:557:12>>*/ match$0 =  /*<<seq.ml:557:12>>*/ caml_call1(f, x);
+     if(0 === match$0[0]){
+      var y = match$0[1];
+       /*<<seq.ml:559:10>>*/ return [0,
+              y,
+              function(_B_){
+                /*<<?>>*/ return filter_map_find_left_map(f, xs$1, _B_);
+              }];
+     }
+     var xs$0 = xs$1;
+    }
+    /*<<seq.ml:561:42>>*/ }
+   function filter_map_find_right_map(f, xs, param){
+     /*<<seq.ml:564:2>>*/ var xs$0 = xs;
+     /*<<seq.ml:564:2>>*/ for(;;){
+      /*<<seq.ml:564:8>>*/  /*<<seq.ml:564:8>>*/ var
+      match =  /*<<seq.ml:564:8>>*/ caml_call1(xs$0, 0);
+     if(! match)  /*<<seq.ml:566:6>>*/ return 0;
+      /*<<seq.ml:568:12>>*/ var
+      xs$1 = match[2],
+      x = match[1],
+       /*<<seq.ml:568:12>>*/ match$0 =  /*<<seq.ml:568:12>>*/ caml_call1(f, x);
+     if(0 !== match$0[0]){
+      var z = match$0[1];
+       /*<<seq.ml:572:10>>*/ return [0,
+              z,
+              function(_A_){
+                /*<<?>>*/ return filter_map_find_right_map(f, xs$1, _A_);
+              }];
+     }
+     var xs$0 = xs$1;
+    }
+    /*<<seq.ml:572:50>>*/ }
+   function partition_map(f, xs){
+     /*<<seq.ml:576:2>>*/ function _x_(_z_){
+      /*<<?>>*/ return filter_map_find_right_map(f, xs, _z_);
+    }
+     /*<<seq.ml:575:2>>*/ return [0,
+            function(_y_){
+              /*<<?>>*/ return filter_map_find_left_map(f, xs, _y_);
+            },
+            _x_];
+    /*<<seq.ml:576:32>>*/ }
+   function partition(p, xs){
+    function _t_(x){
+      /*<<seq.ml:579:32>>*/ return 1 -  /*<<seq.ml:579:36>>*/ caml_call1(p, x);
+     /*<<seq.ml:579:41>>*/ }
+     /*<<seq.ml:579:15>>*/ function _u_(_w_){
+      /*<<?>>*/ return filter(_t_, xs, _w_);
+    }
+     /*<<seq.ml:579:2>>*/ return [0,
+            function(_v_){ /*<<?>>*/ return filter(p, xs, _v_);},
+            _u_];
+    /*<<seq.ml:579:45>>*/ }
+   function peel(xss){
+     /*<<seq.ml:591:2>>*/ return unzip
+            (function(_s_){ /*<<?>>*/ return filter_map(uncons, xss, _s_);});
+    /*<<seq.ml:591:31>>*/ }
+   function transpose(xss, param){
+     /*<<seq.ml:594:2>>*/ var
+      /*<<seq.ml:594:21>>*/ match = peel(xss),
+     tails = match[2],
+     heads = match[1];
+     /*<<seq.ml:595:5>>*/ if(! is_empty(heads))
+      /*<<seq.ml:600:4>>*/ return [0,
+             heads,
+             function(_r_){ /*<<?>>*/ return transpose(tails, _r_);}];
+     /*<<seq.ml:596:11>>*/ if(is_empty(tails))  /*<<seq.ml:597:4>>*/ return 0;
+     /*<<seq.ml:596:4>>*/ throw  /*<<seq.ml:596:4>>*/ caml_maybe_attach_backtrace
+           ([0, Assert_failure, _a_], 1);
+    /*<<seq.ml:600:33>>*/ }
+   function _b_(remainders, xss, param){
+     /*<<seq.ml:607:2>>*/  /*<<seq.ml:607:8>>*/ var
+     match =  /*<<seq.ml:607:8>>*/ caml_call1(xss, 0);
+    if(! match)  /*<<seq.ml:629:6>>*/ return transpose(remainders, 0);
+     /*<<seq.ml:609:18>>*/ var
+     xss$0 = match[2],
+     xs = match[1],
+      /*<<seq.ml:609:18>>*/ match$0 =  /*<<seq.ml:609:18>>*/ caml_call1(xs, 0);
+    if(match$0){
+      /*<<seq.ml:617:29>>*/ var
+      xs$0 = match$0[2],
+      x = match$0[1],
+       /*<<seq.ml:617:29>>*/ match$1 = peel(remainders),
+      tails = match$1[2],
+      heads = match$1[1],
+       /*<<seq.ml:618:40>>*/ _l_ =
+        function(_q_){ /*<<?>>*/ return [0, xs$0, tails];},
+       /*<<seq.ml:618:30>>*/ _m_ =
+        function(_p_){ /*<<?>>*/ return _b_(_l_, xss$0, _p_);};
+      /*<<seq.ml:618:10>>*/ return [0,
+             function(_o_){ /*<<?>>*/ return [0, x, heads];},
+             _m_];
+    }
+     /*<<seq.ml:623:29>>*/ var
+      /*<<seq.ml:623:29>>*/ match$2 = peel(remainders),
+     tails$0 = match$2[2],
+     heads$0 = match$2[1];
+     /*<<seq.ml:624:10>>*/ return [0,
+            heads$0,
+            function(_n_){ /*<<?>>*/ return _b_(tails$0, xss$0, _n_);}];
+    /*<<seq.ml:629:29>>*/ }
+   function map_product(f, xs, ys){
+    function _f_(x){
+     function _j_(y){
+       /*<<seq.ml:651:8>>*/ return  /*<<seq.ml:651:8>>*/ caml_call2(f, x, y);
+      /*<<seq.ml:651:13>>*/ }
+      /*<<seq.ml:650:10>>*/ return function(_k_){
+       /*<<?>>*/ return map(_j_, ys, _k_);};
+     /*<<seq.ml:652:10>>*/ }
+     /*<<seq.ml:648:20>>*/ function xss(_i_){
+      /*<<?>>*/ return map(_f_, xs, _i_);
+    }
+     /*<<seq.ml:645:2>>*/ function _e_(_h_){
+      /*<<?>>*/ return _b_(empty, xss, _h_);
+    }
+     /*<<seq.ml:648:9>>*/ return function(_g_){
+      /*<<?>>*/ return concat(_e_, _g_);};
+    /*<<seq.ml:654:4>>*/ }
+   function product(xs, ys){
+     /*<<seq.ml:657:2>>*/ return map_product
+            (function(x, y){
+               /*<<seq.ml:657:26>>*/ return [0, x, y];
+              /*<<seq.ml:657:32>>*/ },
+             xs,
+             ys);
+    /*<<seq.ml:657:39>>*/ }
+   function of_dispenser(it){
+    function c(param){
+      /*<<seq.ml:661:4>>*/  /*<<seq.ml:661:10>>*/ var
+      match =  /*<<seq.ml:661:10>>*/ caml_call1(it, 0);
+     if(! match)  /*<<seq.ml:663:8>>*/ return 0;
+     var x = match[1];
+      /*<<seq.ml:665:8>>*/ return [0, x, c];
+     /*<<seq.ml:665:19>>*/ }
+     /*<<seq.ml:667:2>>*/ return c;
+    /*<<seq.ml:667:3>>*/ }
+   function to_dispenser(xs){
+     /*<<seq.ml:670:2>>*/  /*<<seq.ml:670:10>>*/ var s = [0, xs];
+     /*<<seq.ml:671:2>>*/ return function(param){
+      /*<<seq.ml:672:4>>*/  /*<<seq.ml:672:10>>*/ var
+      match =  /*<<seq.ml:672:10>>*/ caml_call1(s[1], 0);
+     if(! match)  /*<<seq.ml:674:8>>*/ return 0;
+     var xs = match[2], x = match[1];
+     s[1] = xs;
+      /*<<seq.ml:677:8>>*/ return [0, x]; /*<<seq.ml:677:14>>*/ };
+    /*<<seq.ml:677:14>>*/ }
+   function ints(i, param){
+     /*<<seq.ml:682:2>>*/  /*<<seq.ml:682:2>>*/ var _c_ = i + 1 | 0;
+     /*<<seq.ml:682:2>>*/ return [0,
+            i,
+            function(_d_){ /*<<?>>*/ return ints(_c_, _d_);}];
+    /*<<seq.ml:682:24>>*/ }
+   var
+    Stdlib_Seq =
+      [0,
+       is_empty,
+       uncons,
+       length,
+       iter,
+       fold_left,
+       iteri,
+       fold_lefti,
+       for_all,
+       exists,
+       find,
+       find_map,
+       iter2,
+       fold_left2,
+       for_all2,
+       exists2,
+       equal,
+       compare,
+       empty,
+       return$0,
+       cons,
+       init,
+       unfold,
+       repeat,
+       forever,
+       cycle,
+       iterate,
+       map,
+       mapi,
+       filter,
+       filter_map,
+       scan,
+       take,
+       drop,
+       take_while,
+       drop_while,
+       group,
+       memoize,
+       Forced_twice,
+       once,
+       transpose,
+       append,
+       concat,
+       flat_map,
+       flat_map,
+       zip,
+       map2,
+       interleave,
+       sorted_merge,
+       product,
+       map_product,
+       unzip,
+       unzip,
+       partition_map,
+       partition,
+       of_dispenser,
+       to_dispenser,
+       ints];
+   runtime.caml_register_global(10, Stdlib_Seq, "Stdlib__Seq");
+   return;
+   /*<<?>>*/ }
+  (globalThis));
+
+//# unitInfo: Provides: Stdlib__Option
+//# unitInfo: Requires: Stdlib, Stdlib__Seq
+(function
+  (globalThis){
+   "use strict";
+   var runtime = globalThis.jsoo_runtime;
+    /*<<?>>*/ function caml_call1(f, a0){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 1
+            ? f(a0)
+            : runtime.caml_call_gen(f, [a0]);
+   }
+    /*<<?>>*/ function caml_call2(f, a0, a1){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 2
+            ? f(a0, a1)
+            : runtime.caml_call_gen(f, [a0, a1]);
+   }
+   var
+    global_data = runtime.caml_get_global_data(),
+    Stdlib_Seq = global_data.Stdlib__Seq,
+    Stdlib = global_data.Stdlib,
+    cst_option_is_None = "option is None",
+    none = 0;
+   function some(v){
+     /*<<option.ml:19:13>>*/ return [0, v];
+    /*<<option.ml:19:19>>*/ }
+   function value(o, default$0){
+     /*<<option.ml:20:23>>*/ if(! o)
+      /*<<option.ml:20:58>>*/ return default$0;
+    var v = o[1];
+     /*<<option.ml:20:46>>*/ return v;
+    /*<<option.ml:20:65>>*/ }
+   function get(param){
+     /*<<option.ml:21:10>>*/ if(! param)
+      /*<<option.ml:21:41>>*/ return  /*<<option.ml:21:41>>*/ caml_call1
+             (Stdlib[1], cst_option_is_None);
+    var v = param[1];
+     /*<<option.ml:21:29>>*/ return v;
+    /*<<option.ml:21:69>>*/ }
+   function bind(o, f){
+     /*<<option.ml:22:15>>*/ if(! o)  /*<<option.ml:22:36>>*/ return 0;
+    var v = o[1];
+     /*<<option.ml:22:53>>*/ return  /*<<option.ml:22:53>>*/ caml_call1(f, v);
+    /*<<option.ml:22:56>>*/ }
+   function join(param){
+     /*<<option.ml:23:11>>*/ if(! param)  /*<<option.ml:23:42>>*/ return 0;
+    var o = param[1];
+     /*<<option.ml:23:30>>*/ return o;
+    /*<<option.ml:23:46>>*/ }
+   function map(f, o){
+     /*<<option.ml:24:14>>*/ if(! o)  /*<<option.ml:24:35>>*/ return 0;
+    var v = o[1];
+     /*<<option.ml:24:52>>*/ return [0,
+             /*<<option.ml:24:57>>*/ caml_call1(f, v)];
+    /*<<option.ml:24:62>>*/ }
+   function fold(none, some, param){
+     /*<<?>>*/ if(! param)  /*<<option.ml:25:59>>*/ return none;
+    var v = param[1];
+     /*<<option.ml:25:42>>*/ return  /*<<option.ml:25:42>>*/ caml_call1
+            (some, v);
+   }
+   function iter(f, param){
+     /*<<?>>*/ if(! param)  /*<<option.ml:26:46>>*/ return 0;
+    var v = param[1];
+     /*<<option.ml:26:32>>*/ return  /*<<option.ml:26:32>>*/ caml_call1(f, v);
+   }
+   function is_none(param){
+     /*<<option.ml:27:14>>*/ return param ? 0 : 1;
+    /*<<option.ml:27:53>>*/ }
+   function is_some(param){
+     /*<<option.ml:28:14>>*/ return param ? 1 : 0;
+    /*<<option.ml:28:53>>*/ }
+   function equal(eq, o0, o1){
+     /*<<option.ml:30:21>>*/ if(o0){
+     if(o1){
+      var v1 = o1[1], v0 = o0[1];
+       /*<<option.ml:31:22>>*/ return  /*<<option.ml:31:22>>*/ caml_call2
+              (eq, v0, v1);
+     }
+    }
+    else if(! o1)  /*<<option.ml:32:16>>*/ return 1;
+     /*<<option.ml:33:7>>*/ return 0;
+    /*<<option.ml:33:12>>*/ }
+   function compare(cmp, o0, o1){
+     /*<<option.ml:35:24>>*/ if(! o0) return o1 ? -1 : 0;
+    var v0 = o0[1];
+    if(! o1)  /*<<option.ml:39:18>>*/ return 1;
+    var v1 = o1[1];
+     /*<<option.ml:36:22>>*/ return  /*<<option.ml:36:22>>*/ caml_call2
+            (cmp, v0, v1);
+    /*<<option.ml:39:19>>*/ }
+   function to_result(none, param){
+     /*<<?>>*/ if(! param)  /*<<option.ml:41:39>>*/ return [1, none];
+    var v = param[1];
+     /*<<option.ml:41:62>>*/ return [0, v];
+   }
+   function to_list(param){
+     /*<<option.ml:42:14>>*/ if(! param)  /*<<option.ml:42:31>>*/ return 0;
+    var v = param[1];
+     /*<<option.ml:42:46>>*/ return [0, v, 0];
+    /*<<option.ml:42:49>>*/ }
+   function to_seq(param){
+     /*<<option.ml:43:13>>*/ if(! param)
+      /*<<option.ml:43:30>>*/ return Stdlib_Seq[18];
+    var v = param[1];
+     /*<<option.ml:43:52>>*/ return  /*<<option.ml:43:52>>*/ caml_call1
+            (Stdlib_Seq[19], v);
+    /*<<option.ml:43:64>>*/ }
+   var
+    Stdlib_Option =
+      [0,
+       none,
+       some,
+       value,
+       get,
+       bind,
+       join,
+       map,
+       fold,
+       iter,
+       is_none,
+       is_some,
+       equal,
+       compare,
+       to_result,
+       to_list,
+       to_seq];
+   runtime.caml_register_global(3, Stdlib_Option, "Stdlib__Option");
+   return;
+   /*<<?>>*/ }
+  (globalThis));
+
+//# unitInfo: Provides: Stdlib__Result
+//# unitInfo: Requires: Stdlib, Stdlib__Seq
+(function
+  (globalThis){
+   "use strict";
+   var runtime = globalThis.jsoo_runtime;
+    /*<<?>>*/ function caml_call1(f, a0){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 1
+            ? f(a0)
+            : runtime.caml_call_gen(f, [a0]);
+   }
+    /*<<?>>*/ function caml_call2(f, a0, a1){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 2
+            ? f(a0, a1)
+            : runtime.caml_call_gen(f, [a0, a1]);
+   }
+   var
+    global_data = runtime.caml_get_global_data(),
+    Stdlib_Seq = global_data.Stdlib__Seq,
+    Stdlib = global_data.Stdlib,
+    cst_result_is_Ok = "result is Ok _",
+    cst_result_is_Error = "result is Error _";
+   function ok(v){
+     /*<<result.ml:18:11>>*/ return [0, v];
+    /*<<result.ml:18:15>>*/ }
+   function error(e){
+     /*<<result.ml:19:14>>*/ return [1, e];
+    /*<<result.ml:19:21>>*/ }
+   function value(r, default$0){
+     /*<<result.ml:20:23>>*/ if(0 !== r[0])
+      /*<<result.ml:20:59>>*/ return default$0;
+    var v = r[1];
+     /*<<result.ml:20:44>>*/ return v;
+    /*<<result.ml:20:66>>*/ }
+   function get_ok(param){
+     /*<<result.ml:21:13>>*/ if(0 !== param[0])
+      /*<<result.ml:21:45>>*/ return  /*<<result.ml:21:45>>*/ caml_call1
+             (Stdlib[1], cst_result_is_Error);
+    var v = param[1];
+     /*<<result.ml:21:30>>*/ return v;
+    /*<<result.ml:21:76>>*/ }
+   function get_error(param){
+     /*<<result.ml:22:16>>*/ if(0 === param[0])
+      /*<<result.ml:22:48>>*/ return  /*<<result.ml:22:48>>*/ caml_call1
+             (Stdlib[1], cst_result_is_Ok);
+    var e = param[1];
+     /*<<result.ml:22:36>>*/ return e;
+    /*<<result.ml:22:76>>*/ }
+   function bind(r, f){
+     /*<<result.ml:23:15>>*/ if(0 !== r[0])  /*<<result.ml:23:58>>*/ return r;
+    var v = r[1];
+     /*<<result.ml:23:36>>*/ return  /*<<result.ml:23:36>>*/ caml_call1(f, v);
+    /*<<result.ml:23:59>>*/ }
+   function join(e){
+     /*<<result.ml:24:11>>*/ if(0 !== e[0])  /*<<result.ml:24:48>>*/ return e;
+    var r = e[1];
+     /*<<result.ml:24:28>>*/ return r;
+    /*<<result.ml:24:49>>*/ }
+   function map(f, e){
+     /*<<?>>*/ if(0 !== e[0])  /*<<result.ml:25:56>>*/ return e;
+    var v = e[1];
+     /*<<result.ml:25:29>>*/ return [0,
+             /*<<result.ml:25:32>>*/ caml_call1(f, v)];
+   }
+   function map_error(f, v){
+     /*<<?>>*/ if(0 === v[0])  /*<<result.ml:26:65>>*/ return v;
+    var e = v[1];
+     /*<<result.ml:26:38>>*/ return [1,
+             /*<<result.ml:26:44>>*/ caml_call1(f, e)];
+   }
+   function fold(ok, error, param){
+     /*<<?>>*/ if(0 === param[0]){
+     var v = param[1];
+      /*<<result.ml:27:39>>*/ return  /*<<result.ml:27:39>>*/ caml_call1
+             (ok, v);
+    }
+    var e = param[1];
+     /*<<result.ml:27:57>>*/ return  /*<<result.ml:27:57>>*/ caml_call1
+            (error, e);
+   }
+   function iter(f, param){
+     /*<<?>>*/ if(0 !== param[0])  /*<<result.ml:28:47>>*/ return 0;
+    var v = param[1];
+     /*<<result.ml:28:30>>*/ return  /*<<result.ml:28:30>>*/ caml_call1(f, v);
+   }
+   function iter_error(f, param){
+     /*<<?>>*/ if(0 === param[0])  /*<<result.ml:29:53>>*/ return 0;
+    var e = param[1];
+     /*<<result.ml:29:39>>*/ return  /*<<result.ml:29:39>>*/ caml_call1(f, e);
+   }
+   function is_ok(param){
+     /*<<result.ml:30:12>>*/ return 0 === param[0] ? 1 : 0;
+    /*<<result.ml:30:52>>*/ }
+   function is_error(param){
+     /*<<result.ml:31:15>>*/ return 0 === param[0] ? 0 : 1;
+    /*<<result.ml:31:55>>*/ }
+   function equal(ok, error, r0, r1){
+     /*<<result.ml:33:29>>*/ if(0 === r0[0]){
+     var v0 = r0[1];
+     if(0 === r1[0]){
+      var v1 = r1[1];
+       /*<<result.ml:34:18>>*/ return  /*<<result.ml:34:18>>*/ caml_call2
+              (ok, v0, v1);
+     }
+    }
+    else{
+     var e0 = r0[1];
+     if(0 !== r1[0]){
+      var e1 = r1[1];
+       /*<<result.ml:35:24>>*/ return  /*<<result.ml:35:24>>*/ caml_call2
+              (error, e0, e1);
+     }
+    }
+     /*<<result.ml:36:10>>*/ return 0;
+    /*<<result.ml:36:15>>*/ }
+   function compare(ok, error, r0, r1){
+     /*<<result.ml:38:31>>*/ if(0 === r0[0]){
+     var v0 = r0[1];
+     if(0 !== r1[0])  /*<<result.ml:41:19>>*/ return -1;
+     var v1 = r1[1];
+      /*<<result.ml:39:18>>*/ return  /*<<result.ml:39:18>>*/ caml_call2
+             (ok, v0, v1);
+    }
+    var e0 = r0[1];
+    if(0 === r1[0])  /*<<result.ml:42:19>>*/ return 1;
+    var e1 = r1[1];
+     /*<<result.ml:40:24>>*/ return  /*<<result.ml:40:24>>*/ caml_call2
+            (error, e0, e1);
+    /*<<result.ml:42:20>>*/ }
+   function to_option(param){
+     /*<<result.ml:44:16>>*/ if(0 !== param[0])
+      /*<<result.ml:44:53>>*/ return 0;
+    var v = param[1];
+     /*<<result.ml:44:33>>*/ return [0, v];
+    /*<<result.ml:44:57>>*/ }
+   function to_list(param){
+     /*<<result.ml:45:14>>*/ if(0 !== param[0])
+      /*<<result.ml:45:48>>*/ return 0;
+    var v = param[1];
+     /*<<result.ml:45:31>>*/ return [0, v, 0];
+    /*<<result.ml:45:50>>*/ }
+   function to_seq(param){
+     /*<<result.ml:46:13>>*/ if(0 !== param[0])
+      /*<<result.ml:46:56>>*/ return Stdlib_Seq[18];
+    var v = param[1];
+     /*<<result.ml:46:30>>*/ return  /*<<result.ml:46:30>>*/ caml_call1
+            (Stdlib_Seq[19], v);
+    /*<<result.ml:46:65>>*/ }
+   var
+    Stdlib_Result =
+      [0,
+       ok,
+       error,
+       value,
+       get_ok,
+       get_error,
+       bind,
+       join,
+       map,
+       map_error,
+       fold,
+       iter,
+       iter_error,
+       is_ok,
+       is_error,
+       equal,
+       compare,
+       to_option,
+       to_list,
+       to_seq];
+   runtime.caml_register_global(4, Stdlib_Result, "Stdlib__Result");
+   return;
+   /*<<?>>*/ }
+  (globalThis));
+
+//# unitInfo: Provides: Stdlib__Bool
+(function(globalThis){
+   "use strict";
+   var
+    runtime = globalThis.jsoo_runtime,
+    cst_true = "true",
+    cst_false = "false";
+   function equal(_e_, _d_){ /*<<?>>*/ return _e_ === _d_ ? 1 : 0;}
+   var compare = runtime.caml_int_compare;
+   function to_float(param){
+     /*<<bool.ml:24:15>>*/ return param ? 1. : 0.;
+    /*<<bool.ml:24:48>>*/ }
+   function to_string(param){
+     /*<<bool.ml:33:16>>*/ return param ? cst_true : cst_false;
+    /*<<bool.ml:33:58>>*/ }
+   function _a_(_c_){ /*<<?>>*/ return _c_;}
+   var
+    Stdlib_Bool =
+      [0,
+       function(_b_){ /*<<?>>*/ return 1 - _b_;},
+       equal,
+       compare,
+       _a_,
+       to_float,
+       to_string];
+   runtime.caml_register_global(4, Stdlib_Bool, "Stdlib__Bool");
+   return;
+   /*<<?>>*/ }
+  (globalThis));
+
+//# unitInfo: Provides: Stdlib__Char
+//# unitInfo: Requires: Stdlib
+(function
+  (globalThis){
+   "use strict";
+   var
+    runtime = globalThis.jsoo_runtime,
+    caml_bytes_unsafe_set = runtime.caml_bytes_unsafe_set,
+    caml_create_bytes = runtime.caml_create_bytes,
+    caml_string_of_bytes = runtime.caml_string_of_bytes;
+    /*<<?>>*/ function caml_call1(f, a0){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 1
+            ? f(a0)
+            : runtime.caml_call_gen(f, [a0]);
+   }
+   var
+    global_data = runtime.caml_get_global_data(),
+    cst = "\\\\",
+    cst$0 = "\\'",
+    Stdlib = global_data.Stdlib,
+    cst_b = "\\b",
+    cst_t = "\\t",
+    cst_n = "\\n",
+    cst_r = "\\r",
+    cst_Char_chr = "Char.chr";
+   function chr(n){
+     /*<<char.ml:22:2>>*/ if(0 <= n && 255 >= n)
+      /*<<char.ml:22:55>>*/ return n;
+     /*<<char.ml:22:27>>*/ return  /*<<char.ml:22:27>>*/ caml_call1
+            (Stdlib[1], cst_Char_chr);
+    /*<<char.ml:22:67>>*/ }
+   function escaped(c){
+     /*<<char.ml:29:14>>*/ a:
+    {
+     if(40 <= c){
+      if(92 === c)  /*<<char.ml:31:12>>*/ return cst;
+      if(127 > c) break a;
+     }
+     else{
+      if(32 <= c){if(39 <= c)  /*<<char.ml:30:12>>*/ return cst$0; break a;}
+      if(14 > c)
+       switch(c){
+         case 8:
+           /*<<char.ml:35:12>>*/ return cst_b;
+         case 9:
+           /*<<char.ml:33:12>>*/ return cst_t;
+         case 10:
+           /*<<char.ml:32:12>>*/ return cst_n;
+         case 13:
+           /*<<char.ml:34:12>>*/ return cst_r;
+       }
+     }
+      /*<<char.ml:42:14>>*/  /*<<char.ml:42:14>>*/ var
+      s =  /*<<char.ml:42:14>>*/ caml_create_bytes(4);
+     caml_bytes_unsafe_set(s, 0, 92);
+     caml_bytes_unsafe_set(s, 1, 48 + (c / 100 | 0) | 0);
+     caml_bytes_unsafe_set(s, 2, 48 + ((c / 10 | 0) % 10 | 0) | 0);
+     caml_bytes_unsafe_set(s, 3, 48 + (c % 10 | 0) | 0);
+     return caml_string_of_bytes(s);
+    }
+     /*<<char.ml:37:14>>*/  /*<<char.ml:37:14>>*/ var
+     s$0 =  /*<<char.ml:37:14>>*/ caml_create_bytes(1);
+    caml_bytes_unsafe_set(s$0, 0, c);
+    return caml_string_of_bytes(s$0);
+    /*<<char.ml:47:24>>*/ }
+   function lowercase_ascii(c){
+     /*<<char.ml:49:22>>*/ return 25 < c - 65 >>> 0 ? c : c + 32 | 0;
+    /*<<char.ml:51:10>>*/ }
+   function uppercase_ascii(c){
+     /*<<char.ml:53:22>>*/ return 25 < c - 97 >>> 0 ? c : c - 32 | 0;
+    /*<<char.ml:55:10>>*/ }
+   function compare(c1, c2){
+     /*<<char.ml:59:20>>*/ return c1 - c2 | 0;
+    /*<<char.ml:59:37>>*/ }
+   function equal(c1, c2){
+     /*<<char.ml:60:28>>*/ return 0 === (c1 - c2 | 0) ? 1 : 0;
+    /*<<char.ml:60:45>>*/ }
+   var
+    Stdlib_Char =
+      [0, chr, escaped, lowercase_ascii, uppercase_ascii, compare, equal];
+   runtime.caml_register_global(8, Stdlib_Char, "Stdlib__Char");
+   return;
+   /*<<?>>*/ }
+  (globalThis));
+
+//# unitInfo: Provides: Stdlib__Uchar
+//# unitInfo: Requires: Assert_failure, Stdlib
+(function
+  (globalThis){
+   "use strict";
+   var
+    runtime = globalThis.jsoo_runtime,
+    cst_uchar_ml = "uchar.ml",
+    caml_format_int = runtime.caml_format_int,
+    caml_maybe_attach_backtrace = runtime.caml_maybe_attach_backtrace;
+    /*<<?>>*/ function caml_call1(f, a0){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 1
+            ? f(a0)
+            : runtime.caml_call_gen(f, [a0]);
+   }
+    /*<<?>>*/ function caml_call2(f, a0, a1){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 2
+            ? f(a0, a1)
+            : runtime.caml_call_gen(f, [a0, a1]);
+   }
+   var
+    global_data = runtime.caml_get_global_data(),
+    err_no_pred = "U+0000 has no predecessor",
+    err_no_succ = "U+10FFFF has no successor",
+    Assert_failure = global_data.Assert_failure,
+    Stdlib = global_data.Stdlib,
+    _d_ = [0, cst_uchar_ml, 88, 18],
+    _c_ = [0, cst_uchar_ml, 91, 7],
+    _b_ = [0, cst_uchar_ml, 80, 18],
+    _a_ = [0, cst_uchar_ml, 85, 7],
+    cst_is_not_a_latin1_character = " is not a latin1 character",
+    cst_U = "U+",
+    cst_is_not_an_Unicode_scalar_v = " is not an Unicode scalar value",
+    min = 0,
+    max = 1114111,
+    lo_bound = 55295,
+    hi_bound = 57344,
+    bom = 65279,
+    rep = 65533;
+   function succ(u){
+     /*<<uchar.ml:34:2>>*/ return u === 55295
+            ? hi_bound
+            : u === 1114111 ? caml_call1(Stdlib[1], err_no_succ) : u + 1 | 0;
+    /*<<uchar.ml:36:7>>*/ }
+   function pred(u){
+     /*<<uchar.ml:39:2>>*/ return u === 57344
+            ? lo_bound
+            : u === 0 ? caml_call1(Stdlib[1], err_no_pred) : u - 1 | 0;
+    /*<<uchar.ml:41:7>>*/ }
+   function is_valid(i){
+     /*<<uchar.ml:43:17>>*/ var
+     _o_ = 0 <= i ? 1 : 0,
+     _p_ = _o_ ? i <= 55295 ? 1 : 0 : _o_;
+    if(_p_)
+     var _q_ = _p_;
+    else
+     var _r_ = 57344 <= i ? 1 : 0, _q_ = _r_ ? i <= 1114111 ? 1 : 0 : _r_;
+    return _q_;
+    /*<<uchar.ml:43:75>>*/ }
+   function of_int(i){
+     /*<<uchar.ml:44:15>>*/ if(is_valid(i))  /*<<uchar.ml:44:34>>*/ return i;
+     /*<<uchar.ml:20:19>>*/  /*<<uchar.ml:20:19>>*/ var
+     _n_ =
+        /*<<uchar.ml:20:19>>*/ caml_call2
+        (Stdlib[28],
+          /*<<uchar.ml:20:19>>*/ caml_format_int("%X", i),
+         cst_is_not_an_Unicode_scalar_v);
+     /*<<uchar.ml:44:53>>*/ return  /*<<uchar.ml:44:53>>*/ caml_call1
+            (Stdlib[1], _n_);
+    /*<<uchar.ml:44:67>>*/ }
+   function is_char(u){
+     /*<<uchar.ml:48:16>>*/ return u < 256 ? 1 : 0;
+    /*<<uchar.ml:48:23>>*/ }
+   function of_char(c){
+     /*<<uchar.ml:49:16>>*/ return c;
+    /*<<uchar.ml:49:27>>*/ }
+   function to_char(u){
+     /*<<uchar.ml:51:2>>*/ if(255 >= u)  /*<<uchar.ml:52:2>>*/ return u;
+     /*<<uchar.ml:21:30>>*/ var
+      /*<<uchar.ml:21:30>>*/ _l_ =
+        /*<<uchar.ml:21:30>>*/ caml_call2
+        (Stdlib[28],
+          /*<<uchar.ml:21:30>>*/ caml_format_int("%04X", u),
+         cst_is_not_a_latin1_character),
+      /*<<uchar.ml:21:30>>*/ _m_ =
+        /*<<uchar.ml:21:30>>*/ caml_call2(Stdlib[28], cst_U, _l_);
+     /*<<uchar.ml:51:30>>*/ return  /*<<uchar.ml:51:30>>*/ caml_call1
+            (Stdlib[1], _m_);
+    /*<<uchar.ml:52:19>>*/ }
+   function unsafe_to_char(_k_){ /*<<?>>*/ return _k_;}
+   function equal(_j_, _i_){ /*<<?>>*/ return _j_ === _i_ ? 1 : 0;}
+   var compare = runtime.caml_int_compare;
+   function hash(_h_){ /*<<?>>*/ return _h_;}
+   function utf_decode_is_valid(d){
+     /*<<uchar.ml:73:37>>*/ return 1 === (d >>> 27 | 0) ? 1 : 0;
+    /*<<uchar.ml:73:58>>*/ }
+   function utf_decode_length(d){
+     /*<<uchar.ml:74:35>>*/ return (d >>> 24 | 0) & 7;
+    /*<<uchar.ml:74:65>>*/ }
+   function utf_decode_uchar(d){
+     /*<<uchar.ml:75:34>>*/ return d & 16777215;
+    /*<<uchar.ml:75:65>>*/ }
+   function utf_decode(n, u){
+     /*<<uchar.ml:76:30>>*/ return (8 | n) << 24 | u;
+    /*<<uchar.ml:76:72>>*/ }
+   function utf_decode_invalid(n){
+     /*<<uchar.ml:77:36>>*/ return n << 24 | 65533;
+    /*<<uchar.ml:77:63>>*/ }
+   function utf_8_byte_length(u){
+     /*<<uchar.ml:79:26>>*/ if(0 > u)
+      /*<<uchar.ml:80:18>>*/ throw  /*<<uchar.ml:80:18>>*/ caml_maybe_attach_backtrace
+            ([0, Assert_failure, _b_], 1);
+     /*<<uchar.ml:81:9>>*/ if(127 >= u)  /*<<uchar.ml:81:24>>*/ return 1;
+     /*<<uchar.ml:82:9>>*/ if(2047 >= u)  /*<<uchar.ml:82:24>>*/ return 2;
+     /*<<uchar.ml:83:9>>*/ if(65535 >= u)  /*<<uchar.ml:83:24>>*/ return 3;
+     /*<<uchar.ml:84:9>>*/ if(1114111 < u)
+      /*<<uchar.ml:85:7>>*/ throw  /*<<uchar.ml:85:7>>*/ caml_maybe_attach_backtrace
+            ([0, Assert_failure, _a_], 1);
+     /*<<uchar.ml:84:26>>*/ return 4;
+    /*<<uchar.ml:85:19>>*/ }
+   function utf_16_byte_length(u){
+     /*<<uchar.ml:87:27>>*/ if(0 > u)
+      /*<<uchar.ml:88:18>>*/ throw  /*<<uchar.ml:88:18>>*/ caml_maybe_attach_backtrace
+            ([0, Assert_failure, _d_], 1);
+     /*<<uchar.ml:89:9>>*/ if(65535 >= u)  /*<<uchar.ml:89:24>>*/ return 2;
+     /*<<uchar.ml:90:9>>*/ if(1114111 < u)
+      /*<<uchar.ml:91:7>>*/ throw  /*<<uchar.ml:91:7>>*/ caml_maybe_attach_backtrace
+            ([0, Assert_failure, _c_], 1);
+     /*<<uchar.ml:90:26>>*/ return 4;
+    /*<<uchar.ml:91:19>>*/ }
+   function _e_(_g_){ /*<<?>>*/ return _g_;}
+   var
+    Stdlib_Uchar =
+      [0,
+       min,
+       max,
+       bom,
+       rep,
+       succ,
+       pred,
+       is_valid,
+       of_int,
+       function(_f_){ /*<<?>>*/ return _f_;},
+       _e_,
+       is_char,
+       of_char,
+       to_char,
+       unsafe_to_char,
+       equal,
+       compare,
+       hash,
+       utf_decode_is_valid,
+       utf_decode_uchar,
+       utf_decode_length,
+       utf_decode,
+       utf_decode_invalid,
+       utf_8_byte_length,
+       utf_16_byte_length];
+   runtime.caml_register_global(13, Stdlib_Uchar, "Stdlib__Uchar");
+   return;
+   /*<<?>>*/ }
+  (globalThis));
+
+//# unitInfo: Provides: Stdlib__List
+//# unitInfo: Requires: Stdlib, Stdlib__Seq, Stdlib__Sys
+(function
+  (globalThis){
+   "use strict";
+   var
+    runtime = globalThis.jsoo_runtime,
+    cst_List_nth$1 = "List.nth",
+    caml_compare = runtime.caml_compare,
+    caml_maybe_attach_backtrace = runtime.caml_maybe_attach_backtrace;
+    /*<<?>>*/ function caml_call1(f, a0){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 1
+            ? f(a0)
+            : runtime.caml_call_gen(f, [a0]);
+   }
+    /*<<?>>*/ function caml_call2(f, a0, a1){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 2
+            ? f(a0, a1)
+            : runtime.caml_call_gen(f, [a0, a1]);
+   }
+    /*<<?>>*/ function caml_call3(f, a0, a1, a2){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 3
+            ? f(a0, a1, a2)
+            : runtime.caml_call_gen(f, [a0, a1, a2]);
+   }
+   var
+    global_data = runtime.caml_get_global_data(),
+    Stdlib = global_data.Stdlib,
+    Stdlib_Seq = global_data.Stdlib__Seq,
+    Stdlib_Sys = global_data.Stdlib__Sys,
+    cst_List_map2 = "List.map2",
+    cst_List_iter2 = "List.iter2",
+    cst_List_fold_left2 = "List.fold_left2",
+    cst_List_fold_right2 = "List.fold_right2",
+    cst_List_for_all2 = "List.for_all2",
+    cst_List_exists2 = "List.exists2",
+    _b_ = [0, 0, 0],
+    cst_List_combine = "List.combine",
+    cst_List_rev_map2 = "List.rev_map2",
+    cst_List_init = "List.init",
+    cst_List_nth$0 = cst_List_nth$1,
+    cst_nth = "nth",
+    cst_List_nth = cst_List_nth$1,
+    cst_tl = "tl",
+    cst_hd = "hd";
+   function length(l$0){
+     /*<<list.ml:25:15>>*/ var len = 0, param = l$0;
+    for(;;){
+     if(! param)  /*<<list.ml:22:10>>*/ return len;
+      /*<<list.ml:23:12>>*/ var
+      l = param[2],
+       /*<<list.ml:23:12>>*/ len$0 = len + 1 | 0,
+      len = len$0,
+      param = l;
+    }
+    /*<<list.ml:25:29>>*/ }
+   function cons(a, l){
+     /*<<list.ml:27:15>>*/ return [0, a, l];
+    /*<<list.ml:27:19>>*/ }
+   function hd(param){
+     /*<<list.ml:29:9>>*/ if(! param)
+      /*<<list.ml:30:10>>*/ return  /*<<list.ml:30:10>>*/ caml_call1
+             (Stdlib[2], cst_hd);
+    var a = param[1];
+     /*<<list.ml:31:12>>*/ return a;
+    /*<<list.ml:31:13>>*/ }
+   function tl(param){
+     /*<<list.ml:33:9>>*/ if(! param)
+      /*<<list.ml:34:10>>*/ return  /*<<list.ml:34:10>>*/ caml_call1
+             (Stdlib[2], cst_tl);
+    var l = param[2];
+     /*<<list.ml:35:12>>*/ return l;
+    /*<<list.ml:35:13>>*/ }
+   function nth(l, n){
+     /*<<list.ml:38:2>>*/ if(0 > n)
+      /*<<list.ml:38:16>>*/ return  /*<<list.ml:38:16>>*/ caml_call1
+             (Stdlib[1], cst_List_nth);
+    var l$0 = l, n$0 = n;
+     /*<<list.ml:40:4>>*/ for(;;){
+     if(! l$0)
+       /*<<list.ml:41:12>>*/ return  /*<<list.ml:41:12>>*/ caml_call1
+              (Stdlib[2], cst_nth);
+     var l$1 = l$0[2], a = l$0[1];
+      /*<<list.ml:42:14>>*/ if(0 === n$0)  /*<<list.ml:42:28>>*/ return a;
+      /*<<list.ml:42:35>>*/ var
+       /*<<list.ml:42:35>>*/ n$1 = n$0 - 1 | 0,
+      l$0 = l$1,
+      n$0 = n$1;
+    }
+    /*<<list.ml:43:16>>*/ }
+   function nth_opt(l, n){
+     /*<<list.ml:46:2>>*/ if(0 > n)
+      /*<<list.ml:46:16>>*/ return  /*<<list.ml:46:16>>*/ caml_call1
+             (Stdlib[1], cst_List_nth$0);
+    var l$0 = l, n$0 = n;
+     /*<<list.ml:48:4>>*/ for(;;){
+     if(! l$0)  /*<<list.ml:49:12>>*/ return 0;
+     var l$1 = l$0[2], a = l$0[1];
+      /*<<list.ml:50:14>>*/ if(0 === n$0)
+       /*<<list.ml:50:28>>*/ return [0, a];
+      /*<<list.ml:50:40>>*/ var
+       /*<<list.ml:50:40>>*/ n$1 = n$0 - 1 | 0,
+      l$0 = l$1,
+      n$0 = n$1;
+    }
+    /*<<list.ml:51:16>>*/ }
+   var append = Stdlib[37];
+   function rev_append(l1, l2){
+     /*<<list.ml:56:2>>*/ var l1$0 = l1, l2$0 = l2;
+     /*<<list.ml:56:2>>*/ for(;;){
+     if(! l1$0)  /*<<list.ml:57:10>>*/ return l2$0;
+      /*<<list.ml:58:27>>*/ var
+      l1$1 = l1$0[2],
+      a = l1$0[1],
+       /*<<list.ml:58:27>>*/ l2$1 = [0, a, l2$0],
+      l1$0 = l1$1,
+      l2$0 = l2$1;
+    }
+    /*<<list.ml:58:36>>*/ }
+   function rev(l){
+     /*<<list.ml:60:12>>*/ return rev_append(l, 0);
+    /*<<list.ml:60:27>>*/ }
+   function init_aux(i, n, f){
+     /*<<list.ml:67:2>>*/ if(n <= i)  /*<<list.ml:67:17>>*/ return 0;
+     /*<<list.ml:69:12>>*/  /*<<list.ml:69:12>>*/ var
+     r =  /*<<list.ml:69:12>>*/ caml_call1(f, i);
+     /*<<list.ml:70:4>>*/ return [0, r, init_aux(i + 1 | 0, n, f)];
+    /*<<list.ml:70:27>>*/ }
+   var rev_init_threshold = typeof Stdlib_Sys[5] === "number" ? 10000 : 50;
+   function init(len, f){
+     /*<<list.ml:80:2>>*/ if(0 > len)
+      /*<<list.ml:80:18>>*/ return  /*<<list.ml:80:18>>*/ caml_call1
+             (Stdlib[1], cst_List_init);
+    if(rev_init_threshold >= len)
+      /*<<list.ml:82:7>>*/ return init_aux(0, len, f);
+    var acc = 0, i = 0;
+     /*<<list.ml:63:2>>*/ for(;;){
+     if(len <= i)  /*<<list.ml:81:39>>*/ return rev(acc);
+      /*<<list.ml:64:24>>*/ var
+      i$0 = i + 1 | 0,
+       /*<<list.ml:64:24>>*/ acc$0 =
+        [0,  /*<<list.ml:64:25>>*/ caml_call1(f, i), acc],
+      acc = acc$0,
+      i = i$0;
+    }
+    /*<<list.ml:82:23>>*/ }
+   function flatten(param){
+     /*<<list.ml:84:18>>*/ if(! param)  /*<<list.ml:85:10>>*/ return 0;
+     /*<<list.ml:86:16>>*/ var
+     r = param[2],
+     l = param[1],
+      /*<<list.ml:86:16>>*/ _J_ = flatten(r);
+     /*<<list.ml:86:16>>*/ return  /*<<list.ml:86:16>>*/ caml_call2
+            (Stdlib[37], l, _J_);
+    /*<<list.ml:86:25>>*/ }
+   function map(f, param){
+     /*<<?>>*/ if(! param)  /*<<list.ml:91:10>>*/ return 0;
+     /*<<list.ml:92:20>>*/ var
+     l = param[2],
+     a = param[1],
+      /*<<list.ml:92:20>>*/ r =  /*<<list.ml:92:20>>*/ caml_call1(f, a);
+     /*<<list.ml:92:27>>*/ return [0, r, map(f, l)];
+   }
+   function _a_(i, f, param){
+     /*<<?>>*/ if(! param)  /*<<list.ml:95:10>>*/ return 0;
+     /*<<list.ml:96:20>>*/ var
+     l = param[2],
+     a = param[1],
+      /*<<list.ml:96:20>>*/ r =  /*<<list.ml:96:20>>*/ caml_call2(f, i, a);
+     /*<<list.ml:96:29>>*/ return [0, r, _a_(i + 1 | 0, f, l)];
+   }
+   function mapi(f, l){
+     /*<<list.ml:98:15>>*/ return _a_(0, f, l);
+    /*<<list.ml:98:25>>*/ }
+   function rev_map(f, l){
+     /*<<list.ml:101:2>>*/ var accu = 0, param = l;
+    for(;;){
+     if(! param)  /*<<list.ml:102:12>>*/ return accu;
+      /*<<list.ml:103:21>>*/ var
+      l$0 = param[2],
+      a = param[1],
+       /*<<list.ml:103:21>>*/ accu$0 =
+        [0,  /*<<list.ml:103:22>>*/ caml_call1(f, a), accu],
+      accu = accu$0,
+      param = l$0;
+    }
+    /*<<list.ml:105:13>>*/ }
+   function iter(f, param){
+    var param$0 = param;
+    for(;;){
+     if(! param$0)  /*<<list.ml:109:10>>*/ return 0;
+     var l = param$0[2], a = param$0[1];
+      /*<<list.ml:110:12>>*/  /*<<list.ml:110:12>>*/ caml_call1(f, a);
+     var param$0 = l;
+    }
+   }
+   function iteri(f, l$0){
+     /*<<list.ml:116:16>>*/ var i = 0, param = l$0;
+    for(;;){
+     if(! param)  /*<<list.ml:113:10>>*/ return 0;
+     var l = param[2], a = param[1];
+      /*<<list.ml:114:12>>*/  /*<<list.ml:114:12>>*/ caml_call2(f, i, a);
+     var i$0 = i + 1 | 0, i = i$0, param = l;
+    }
+    /*<<list.ml:116:27>>*/ }
+   function fold_left(f, accu, l){
+     /*<<list.ml:119:2>>*/ var accu$0 = accu, l$0 = l;
+     /*<<list.ml:119:2>>*/ for(;;){
+     if(! l$0)  /*<<list.ml:120:10>>*/ return accu$0;
+      /*<<list.ml:121:24>>*/ var
+      l$1 = l$0[2],
+      a = l$0[1],
+       /*<<list.ml:121:24>>*/ accu$1 =
+         /*<<list.ml:121:24>>*/ caml_call2(f, accu$0, a),
+      accu$0 = accu$1,
+      l$0 = l$1;
+    }
+    /*<<list.ml:121:36>>*/ }
+   function fold_right(f, l, accu){
+     /*<<list.ml:124:2>>*/ if(! l)  /*<<list.ml:125:10>>*/ return accu;
+    var l$0 = l[2], a = l[1];
+     /*<<list.ml:126:16>>*/ return  /*<<list.ml:126:16>>*/ caml_call2
+            (f, a, fold_right(f, l$0, accu));
+    /*<<list.ml:126:37>>*/ }
+   function map2(f, l1, l2){
+     /*<<list.ml:129:2>>*/ if(l1){
+     if(l2){
+       /*<<list.ml:131:32>>*/ var
+       l2$0 = l2[2],
+       a2 = l2[1],
+       l1$0 = l1[2],
+       a1 = l1[1],
+        /*<<list.ml:131:32>>*/ r =
+          /*<<list.ml:131:32>>*/ caml_call2(f, a1, a2);
+       /*<<list.ml:131:43>>*/ return [0, r, map2(f, l1$0, l2$0)];
+     }
+    }
+    else if(! l2)  /*<<list.ml:130:16>>*/ return 0;
+     /*<<list.ml:132:14>>*/ return  /*<<list.ml:132:14>>*/ caml_call1
+            (Stdlib[1], cst_List_map2);
+    /*<<list.ml:132:37>>*/ }
+   function rev_map2(f, l1, l2){
+     /*<<list.ml:135:2>>*/ var accu = 0, l1$0 = l1, l2$0 = l2;
+     /*<<list.ml:136:4>>*/ for(;;){
+     if(l1$0){
+      if(l2$0){
+        /*<<list.ml:138:34>>*/ var
+        l2$1 = l2$0[2],
+        a2 = l2$0[1],
+        l1$1 = l1$0[2],
+        a1 = l1$0[1],
+         /*<<list.ml:138:34>>*/ accu$0 =
+          [0,  /*<<list.ml:138:35>>*/ caml_call2(f, a1, a2), accu],
+        accu = accu$0,
+        l1$0 = l1$1,
+        l2$0 = l2$1;
+       continue;
+      }
+     }
+     else if(! l2$0)  /*<<list.ml:137:18>>*/ return accu;
+      /*<<list.ml:139:16>>*/ return  /*<<list.ml:139:16>>*/ caml_call1
+             (Stdlib[1], cst_List_rev_map2);
+    }
+    /*<<list.ml:141:18>>*/ }
+   function iter2(f, l1, l2){
+     /*<<list.ml:145:2>>*/ var l1$0 = l1, l2$0 = l2;
+     /*<<list.ml:145:2>>*/ for(;;){
+     if(l1$0){
+      if(l2$0){
+       var l2$1 = l2$0[2], a2 = l2$0[1], l1$1 = l1$0[2], a1 = l1$0[1];
+        /*<<list.ml:147:24>>*/  /*<<list.ml:147:24>>*/ caml_call2(f, a1, a2);
+       var l1$0 = l1$1, l2$0 = l2$1;
+       continue;
+      }
+     }
+     else if(! l2$0)  /*<<list.ml:146:16>>*/ return 0;
+      /*<<list.ml:148:14>>*/ return  /*<<list.ml:148:14>>*/ caml_call1
+             (Stdlib[1], cst_List_iter2);
+    }
+    /*<<list.ml:148:38>>*/ }
+   function fold_left2(f, accu, l1, l2){
+     /*<<list.ml:151:2>>*/ var accu$0 = accu, l1$0 = l1, l2$0 = l2;
+     /*<<list.ml:151:2>>*/ for(;;){
+     if(l1$0){
+      if(l2$0){
+        /*<<list.ml:153:37>>*/ var
+        l2$1 = l2$0[2],
+        a2 = l2$0[1],
+        l1$1 = l1$0[2],
+        a1 = l1$0[1],
+         /*<<list.ml:153:37>>*/ accu$1 =
+           /*<<list.ml:153:37>>*/ caml_call3(f, accu$0, a1, a2),
+        accu$0 = accu$1,
+        l1$0 = l1$1,
+        l2$0 = l2$1;
+       continue;
+      }
+     }
+     else if(! l2$0)  /*<<list.ml:152:16>>*/ return accu$0;
+      /*<<list.ml:154:14>>*/ return  /*<<list.ml:154:14>>*/ caml_call1
+             (Stdlib[1], cst_List_fold_left2);
+    }
+    /*<<list.ml:154:43>>*/ }
+   function fold_right2(f, l1, l2, accu){
+     /*<<list.ml:157:2>>*/ if(l1){
+     if(l2){
+      var l2$0 = l2[2], a2 = l2[1], l1$0 = l1[2], a1 = l1[1];
+       /*<<list.ml:159:32>>*/ return  /*<<list.ml:159:32>>*/ caml_call3
+              (f, a1, a2, fold_right2(f, l1$0, l2$0, accu));
+     }
+    }
+    else if(! l2)  /*<<list.ml:158:16>>*/ return accu;
+     /*<<list.ml:160:14>>*/ return  /*<<list.ml:160:14>>*/ caml_call1
+            (Stdlib[1], cst_List_fold_right2);
+    /*<<list.ml:160:44>>*/ }
+   function for_all(p, param){
+    var param$0 = param;
+    for(;;){
+     if(! param$0)  /*<<list.ml:163:10>>*/ return 1;
+      /*<<list.ml:164:12>>*/ var
+      l = param$0[2],
+      a = param$0[1],
+       /*<<list.ml:164:12>>*/ _I_ =  /*<<list.ml:164:12>>*/ caml_call1(p, a);
+      /*<<list.ml:164:12>>*/ if(! _I_)  /*<<list.ml:164:12>>*/ return _I_;
+     var param$0 = l;
+    }
+   }
+   function exists(p, param){
+    var param$0 = param;
+    for(;;){
+     if(! param$0)  /*<<list.ml:167:10>>*/ return 0;
+      /*<<list.ml:168:12>>*/ var
+      l = param$0[2],
+      a = param$0[1],
+       /*<<list.ml:168:12>>*/ _H_ =  /*<<list.ml:168:12>>*/ caml_call1(p, a);
+      /*<<list.ml:168:12>>*/ if(_H_)  /*<<list.ml:168:12>>*/ return _H_;
+     var param$0 = l;
+    }
+   }
+   function for_all2(p, l1, l2){
+     /*<<list.ml:171:2>>*/ var l1$0 = l1, l2$0 = l2;
+     /*<<list.ml:171:2>>*/ for(;;){
+     if(l1$0){
+      if(l2$0){
+        /*<<list.ml:173:24>>*/ var
+        l2$1 = l2$0[2],
+        a2 = l2$0[1],
+        l1$1 = l1$0[2],
+        a1 = l1$0[1],
+         /*<<list.ml:173:24>>*/ _G_ =
+           /*<<list.ml:173:24>>*/ caml_call2(p, a1, a2);
+        /*<<list.ml:173:24>>*/ if(! _G_)  /*<<list.ml:173:24>>*/ return _G_;
+       var l1$0 = l1$1, l2$0 = l2$1;
+       continue;
+      }
+     }
+     else if(! l2$0)  /*<<list.ml:172:16>>*/ return 1;
+      /*<<list.ml:174:14>>*/ return  /*<<list.ml:174:14>>*/ caml_call1
+             (Stdlib[1], cst_List_for_all2);
+    }
+    /*<<list.ml:174:41>>*/ }
+   function exists2(p, l1, l2){
+     /*<<list.ml:177:2>>*/ var l1$0 = l1, l2$0 = l2;
+     /*<<list.ml:177:2>>*/ for(;;){
+     if(l1$0){
+      if(l2$0){
+        /*<<list.ml:179:24>>*/ var
+        l2$1 = l2$0[2],
+        a2 = l2$0[1],
+        l1$1 = l1$0[2],
+        a1 = l1$0[1],
+         /*<<list.ml:179:24>>*/ _F_ =
+           /*<<list.ml:179:24>>*/ caml_call2(p, a1, a2);
+        /*<<list.ml:179:24>>*/ if(_F_)  /*<<list.ml:179:24>>*/ return _F_;
+       var l1$0 = l1$1, l2$0 = l2$1;
+       continue;
+      }
+     }
+     else if(! l2$0)  /*<<list.ml:178:16>>*/ return 0;
+      /*<<list.ml:180:14>>*/ return  /*<<list.ml:180:14>>*/ caml_call1
+             (Stdlib[1], cst_List_exists2);
+    }
+    /*<<list.ml:180:40>>*/ }
+   function mem(x, param){
+    var param$0 = param;
+    for(;;){
+     if(! param$0)  /*<<list.ml:183:10>>*/ return 0;
+     var
+      l = param$0[2],
+      a = param$0[1],
+      _E_ = 0 ===  /*<<list.ml:184:12>>*/ caml_compare(a, x) ? 1 : 0;
+     if(_E_) return _E_;
+     var param$0 = l;
+    }
+   }
+   function memq(x, param){
+    var param$0 = param;
+    for(;;){
+     if(! param$0)  /*<<list.ml:187:10>>*/ return 0;
+     var l = param$0[2], a = param$0[1], _D_ = a === x ? 1 : 0;
+     if(_D_) return _D_;
+     var param$0 = l;
+    }
+   }
+   function assoc(x, param){
+    var param$0 = param;
+    for(;;){
+     if(! param$0)
+       /*<<list.ml:191:10>>*/ throw  /*<<list.ml:191:10>>*/ caml_maybe_attach_backtrace
+             (Stdlib[8], 1);
+     var l = param$0[2], match = param$0[1], b = match[2], a = match[1];
+      /*<<list.ml:192:19>>*/ if
+      (0 ===  /*<<list.ml:192:19>>*/ caml_compare(a, x))
+       /*<<list.ml:192:40>>*/ return b;
+     var param$0 = l;
+    }
+   }
+   function assoc_opt(x, param){
+    var param$0 = param;
+    for(;;){
+     if(! param$0)  /*<<list.ml:195:10>>*/ return 0;
+     var l = param$0[2], match = param$0[1], b = match[2], a = match[1];
+      /*<<list.ml:196:19>>*/ if
+      (0 ===  /*<<list.ml:196:19>>*/ caml_compare(a, x))
+       /*<<list.ml:196:40>>*/ return [0, b];
+     var param$0 = l;
+    }
+   }
+   function assq(x, param){
+    var param$0 = param;
+    for(;;){
+     if(! param$0)
+       /*<<list.ml:199:10>>*/ throw  /*<<list.ml:199:10>>*/ caml_maybe_attach_backtrace
+             (Stdlib[8], 1);
+     var l = param$0[2], match = param$0[1], b = match[2], a = match[1];
+     if(a === x)  /*<<list.ml:200:31>>*/ return b;
+     var param$0 = l;
+    }
+   }
+   function assq_opt(x, param){
+    var param$0 = param;
+    for(;;){
+     if(! param$0)  /*<<list.ml:203:10>>*/ return 0;
+     var l = param$0[2], match = param$0[1], b = match[2], a = match[1];
+     if(a === x)  /*<<list.ml:204:31>>*/ return [0, b];
+     var param$0 = l;
+    }
+   }
+   function mem_assoc(x, param){
+    var param$0 = param;
+    for(;;){
+     if(! param$0)  /*<<list.ml:207:10>>*/ return 0;
+     var
+      l = param$0[2],
+      a = param$0[1][1],
+      _C_ = 0 ===  /*<<list.ml:208:19>>*/ caml_compare(a, x) ? 1 : 0;
+     if(_C_) return _C_;
+     var param$0 = l;
+    }
+   }
+   function mem_assq(x, param){
+    var param$0 = param;
+    for(;;){
+     if(! param$0)  /*<<list.ml:211:10>>*/ return 0;
+     var l = param$0[2], a = param$0[1][1], _B_ = a === x ? 1 : 0;
+     if(_B_) return _B_;
+     var param$0 = l;
+    }
+   }
+   function remove_assoc(x, param){
+     /*<<?>>*/ if(! param)  /*<<list.ml:215:10>>*/ return 0;
+    var l = param[2], pair = param[1], a = pair[1];
+     /*<<list.ml:217:9>>*/ return 0
+            ===  /*<<list.ml:217:9>>*/ caml_compare(a, x)
+            ? l
+            : [0, pair, remove_assoc(x, l)];
+   }
+   function remove_assq(x, param){
+     /*<<?>>*/ if(! param)  /*<<list.ml:220:10>>*/ return 0;
+    var l = param[2], pair = param[1], a = pair[1];
+    return a === x ? l : [0, pair, remove_assq(x, l)];
+   }
+   function find(p, param){
+    var param$0 = param;
+    for(;;){
+     if(! param$0)
+       /*<<list.ml:224:10>>*/ throw  /*<<list.ml:224:10>>*/ caml_maybe_attach_backtrace
+             (Stdlib[8], 1);
+     var l = param$0[2], x = param$0[1];
+      /*<<list.ml:225:17>>*/ if( /*<<list.ml:225:17>>*/ caml_call1(p, x))
+       /*<<list.ml:225:26>>*/ return x;
+     var param$0 = l;
+    }
+   }
+   function find_opt(p, param){
+    var param$0 = param;
+    for(;;){
+     if(! param$0)  /*<<list.ml:228:10>>*/ return 0;
+     var l = param$0[2], x = param$0[1];
+      /*<<list.ml:229:17>>*/ if( /*<<list.ml:229:17>>*/ caml_call1(p, x))
+       /*<<list.ml:229:26>>*/ return [0, x];
+     var param$0 = l;
+    }
+   }
+   function find_map(f, param){
+    var param$0 = param;
+    for(;;){
+     if(! param$0)  /*<<list.ml:232:10>>*/ return 0;
+      /*<<list.ml:234:17>>*/ var
+      l = param$0[2],
+      x = param$0[1],
+       /*<<list.ml:234:17>>*/ result =
+         /*<<list.ml:234:17>>*/ caml_call1(f, x);
+     if(result)  /*<<list.ml:235:29>>*/ return result;
+     var param$0 = l;
+    }
+   }
+   function find_all(p){
+     /*<<list.ml:240:2>>*/  /*<<list.ml:243:2>>*/ var accu = 0;
+     /*<<list.ml:243:2>>*/ return function(param$0){
+     var accu$0 = accu, param = param$0;
+     for(;;){
+      if(! param)  /*<<list.ml:241:10>>*/ return rev(accu$0);
+      var l = param[2], x = param[1];
+       /*<<list.ml:242:17>>*/ if( /*<<list.ml:242:17>>*/ caml_call1(p, x))
+        /*<<list.ml:242:31>>*/ var
+         /*<<list.ml:242:31>>*/ accu$1 = [0, x, accu$0],
+        accu$0 = accu$1,
+        param = l;
+      else
+       var param = l;
+     }};
+    /*<<list.ml:243:9>>*/ }
+   function filteri(p, l){
+     /*<<list.ml:248:2>>*/ var i = 0, acc = 0, param = l;
+    for(;;){
+     if(! param)  /*<<list.ml:249:10>>*/ return rev(acc);
+      /*<<list.ml:250:28>>*/ var
+      l$0 = param[2],
+      x = param[1],
+       /*<<list.ml:250:28>>*/ acc$0 =
+         /*<<list.ml:250:28>>*/ caml_call2(p, i, x) ? [0, x, acc] : acc,
+      i$0 = i + 1 | 0,
+      i = i$0,
+      acc = acc$0,
+      param = l$0;
+    }
+    /*<<list.ml:252:12>>*/ }
+   function filter_map(f){
+     /*<<list.ml:255:2>>*/  /*<<list.ml:262:2>>*/ var accu = 0;
+     /*<<list.ml:262:2>>*/ return function(param$0){
+     var accu$0 = accu, param = param$0;
+     for(;;){
+      if(! param)  /*<<list.ml:256:12>>*/ return rev(accu$0);
+       /*<<list.ml:258:14>>*/ var
+       l = param[2],
+       x = param[1],
+        /*<<list.ml:258:14>>*/ match =
+          /*<<list.ml:258:14>>*/ caml_call1(f, x);
+      if(match)
+        /*<<list.ml:260:24>>*/ var
+        v = match[1],
+         /*<<list.ml:260:24>>*/ accu$1 = [0, v, accu$0],
+        accu$0 = accu$1,
+        param = l;
+      else
+       var param = l;
+     }};
+    /*<<list.ml:262:8>>*/ }
+   function concat_map(f, l){
+     /*<<list.ml:265:2>>*/ var acc = 0, param = l;
+    for(;;){
+     if(! param)  /*<<list.ml:266:12>>*/ return rev(acc);
+      /*<<list.ml:268:16>>*/ var
+      l$0 = param[2],
+      x = param[1],
+       /*<<list.ml:268:16>>*/ xs =  /*<<list.ml:268:16>>*/ caml_call1(f, x),
+       /*<<list.ml:269:13>>*/ acc$0 = rev_append(xs, acc),
+      acc = acc$0,
+      param = l$0;
+    }
+    /*<<list.ml:270:15>>*/ }
+   function fold_left_map(f, accu, l){
+     /*<<list.ml:273:2>>*/ var accu$0 = accu, l_accu = 0, param = l;
+    for(;;){
+     if(! param)  /*<<list.ml:274:12>>*/ return [0, accu$0, rev(l_accu)];
+      /*<<list.ml:276:22>>*/ var
+      l$0 = param[2],
+      x = param[1],
+       /*<<list.ml:276:22>>*/ match =
+         /*<<list.ml:276:22>>*/ caml_call2(f, accu$0, x),
+      x$0 = match[2],
+      accu$1 = match[1],
+       /*<<list.ml:277:17>>*/ l_accu$0 = [0, x$0, l_accu],
+      accu$0 = accu$1,
+      l_accu = l_accu$0,
+      param = l$0;
+    }
+    /*<<list.ml:278:15>>*/ }
+   function partition(p, l){
+     /*<<list.ml:281:2>>*/ var yes = 0, no = 0, param = l;
+    for(;;){
+     if(! param){
+       /*<<list.ml:282:20>>*/  /*<<list.ml:282:20>>*/ var _A_ = rev(no);
+       /*<<list.ml:282:10>>*/ return [0, rev(yes), _A_];
+     }
+     var l$0 = param[2], x = param[1];
+      /*<<list.ml:283:17>>*/ if( /*<<list.ml:283:17>>*/ caml_call1(p, x))
+       /*<<list.ml:283:31>>*/ var
+        /*<<list.ml:283:31>>*/ yes$0 = [0, x, yes],
+       yes = yes$0,
+       param = l$0;
+     else
+       /*<<list.ml:283:61>>*/ var
+        /*<<list.ml:283:61>>*/ no$0 = [0, x, no],
+       no = no$0,
+       param = l$0;
+    }
+    /*<<list.ml:284:14>>*/ }
+   function partition_map(p, l){
+     /*<<list.ml:287:2>>*/ var left = 0, right = 0, param = l;
+    for(;;){
+     if(! param){
+       /*<<list.ml:288:21>>*/  /*<<list.ml:288:21>>*/ var _z_ = rev(right);
+       /*<<list.ml:288:10>>*/ return [0, rev(left), _z_];
+     }
+      /*<<list.ml:290:17>>*/ var
+      l$0 = param[2],
+      x = param[1],
+       /*<<list.ml:290:17>>*/ match =  /*<<list.ml:290:17>>*/ caml_call1(p, x);
+     if(0 === match[0])
+       /*<<list.ml:291:31>>*/ var
+       v = match[1],
+        /*<<list.ml:291:31>>*/ left$0 = [0, v, left],
+       left = left$0,
+       param = l$0;
+     else
+       /*<<list.ml:292:37>>*/ var
+       v$0 = match[1],
+        /*<<list.ml:292:37>>*/ right$0 = [0, v$0, right],
+       right = right$0,
+       param = l$0;
+    }
+    /*<<list.ml:295:14>>*/ }
+   function split(param){
+     /*<<list.ml:297:16>>*/ if(! param)  /*<<list.ml:298:10>>*/ return _b_;
+     /*<<list.ml:300:21>>*/ var
+     l = param[2],
+     match = param[1],
+     y = match[2],
+     x = match[1],
+      /*<<list.ml:300:21>>*/ match$0 = split(l),
+     ry = match$0[2],
+     rx = match$0[1];
+     /*<<list.ml:300:32>>*/ return [0, [0, x, rx], [0, y, ry]];
+    /*<<list.ml:300:46>>*/ }
+   function combine(l1, l2){
+     /*<<list.ml:303:2>>*/ if(l1){
+     if(l2){
+      var l2$0 = l2[2], a2 = l2[1], l1$0 = l1[2], a1 = l1[1];
+       /*<<list.ml:305:24>>*/ return [0, [0, a1, a2], combine(l1$0, l2$0)];
+     }
+    }
+    else if(! l2)  /*<<list.ml:304:16>>*/ return 0;
+     /*<<list.ml:306:14>>*/ return  /*<<list.ml:306:14>>*/ caml_call1
+            (Stdlib[1], cst_List_combine);
+    /*<<list.ml:306:40>>*/ }
+   function merge(cmp, l1, l2){
+     /*<<list.ml:311:2>>*/ if(! l1)  /*<<list.ml:312:14>>*/ return l2;
+    if(! l2)  /*<<list.ml:313:14>>*/ return l1;
+    var t2 = l2[2], h2 = l2[1], t1 = l1[2], h1 = l1[1];
+     /*<<list.ml:315:9>>*/ return 0
+            <  /*<<list.ml:315:9>>*/ caml_call2(cmp, h1, h2)
+            ? [0, h2, merge(cmp, l1, t2)]
+            : [0, h1, merge(cmp, t1, l2)];
+    /*<<list.ml:317:32>>*/ }
+   function stable_sort(cmp, l){
+    function sort(n, l){
+      /*<<list.ml:340:4>>*/ if(2 === n){
+      if(l){
+       var match = l[2];
+       if(match){
+         /*<<list.ml:342:19>>*/ var
+         tl = match[2],
+         x2 = match[1],
+         x1 = l[1],
+          /*<<list.ml:342:19>>*/ s =
+           0 <  /*<<list.ml:342:19>>*/ caml_call2(cmp, x1, x2)
+            ? [0, x2, [0, x1, 0]]
+            : [0, x1, [0, x2, 0]];
+         /*<<list.ml:343:8>>*/ return [0, s, tl];
+       }
+      }
+     }
+     else if(3 === n && l){
+      var _y_ = l[2];
+      if(_y_){
+       var match$2 = _y_[2];
+       if(match$2){
+         /*<<list.ml:346:13>>*/ var
+         tl$1 = match$2[2],
+         x3 = match$2[1],
+         x2$0 = _y_[1],
+         x1$0 = l[1],
+          /*<<list.ml:346:13>>*/ s$0 =
+           0 <  /*<<list.ml:346:13>>*/ caml_call2(cmp, x1$0, x2$0)
+            ? 0
+              <  /*<<list.ml:350:18>>*/ caml_call2(cmp, x1$0, x3)
+              ? 0
+                <  /*<<list.ml:351:18>>*/ caml_call2(cmp, x2$0, x3)
+                ? [0, x3, [0, x2$0, [0, x1$0, 0]]]
+                : [0, x2$0, [0, x3, [0, x1$0, 0]]]
+              : [0, x2$0, [0, x1$0, [0, x3, 0]]]
+            : 0
+              <  /*<<list.ml:347:15>>*/ caml_call2(cmp, x2$0, x3)
+              ? 0
+                <  /*<<list.ml:348:20>>*/ caml_call2(cmp, x1$0, x3)
+                ? [0, x3, [0, x1$0, [0, x2$0, 0]]]
+                : [0, x1$0, [0, x3, [0, x2$0, 0]]]
+              : [0, x1$0, [0, x2$0, [0, x3, 0]]];
+         /*<<list.ml:354:8>>*/ return [0, s$0, tl$1];
+       }
+      }
+     }
+      /*<<list.ml:358:21>>*/ var
+      n1 = n >> 1,
+      n2 = n - n1 | 0,
+       /*<<list.ml:358:21>>*/ match$0 = rev_sort(n1, l),
+      l2$0 = match$0[2],
+      s1 = match$0[1],
+       /*<<list.ml:359:21>>*/ match$1 = rev_sort(n2, l2$0),
+      tl$0 = match$1[2],
+      s2 = match$1[1],
+      l1 = s1,
+      l2 = s2,
+      accu = 0;
+      /*<<list.ml:331:4>>*/ for(;;){
+      if(l1){
+       if(l2){
+        var t2 = l2[2], h2 = l2[1], t1 = l1[2], h1 = l1[1];
+         /*<<list.ml:335:11>>*/ if
+         (0 <  /*<<list.ml:335:11>>*/ caml_call2(cmp, h1, h2)){
+          /*<<list.ml:336:33>>*/ var
+           /*<<list.ml:336:33>>*/ accu$0 = [0, h1, accu],
+          l1 = t1,
+          accu = accu$0;
+         continue;
+        }
+         /*<<list.ml:337:33>>*/ var
+          /*<<list.ml:337:33>>*/ accu$1 = [0, h2, accu],
+         l2 = t2,
+         accu = accu$1;
+        continue;
+       }
+       var _x_ = rev_append(l1, accu);
+      }
+      else
+       var _x_ = rev_append(l2, accu);
+       /*<<list.ml:360:8>>*/ return [0, _x_, tl$0];
+     }
+     /*<<list.ml:360:36>>*/ }
+    function rev_sort(n, l){
+      /*<<list.ml:362:4>>*/ if(2 === n){
+      if(l){
+       var match = l[2];
+       if(match){
+         /*<<list.ml:364:19>>*/ var
+         tl = match[2],
+         x2 = match[1],
+         x1 = l[1],
+          /*<<list.ml:364:19>>*/ s =
+           0 <  /*<<list.ml:364:19>>*/ caml_call2(cmp, x1, x2)
+            ? [0, x1, [0, x2, 0]]
+            : [0, x2, [0, x1, 0]];
+         /*<<list.ml:365:8>>*/ return [0, s, tl];
+       }
+      }
+     }
+     else if(3 === n && l){
+      var _w_ = l[2];
+      if(_w_){
+       var match$2 = _w_[2];
+       if(match$2){
+         /*<<list.ml:368:13>>*/ var
+         tl$1 = match$2[2],
+         x3 = match$2[1],
+         x2$0 = _w_[1],
+         x1$0 = l[1],
+          /*<<list.ml:368:13>>*/ s$0 =
+           0 <  /*<<list.ml:368:13>>*/ caml_call2(cmp, x1$0, x2$0)
+            ? 0
+              <  /*<<list.ml:369:15>>*/ caml_call2(cmp, x2$0, x3)
+              ? [0, x1$0, [0, x2$0, [0, x3, 0]]]
+              : 0
+                <  /*<<list.ml:370:20>>*/ caml_call2(cmp, x1$0, x3)
+                ? [0, x1$0, [0, x3, [0, x2$0, 0]]]
+                : [0, x3, [0, x1$0, [0, x2$0, 0]]]
+            : 0
+              <  /*<<list.ml:372:18>>*/ caml_call2(cmp, x1$0, x3)
+              ? [0, x2$0, [0, x1$0, [0, x3, 0]]]
+              : 0
+                <  /*<<list.ml:373:18>>*/ caml_call2(cmp, x2$0, x3)
+                ? [0, x2$0, [0, x3, [0, x1$0, 0]]]
+                : [0, x3, [0, x2$0, [0, x1$0, 0]]];
+         /*<<list.ml:376:8>>*/ return [0, s$0, tl$1];
+       }
+      }
+     }
+      /*<<list.ml:380:21>>*/ var
+      n1 = n >> 1,
+      n2 = n - n1 | 0,
+       /*<<list.ml:380:21>>*/ match$0 = sort(n1, l),
+      l2$0 = match$0[2],
+      s1 = match$0[1],
+       /*<<list.ml:381:21>>*/ match$1 = sort(n2, l2$0),
+      tl$0 = match$1[2],
+      s2 = match$1[1],
+      l1 = s1,
+      l2 = s2,
+      accu = 0;
+      /*<<list.ml:322:4>>*/ for(;;){
+      if(l1){
+       if(l2){
+        var t2 = l2[2], h2 = l2[1], t1 = l1[2], h1 = l1[1];
+         /*<<list.ml:326:11>>*/ if
+         (0 <  /*<<list.ml:326:11>>*/ caml_call2(cmp, h1, h2)){
+          /*<<list.ml:328:29>>*/ var
+           /*<<list.ml:328:29>>*/ accu$0 = [0, h2, accu],
+          l2 = t2,
+          accu = accu$0;
+         continue;
+        }
+         /*<<list.ml:327:29>>*/ var
+          /*<<list.ml:327:29>>*/ accu$1 = [0, h1, accu],
+         l1 = t1,
+         accu = accu$1;
+        continue;
+       }
+       var _v_ = rev_append(l1, accu);
+      }
+      else
+       var _v_ = rev_append(l2, accu);
+       /*<<list.ml:382:8>>*/ return [0, _v_, tl$0];
+     }
+     /*<<list.ml:382:32>>*/ }
+     /*<<list.ml:384:12>>*/  /*<<list.ml:384:12>>*/ var len = length(l);
+     /*<<list.ml:385:2>>*/ return 2 <= len ? sort(len, l)[1] : l;
+    /*<<list.ml:385:41>>*/ }
+   function sort_uniq(cmp, l){
+    function sort(n, l){
+      /*<<list.ml:450:4>>*/ if(2 === n){
+      if(l){
+       var match = l[2];
+       if(match){
+         /*<<list.ml:453:18>>*/ var
+         tl = match[2],
+         x2 = match[1],
+         x1 = l[1],
+          /*<<list.ml:453:18>>*/ c$0 =
+            /*<<list.ml:453:18>>*/ caml_call2(cmp, x1, x2),
+          /*<<list.ml:454:10>>*/ s =
+           0 === c$0
+            ? [0, x1, 0]
+            : 0 <= c$0 ? [0, x2, [0, x1, 0]] : [0, x1, [0, x2, 0]];
+         /*<<list.ml:456:8>>*/ return [0, s, tl];
+       }
+      }
+     }
+     else if(3 === n && l){
+      var _p_ = l[2];
+      if(_p_){
+       var match$2 = _p_[2];
+       if(match$2){
+         /*<<list.ml:459:18>>*/ var
+         tl$1 = match$2[2],
+         x3 = match$2[1],
+         x2$0 = _p_[1],
+         x1$0 = l[1],
+          /*<<list.ml:459:18>>*/ c$1 =
+            /*<<list.ml:459:18>>*/ caml_call2(cmp, x1$0, x2$0);
+         /*<<list.ml:460:10>>*/ if(0 === c$1)
+          /*<<list.ml:461:20>>*/ var
+           /*<<list.ml:461:20>>*/ c$2 =
+             /*<<list.ml:461:20>>*/ caml_call2(cmp, x2$0, x3),
+           /*<<list.ml:462:12>>*/ _q_ =
+            0 === c$2
+             ? [0, x2$0, 0]
+             : 0 <= c$2 ? [0, x3, [0, x2$0, 0]] : [0, x2$0, [0, x3, 0]],
+          s$0 = _q_;
+        else if(0 <= c$1){
+          /*<<list.ml:473:20>>*/  /*<<list.ml:473:20>>*/ var
+          c$3 =  /*<<list.ml:473:20>>*/ caml_call2(cmp, x1$0, x3);
+          /*<<list.ml:474:12>>*/ if(0 === c$3)
+          var _r_ = [0, x2$0, [0, x1$0, 0]];
+         else if(0 <= c$3)
+           /*<<list.ml:477:22>>*/ var
+            /*<<list.ml:477:22>>*/ c$4 =
+              /*<<list.ml:477:22>>*/ caml_call2(cmp, x2$0, x3),
+            /*<<list.ml:478:14>>*/ _s_ =
+             0 === c$4
+              ? [0, x2$0, [0, x1$0, 0]]
+              : 0
+                <= c$4
+                ? [0, x3, [0, x2$0, [0, x1$0, 0]]]
+                : [0, x2$0, [0, x3, [0, x1$0, 0]]],
+           _r_ = _s_;
+         else
+          var _r_ = [0, x2$0, [0, x1$0, [0, x3, 0]]];
+         var s$0 = _r_;
+        }
+        else{
+          /*<<list.ml:464:20>>*/  /*<<list.ml:464:20>>*/ var
+          c$5 =  /*<<list.ml:464:20>>*/ caml_call2(cmp, x2$0, x3);
+          /*<<list.ml:465:12>>*/ if(0 === c$5)
+          var _t_ = [0, x1$0, [0, x2$0, 0]];
+         else if(0 <= c$5)
+           /*<<list.ml:468:22>>*/ var
+            /*<<list.ml:468:22>>*/ c$6 =
+              /*<<list.ml:468:22>>*/ caml_call2(cmp, x1$0, x3),
+            /*<<list.ml:469:14>>*/ _u_ =
+             0 === c$6
+              ? [0, x1$0, [0, x2$0, 0]]
+              : 0
+                <= c$6
+                ? [0, x3, [0, x1$0, [0, x2$0, 0]]]
+                : [0, x1$0, [0, x3, [0, x2$0, 0]]],
+           _t_ = _u_;
+         else
+          var _t_ = [0, x1$0, [0, x2$0, [0, x3, 0]]];
+         var s$0 = _t_;
+        }
+         /*<<list.ml:482:8>>*/ return [0, s$0, tl$1];
+       }
+      }
+     }
+      /*<<list.ml:486:21>>*/ var
+      n1 = n >> 1,
+      n2 = n - n1 | 0,
+       /*<<list.ml:486:21>>*/ match$0 = rev_sort(n1, l),
+      l2$0 = match$0[2],
+      s1 = match$0[1],
+       /*<<list.ml:487:21>>*/ match$1 = rev_sort(n2, l2$0),
+      tl$0 = match$1[2],
+      s2 = match$1[1],
+      l1 = s1,
+      l2 = s2,
+      accu = 0;
+      /*<<list.ml:439:4>>*/ for(;;){
+      if(l1){
+       if(l2){
+         /*<<list.ml:443:16>>*/ var
+         t2 = l2[2],
+         h2 = l2[1],
+         t1 = l1[2],
+         h1 = l1[1],
+          /*<<list.ml:443:16>>*/ c =
+            /*<<list.ml:443:16>>*/ caml_call2(cmp, h1, h2);
+         /*<<list.ml:444:8>>*/ if(0 === c){
+          /*<<list.ml:444:42>>*/ var
+           /*<<list.ml:444:42>>*/ accu$0 = [0, h1, accu],
+          l1 = t1,
+          l2 = t2,
+          accu = accu$0;
+         continue;
+        }
+        if(0 < c){
+          /*<<list.ml:446:33>>*/ var
+           /*<<list.ml:446:33>>*/ accu$1 = [0, h1, accu],
+          l1 = t1,
+          accu = accu$1;
+         continue;
+        }
+         /*<<list.ml:447:33>>*/ var
+          /*<<list.ml:447:33>>*/ accu$2 = [0, h2, accu],
+         l2 = t2,
+         accu = accu$2;
+        continue;
+       }
+       var _o_ = rev_append(l1, accu);
+      }
+      else
+       var _o_ = rev_append(l2, accu);
+       /*<<list.ml:488:8>>*/ return [0, _o_, tl$0];
+     }
+     /*<<list.ml:488:36>>*/ }
+    function rev_sort(n, l){
+      /*<<list.ml:490:4>>*/ if(2 === n){
+      if(l){
+       var match = l[2];
+       if(match){
+         /*<<list.ml:493:18>>*/ var
+         tl = match[2],
+         x2 = match[1],
+         x1 = l[1],
+          /*<<list.ml:493:18>>*/ c$0 =
+            /*<<list.ml:493:18>>*/ caml_call2(cmp, x1, x2),
+          /*<<list.ml:494:10>>*/ s =
+           0 === c$0
+            ? [0, x1, 0]
+            : 0 < c$0 ? [0, x1, [0, x2, 0]] : [0, x2, [0, x1, 0]];
+         /*<<list.ml:496:8>>*/ return [0, s, tl];
+       }
+      }
+     }
+     else if(3 === n && l){
+      var _i_ = l[2];
+      if(_i_){
+       var match$2 = _i_[2];
+       if(match$2){
+         /*<<list.ml:499:18>>*/ var
+         tl$1 = match$2[2],
+         x3 = match$2[1],
+         x2$0 = _i_[1],
+         x1$0 = l[1],
+          /*<<list.ml:499:18>>*/ c$1 =
+            /*<<list.ml:499:18>>*/ caml_call2(cmp, x1$0, x2$0);
+         /*<<list.ml:500:10>>*/ if(0 === c$1)
+          /*<<list.ml:501:20>>*/ var
+           /*<<list.ml:501:20>>*/ c$2 =
+             /*<<list.ml:501:20>>*/ caml_call2(cmp, x2$0, x3),
+           /*<<list.ml:502:12>>*/ _j_ =
+            0 === c$2
+             ? [0, x2$0, 0]
+             : 0 < c$2 ? [0, x2$0, [0, x3, 0]] : [0, x3, [0, x2$0, 0]],
+          s$0 = _j_;
+        else if(0 < c$1){
+          /*<<list.ml:504:20>>*/  /*<<list.ml:504:20>>*/ var
+          c$3 =  /*<<list.ml:504:20>>*/ caml_call2(cmp, x2$0, x3);
+          /*<<list.ml:505:12>>*/ if(0 === c$3)
+          var _k_ = [0, x1$0, [0, x2$0, 0]];
+         else if(0 < c$3)
+          var _k_ = [0, x1$0, [0, x2$0, [0, x3, 0]]];
+         else
+           /*<<list.ml:508:22>>*/ var
+            /*<<list.ml:508:22>>*/ c$4 =
+              /*<<list.ml:508:22>>*/ caml_call2(cmp, x1$0, x3),
+            /*<<list.ml:509:14>>*/ _l_ =
+             0 === c$4
+              ? [0, x1$0, [0, x2$0, 0]]
+              : 0
+                < c$4
+                ? [0, x1$0, [0, x3, [0, x2$0, 0]]]
+                : [0, x3, [0, x1$0, [0, x2$0, 0]]],
+           _k_ = _l_;
+         var s$0 = _k_;
+        }
+        else{
+          /*<<list.ml:513:20>>*/  /*<<list.ml:513:20>>*/ var
+          c$5 =  /*<<list.ml:513:20>>*/ caml_call2(cmp, x1$0, x3);
+          /*<<list.ml:514:12>>*/ if(0 === c$5)
+          var _m_ = [0, x2$0, [0, x1$0, 0]];
+         else if(0 < c$5)
+          var _m_ = [0, x2$0, [0, x1$0, [0, x3, 0]]];
+         else
+           /*<<list.ml:517:22>>*/ var
+            /*<<list.ml:517:22>>*/ c$6 =
+              /*<<list.ml:517:22>>*/ caml_call2(cmp, x2$0, x3),
+            /*<<list.ml:518:14>>*/ _n_ =
+             0 === c$6
+              ? [0, x2$0, [0, x1$0, 0]]
+              : 0
+                < c$6
+                ? [0, x2$0, [0, x3, [0, x1$0, 0]]]
+                : [0, x3, [0, x2$0, [0, x1$0, 0]]],
+           _m_ = _n_;
+         var s$0 = _m_;
+        }
+         /*<<list.ml:522:8>>*/ return [0, s$0, tl$1];
+       }
+      }
+     }
+      /*<<list.ml:526:21>>*/ var
+      n1 = n >> 1,
+      n2 = n - n1 | 0,
+       /*<<list.ml:526:21>>*/ match$0 = sort(n1, l),
+      l2$0 = match$0[2],
+      s1 = match$0[1],
+       /*<<list.ml:527:21>>*/ match$1 = sort(n2, l2$0),
+      tl$0 = match$1[2],
+      s2 = match$1[1],
+      l1 = s1,
+      l2 = s2,
+      accu = 0;
+      /*<<list.ml:428:4>>*/ for(;;){
+      if(l1){
+       if(l2){
+         /*<<list.ml:432:16>>*/ var
+         t2 = l2[2],
+         h2 = l2[1],
+         t1 = l1[2],
+         h1 = l1[1],
+          /*<<list.ml:432:16>>*/ c =
+            /*<<list.ml:432:16>>*/ caml_call2(cmp, h1, h2);
+         /*<<list.ml:433:8>>*/ if(0 === c){
+          /*<<list.ml:433:38>>*/ var
+           /*<<list.ml:433:38>>*/ accu$0 = [0, h1, accu],
+          l1 = t1,
+          l2 = t2,
+          accu = accu$0;
+         continue;
+        }
+        if(0 <= c){
+          /*<<list.ml:436:29>>*/ var
+           /*<<list.ml:436:29>>*/ accu$1 = [0, h2, accu],
+          l2 = t2,
+          accu = accu$1;
+         continue;
+        }
+         /*<<list.ml:435:29>>*/ var
+          /*<<list.ml:435:29>>*/ accu$2 = [0, h1, accu],
+         l1 = t1,
+         accu = accu$2;
+        continue;
+       }
+       var _h_ = rev_append(l1, accu);
+      }
+      else
+       var _h_ = rev_append(l2, accu);
+       /*<<list.ml:528:8>>*/ return [0, _h_, tl$0];
+     }
+     /*<<list.ml:528:32>>*/ }
+     /*<<list.ml:530:12>>*/  /*<<list.ml:530:12>>*/ var len = length(l);
+     /*<<list.ml:531:2>>*/ return 2 <= len ? sort(len, l)[1] : l;
+    /*<<list.ml:531:41>>*/ }
+   function compare_lengths(l1, l2){
+     /*<<list.ml:535:2>>*/ var l1$0 = l1, l2$0 = l2;
+     /*<<list.ml:535:2>>*/ for(;;){
+     if(! l1$0) return l2$0 ? -1 : 0;
+     if(! l2$0)  /*<<list.ml:538:13>>*/ return 1;
+     var l2$1 = l2$0[2], l1$1 = l1$0[2], l1$0 = l1$1, l2$0 = l2$1;
+    }
+    /*<<list.ml:539:45>>*/ }
+   function compare_length_with(l, n){
+     /*<<list.ml:542:2>>*/ var l$0 = l, n$0 = n;
+     /*<<list.ml:542:2>>*/ for(;;){
+     if(! l$0) return 0 === n$0 ? 0 : 0 < n$0 ? -1 : 1;
+     var l$1 = l$0[2];
+      /*<<list.ml:547:4>>*/ if(0 >= n$0)  /*<<list.ml:547:19>>*/ return 1;
+      /*<<list.ml:548:6>>*/ var
+       /*<<list.ml:548:6>>*/ n$1 = n$0 - 1 | 0,
+      l$0 = l$1,
+      n$0 = n$1;
+    }
+    /*<<list.ml:548:33>>*/ }
+   function equal(eq, l1, l2){
+     /*<<list.ml:558:2>>*/ var l1$0 = l1, l2$0 = l2;
+     /*<<list.ml:558:2>>*/ for(;;){
+     if(l1$0){
+      if(l2$0){
+        /*<<list.ml:561:22>>*/ var
+        l2$1 = l2$0[2],
+        a2 = l2$0[1],
+        l1$1 = l1$0[2],
+        a1 = l1$0[1],
+         /*<<list.ml:561:22>>*/ _g_ =
+           /*<<list.ml:561:22>>*/ caml_call2(eq, a1, a2);
+        /*<<list.ml:561:22>>*/ if(! _g_)  /*<<list.ml:561:22>>*/ return _g_;
+       var l1$0 = l1$1, l2$0 = l2$1;
+       continue;
+      }
+     }
+     else if(! l2$0)  /*<<list.ml:559:14>>*/ return 1;
+      /*<<list.ml:560:27>>*/ return 0;
+    }
+    /*<<list.ml:561:48>>*/ }
+   function compare(cmp, l1, l2){
+     /*<<list.ml:564:2>>*/ var l1$0 = l1, l2$0 = l2;
+     /*<<list.ml:564:2>>*/ for(;;){
+     if(! l1$0) return l2$0 ? -1 : 0;
+     var l1$1 = l1$0[2], a1 = l1$0[1];
+     if(! l2$0)  /*<<list.ml:567:16>>*/ return 1;
+      /*<<list.ml:569:12>>*/ var
+      l2$1 = l2$0[2],
+      a2 = l2$0[1],
+       /*<<list.ml:569:12>>*/ c =
+         /*<<list.ml:569:12>>*/ caml_call2(cmp, a1, a2);
+      /*<<list.ml:570:4>>*/ if(0 !== c)  /*<<list.ml:570:19>>*/ return c;
+     var l1$0 = l1$1, l2$0 = l2$1;
+    }
+    /*<<list.ml:571:26>>*/ }
+   function to_seq(l){
+     /*<<list.ml:576:2>>*/ function aux(l, param){
+      /*<<list.ml:576:21>>*/ if(! l)  /*<<list.ml:577:12>>*/ return 0;
+     var tail = l[2], x = l[1];
+      /*<<list.ml:578:19>>*/ return [0,
+             x,
+             function(_f_){ /*<<?>>*/ return aux(tail, _f_);}];
+     /*<<list.ml:578:41>>*/ }
+     /*<<list.ml:580:2>>*/ return function(_e_){
+      /*<<?>>*/ return aux(l, _e_);};
+    /*<<list.ml:580:7>>*/ }
+   function of_seq(seq){
+    function direct(depth, seq){
+      /*<<list.ml:584:4>>*/ if(0 === depth){
+      var
+       _c_ = 0,
+       _d_ =
+         function(acc, x){
+           /*<<list.ml:586:34>>*/ return [0, x, acc];
+          /*<<list.ml:586:40>>*/ };
+       /*<<list.ml:586:6>>*/ return rev
+              ( /*<<list.ml:586:6>>*/ caml_call3(Stdlib_Seq[5], _d_, _c_, seq));
+     }
+      /*<<list.ml:588:15>>*/  /*<<list.ml:588:15>>*/ var
+      match =  /*<<list.ml:588:15>>*/ caml_call1(seq, 0);
+     if(! match)  /*<<list.ml:589:19>>*/ return 0;
+     var next = match[2], x = match[1];
+      /*<<list.ml:590:30>>*/ return [0, x, direct(depth - 1 | 0, next)];
+     /*<<list.ml:590:56>>*/ }
+     /*<<list.ml:592:2>>*/ return direct(500, seq);
+    /*<<list.ml:592:16>>*/ }
+   var
+    Stdlib_List =
+      [0,
+       length,
+       compare_lengths,
+       compare_length_with,
+       cons,
+       hd,
+       tl,
+       nth,
+       nth_opt,
+       rev,
+       init,
+       append,
+       rev_append,
+       flatten,
+       flatten,
+       equal,
+       compare,
+       iter,
+       iteri,
+       map,
+       mapi,
+       rev_map,
+       filter_map,
+       concat_map,
+       fold_left_map,
+       fold_left,
+       fold_right,
+       iter2,
+       map2,
+       rev_map2,
+       fold_left2,
+       fold_right2,
+       for_all,
+       exists,
+       for_all2,
+       exists2,
+       mem,
+       memq,
+       find,
+       find_opt,
+       find_map,
+       find_all,
+       find_all,
+       filteri,
+       partition,
+       partition_map,
+       assoc,
+       assoc_opt,
+       assq,
+       assq_opt,
+       mem_assoc,
+       mem_assq,
+       remove_assoc,
+       remove_assq,
+       split,
+       combine,
+       stable_sort,
+       stable_sort,
+       stable_sort,
+       sort_uniq,
+       merge,
+       to_seq,
+       of_seq];
+   runtime.caml_register_global(18, Stdlib_List, "Stdlib__List");
+   return;
+   /*<<?>>*/ }
+  (globalThis));
+
+//# unitInfo: Provides: Stdlib__Int
+(function(globalThis){
+   "use strict";
+   var runtime = globalThis.jsoo_runtime, zero = 0, one = 1, minus_one = -1;
+   function abs(x){
+     /*<<int.ml:29:12>>*/ return 0 <= x ? x : - x | 0;
+    /*<<int.ml:29:36>>*/ }
+   var max_int = 2147483647, min_int = -2147483648;
+   function lognot(x){
+     /*<<int.ml:35:15>>*/ return x ^ -1;
+    /*<<int.ml:35:28>>*/ }
+   function equal(_b_, _a_){ /*<<?>>*/ return _b_ === _a_ ? 1 : 0;}
+   var compare = runtime.caml_int_compare;
+   function min(x, y){
+     /*<<int.ml:41:18>>*/ return x <= y ? x : y;
+    /*<<int.ml:41:41>>*/ }
+   function max(x, y){
+     /*<<int.ml:42:18>>*/ return y <= x ? x : y;
+    /*<<int.ml:42:41>>*/ }
+   function to_string(x){
+     /*<<int.ml:52:18>>*/ return "" + x;
+    /*<<int.ml:52:35>>*/ }
+   var
+    Stdlib_Int =
+      [0,
+       zero,
+       one,
+       minus_one,
+       abs,
+       max_int,
+       min_int,
+       lognot,
+       equal,
+       compare,
+       min,
+       max,
+       to_string];
+   runtime.caml_register_global(1, Stdlib_Int, "Stdlib__Int");
+   return;
+   /*<<?>>*/ }
+  (globalThis));
+
+//# unitInfo: Provides: Stdlib__Bytes
+//# unitInfo: Requires: Assert_failure, Stdlib, Stdlib__Char, Stdlib__Int, Stdlib__Seq, Stdlib__Sys, Stdlib__Uchar
+(function
+  (globalThis){
+   "use strict";
+   var
+    runtime = globalThis.jsoo_runtime,
+    cst_bytes_ml = "bytes.ml",
+    cst_index_out_of_bounds$3 = "index out of bounds",
+    caml_blit_bytes = runtime.caml_blit_bytes,
+    caml_bswap16 = runtime.caml_bswap16,
+    caml_bytes_get = runtime.caml_bytes_get,
+    caml_bytes_get16 = runtime.caml_bytes_get16,
+    caml_bytes_get32 = runtime.caml_bytes_get32,
+    caml_bytes_get64 = runtime.caml_bytes_get64,
+    caml_bytes_of_string = runtime.caml_bytes_of_string,
+    caml_bytes_set = runtime.caml_bytes_set,
+    caml_bytes_set16 = runtime.caml_bytes_set16,
+    caml_bytes_set32 = runtime.caml_bytes_set32,
+    caml_bytes_set64 = runtime.caml_bytes_set64,
+    caml_bytes_unsafe_get = runtime.caml_bytes_unsafe_get,
+    caml_bytes_unsafe_set = runtime.caml_bytes_unsafe_set,
+    caml_create_bytes = runtime.caml_create_bytes,
+    caml_fill_bytes = runtime.caml_fill_bytes,
+    caml_int32_bswap = runtime.caml_int32_bswap,
+    caml_int64_bswap = runtime.caml_int64_bswap,
+    caml_maybe_attach_backtrace = runtime.caml_maybe_attach_backtrace,
+    caml_ml_bytes_length = runtime.caml_ml_bytes_length,
+    caml_string_of_bytes = runtime.caml_string_of_bytes,
+    caml_wrap_exception = runtime.caml_wrap_exception;
+    /*<<?>>*/ function caml_call1(f, a0){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 1
+            ? f(a0)
+            : runtime.caml_call_gen(f, [a0]);
+   }
+    /*<<?>>*/ function caml_call2(f, a0, a1){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 2
+            ? f(a0, a1)
+            : runtime.caml_call_gen(f, [a0, a1]);
+   }
+   var
+    global_data = runtime.caml_get_global_data(),
+    Stdlib = global_data.Stdlib,
+    Stdlib_Uchar = global_data.Stdlib__Uchar,
+    Assert_failure = global_data.Assert_failure,
+    Stdlib_Sys = global_data.Stdlib__Sys,
+    Stdlib_Int = global_data.Stdlib__Int,
+    Stdlib_Seq = global_data.Stdlib__Seq,
+    Stdlib_Char = global_data.Stdlib__Char,
+    cst_index_out_of_bounds$2 = cst_index_out_of_bounds$3,
+    _f_ = [0, cst_bytes_ml, 820, 20],
+    _e_ = [0, cst_bytes_ml, 831, 9],
+    cst_index_out_of_bounds$1 = cst_index_out_of_bounds$3,
+    cst_index_out_of_bounds$0 = cst_index_out_of_bounds$3,
+    _d_ = [0, cst_bytes_ml, 766, 20],
+    _c_ = [0, cst_bytes_ml, 777, 9],
+    cst_index_out_of_bounds = cst_index_out_of_bounds$3,
+    _b_ = [0, cst_bytes_ml, 654, 20],
+    _a_ = [0, cst_bytes_ml, 679, 9],
+    cst_Bytes_of_seq_cannot_grow_b = "Bytes.of_seq: cannot grow bytes",
+    cst_String_rcontains_from_Byte =
+      "String.rcontains_from / Bytes.rcontains_from",
+    cst_String_contains_from_Bytes =
+      "String.contains_from / Bytes.contains_from",
+    cst_String_rindex_from_opt_Byt =
+      "String.rindex_from_opt / Bytes.rindex_from_opt",
+    cst_String_rindex_from_Bytes_r = "String.rindex_from / Bytes.rindex_from",
+    cst_String_index_from_opt_Byte =
+      "String.index_from_opt / Bytes.index_from_opt",
+    cst_String_index_from_Bytes_in = "String.index_from / Bytes.index_from",
+    cst_Bytes_concat = "Bytes.concat",
+    cst_String_blit_Bytes_blit_str = "String.blit / Bytes.blit_string",
+    cst_Bytes_blit = "Bytes.blit",
+    cst_String_fill_Bytes_fill = "String.fill / Bytes.fill",
+    cst_Bytes_extend = "Bytes.extend",
+    cst_String_sub_Bytes_sub = "String.sub / Bytes.sub";
+   function make(n, c){
+     /*<<bytes.ml:42:2>>*/  /*<<bytes.ml:42:10>>*/ var
+     s =  /*<<bytes.ml:42:10>>*/ caml_create_bytes(n);
+     /*<<bytes.ml:43:2>>*/  /*<<bytes.ml:43:2>>*/ caml_fill_bytes(s, 0, n, c);
+     /*<<bytes.ml:43:2>>*/ return s;
+    /*<<bytes.ml:44:3>>*/ }
+   function init(n, f){
+     /*<<bytes.ml:47:2>>*/ var
+      /*<<bytes.ml:47:10>>*/ s =  /*<<bytes.ml:47:10>>*/ caml_create_bytes(n),
+      /*<<bytes.ml:48:2>>*/ _aq_ = n - 1 | 0,
+      /*<<bytes.ml:47:10>>*/ _ap_ = 0;
+    if(_aq_ >= 0){
+     var i = _ap_;
+     for(;;){
+      caml_bytes_unsafe_set(s, i,  /*<<bytes.ml:49:19>>*/ caml_call1(f, i));
+       /*<<bytes.ml:48:2>>*/  /*<<bytes.ml:48:2>>*/ var _ar_ = i + 1 | 0;
+      if(_aq_ === i) break;
+      var i = _ar_;
+     }
+    }
+     /*<<bytes.ml:51:2>>*/ return s;
+    /*<<bytes.ml:51:3>>*/ }
+    /*<<bytes.ml:53:12>>*/  /*<<bytes.ml:53:12>>*/ var
+    empty =  /*<<bytes.ml:53:12>>*/ caml_create_bytes(0);
+   function copy(s){
+     /*<<bytes.ml:56:2>>*/ var
+     len = caml_ml_bytes_length(s),
+      /*<<bytes.ml:57:10>>*/ r =
+        /*<<bytes.ml:57:10>>*/ caml_create_bytes(len);
+     /*<<bytes.ml:58:2>>*/  /*<<bytes.ml:58:2>>*/ caml_blit_bytes
+     (s, 0, r, 0, len);
+     /*<<bytes.ml:58:2>>*/ return r;
+    /*<<bytes.ml:59:3>>*/ }
+   function to_string(b){
+     /*<<bytes.ml:61:18>>*/ return  /*<<bytes.ml:61:35>>*/ caml_string_of_bytes
+            (copy(b));
+    /*<<bytes.ml:61:43>>*/ }
+   function of_string(s){
+     /*<<bytes.ml:62:18>>*/ return copy(caml_bytes_of_string(s));
+    /*<<bytes.ml:62:43>>*/ }
+   function sub(s, ofs, len){
+     /*<<bytes.ml:65:2>>*/ if
+     (0 <= ofs && 0 <= len && (caml_ml_bytes_length(s) - len | 0) >= ofs){
+      /*<<bytes.ml:68:12>>*/  /*<<bytes.ml:68:12>>*/ var
+      r =  /*<<bytes.ml:68:12>>*/ caml_create_bytes(len);
+      /*<<bytes.ml:69:4>>*/  /*<<bytes.ml:69:4>>*/ caml_blit_bytes
+      (s, ofs, r, 0, len);
+      /*<<bytes.ml:69:4>>*/ return r;
+    }
+     /*<<bytes.ml:66:7>>*/ return  /*<<bytes.ml:66:7>>*/ caml_call1
+            (Stdlib[1], cst_String_sub_Bytes_sub);
+    /*<<bytes.ml:71:5>>*/ }
+   function sub_string(b, ofs, len){
+     /*<<bytes.ml:73:27>>*/ return  /*<<bytes.ml:73:44>>*/ caml_string_of_bytes
+            (sub(b, ofs, len));
+    /*<<bytes.ml:73:59>>*/ }
+   function symbol(a, b){
+     /*<<bytes.ml:77:2>>*/ var
+     c = a + b | 0,
+     _ao_ = b < 0 ? 1 : 0,
+     match = c < 0 ? 1 : 0;
+    a:
+    {
+     if(a < 0){if(_ao_ && ! match) break a;} else if(! _ao_ && match) break a;
+      /*<<bytes.ml:81:9>>*/ return c;
+    }
+     /*<<bytes.ml:80:27>>*/ return  /*<<bytes.ml:80:27>>*/ caml_call1
+            (Stdlib[1], cst_Bytes_extend);
+    /*<<bytes.ml:81:10>>*/ }
+   function extend(s, left, right){
+     /*<<bytes.ml:84:2>>*/ var
+      /*<<bytes.ml:84:12>>*/ len =
+       symbol(symbol(caml_ml_bytes_length(s), left), right),
+      /*<<bytes.ml:85:10>>*/ r =
+        /*<<bytes.ml:85:10>>*/ caml_create_bytes(len);
+    if(0 <= left)
+     var dstoff = left, srcoff = 0;
+    else
+     var dstoff = 0, srcoff = - left | 0;
+     /*<<bytes.ml:87:15>>*/  /*<<bytes.ml:87:15>>*/ var
+     cpylen =
+        /*<<bytes.ml:87:15>>*/ caml_call2
+        (Stdlib_Int[10],
+         caml_ml_bytes_length(s) - srcoff | 0,
+         len - dstoff | 0);
+    if(0 < cpylen)
+      /*<<bytes.ml:88:21>>*/  /*<<bytes.ml:88:21>>*/ caml_blit_bytes
+      (s, srcoff, r, dstoff, cpylen);
+     /*<<bytes.ml:88:21>>*/ return r;
+    /*<<bytes.ml:89:3>>*/ }
+   function fill(s, ofs, len, c){
+     /*<<bytes.ml:92:2>>*/ if
+     (0 <= ofs && 0 <= len && (caml_ml_bytes_length(s) - len | 0) >= ofs)
+      /*<<bytes.ml:94:7>>*/ return  /*<<bytes.ml:94:7>>*/ caml_fill_bytes
+             (s, ofs, len, c);
+     /*<<bytes.ml:93:7>>*/ return  /*<<bytes.ml:93:7>>*/ caml_call1
+            (Stdlib[1], cst_String_fill_Bytes_fill);
+    /*<<bytes.ml:94:30>>*/ }
+   function blit(s1, ofs1, s2, ofs2, len){
+     /*<<bytes.ml:97:2>>*/ if
+     (0 <= len
+      &&
+       0 <= ofs1
+       &&
+        (caml_ml_bytes_length(s1) - len | 0) >= ofs1
+        && 0 <= ofs2 && (caml_ml_bytes_length(s2) - len | 0) >= ofs2)
+      /*<<bytes.ml:100:7>>*/ return  /*<<bytes.ml:100:7>>*/ caml_blit_bytes
+             (s1, ofs1, s2, ofs2, len);
+     /*<<bytes.ml:99:7>>*/ return  /*<<bytes.ml:99:7>>*/ caml_call1
+            (Stdlib[1], cst_Bytes_blit);
+    /*<<bytes.ml:100:38>>*/ }
+   function blit_string(s1, ofs1, s2, ofs2, len){
+     /*<<bytes.ml:103:2>>*/ if
+     (0 <= len
+      &&
+       0 <= ofs1
+       &&
+        (runtime.caml_ml_string_length(s1) - len | 0) >= ofs1
+        && 0 <= ofs2 && (caml_ml_bytes_length(s2) - len | 0) >= ofs2)
+      /*<<bytes.ml:106:7>>*/ return  /*<<bytes.ml:106:7>>*/ runtime.caml_blit_string
+             (s1, ofs1, s2, ofs2, len);
+     /*<<bytes.ml:105:7>>*/ return  /*<<bytes.ml:105:7>>*/ caml_call1
+            (Stdlib[1], cst_String_blit_Bytes_blit_str);
+    /*<<bytes.ml:106:45>>*/ }
+   function iter(f, a){
+     /*<<bytes.ml:110:2>>*/ var
+     _am_ = caml_ml_bytes_length(a) - 1 | 0,
+      /*<<bytes.ml:110:2>>*/ _al_ = 0;
+    if(_am_ >= 0){
+     var i = _al_;
+     for(;;){
+       /*<<bytes.ml:110:31>>*/  /*<<bytes.ml:110:31>>*/ caml_call1
+       (f, caml_bytes_unsafe_get(a, i));
+       /*<<bytes.ml:110:31>>*/  /*<<bytes.ml:110:31>>*/ var _an_ = i + 1 | 0;
+      if(_am_ === i) break;
+      var i = _an_;
+     }
+    }
+    return 0;
+    /*<<bytes.ml:110:53>>*/ }
+   function iteri(f, a){
+     /*<<bytes.ml:114:2>>*/ var
+     _aj_ = caml_ml_bytes_length(a) - 1 | 0,
+      /*<<bytes.ml:114:2>>*/ _ai_ = 0;
+    if(_aj_ >= 0){
+     var i = _ai_;
+     for(;;){
+       /*<<bytes.ml:114:31>>*/  /*<<bytes.ml:114:31>>*/ caml_call2
+       (f, i, caml_bytes_unsafe_get(a, i));
+       /*<<bytes.ml:114:31>>*/  /*<<bytes.ml:114:31>>*/ var _ak_ = i + 1 | 0;
+      if(_aj_ === i) break;
+      var i = _ak_;
+     }
+    }
+    return 0;
+    /*<<bytes.ml:114:56>>*/ }
+   function concat(sep, l){
+     /*<<?>>*/ if(! l)  /*<<bytes.ml:53:12>>*/ return empty;
+    var seplen = caml_ml_bytes_length(sep), acc = 0, param = l, pos$1 = 0;
+    for(;;){
+     if(param){
+      var hd = param[1];
+      if(param[2]){
+       var
+        tl = param[2],
+        x = (caml_ml_bytes_length(hd) + seplen | 0) + acc | 0,
+        acc$0 =
+          acc <= x
+           ? x
+           :  /*<<bytes.ml:116:48>>*/ caml_call1(Stdlib[1], cst_Bytes_concat),
+        acc = acc$0,
+        param = tl;
+       continue;
+      }
+      var _ah_ = caml_ml_bytes_length(hd) + acc | 0;
+     }
+     else
+      var _ah_ = acc;
+      /*<<bytes.ml:136:12>>*/ var
+       /*<<bytes.ml:136:12>>*/ dst =
+         /*<<bytes.ml:136:12>>*/ caml_create_bytes(_ah_),
+      pos = pos$1,
+      param$0 = l;
+     for(;;){
+      if(! param$0)  /*<<bytes.ml:124:10>>*/ return dst;
+      var hd$0 = param$0[1];
+      if(! param$0[2]){
+        /*<<bytes.ml:126:4>>*/  /*<<bytes.ml:126:4>>*/ caml_blit_bytes
+        (hd$0, 0, dst, pos, caml_ml_bytes_length(hd$0));
+        /*<<bytes.ml:126:4>>*/ return dst;
+      }
+      var tl$0 = param$0[2];
+       /*<<bytes.ml:128:4>>*/  /*<<bytes.ml:128:4>>*/ caml_blit_bytes
+       (hd$0, 0, dst, pos,  /*<<bytes.ml:128:4>>*/ caml_ml_bytes_length(hd$0));
+       /*<<bytes.ml:129:4>>*/  /*<<bytes.ml:129:4>>*/ caml_blit_bytes
+       (sep, 0, dst, pos + caml_ml_bytes_length(hd$0) | 0, seplen);
+      var
+       pos$0 = (pos + caml_ml_bytes_length(hd$0) | 0) + seplen | 0,
+       pos = pos$0,
+       param$0 = tl$0;
+     }
+    }
+   }
+   function cat(s1, s2){
+     /*<<bytes.ml:140:2>>*/ var
+     l1 = caml_ml_bytes_length(s1),
+      /*<<bytes.ml:141:2>>*/ l2 =
+        /*<<bytes.ml:141:2>>*/ caml_ml_bytes_length(s2),
+      /*<<bytes.ml:142:10>>*/ r =
+        /*<<bytes.ml:142:10>>*/ caml_create_bytes(l1 + l2 | 0);
+     /*<<bytes.ml:143:2>>*/  /*<<bytes.ml:143:2>>*/ caml_blit_bytes
+     (s1, 0, r, 0, l1);
+     /*<<bytes.ml:144:2>>*/  /*<<bytes.ml:144:2>>*/ caml_blit_bytes
+     (s2, 0, r, l1, l2);
+     /*<<bytes.ml:144:2>>*/ return r;
+    /*<<bytes.ml:145:3>>*/ }
+   function is_space(param){
+     /*<<bytes.ml:151:15>>*/  /*<<bytes.ml:151:15>>*/ var
+     _ag_ = param - 9 | 0;
+    a:
+    {
+     if(4 < _ag_ >>> 0){if(23 !== _ag_) break a;} else if(2 === _ag_) break a;
+      /*<<bytes.ml:152:41>>*/ return 1;
+    }
+     /*<<bytes.ml:153:9>>*/ return 0;
+    /*<<bytes.ml:153:14>>*/ }
+   function trim(s){
+     /*<<bytes.ml:156:2>>*/ var
+     len = caml_ml_bytes_length(s),
+      /*<<bytes.ml:157:10>>*/ i = [0, 0];
+    for(;;){
+      /*<<bytes.ml:158:20>>*/ if
+      (i[1] < len && is_space(caml_bytes_unsafe_get(s, i[1]))){i[1]++; continue;}
+      /*<<bytes.ml:161:10>>*/  /*<<bytes.ml:161:10>>*/ var
+      j = [0, len - 1 | 0];
+     for(;;){
+       /*<<bytes.ml:162:20>>*/ if
+       (i[1] <= j[1] && is_space(caml_bytes_unsafe_get(s, j[1]))){j[1] += -1; continue;}
+      return i[1] <= j[1] ? sub(s, i[1], (j[1] - i[1] | 0) + 1 | 0) : empty;
+     }
+    }
+    /*<<bytes.ml:168:9>>*/ }
+   function unsafe_escape(s){
+     /*<<bytes.ml:184:2>>*/ var
+      /*<<bytes.ml:184:10>>*/ n = [0, 0],
+     _$_ = caml_ml_bytes_length(s) - 1 | 0,
+      /*<<bytes.ml:184:10>>*/ ___ = 0;
+    if(_$_ >= 0){
+     var i$0 = ___;
+     for(;;){
+      var match = caml_bytes_unsafe_get(s, i$0);
+      a:
+      {
+       b:
+       {
+        c:
+        {
+         if(32 <= match){
+          var _ad_ = match - 34 | 0;
+          if(58 < _ad_ >>> 0){
+           if(93 <= _ad_) break c;
+          }
+          else if(56 < _ad_ - 1 >>> 0) break b;
+          var _ae_ = 1;
+          break a;
+         }
+         if(11 <= match){
+          if(13 === match) break b;
+         }
+         else if(8 <= match) break b;
+        }
+        var _ae_ = 4;
+        break a;
+       }
+       var _ae_ = 2;
+      }
+      n[1] = n[1] + _ae_ | 0;
+       /*<<bytes.ml:185:2>>*/  /*<<bytes.ml:185:2>>*/ var _af_ = i$0 + 1 | 0;
+      if(_$_ === i$0) break;
+      var i$0 = _af_;
+     }
+    }
+    if(n[1] === caml_ml_bytes_length(s))  /*<<bytes.ml:192:24>>*/ return s;
+     /*<<bytes.ml:194:13>>*/  /*<<bytes.ml:194:13>>*/ var
+     s$0 =  /*<<bytes.ml:194:13>>*/ caml_create_bytes(n[1]);
+    n[1] = 0;
+     /*<<bytes.ml:196:4>>*/ var
+     _ab_ = caml_ml_bytes_length(s) - 1 | 0,
+      /*<<bytes.ml:196:4>>*/ _aa_ = 0;
+    if(_ab_ >= 0){
+     var i = _aa_;
+     for(;;){
+      var c = caml_bytes_unsafe_get(s, i);
+      a:
+      {
+       b:
+       {
+        c:
+        {
+         if(35 <= c){
+          if(92 !== c){if(127 <= c) break c; break b;}
+         }
+         else{
+          if(32 > c){
+           if(14 <= c) break c;
+           switch(c){
+             case 8:
+              caml_bytes_unsafe_set(s$0, n[1], 92);
+              n[1]++;
+              caml_bytes_unsafe_set(s$0, n[1], 98);
+              break a;
+             case 9:
+              caml_bytes_unsafe_set(s$0, n[1], 92);
+              n[1]++;
+              caml_bytes_unsafe_set(s$0, n[1], 116);
+              break a;
+             case 10:
+              caml_bytes_unsafe_set(s$0, n[1], 92);
+              n[1]++;
+              caml_bytes_unsafe_set(s$0, n[1], 110);
+              break a;
+             case 13:
+              caml_bytes_unsafe_set(s$0, n[1], 92);
+              n[1]++;
+              caml_bytes_unsafe_set(s$0, n[1], 114);
+              break a;
+             default: break c;
+           }
+          }
+          if(34 > c) break b;
+         }
+         caml_bytes_unsafe_set(s$0, n[1], 92);
+         n[1]++;
+         caml_bytes_unsafe_set(s$0, n[1], c);
+         break a;
+        }
+        caml_bytes_unsafe_set(s$0, n[1], 92);
+        n[1]++;
+        caml_bytes_unsafe_set(s$0, n[1], 48 + (c / 100 | 0) | 0);
+        n[1]++;
+        caml_bytes_unsafe_set(s$0, n[1], 48 + ((c / 10 | 0) % 10 | 0) | 0);
+        n[1]++;
+        caml_bytes_unsafe_set(s$0, n[1], 48 + (c % 10 | 0) | 0);
+        break a;
+       }
+       caml_bytes_unsafe_set(s$0, n[1], c);
+      }
+      n[1]++;
+       /*<<bytes.ml:196:4>>*/  /*<<bytes.ml:196:4>>*/ var _ac_ = i + 1 | 0;
+      if(_ab_ === i) break;
+      var i = _ac_;
+     }
+    }
+     /*<<bytes.ml:221:4>>*/ return s$0;
+    /*<<bytes.ml:222:5>>*/ }
+   function escaped(b){
+     /*<<bytes.ml:225:2>>*/  /*<<bytes.ml:225:10>>*/ var b$0 = copy(b);
+     /*<<bytes.ml:228:2>>*/ return unsafe_escape(b$0);
+    /*<<bytes.ml:228:17>>*/ }
+   function map(f, s){
+     /*<<bytes.ml:231:2>>*/ var l = caml_ml_bytes_length(s);
+     /*<<bytes.ml:232:2>>*/ if(0 === l)  /*<<bytes.ml:232:16>>*/ return s;
+     /*<<bytes.ml:233:12>>*/ var
+      /*<<bytes.ml:233:12>>*/ r =
+        /*<<bytes.ml:233:12>>*/ caml_create_bytes(l),
+      /*<<bytes.ml:234:4>>*/ _Y_ = l - 1 | 0,
+      /*<<bytes.ml:233:12>>*/ _X_ = 0;
+    if(_Y_ >= 0){
+     var i = _X_;
+     for(;;){
+      caml_bytes_unsafe_set
+       (r,
+        i,
+         /*<<bytes.ml:234:41>>*/ caml_call1(f, caml_bytes_unsafe_get(s, i)));
+       /*<<bytes.ml:234:4>>*/  /*<<bytes.ml:234:4>>*/ var _Z_ = i + 1 | 0;
+      if(_Y_ === i) break;
+      var i = _Z_;
+     }
+    }
+     /*<<bytes.ml:235:4>>*/ return r;
+    /*<<bytes.ml:236:5>>*/ }
+   function mapi(f, s){
+     /*<<bytes.ml:239:2>>*/ var l = caml_ml_bytes_length(s);
+     /*<<bytes.ml:240:2>>*/ if(0 === l)  /*<<bytes.ml:240:16>>*/ return s;
+     /*<<bytes.ml:241:12>>*/ var
+      /*<<bytes.ml:241:12>>*/ r =
+        /*<<bytes.ml:241:12>>*/ caml_create_bytes(l),
+      /*<<bytes.ml:242:4>>*/ _V_ = l - 1 | 0,
+      /*<<bytes.ml:241:12>>*/ _U_ = 0;
+    if(_V_ >= 0){
+     var i = _U_;
+     for(;;){
+      caml_bytes_unsafe_set
+       (r,
+        i,
+         /*<<bytes.ml:242:41>>*/ caml_call2(f, i, caml_bytes_unsafe_get(s, i)));
+       /*<<bytes.ml:242:4>>*/  /*<<bytes.ml:242:4>>*/ var _W_ = i + 1 | 0;
+      if(_V_ === i) break;
+      var i = _W_;
+     }
+    }
+     /*<<bytes.ml:243:4>>*/ return r;
+    /*<<bytes.ml:244:5>>*/ }
+   function fold_left(f, x, a){
+     /*<<bytes.ml:247:2>>*/ var
+      /*<<bytes.ml:247:10>>*/ r = [0, x],
+     _S_ = caml_ml_bytes_length(a) - 1 | 0,
+      /*<<bytes.ml:247:10>>*/ _R_ = 0;
+    if(_S_ >= 0){
+     var i = _R_;
+     for(;;){
+      r[1] =
+        /*<<bytes.ml:249:9>>*/ caml_call2
+        (f, r[1], caml_bytes_unsafe_get(a, i));
+       /*<<bytes.ml:248:2>>*/  /*<<bytes.ml:248:2>>*/ var _T_ = i + 1 | 0;
+      if(_S_ === i) break;
+      var i = _T_;
+     }
+    }
+    return r[1];
+    /*<<bytes.ml:251:4>>*/ }
+   function fold_right(f, a, x){
+     /*<<bytes.ml:254:2>>*/ var
+      /*<<bytes.ml:254:10>>*/ r = [0, x],
+      /*<<bytes.ml:255:2>>*/ _P_ =
+        /*<<bytes.ml:255:2>>*/ caml_ml_bytes_length(a) - 1 | 0;
+    if(_P_ >= 0){
+     var i = _P_;
+     for(;;){
+      r[1] =
+        /*<<bytes.ml:256:9>>*/ caml_call2
+        (f, caml_bytes_unsafe_get(a, i), r[1]);
+       /*<<bytes.ml:255:2>>*/  /*<<bytes.ml:255:2>>*/ var _Q_ = i - 1 | 0;
+      if(0 === i) break;
+      var i = _Q_;
+     }
+    }
+    return r[1];
+    /*<<bytes.ml:258:4>>*/ }
+   function exists(p, s){
+     /*<<bytes.ml:261:2>>*/ var n = caml_ml_bytes_length(s), i = 0;
+     /*<<bytes.ml:263:4>>*/ for(;;){
+     if(i === n)  /*<<bytes.ml:263:18>>*/ return 0;
+      /*<<bytes.ml:264:12>>*/ if
+      ( /*<<bytes.ml:264:12>>*/ caml_call1(p, caml_bytes_unsafe_get(s, i)))
+       /*<<bytes.ml:264:36>>*/ return 1;
+      /*<<bytes.ml:265:9>>*/ var
+       /*<<bytes.ml:265:9>>*/ i$0 = i + 1 | 0,
+      i = i$0;
+    }
+    /*<<bytes.ml:266:8>>*/ }
+   function for_all(p, s){
+     /*<<bytes.ml:269:2>>*/ var n = caml_ml_bytes_length(s), i = 0;
+     /*<<bytes.ml:271:4>>*/ for(;;){
+     if(i === n)  /*<<bytes.ml:271:18>>*/ return 1;
+      /*<<bytes.ml:272:12>>*/ if
+      (!  /*<<bytes.ml:272:12>>*/ caml_call1(p, caml_bytes_unsafe_get(s, i)))
+       /*<<bytes.ml:273:9>>*/ return 0;
+      /*<<bytes.ml:272:36>>*/ var
+       /*<<bytes.ml:272:36>>*/ i$0 = i + 1 | 0,
+      i = i$0;
+    }
+    /*<<bytes.ml:274:8>>*/ }
+   function uppercase_ascii(s){
+     /*<<bytes.ml:276:24>>*/ return map(Stdlib_Char[4], s);
+    /*<<bytes.ml:276:50>>*/ }
+   function lowercase_ascii(s){
+     /*<<bytes.ml:277:24>>*/ return map(Stdlib_Char[3], s);
+    /*<<bytes.ml:277:50>>*/ }
+   function apply1(f, s){
+     /*<<bytes.ml:280:2>>*/ if(0 === caml_ml_bytes_length(s))
+      /*<<bytes.ml:280:23>>*/ return s;
+     /*<<bytes.ml:281:12>>*/  /*<<bytes.ml:281:12>>*/ var r = copy(s);
+    caml_bytes_unsafe_set
+     (r,
+      0,
+       /*<<bytes.ml:282:19>>*/ caml_call1(f, caml_bytes_unsafe_get(s, 0)));
+     /*<<bytes.ml:283:4>>*/ return r;
+    /*<<bytes.ml:284:5>>*/ }
+   function capitalize_ascii(s){
+     /*<<bytes.ml:286:25>>*/ return apply1(Stdlib_Char[4], s);
+    /*<<bytes.ml:286:54>>*/ }
+   function uncapitalize_ascii(s){
+     /*<<bytes.ml:287:27>>*/ return apply1(Stdlib_Char[3], s);
+    /*<<bytes.ml:287:56>>*/ }
+   function starts_with(prefix, s){
+     /*<<bytes.ml:291:2>>*/ var
+     len_s = caml_ml_bytes_length(s),
+     len_pre = caml_ml_bytes_length(prefix),
+     _O_ = len_pre <= len_s ? 1 : 0;
+    if(! _O_) return _O_;
+    var i = 0;
+     /*<<bytes.ml:294:4>>*/ for(;;){
+     if(i === len_pre)  /*<<bytes.ml:294:24>>*/ return 1;
+     if(caml_bytes_unsafe_get(s, i) !== caml_bytes_unsafe_get(prefix, i))
+       /*<<bytes.ml:295:55>>*/ return 0;
+      /*<<bytes.ml:296:9>>*/ var
+       /*<<bytes.ml:296:9>>*/ i$0 = i + 1 | 0,
+      i = i$0;
+    }
+    /*<<bytes.ml:297:30>>*/ }
+   function ends_with(suffix, s){
+     /*<<bytes.ml:301:2>>*/ var
+     len_s = caml_ml_bytes_length(s),
+     len_suf = caml_ml_bytes_length(suffix),
+     diff = len_s - len_suf | 0,
+     _N_ = 0 <= diff ? 1 : 0;
+    if(! _N_) return _N_;
+    var i = 0;
+     /*<<bytes.ml:305:4>>*/ for(;;){
+     if(i === len_suf)  /*<<bytes.ml:305:24>>*/ return 1;
+     if
+      (caml_bytes_unsafe_get(s, diff + i | 0)
+       !== caml_bytes_unsafe_get(suffix, i))
+       /*<<bytes.ml:306:64>>*/ return 0;
+      /*<<bytes.ml:307:9>>*/ var
+       /*<<bytes.ml:307:9>>*/ i$0 = i + 1 | 0,
+      i = i$0;
+    }
+    /*<<bytes.ml:308:23>>*/ }
+   function index_rec(s, lim, i, c){
+     /*<<bytes.ml:312:2>>*/ var i$0 = i;
+     /*<<bytes.ml:312:2>>*/ for(;;){
+     if(lim <= i$0)
+       /*<<bytes.ml:312:19>>*/ throw  /*<<bytes.ml:312:19>>*/ caml_maybe_attach_backtrace
+             (Stdlib[8], 1);
+     if(caml_bytes_unsafe_get(s, i$0) === c)
+       /*<<bytes.ml:313:29>>*/ return i$0;
+     var i$1 = i$0 + 1 | 0, i$0 = i$1;
+    }
+    /*<<bytes.ml:313:61>>*/ }
+   function index(s, c){
+     /*<<bytes.ml:316:16>>*/ return index_rec
+            (s, caml_ml_bytes_length(s), 0, c);
+    /*<<bytes.ml:316:42>>*/ }
+   function index_rec_opt(s, lim, i, c){
+     /*<<bytes.ml:320:2>>*/ var i$0 = i;
+     /*<<bytes.ml:320:2>>*/ for(;;){
+     if(lim <= i$0)  /*<<bytes.ml:320:19>>*/ return 0;
+     if(caml_bytes_unsafe_get(s, i$0) === c)
+       /*<<bytes.ml:321:29>>*/ return [0, i$0];
+     var i$1 = i$0 + 1 | 0, i$0 = i$1;
+    }
+    /*<<bytes.ml:321:70>>*/ }
+   function index_opt(s, c){
+     /*<<bytes.ml:324:20>>*/ return index_rec_opt
+            (s, caml_ml_bytes_length(s), 0, c);
+    /*<<bytes.ml:324:50>>*/ }
+   function index_from(s, i, c){
+     /*<<bytes.ml:328:2>>*/ var l = caml_ml_bytes_length(s);
+    if(0 <= i && l >= i)  /*<<bytes.ml:330:2>>*/ return index_rec(s, l, i, c);
+     /*<<bytes.ml:329:25>>*/ return  /*<<bytes.ml:329:25>>*/ caml_call1
+            (Stdlib[1], cst_String_index_from_Bytes_in);
+    /*<<bytes.ml:330:19>>*/ }
+   function index_from_opt(s, i, c){
+     /*<<bytes.ml:334:2>>*/ var l = caml_ml_bytes_length(s);
+    if(0 <= i && l >= i)
+      /*<<bytes.ml:338:4>>*/ return index_rec_opt(s, l, i, c);
+     /*<<bytes.ml:336:4>>*/ return  /*<<bytes.ml:336:4>>*/ caml_call1
+            (Stdlib[1], cst_String_index_from_opt_Byte);
+    /*<<bytes.ml:338:25>>*/ }
+   function rindex_rec(s, i, c){
+     /*<<bytes.ml:342:2>>*/ var i$0 = i;
+     /*<<bytes.ml:342:2>>*/ for(;;){
+     if(0 > i$0)
+       /*<<bytes.ml:342:16>>*/ throw  /*<<bytes.ml:342:16>>*/ caml_maybe_attach_backtrace
+             (Stdlib[8], 1);
+     if(caml_bytes_unsafe_get(s, i$0) === c)
+       /*<<bytes.ml:343:29>>*/ return i$0;
+     var i$1 = i$0 - 1 | 0, i$0 = i$1;
+    }
+    /*<<bytes.ml:343:58>>*/ }
+   function rindex(s, c){
+     /*<<bytes.ml:346:17>>*/ return rindex_rec
+            (s, caml_ml_bytes_length(s) - 1 | 0, c);
+    /*<<bytes.ml:346:46>>*/ }
+   function rindex_from(s, i, c){
+     /*<<bytes.ml:350:2>>*/ if(-1 <= i && caml_ml_bytes_length(s) > i)
+      /*<<bytes.ml:353:4>>*/ return rindex_rec(s, i, c);
+     /*<<bytes.ml:351:4>>*/ return  /*<<bytes.ml:351:4>>*/ caml_call1
+            (Stdlib[1], cst_String_rindex_from_Bytes_r);
+    /*<<bytes.ml:353:20>>*/ }
+   function rindex_rec_opt(s, i, c){
+     /*<<bytes.ml:357:2>>*/ var i$0 = i;
+     /*<<bytes.ml:357:2>>*/ for(;;){
+     if(0 > i$0)  /*<<bytes.ml:357:16>>*/ return 0;
+     if(caml_bytes_unsafe_get(s, i$0) === c)
+       /*<<bytes.ml:358:29>>*/ return [0, i$0];
+     var i$1 = i$0 - 1 | 0, i$0 = i$1;
+    }
+    /*<<bytes.ml:358:67>>*/ }
+   function rindex_opt(s, c){
+     /*<<bytes.ml:361:21>>*/ return rindex_rec_opt
+            (s, caml_ml_bytes_length(s) - 1 | 0, c);
+    /*<<bytes.ml:361:54>>*/ }
+   function rindex_from_opt(s, i, c){
+     /*<<bytes.ml:365:2>>*/ if(-1 <= i && caml_ml_bytes_length(s) > i)
+      /*<<bytes.ml:368:4>>*/ return rindex_rec_opt(s, i, c);
+     /*<<bytes.ml:366:4>>*/ return  /*<<bytes.ml:366:4>>*/ caml_call1
+            (Stdlib[1], cst_String_rindex_from_opt_Byt);
+    /*<<bytes.ml:368:24>>*/ }
+   function contains_from(s, i, c){
+     /*<<bytes.ml:373:2>>*/ var l = caml_ml_bytes_length(s);
+    if(0 <= i && l >= i)
+      /*<<bytes.ml:377:4>>*/ try{
+       /*<<bytes.ml:377:15>>*/ index_rec(s, l, i, c);
+       /*<<bytes.ml:377:36>>*/  /*<<bytes.ml:377:36>>*/ var _L_ = 1;
+       /*<<bytes.ml:377:36>>*/ return _L_;
+     }
+     catch(_M_){
+      var _K_ = caml_wrap_exception(_M_);
+      if(_K_ === Stdlib[8])  /*<<bytes.ml:377:59>>*/ return 0;
+      throw caml_maybe_attach_backtrace(_K_, 0);
+     }
+     /*<<bytes.ml:375:4>>*/ return  /*<<bytes.ml:375:4>>*/ caml_call1
+            (Stdlib[1], cst_String_contains_from_Bytes);
+    /*<<bytes.ml:377:64>>*/ }
+   function contains(s, c){
+     /*<<bytes.ml:381:19>>*/ return contains_from(s, 0, c);
+    /*<<bytes.ml:381:38>>*/ }
+   function rcontains_from(s, i, c){
+     /*<<bytes.ml:385:2>>*/ if(0 <= i && caml_ml_bytes_length(s) > i)
+      /*<<bytes.ml:388:4>>*/ try{
+       /*<<bytes.ml:388:15>>*/ rindex_rec(s, i, c);
+       /*<<bytes.ml:388:35>>*/  /*<<bytes.ml:388:35>>*/ var _I_ = 1;
+       /*<<bytes.ml:388:35>>*/ return _I_;
+     }
+     catch(_J_){
+      var _H_ = caml_wrap_exception(_J_);
+      if(_H_ === Stdlib[8])  /*<<bytes.ml:388:58>>*/ return 0;
+      throw caml_maybe_attach_backtrace(_H_, 0);
+     }
+     /*<<bytes.ml:386:4>>*/ return  /*<<bytes.ml:386:4>>*/ caml_call1
+            (Stdlib[1], cst_String_rcontains_from_Byte);
+    /*<<bytes.ml:388:63>>*/ }
+   var compare = runtime.caml_bytes_compare;
+   function split_on_char(sep, s){
+     /*<<bytes.ml:398:2>>*/ var
+      /*<<bytes.ml:398:10>>*/ r = [0, 0],
+      /*<<bytes.ml:399:10>>*/ j =
+       [0,  /*<<bytes.ml:399:2>>*/ caml_ml_bytes_length(s)],
+      /*<<bytes.ml:400:2>>*/ _D_ =
+        /*<<bytes.ml:400:2>>*/ caml_ml_bytes_length(s) - 1 | 0;
+    if(_D_ >= 0){
+     var i = _D_;
+     for(;;){
+      if(caml_bytes_unsafe_get(s, i) === sep){
+       var _F_ = r[1];
+       r[1] = [0, sub(s, i + 1 | 0, (j[1] - i | 0) - 1 | 0), _F_];
+       j[1] = i;
+      }
+       /*<<bytes.ml:400:2>>*/  /*<<bytes.ml:400:2>>*/ var _G_ = i - 1 | 0;
+      if(0 === i) break;
+      var i = _G_;
+     }
+    }
+    var _E_ = r[1];
+     /*<<bytes.ml:406:2>>*/ return [0, sub(s, 0, j[1]), _E_];
+    /*<<bytes.ml:406:18>>*/ }
+   function to_seq(s){
+    function aux(i, param){
+      /*<<bytes.ml:412:4>>*/ if(i === caml_ml_bytes_length(s))
+       /*<<bytes.ml:412:25>>*/ return 0;
+      /*<<bytes.ml:414:14>>*/ var
+       /*<<bytes.ml:414:14>>*/ x =
+         /*<<bytes.ml:414:14>>*/ caml_bytes_get(s, i),
+       /*<<bytes.ml:414:14>>*/ _B_ = i + 1 | 0;
+      /*<<bytes.ml:415:6>>*/ return [0,
+             x,
+             function(_C_){ /*<<?>>*/ return aux(_B_, _C_);}];
+     /*<<bytes.ml:415:29>>*/ }
+     /*<<bytes.ml:417:2>>*/  /*<<bytes.ml:417:2>>*/ var _z_ = 0;
+     /*<<bytes.ml:417:2>>*/ return function(_A_){
+      /*<<?>>*/ return aux(_z_, _A_);};
+    /*<<bytes.ml:417:7>>*/ }
+   function to_seqi(s){
+    function aux(i, param){
+      /*<<bytes.ml:421:4>>*/ if(i === caml_ml_bytes_length(s))
+       /*<<bytes.ml:421:25>>*/ return 0;
+      /*<<bytes.ml:423:14>>*/ var
+       /*<<bytes.ml:423:14>>*/ x =
+         /*<<bytes.ml:423:14>>*/ caml_bytes_get(s, i),
+       /*<<bytes.ml:423:14>>*/ _x_ = i + 1 | 0;
+      /*<<bytes.ml:424:6>>*/ return [0,
+             [0, i, x],
+             function(_y_){ /*<<?>>*/ return aux(_x_, _y_);}];
+     /*<<bytes.ml:424:33>>*/ }
+     /*<<bytes.ml:426:2>>*/  /*<<bytes.ml:426:2>>*/ var _v_ = 0;
+     /*<<bytes.ml:426:2>>*/ return function(_w_){
+      /*<<?>>*/ return aux(_v_, _w_);};
+    /*<<bytes.ml:426:7>>*/ }
+   function of_seq(i){
+     /*<<bytes.ml:429:2>>*/ var
+      /*<<bytes.ml:429:10>>*/ n = [0, 0],
+      /*<<bytes.ml:430:12>>*/ buf = [0, make(256, 0)];
+    function _u_(c){
+      /*<<bytes.ml:441:7>>*/ if(n[1] === caml_ml_bytes_length(buf[1])){
+       /*<<bytes.ml:433:18>>*/  /*<<bytes.ml:433:18>>*/ var
+       new_len =
+          /*<<bytes.ml:433:18>>*/ caml_call2
+          (Stdlib_Int[10],
+           2 * caml_ml_bytes_length(buf[1]) | 0,
+           Stdlib_Sys[12]);
+      if(caml_ml_bytes_length(buf[1]) === new_len)
+        /*<<bytes.ml:434:34>>*/  /*<<bytes.ml:434:34>>*/ caml_call1
+        (Stdlib[2], cst_Bytes_of_seq_cannot_grow_b);
+       /*<<bytes.ml:435:18>>*/  /*<<bytes.ml:435:18>>*/ var
+       new_buf = make(new_len, 0);
+       /*<<bytes.ml:436:4>>*/ blit(buf[1], 0, new_buf, 0, n[1]);
+      buf[1] = new_buf;
+     }
+      /*<<bytes.ml:442:7>>*/  /*<<bytes.ml:442:7>>*/ caml_bytes_set
+      (buf[1], n[1], c);
+     n[1]++;
+     return 0;
+     /*<<bytes.ml:443:13>>*/ }
+     /*<<bytes.ml:439:2>>*/  /*<<bytes.ml:439:2>>*/ caml_call2
+     (Stdlib_Seq[4], _u_, i);
+    return sub(buf[1], 0, n[1]);
+    /*<<bytes.ml:445:15>>*/ }
+   function unsafe_get_uint16_le(b, i){
+     /*<<bytes.ml:470:2>>*/ return Stdlib_Sys[11]
+            ?  /*<<bytes.ml:471:14>>*/ caml_bswap16
+              ( /*<<bytes.ml:471:14>>*/ caml_bytes_get16(b, i))
+            :  /*<<bytes.ml:472:7>>*/ caml_bytes_get16(b, i);
+    /*<<bytes.ml:472:31>>*/ }
+   function unsafe_get_uint16_be(b, i){
+     /*<<bytes.ml:475:2>>*/ return Stdlib_Sys[11]
+            ?  /*<<bytes.ml:476:7>>*/ caml_bytes_get16(b, i)
+            :  /*<<bytes.ml:477:14>>*/ caml_bswap16
+              ( /*<<bytes.ml:477:14>>*/ caml_bytes_get16(b, i));
+    /*<<bytes.ml:477:40>>*/ }
+   function get_int8(b, i){
+     /*<<bytes.ml:480:2>>*/ var
+      /*<<bytes.ml:480:2>>*/ _s_ = Stdlib_Sys[10] - 8 | 0,
+     _t_ = Stdlib_Sys[10] - 8 | 0;
+    return  /*<<bytes.ml:480:3>>*/ caml_bytes_get(b, i) << _t_ >> _s_;
+    /*<<bytes.ml:480:65>>*/ }
+   function get_uint16_le(b, i){
+     /*<<bytes.ml:483:2>>*/ return Stdlib_Sys[11]
+            ?  /*<<bytes.ml:483:32>>*/ caml_bswap16
+              ( /*<<bytes.ml:483:32>>*/ caml_bytes_get16(b, i))
+            :  /*<<bytes.ml:484:7>>*/ caml_bytes_get16(b, i);
+    /*<<bytes.ml:484:24>>*/ }
+   function get_uint16_be(b, i){
+     /*<<bytes.ml:487:2>>*/ return Stdlib_Sys[11]
+            ?  /*<<bytes.ml:488:7>>*/ caml_bytes_get16(b, i)
+            :  /*<<bytes.ml:487:36>>*/ caml_bswap16
+              ( /*<<bytes.ml:487:36>>*/ caml_bytes_get16(b, i));
+    /*<<bytes.ml:488:24>>*/ }
+   function get_int16_ne(b, i){
+     /*<<bytes.ml:491:2>>*/ var
+      /*<<bytes.ml:491:2>>*/ _q_ = Stdlib_Sys[10] - 16 | 0,
+     _r_ = Stdlib_Sys[10] - 16 | 0;
+    return  /*<<bytes.ml:491:3>>*/ caml_bytes_get16(b, i) << _r_ >> _q_;
+    /*<<bytes.ml:491:71>>*/ }
+   function get_int16_le(b, i){
+     /*<<bytes.ml:494:2>>*/ var
+      /*<<bytes.ml:494:2>>*/ _o_ = Stdlib_Sys[10] - 16 | 0,
+     _p_ = Stdlib_Sys[10] - 16 | 0;
+    return get_uint16_le(b, i) << _p_ >> _o_;
+    /*<<bytes.ml:494:71>>*/ }
+   function get_int16_be(b, i){
+     /*<<bytes.ml:497:2>>*/ var
+      /*<<bytes.ml:497:2>>*/ _m_ = Stdlib_Sys[10] - 16 | 0,
+     _n_ = Stdlib_Sys[10] - 16 | 0;
+    return get_uint16_be(b, i) << _n_ >> _m_;
+    /*<<bytes.ml:497:71>>*/ }
+   function get_int32_le(b, i){
+     /*<<bytes.ml:500:2>>*/ return Stdlib_Sys[11]
+            ?  /*<<bytes.ml:500:25>>*/ caml_int32_bswap
+              ( /*<<bytes.ml:500:32>>*/ caml_bytes_get32(b, i))
+            :  /*<<bytes.ml:501:7>>*/ caml_bytes_get32(b, i);
+    /*<<bytes.ml:501:23>>*/ }
+   function get_int32_be(b, i){
+     /*<<bytes.ml:504:2>>*/ return Stdlib_Sys[11]
+            ?  /*<<bytes.ml:505:7>>*/ caml_bytes_get32(b, i)
+            :  /*<<bytes.ml:504:29>>*/ caml_int32_bswap
+              ( /*<<bytes.ml:504:36>>*/ caml_bytes_get32(b, i));
+    /*<<bytes.ml:505:23>>*/ }
+   function get_int64_le(b, i){
+     /*<<bytes.ml:508:2>>*/ return Stdlib_Sys[11]
+            ?  /*<<bytes.ml:508:25>>*/ caml_int64_bswap
+              ( /*<<bytes.ml:508:32>>*/ caml_bytes_get64(b, i))
+            :  /*<<bytes.ml:509:7>>*/ caml_bytes_get64(b, i);
+    /*<<bytes.ml:509:23>>*/ }
+   function get_int64_be(b, i){
+     /*<<bytes.ml:512:2>>*/ return Stdlib_Sys[11]
+            ?  /*<<bytes.ml:513:7>>*/ caml_bytes_get64(b, i)
+            :  /*<<bytes.ml:512:29>>*/ caml_int64_bswap
+              ( /*<<bytes.ml:512:36>>*/ caml_bytes_get64(b, i));
+    /*<<bytes.ml:513:23>>*/ }
+   function unsafe_set_uint16_le(b, i, x){
+     /*<<bytes.ml:516:2>>*/ return Stdlib_Sys[11]
+            ?  /*<<bytes.ml:517:7>>*/ caml_bytes_set16(b, i, caml_bswap16(x))
+            :  /*<<bytes.ml:518:7>>*/ caml_bytes_set16(b, i, x);
+    /*<<bytes.ml:518:33>>*/ }
+   function unsafe_set_uint16_be(b, i, x){
+     /*<<bytes.ml:521:2>>*/ return Stdlib_Sys[11]
+            ?  /*<<bytes.ml:522:7>>*/ caml_bytes_set16(b, i, x)
+            :  /*<<bytes.ml:523:2>>*/ caml_bytes_set16(b, i, caml_bswap16(x));
+    /*<<bytes.ml:523:37>>*/ }
+   function set_int16_le(b, i, x){
+     /*<<bytes.ml:526:2>>*/ return Stdlib_Sys[11]
+            ?  /*<<bytes.ml:526:25>>*/ caml_bytes_set16(b, i, caml_bswap16(x))
+            :  /*<<bytes.ml:527:7>>*/ caml_bytes_set16(b, i, x);
+    /*<<bytes.ml:527:25>>*/ }
+   function set_int16_be(b, i, x){
+     /*<<bytes.ml:530:2>>*/ return Stdlib_Sys[11]
+            ?  /*<<bytes.ml:531:7>>*/ caml_bytes_set16(b, i, x)
+            :  /*<<bytes.ml:530:29>>*/ caml_bytes_set16(b, i, caml_bswap16(x));
+    /*<<bytes.ml:531:25>>*/ }
+   function set_int32_le(b, i, x){
+     /*<<bytes.ml:534:2>>*/ return Stdlib_Sys[11]
+            ?  /*<<bytes.ml:534:25>>*/ caml_bytes_set32
+              (b, i,  /*<<bytes.ml:534:42>>*/ caml_int32_bswap(x))
+            :  /*<<bytes.ml:535:7>>*/ caml_bytes_set32(b, i, x);
+    /*<<bytes.ml:535:25>>*/ }
+   function set_int32_be(b, i, x){
+     /*<<bytes.ml:538:2>>*/ return Stdlib_Sys[11]
+            ?  /*<<bytes.ml:539:7>>*/ caml_bytes_set32(b, i, x)
+            :  /*<<bytes.ml:538:29>>*/ caml_bytes_set32
+              (b, i,  /*<<bytes.ml:538:46>>*/ caml_int32_bswap(x));
+    /*<<bytes.ml:539:25>>*/ }
+   function set_int64_le(b, i, x){
+     /*<<bytes.ml:542:2>>*/ return Stdlib_Sys[11]
+            ?  /*<<bytes.ml:542:25>>*/ caml_bytes_set64
+              (b, i,  /*<<bytes.ml:542:42>>*/ caml_int64_bswap(x))
+            :  /*<<bytes.ml:543:7>>*/ caml_bytes_set64(b, i, x);
+    /*<<bytes.ml:543:25>>*/ }
+   function set_int64_be(b, i, x){
+     /*<<bytes.ml:546:2>>*/ return Stdlib_Sys[11]
+            ?  /*<<bytes.ml:547:7>>*/ caml_bytes_set64(b, i, x)
+            :  /*<<bytes.ml:546:29>>*/ caml_bytes_set64
+              (b, i,  /*<<bytes.ml:546:46>>*/ caml_int64_bswap(x));
+    /*<<bytes.ml:547:25>>*/ }
+   var
+    set_uint8 = caml_bytes_set,
+    set_uint16_ne = caml_bytes_set16,
+    dec_invalid = Stdlib_Uchar[22];
+   function dec_ret(n, u){
+     /*<<bytes.ml:557:27>>*/  /*<<bytes.ml:557:46>>*/ var
+     _l_ =  /*<<bytes.ml:557:46>>*/ caml_call1(Stdlib_Uchar[9], u);
+     /*<<bytes.ml:557:46>>*/ return  /*<<bytes.ml:557:46>>*/ caml_call2
+            (Stdlib_Uchar[21], n, _l_);
+    /*<<bytes.ml:557:69>>*/ }
+   function not_in_x80_to_xBF(b){
+     /*<<bytes.ml:575:35>>*/ return 2 !== (b >>> 6 | 0) ? 1 : 0;
+    /*<<bytes.ml:575:50>>*/ }
+   function not_in_xA0_to_xBF(b){
+     /*<<bytes.ml:576:35>>*/ return 5 !== (b >>> 5 | 0) ? 1 : 0;
+    /*<<bytes.ml:576:51>>*/ }
+   function not_in_x80_to_x9F(b){
+     /*<<bytes.ml:577:35>>*/ return 4 !== (b >>> 5 | 0) ? 1 : 0;
+    /*<<bytes.ml:577:51>>*/ }
+   function not_in_x90_to_xBF(b){
+     /*<<bytes.ml:578:35>>*/ var
+     _j_ = b < 144 ? 1 : 0,
+     _k_ = _j_ || (191 < b ? 1 : 0);
+    return _k_;
+    /*<<bytes.ml:578:55>>*/ }
+   function not_in_x80_to_x8F(b){
+     /*<<bytes.ml:579:35>>*/ return 8 !== (b >>> 4 | 0) ? 1 : 0;
+    /*<<bytes.ml:579:49>>*/ }
+   function utf_8_uchar_3(b0, b1, b2){
+     /*<<bytes.ml:586:2>>*/ return (b0 & 15) << 12 | (b1 & 63) << 6 | b2 & 63;
+    /*<<bytes.ml:588:18>>*/ }
+   function utf_8_uchar_4(b0, b1, b2, b3){
+     /*<<bytes.ml:591:2>>*/ return (b0 & 7) << 18 | (b1 & 63) << 12
+           | (b2 & 63) << 6
+           | b3 & 63;
+    /*<<bytes.ml:594:18>>*/ }
+   function get_utf_8_uchar(b, i){
+     /*<<bytes.ml:597:2>>*/ var
+      /*<<bytes.ml:597:11>>*/ b0 =
+        /*<<bytes.ml:597:11>>*/ caml_bytes_get(b, i),
+      /*<<bytes.ml:599:2>>*/ max =
+        /*<<bytes.ml:599:2>>*/ caml_ml_bytes_length(b) - 1 | 0;
+    a:
+    {
+      /*<<bytes.ml:600:2>>*/ if(224 <= b0){
+      if(237 <= b0){
+       if(245 <= b0) break a;
+       switch(b0 - 237 | 0){
+         case 0:
+           /*<<bytes.ml:619:6>>*/  /*<<bytes.ml:619:6>>*/ var i$0 = i + 1 | 0;
+          if(max < i$0)
+            /*<<bytes.ml:619:39>>*/ return  /*<<bytes.ml:619:39>>*/ caml_call1
+                   (dec_invalid, 1);
+           /*<<bytes.ml:620:15>>*/  /*<<bytes.ml:620:15>>*/ var
+           b1 =  /*<<bytes.ml:620:15>>*/ caml_bytes_unsafe_get(b, i$0);
+           /*<<bytes.ml:620:29>>*/ if(not_in_x80_to_x9F(b1))
+            /*<<bytes.ml:620:55>>*/ return  /*<<bytes.ml:620:55>>*/ caml_call1
+                   (dec_invalid, 1);
+           /*<<bytes.ml:621:6>>*/  /*<<bytes.ml:621:6>>*/ var
+           i$1 = i$0 + 1 | 0;
+          if(max < i$1)
+            /*<<bytes.ml:621:39>>*/ return  /*<<bytes.ml:621:39>>*/ caml_call1
+                   (dec_invalid, 2);
+           /*<<bytes.ml:622:15>>*/  /*<<bytes.ml:622:15>>*/ var
+           b2 =  /*<<bytes.ml:622:15>>*/ caml_bytes_unsafe_get(b, i$1);
+           /*<<bytes.ml:622:29>>*/ return not_in_x80_to_xBF(b2)
+                  ?  /*<<bytes.ml:622:55>>*/ caml_call1(dec_invalid, 2)
+                  : dec_ret(3, utf_8_uchar_3(b0, b1, b2));
+         case 3:
+           /*<<bytes.ml:625:6>>*/  /*<<bytes.ml:625:6>>*/ var i$4 = i + 1 | 0;
+          if(max < i$4)
+            /*<<bytes.ml:625:39>>*/ return  /*<<bytes.ml:625:39>>*/ caml_call1
+                   (dec_invalid, 1);
+           /*<<bytes.ml:626:15>>*/  /*<<bytes.ml:626:15>>*/ var
+           b1$1 =  /*<<bytes.ml:626:15>>*/ caml_bytes_unsafe_get(b, i$4);
+           /*<<bytes.ml:626:29>>*/ if(not_in_x90_to_xBF(b1$1))
+            /*<<bytes.ml:626:55>>*/ return  /*<<bytes.ml:626:55>>*/ caml_call1
+                   (dec_invalid, 1);
+           /*<<bytes.ml:627:6>>*/  /*<<bytes.ml:627:6>>*/ var
+           i$5 = i$4 + 1 | 0;
+          if(max < i$5)
+            /*<<bytes.ml:627:39>>*/ return  /*<<bytes.ml:627:39>>*/ caml_call1
+                   (dec_invalid, 2);
+           /*<<bytes.ml:628:15>>*/  /*<<bytes.ml:628:15>>*/ var
+           b2$1 =  /*<<bytes.ml:628:15>>*/ caml_bytes_unsafe_get(b, i$5);
+           /*<<bytes.ml:628:29>>*/ if(not_in_x80_to_xBF(b2$1))
+            /*<<bytes.ml:628:55>>*/ return  /*<<bytes.ml:628:55>>*/ caml_call1
+                   (dec_invalid, 2);
+           /*<<bytes.ml:629:6>>*/  /*<<bytes.ml:629:6>>*/ var
+           i$6 = i$5 + 1 | 0;
+          if(max < i$6)
+            /*<<bytes.ml:629:39>>*/ return  /*<<bytes.ml:629:39>>*/ caml_call1
+                   (dec_invalid, 3);
+           /*<<bytes.ml:630:15>>*/  /*<<bytes.ml:630:15>>*/ var
+           b3 =  /*<<bytes.ml:630:15>>*/ caml_bytes_unsafe_get(b, i$6);
+           /*<<bytes.ml:630:29>>*/ return not_in_x80_to_xBF(b3)
+                  ?  /*<<bytes.ml:630:55>>*/ caml_call1(dec_invalid, 3)
+                  : dec_ret(4, utf_8_uchar_4(b0, b1$1, b2$1, b3));
+         case 7:
+           /*<<bytes.ml:641:6>>*/  /*<<bytes.ml:641:6>>*/ var
+           i$10 = i + 1 | 0;
+          if(max < i$10)
+            /*<<bytes.ml:641:39>>*/ return  /*<<bytes.ml:641:39>>*/ caml_call1
+                   (dec_invalid, 1);
+           /*<<bytes.ml:642:15>>*/  /*<<bytes.ml:642:15>>*/ var
+           b1$3 =  /*<<bytes.ml:642:15>>*/ caml_bytes_unsafe_get(b, i$10);
+           /*<<bytes.ml:642:29>>*/ if(not_in_x80_to_x8F(b1$3))
+            /*<<bytes.ml:642:55>>*/ return  /*<<bytes.ml:642:55>>*/ caml_call1
+                   (dec_invalid, 1);
+           /*<<bytes.ml:643:6>>*/  /*<<bytes.ml:643:6>>*/ var
+           i$11 = i$10 + 1 | 0;
+          if(max < i$11)
+            /*<<bytes.ml:643:39>>*/ return  /*<<bytes.ml:643:39>>*/ caml_call1
+                   (dec_invalid, 2);
+           /*<<bytes.ml:644:15>>*/  /*<<bytes.ml:644:15>>*/ var
+           b2$3 =  /*<<bytes.ml:644:15>>*/ caml_bytes_unsafe_get(b, i$11);
+           /*<<bytes.ml:644:29>>*/ if(not_in_x80_to_xBF(b2$3))
+            /*<<bytes.ml:644:55>>*/ return  /*<<bytes.ml:644:55>>*/ caml_call1
+                   (dec_invalid, 2);
+           /*<<bytes.ml:645:6>>*/  /*<<bytes.ml:645:6>>*/ var
+           i$12 = i$11 + 1 | 0;
+          if(max < i$12)
+            /*<<bytes.ml:645:39>>*/ return  /*<<bytes.ml:645:39>>*/ caml_call1
+                   (dec_invalid, 3);
+           /*<<bytes.ml:646:15>>*/  /*<<bytes.ml:646:15>>*/ var
+           b3$1 =  /*<<bytes.ml:646:15>>*/ caml_bytes_unsafe_get(b, i$12);
+           /*<<bytes.ml:646:29>>*/ return not_in_x80_to_xBF(b3$1)
+                  ?  /*<<bytes.ml:646:55>>*/ caml_call1(dec_invalid, 3)
+                  : dec_ret(4, utf_8_uchar_4(b0, b1$3, b2$3, b3$1));
+         case 1:
+         case 2: break;
+         default:
+           /*<<bytes.ml:633:6>>*/  /*<<bytes.ml:633:6>>*/ var i$7 = i + 1 | 0;
+          if(max < i$7)
+            /*<<bytes.ml:633:39>>*/ return  /*<<bytes.ml:633:39>>*/ caml_call1
+                   (dec_invalid, 1);
+           /*<<bytes.ml:634:15>>*/  /*<<bytes.ml:634:15>>*/ var
+           b1$2 =  /*<<bytes.ml:634:15>>*/ caml_bytes_unsafe_get(b, i$7);
+           /*<<bytes.ml:634:29>>*/ if(not_in_x80_to_xBF(b1$2))
+            /*<<bytes.ml:634:55>>*/ return  /*<<bytes.ml:634:55>>*/ caml_call1
+                   (dec_invalid, 1);
+           /*<<bytes.ml:635:6>>*/  /*<<bytes.ml:635:6>>*/ var
+           i$8 = i$7 + 1 | 0;
+          if(max < i$8)
+            /*<<bytes.ml:635:39>>*/ return  /*<<bytes.ml:635:39>>*/ caml_call1
+                   (dec_invalid, 2);
+           /*<<bytes.ml:636:15>>*/  /*<<bytes.ml:636:15>>*/ var
+           b2$2 =  /*<<bytes.ml:636:15>>*/ caml_bytes_unsafe_get(b, i$8);
+           /*<<bytes.ml:636:29>>*/ if(not_in_x80_to_xBF(b2$2))
+            /*<<bytes.ml:636:55>>*/ return  /*<<bytes.ml:636:55>>*/ caml_call1
+                   (dec_invalid, 2);
+           /*<<bytes.ml:637:6>>*/  /*<<bytes.ml:637:6>>*/ var
+           i$9 = i$8 + 1 | 0;
+          if(max < i$9)
+            /*<<bytes.ml:637:39>>*/ return  /*<<bytes.ml:637:39>>*/ caml_call1
+                   (dec_invalid, 3);
+           /*<<bytes.ml:638:15>>*/  /*<<bytes.ml:638:15>>*/ var
+           b3$0 =  /*<<bytes.ml:638:15>>*/ caml_bytes_unsafe_get(b, i$9);
+           /*<<bytes.ml:638:29>>*/ return not_in_x80_to_xBF(b3$0)
+                  ?  /*<<bytes.ml:638:55>>*/ caml_call1(dec_invalid, 3)
+                  : dec_ret(4, utf_8_uchar_4(b0, b1$2, b2$2, b3$0));
+       }
+      }
+      else if(225 > b0){
+        /*<<bytes.ml:607:6>>*/  /*<<bytes.ml:607:6>>*/ var i$13 = i + 1 | 0;
+       if(max < i$13)
+         /*<<bytes.ml:607:39>>*/ return  /*<<bytes.ml:607:39>>*/ caml_call1
+                (dec_invalid, 1);
+        /*<<bytes.ml:608:15>>*/  /*<<bytes.ml:608:15>>*/ var
+        b1$4 =  /*<<bytes.ml:608:15>>*/ caml_bytes_unsafe_get(b, i$13);
+        /*<<bytes.ml:608:29>>*/ if(not_in_xA0_to_xBF(b1$4))
+         /*<<bytes.ml:608:55>>*/ return  /*<<bytes.ml:608:55>>*/ caml_call1
+                (dec_invalid, 1);
+        /*<<bytes.ml:609:6>>*/  /*<<bytes.ml:609:6>>*/ var
+        i$14 = i$13 + 1 | 0;
+       if(max < i$14)
+         /*<<bytes.ml:609:39>>*/ return  /*<<bytes.ml:609:39>>*/ caml_call1
+                (dec_invalid, 2);
+        /*<<bytes.ml:610:15>>*/  /*<<bytes.ml:610:15>>*/ var
+        b2$4 =  /*<<bytes.ml:610:15>>*/ caml_bytes_unsafe_get(b, i$14);
+        /*<<bytes.ml:610:29>>*/ return not_in_x80_to_xBF(b2$4)
+               ?  /*<<bytes.ml:610:55>>*/ caml_call1(dec_invalid, 2)
+               : dec_ret(3, utf_8_uchar_3(b0, b1$4, b2$4));
+      }
+       /*<<bytes.ml:613:6>>*/  /*<<bytes.ml:613:6>>*/ var i$2 = i + 1 | 0;
+      if(max < i$2)
+        /*<<bytes.ml:613:39>>*/ return  /*<<bytes.ml:613:39>>*/ caml_call1
+               (dec_invalid, 1);
+       /*<<bytes.ml:614:15>>*/  /*<<bytes.ml:614:15>>*/ var
+       b1$0 =  /*<<bytes.ml:614:15>>*/ caml_bytes_unsafe_get(b, i$2);
+       /*<<bytes.ml:614:29>>*/ if(not_in_x80_to_xBF(b1$0))
+        /*<<bytes.ml:614:55>>*/ return  /*<<bytes.ml:614:55>>*/ caml_call1
+               (dec_invalid, 1);
+       /*<<bytes.ml:615:6>>*/  /*<<bytes.ml:615:6>>*/ var i$3 = i$2 + 1 | 0;
+      if(max < i$3)
+        /*<<bytes.ml:615:39>>*/ return  /*<<bytes.ml:615:39>>*/ caml_call1
+               (dec_invalid, 2);
+       /*<<bytes.ml:616:15>>*/  /*<<bytes.ml:616:15>>*/ var
+       b2$0 =  /*<<bytes.ml:616:15>>*/ caml_bytes_unsafe_get(b, i$3);
+       /*<<bytes.ml:616:29>>*/ return not_in_x80_to_xBF(b2$0)
+              ?  /*<<bytes.ml:616:55>>*/ caml_call1(dec_invalid, 2)
+              : dec_ret(3, utf_8_uchar_3(b0, b1$0, b2$0));
+     }
+     if(128 > b0)  /*<<bytes.ml:601:24>>*/ return dec_ret(1, b0);
+     if(194 <= b0){
+       /*<<bytes.ml:603:6>>*/  /*<<bytes.ml:603:6>>*/ var i$15 = i + 1 | 0;
+      if(max < i$15)
+        /*<<bytes.ml:603:39>>*/ return  /*<<bytes.ml:603:39>>*/ caml_call1
+               (dec_invalid, 1);
+       /*<<bytes.ml:604:15>>*/  /*<<bytes.ml:604:15>>*/ var
+       b1$5 =  /*<<bytes.ml:604:15>>*/ caml_bytes_unsafe_get(b, i$15);
+       /*<<bytes.ml:604:29>>*/ return not_in_x80_to_xBF(b1$5)
+              ?  /*<<bytes.ml:604:55>>*/ caml_call1(dec_invalid, 1)
+              : dec_ret(2, (b0 & 31) << 6 | b1$5 & 63);
+     }
+    }
+     /*<<bytes.ml:648:9>>*/ return  /*<<bytes.ml:648:9>>*/ caml_call1
+            (dec_invalid, 1);
+    /*<<bytes.ml:648:22>>*/ }
+   function set_utf_8_uchar(b, i, u){
+     /*<<bytes.ml:651:2>>*/ function set(_i_, _h_, _g_){
+      /*<<?>>*/ caml_bytes_unsafe_set(_i_, _h_, _g_);
+     return 0;
+    }
+     /*<<bytes.ml:652:2>>*/ var
+      /*<<bytes.ml:652:2>>*/ max =
+        /*<<bytes.ml:652:2>>*/ caml_ml_bytes_length(b) - 1 | 0,
+      /*<<bytes.ml:653:8>>*/ u$0 =
+        /*<<bytes.ml:653:8>>*/ caml_call1(Stdlib_Uchar[10], u);
+     /*<<bytes.ml:654:11>>*/ if(0 > u$0)
+      /*<<bytes.ml:654:20>>*/ throw  /*<<bytes.ml:654:20>>*/ caml_maybe_attach_backtrace
+            ([0, Assert_failure, _b_], 1);
+     /*<<bytes.ml:655:11>>*/ if(127 >= u$0){
+      /*<<bytes.ml:656:6>>*/  /*<<bytes.ml:656:6>>*/ caml_bytes_set(b, i, u$0);
+      /*<<bytes.ml:656:6>>*/ return 1;
+    }
+     /*<<bytes.ml:658:11>>*/ if(2047 >= u$0){
+      /*<<bytes.ml:659:6>>*/  /*<<bytes.ml:659:6>>*/ var last$1 = i + 1 | 0;
+     return max < last$1
+             ? 0
+             : ( /*<<bytes.ml:661:7>>*/ caml_bytes_set
+                (b, i, 192 | u$0 >>> 6 | 0),
+               set(b, last$1, 128 | u$0 & 63),
+               2);
+    }
+     /*<<bytes.ml:664:11>>*/ if(65535 >= u$0){
+      /*<<bytes.ml:665:6>>*/  /*<<bytes.ml:665:6>>*/ var last$0 = i + 2 | 0;
+     return max < last$0
+             ? 0
+             : ( /*<<bytes.ml:667:7>>*/ caml_bytes_set
+                (b, i, 224 | u$0 >>> 12 | 0),
+               set(b, i + 1 | 0, 128 | (u$0 >>> 6 | 0) & 63),
+               set(b, last$0, 128 | u$0 & 63),
+               3);
+    }
+     /*<<bytes.ml:671:11>>*/ if(1114111 < u$0)
+      /*<<bytes.ml:679:9>>*/ throw  /*<<bytes.ml:679:9>>*/ caml_maybe_attach_backtrace
+            ([0, Assert_failure, _a_], 1);
+     /*<<bytes.ml:672:6>>*/  /*<<bytes.ml:672:6>>*/ var last = i + 3 | 0;
+    return max < last
+            ? 0
+            : ( /*<<bytes.ml:674:7>>*/ caml_bytes_set
+               (b, i, 240 | u$0 >>> 18 | 0),
+              set(b, i + 1 | 0, 128 | (u$0 >>> 12 | 0) & 63),
+              set(b, i + 2 | 0, 128 | (u$0 >>> 6 | 0) & 63),
+              set(b, last, 128 | u$0 & 63),
+              4);
+    /*<<bytes.ml:679:21>>*/ }
+   function is_valid_utf_8(b){
+     /*<<bytes.ml:682:2>>*/ var max = caml_ml_bytes_length(b) - 1 | 0, i = 0;
+     /*<<bytes.ml:683:4>>*/ for(;;){
+     if(max < i)  /*<<bytes.ml:683:20>>*/ return 1;
+      /*<<bytes.ml:685:26>>*/  /*<<bytes.ml:685:26>>*/ var
+      match =  /*<<bytes.ml:685:26>>*/ caml_bytes_unsafe_get(b, i);
+     a:
+     {
+      if(224 <= match){
+       if(237 <= match){
+        if(245 <= match) break a;
+        switch(match - 237 | 0){
+          case 0:
+            /*<<bytes.ml:708:8>>*/  /*<<bytes.ml:708:8>>*/ var
+            last = i + 2 | 0;
+            /*<<bytes.ml:711:11>>*/ if
+            (max >= last
+             &&
+              !
+              not_in_x80_to_x9F
+               ( /*<<bytes.ml:710:29>>*/ caml_bytes_unsafe_get(b, i + 1 | 0))
+              &&
+               !
+               not_in_x80_to_xBF
+                ( /*<<bytes.ml:711:29>>*/ caml_bytes_unsafe_get(b, last))){
+             /*<<bytes.ml:713:13>>*/ var
+              /*<<bytes.ml:713:13>>*/ i$0 = last + 1 | 0,
+             i = i$0;
+            continue;
+           }
+            /*<<bytes.ml:712:13>>*/ return 0;
+          case 3:
+            /*<<bytes.ml:715:8>>*/  /*<<bytes.ml:715:8>>*/ var
+            last$1 = i + 3 | 0;
+            /*<<bytes.ml:719:11>>*/ if
+            (max >= last$1
+             &&
+              !
+              not_in_x90_to_xBF
+               ( /*<<bytes.ml:717:29>>*/ caml_bytes_unsafe_get(b, i + 1 | 0))
+              &&
+               !
+               not_in_x80_to_xBF
+                ( /*<<bytes.ml:718:29>>*/ caml_bytes_unsafe_get(b, i + 2 | 0))
+               &&
+                !
+                not_in_x80_to_xBF
+                 ( /*<<bytes.ml:719:29>>*/ caml_bytes_unsafe_get(b, last$1))){
+             /*<<bytes.ml:721:13>>*/ var
+              /*<<bytes.ml:721:13>>*/ i$2 = last$1 + 1 | 0,
+             i = i$2;
+            continue;
+           }
+            /*<<bytes.ml:720:13>>*/ return 0;
+          case 7:
+            /*<<bytes.ml:731:8>>*/  /*<<bytes.ml:731:8>>*/ var
+            last$3 = i + 3 | 0;
+            /*<<bytes.ml:735:11>>*/ if
+            (max >= last$3
+             &&
+              !
+              not_in_x80_to_x8F
+               ( /*<<bytes.ml:733:29>>*/ caml_bytes_unsafe_get(b, i + 1 | 0))
+              &&
+               !
+               not_in_x80_to_xBF
+                ( /*<<bytes.ml:734:29>>*/ caml_bytes_unsafe_get(b, i + 2 | 0))
+               &&
+                !
+                not_in_x80_to_xBF
+                 ( /*<<bytes.ml:735:29>>*/ caml_bytes_unsafe_get(b, last$3))){
+             /*<<bytes.ml:737:13>>*/ var
+              /*<<bytes.ml:737:13>>*/ i$4 = last$3 + 1 | 0,
+             i = i$4;
+            continue;
+           }
+            /*<<bytes.ml:736:13>>*/ return 0;
+          case 1:
+          case 2: break;
+          default:
+            /*<<bytes.ml:723:8>>*/  /*<<bytes.ml:723:8>>*/ var
+            last$2 = i + 3 | 0;
+            /*<<bytes.ml:727:11>>*/ if
+            (max >= last$2
+             &&
+              !
+              not_in_x80_to_xBF
+               ( /*<<bytes.ml:725:29>>*/ caml_bytes_unsafe_get(b, i + 1 | 0))
+              &&
+               !
+               not_in_x80_to_xBF
+                ( /*<<bytes.ml:726:29>>*/ caml_bytes_unsafe_get(b, i + 2 | 0))
+               &&
+                !
+                not_in_x80_to_xBF
+                 ( /*<<bytes.ml:727:29>>*/ caml_bytes_unsafe_get(b, last$2))){
+             /*<<bytes.ml:729:13>>*/ var
+              /*<<bytes.ml:729:13>>*/ i$3 = last$2 + 1 | 0,
+             i = i$3;
+            continue;
+           }
+            /*<<bytes.ml:728:13>>*/ return 0;
+        }
+       }
+       else if(225 > match){
+         /*<<bytes.ml:694:8>>*/  /*<<bytes.ml:694:8>>*/ var
+         last$4 = i + 2 | 0;
+         /*<<bytes.ml:697:11>>*/ if
+         (max >= last$4
+          &&
+           !
+           not_in_xA0_to_xBF
+            ( /*<<bytes.ml:696:29>>*/ caml_bytes_unsafe_get(b, i + 1 | 0))
+           &&
+            !
+            not_in_x80_to_xBF
+             ( /*<<bytes.ml:697:29>>*/ caml_bytes_unsafe_get(b, last$4))){
+          /*<<bytes.ml:699:13>>*/ var
+           /*<<bytes.ml:699:13>>*/ i$5 = last$4 + 1 | 0,
+          i = i$5;
+         continue;
+        }
+         /*<<bytes.ml:698:13>>*/ return 0;
+       }
+        /*<<bytes.ml:701:8>>*/  /*<<bytes.ml:701:8>>*/ var last$0 = i + 2 | 0;
+        /*<<bytes.ml:704:11>>*/ if
+        (max >= last$0
+         &&
+          !
+          not_in_x80_to_xBF
+           ( /*<<bytes.ml:703:29>>*/ caml_bytes_unsafe_get(b, i + 1 | 0))
+          &&
+           !
+           not_in_x80_to_xBF
+            ( /*<<bytes.ml:704:29>>*/ caml_bytes_unsafe_get(b, last$0))){
+         /*<<bytes.ml:706:13>>*/ var
+          /*<<bytes.ml:706:13>>*/ i$1 = last$0 + 1 | 0,
+         i = i$1;
+        continue;
+       }
+        /*<<bytes.ml:705:13>>*/ return 0;
+      }
+      if(128 > match){
+        /*<<bytes.ml:686:26>>*/ var
+         /*<<bytes.ml:686:26>>*/ i$7 = i + 1 | 0,
+        i = i$7;
+       continue;
+      }
+      if(194 <= match){
+        /*<<bytes.ml:688:8>>*/  /*<<bytes.ml:688:8>>*/ var last$5 = i + 1 | 0;
+        /*<<bytes.ml:690:11>>*/ if
+        (max >= last$5
+         &&
+          !
+          not_in_x80_to_xBF
+           ( /*<<bytes.ml:690:29>>*/ caml_bytes_unsafe_get(b, last$5))){
+         /*<<bytes.ml:692:13>>*/ var
+          /*<<bytes.ml:692:13>>*/ i$6 = last$5 + 1 | 0,
+         i = i$6;
+        continue;
+       }
+        /*<<bytes.ml:691:13>>*/ return 0;
+      }
+     }
+      /*<<bytes.ml:738:11>>*/ return 0;
+    }
+    /*<<bytes.ml:740:25>>*/ }
+   function get_utf_16be_uchar(b, i){
+     /*<<bytes.ml:745:2>>*/  /*<<bytes.ml:746:2>>*/ var
+     max =  /*<<bytes.ml:746:2>>*/ caml_ml_bytes_length(b) - 1 | 0;
+    if(0 <= i && max >= i){
+     if(i === max)
+       /*<<bytes.ml:748:18>>*/ return  /*<<bytes.ml:748:18>>*/ caml_call1
+              (dec_invalid, 1);
+      /*<<bytes.ml:749:8>>*/  /*<<bytes.ml:749:8>>*/ var
+      hi = unsafe_get_uint16_be(b, i);
+     if(55296 <= hi && 57343 >= hi){
+       /*<<bytes.ml:751:11>>*/ if(56319 < hi)
+        /*<<bytes.ml:751:25>>*/ return  /*<<bytes.ml:751:25>>*/ caml_call1
+               (dec_invalid, 2);
+       /*<<bytes.ml:753:6>>*/  /*<<bytes.ml:753:6>>*/ var last = i + 3 | 0;
+      if(max < last) return caml_call1(dec_invalid, (max - i | 0) + 1 | 0);
+       /*<<bytes.ml:755:12>>*/  /*<<bytes.ml:755:12>>*/ var
+       lo = unsafe_get_uint16_be(b, i + 2 | 0);
+      if(56320 <= lo && 57343 >= lo){
+       var u = ((hi & 1023) << 10 | lo & 1023) + 65536 | 0;
+        /*<<bytes.ml:759:10>>*/ return dec_ret(4, u);
+      }
+       /*<<bytes.ml:756:43>>*/ return  /*<<bytes.ml:756:43>>*/ caml_call1
+              (dec_invalid, 2);
+     }
+      /*<<bytes.ml:750:39>>*/ return dec_ret(2, hi);
+    }
+     /*<<bytes.ml:747:27>>*/ return  /*<<bytes.ml:747:27>>*/ caml_call1
+            (Stdlib[1], cst_index_out_of_bounds);
+    /*<<bytes.ml:759:21>>*/ }
+   function set_utf_16be_uchar(b, i, u){
+     /*<<bytes.ml:762:2>>*/  /*<<bytes.ml:763:2>>*/ var
+     max =  /*<<bytes.ml:763:2>>*/ caml_ml_bytes_length(b) - 1 | 0;
+    if(0 <= i && max >= i){
+      /*<<bytes.ml:765:8>>*/  /*<<bytes.ml:765:8>>*/ var
+      u$0 =  /*<<bytes.ml:765:8>>*/ caml_call1(Stdlib_Uchar[10], u);
+      /*<<bytes.ml:766:11>>*/ if(0 > u$0)
+       /*<<bytes.ml:766:20>>*/ throw  /*<<bytes.ml:766:20>>*/ caml_maybe_attach_backtrace
+             ([0, Assert_failure, _d_], 1);
+      /*<<bytes.ml:767:11>>*/ if(65535 >= u$0){
+       /*<<bytes.ml:768:6>>*/  /*<<bytes.ml:768:6>>*/ var last$0 = i + 1 | 0;
+      return max < last$0 ? 0 : (unsafe_set_uint16_be(b, i, u$0), 2);
+     }
+      /*<<bytes.ml:770:11>>*/ if(1114111 < u$0)
+       /*<<bytes.ml:777:9>>*/ throw  /*<<bytes.ml:777:9>>*/ caml_maybe_attach_backtrace
+             ([0, Assert_failure, _c_], 1);
+      /*<<bytes.ml:771:6>>*/  /*<<bytes.ml:771:6>>*/ var last = i + 3 | 0;
+     if(max < last)  /*<<bytes.ml:772:25>>*/ return 0;
+      /*<<bytes.ml:773:6>>*/ var
+       /*<<bytes.ml:773:6>>*/ u$1 = u$0 - 65536 | 0,
+      hi = 55296 | u$1 >>> 10 | 0,
+      lo = 56320 | u$1 & 1023;
+      /*<<bytes.ml:776:6>>*/ unsafe_set_uint16_be(b, i, hi);
+      /*<<bytes.ml:776:18>>*/ unsafe_set_uint16_be(b, i + 2 | 0, lo);
+      /*<<bytes.ml:776:18>>*/ return 4;
+    }
+     /*<<bytes.ml:764:27>>*/ return  /*<<bytes.ml:764:27>>*/ caml_call1
+            (Stdlib[1], cst_index_out_of_bounds$0);
+    /*<<bytes.ml:777:21>>*/ }
+   function is_valid_utf_16be(b){
+     /*<<bytes.ml:780:2>>*/ var max = caml_ml_bytes_length(b) - 1 | 0, i = 0;
+     /*<<bytes.ml:781:4>>*/ for(;;){
+     if(max < i)  /*<<bytes.ml:782:20>>*/ return 1;
+     if(i === max)  /*<<bytes.ml:783:20>>*/ return 0;
+      /*<<bytes.ml:784:10>>*/  /*<<bytes.ml:784:10>>*/ var
+      u = unsafe_get_uint16_be(b, i);
+     if(55296 <= u && 57343 >= u){
+       /*<<bytes.ml:786:13>>*/ if(56319 < u)
+        /*<<bytes.ml:786:27>>*/ return 0;
+       /*<<bytes.ml:788:8>>*/  /*<<bytes.ml:788:8>>*/ var last = i + 3 | 0;
+      if(max < last)  /*<<bytes.ml:789:27>>*/ return 0;
+       /*<<bytes.ml:790:14>>*/  /*<<bytes.ml:790:14>>*/ var
+       u$0 = unsafe_get_uint16_be(b, i + 2 | 0);
+      if(56320 <= u$0 && 57343 >= u$0){
+        /*<<bytes.ml:792:17>>*/ var
+         /*<<bytes.ml:792:17>>*/ i$1 = i + 4 | 0,
+        i = i$1;
+       continue;
+      }
+       /*<<bytes.ml:791:45>>*/ return 0;
+     }
+      /*<<bytes.ml:785:41>>*/ var
+       /*<<bytes.ml:785:41>>*/ i$0 = i + 2 | 0,
+      i = i$0;
+    }
+    /*<<bytes.ml:794:25>>*/ }
+   function get_utf_16le_uchar(b, i){
+     /*<<bytes.ml:799:2>>*/  /*<<bytes.ml:800:2>>*/ var
+     max =  /*<<bytes.ml:800:2>>*/ caml_ml_bytes_length(b) - 1 | 0;
+    if(0 <= i && max >= i){
+     if(i === max)
+       /*<<bytes.ml:802:18>>*/ return  /*<<bytes.ml:802:18>>*/ caml_call1
+              (dec_invalid, 1);
+      /*<<bytes.ml:803:8>>*/  /*<<bytes.ml:803:8>>*/ var
+      hi = unsafe_get_uint16_le(b, i);
+     if(55296 <= hi && 57343 >= hi){
+       /*<<bytes.ml:805:11>>*/ if(56319 < hi)
+        /*<<bytes.ml:805:25>>*/ return  /*<<bytes.ml:805:25>>*/ caml_call1
+               (dec_invalid, 2);
+       /*<<bytes.ml:807:6>>*/  /*<<bytes.ml:807:6>>*/ var last = i + 3 | 0;
+      if(max < last) return caml_call1(dec_invalid, (max - i | 0) + 1 | 0);
+       /*<<bytes.ml:809:12>>*/  /*<<bytes.ml:809:12>>*/ var
+       lo = unsafe_get_uint16_le(b, i + 2 | 0);
+      if(56320 <= lo && 57343 >= lo){
+       var u = ((hi & 1023) << 10 | lo & 1023) + 65536 | 0;
+        /*<<bytes.ml:813:10>>*/ return dec_ret(4, u);
+      }
+       /*<<bytes.ml:810:43>>*/ return  /*<<bytes.ml:810:43>>*/ caml_call1
+              (dec_invalid, 2);
+     }
+      /*<<bytes.ml:804:39>>*/ return dec_ret(2, hi);
+    }
+     /*<<bytes.ml:801:27>>*/ return  /*<<bytes.ml:801:27>>*/ caml_call1
+            (Stdlib[1], cst_index_out_of_bounds$1);
+    /*<<bytes.ml:813:21>>*/ }
+   function set_utf_16le_uchar(b, i, u){
+     /*<<bytes.ml:816:2>>*/  /*<<bytes.ml:817:2>>*/ var
+     max =  /*<<bytes.ml:817:2>>*/ caml_ml_bytes_length(b) - 1 | 0;
+    if(0 <= i && max >= i){
+      /*<<bytes.ml:819:8>>*/  /*<<bytes.ml:819:8>>*/ var
+      u$0 =  /*<<bytes.ml:819:8>>*/ caml_call1(Stdlib_Uchar[10], u);
+      /*<<bytes.ml:820:11>>*/ if(0 > u$0)
+       /*<<bytes.ml:820:20>>*/ throw  /*<<bytes.ml:820:20>>*/ caml_maybe_attach_backtrace
+             ([0, Assert_failure, _f_], 1);
+      /*<<bytes.ml:821:11>>*/ if(65535 >= u$0){
+       /*<<bytes.ml:822:6>>*/  /*<<bytes.ml:822:6>>*/ var last$0 = i + 1 | 0;
+      return max < last$0 ? 0 : (unsafe_set_uint16_le(b, i, u$0), 2);
+     }
+      /*<<bytes.ml:824:11>>*/ if(1114111 < u$0)
+       /*<<bytes.ml:831:9>>*/ throw  /*<<bytes.ml:831:9>>*/ caml_maybe_attach_backtrace
+             ([0, Assert_failure, _e_], 1);
+      /*<<bytes.ml:825:6>>*/  /*<<bytes.ml:825:6>>*/ var last = i + 3 | 0;
+     if(max < last)  /*<<bytes.ml:826:25>>*/ return 0;
+      /*<<bytes.ml:827:6>>*/ var
+       /*<<bytes.ml:827:6>>*/ u$1 = u$0 - 65536 | 0,
+      hi = 55296 | u$1 >>> 10 | 0,
+      lo = 56320 | u$1 & 1023;
+      /*<<bytes.ml:830:6>>*/ unsafe_set_uint16_le(b, i, hi);
+      /*<<bytes.ml:830:18>>*/ unsafe_set_uint16_le(b, i + 2 | 0, lo);
+      /*<<bytes.ml:830:18>>*/ return 4;
+    }
+     /*<<bytes.ml:818:27>>*/ return  /*<<bytes.ml:818:27>>*/ caml_call1
+            (Stdlib[1], cst_index_out_of_bounds$2);
+    /*<<bytes.ml:831:21>>*/ }
+   function is_valid_utf_16le(b){
+     /*<<bytes.ml:834:2>>*/ var max = caml_ml_bytes_length(b) - 1 | 0, i = 0;
+     /*<<bytes.ml:835:4>>*/ for(;;){
+     if(max < i)  /*<<bytes.ml:836:20>>*/ return 1;
+     if(i === max)  /*<<bytes.ml:837:20>>*/ return 0;
+      /*<<bytes.ml:838:10>>*/  /*<<bytes.ml:838:10>>*/ var
+      u = unsafe_get_uint16_le(b, i);
+     if(55296 <= u && 57343 >= u){
+       /*<<bytes.ml:840:13>>*/ if(56319 < u)
+        /*<<bytes.ml:840:27>>*/ return 0;
+       /*<<bytes.ml:842:8>>*/  /*<<bytes.ml:842:8>>*/ var last = i + 3 | 0;
+      if(max < last)  /*<<bytes.ml:843:27>>*/ return 0;
+       /*<<bytes.ml:844:14>>*/  /*<<bytes.ml:844:14>>*/ var
+       u$0 = unsafe_get_uint16_le(b, i + 2 | 0);
+      if(56320 <= u$0 && 57343 >= u$0){
+        /*<<bytes.ml:846:17>>*/ var
+         /*<<bytes.ml:846:17>>*/ i$1 = i + 4 | 0,
+        i = i$1;
+       continue;
+      }
+       /*<<bytes.ml:845:45>>*/ return 0;
+     }
+      /*<<bytes.ml:839:41>>*/ var
+       /*<<bytes.ml:839:41>>*/ i$0 = i + 2 | 0,
+      i = i$0;
+    }
+    /*<<bytes.ml:848:25>>*/ }
+   var
+    Stdlib_Bytes =
+      [0,
+       make,
+       init,
+       empty,
+       copy,
+       of_string,
+       to_string,
+       sub,
+       sub_string,
+       extend,
+       fill,
+       blit,
+       blit_string,
+       concat,
+       cat,
+       iter,
+       iteri,
+       map,
+       mapi,
+       fold_left,
+       fold_right,
+       for_all,
+       exists,
+       trim,
+       escaped,
+       index,
+       index_opt,
+       rindex,
+       rindex_opt,
+       index_from,
+       index_from_opt,
+       rindex_from,
+       rindex_from_opt,
+       contains,
+       contains_from,
+       rcontains_from,
+       uppercase_ascii,
+       lowercase_ascii,
+       capitalize_ascii,
+       uncapitalize_ascii,
+       compare,
+       runtime.caml_bytes_equal,
+       starts_with,
+       ends_with,
+       caml_string_of_bytes,
+       caml_bytes_of_string,
+       split_on_char,
+       to_seq,
+       to_seqi,
+       of_seq,
+       get_utf_8_uchar,
+       set_utf_8_uchar,
+       is_valid_utf_8,
+       get_utf_16be_uchar,
+       set_utf_16be_uchar,
+       is_valid_utf_16be,
+       get_utf_16le_uchar,
+       set_utf_16le_uchar,
+       is_valid_utf_16le,
+       caml_bytes_get,
+       get_int8,
+       caml_bytes_get16,
+       get_uint16_be,
+       get_uint16_le,
+       get_int16_ne,
+       get_int16_be,
+       get_int16_le,
+       caml_bytes_get32,
+       get_int32_be,
+       get_int32_le,
+       caml_bytes_get64,
+       get_int64_be,
+       get_int64_le,
+       set_uint8,
+       caml_bytes_set,
+       set_uint16_ne,
+       set_int16_be,
+       set_int16_le,
+       caml_bytes_set16,
+       set_int16_be,
+       set_int16_le,
+       caml_bytes_set32,
+       set_int32_be,
+       set_int32_le,
+       caml_bytes_set64,
+       set_int64_be,
+       set_int64_le,
+       unsafe_escape];
+   runtime.caml_register_global(30, Stdlib_Bytes, "Stdlib__Bytes");
+   return;
+   /*<<?>>*/ }
+  (globalThis));
+
+//# unitInfo: Provides: Stdlib__String
+//# unitInfo: Requires: Stdlib, Stdlib__Bytes
+(function
+  (globalThis){
+   "use strict";
+   var
+    runtime = globalThis.jsoo_runtime,
+    cst$0 = "",
+    caml_blit_string = runtime.caml_blit_string,
+    caml_maybe_attach_backtrace = runtime.caml_maybe_attach_backtrace,
+    caml_ml_string_length = runtime.caml_ml_string_length,
+    caml_string_equal = runtime.caml_string_equal,
+    caml_string_hash = runtime.caml_string_hash,
+    caml_string_unsafe_get = runtime.caml_string_unsafe_get,
+    caml_wrap_exception = runtime.caml_wrap_exception;
+    /*<<?>>*/ function caml_call1(f, a0){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 1
+            ? f(a0)
+            : runtime.caml_call_gen(f, [a0]);
+   }
+    /*<<?>>*/ function caml_call2(f, a0, a1){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 2
+            ? f(a0, a1)
+            : runtime.caml_call_gen(f, [a0, a1]);
+   }
+    /*<<?>>*/ function caml_call3(f, a0, a1, a2){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 3
+            ? f(a0, a1, a2)
+            : runtime.caml_call_gen(f, [a0, a1, a2]);
+   }
+   var
+    global_data = runtime.caml_get_global_data(),
+    cst = cst$0,
+    empty = cst$0,
+    Stdlib = global_data.Stdlib,
+    Stdlib_Bytes = global_data.Stdlib__Bytes,
+    bts = Stdlib_Bytes[44],
+    bos = Stdlib_Bytes[45],
+    cst_String_rcontains_from_Byte =
+      "String.rcontains_from / Bytes.rcontains_from",
+    cst_String_contains_from_Bytes =
+      "String.contains_from / Bytes.contains_from",
+    cst_String_rindex_from_opt_Byt =
+      "String.rindex_from_opt / Bytes.rindex_from_opt",
+    cst_String_rindex_from_Bytes_r = "String.rindex_from / Bytes.rindex_from",
+    cst_String_index_from_opt_Byte =
+      "String.index_from_opt / Bytes.index_from_opt",
+    cst_String_index_from_Bytes_in = "String.index_from / Bytes.index_from",
+    cst_String_concat = "String.concat";
+   function make(n, c){
+     /*<<string.ml:36:2>>*/ return  /*<<string.ml:36:2>>*/ caml_call1
+            (bts,  /*<<string.ml:36:2>>*/ caml_call2(Stdlib_Bytes[1], n, c));
+    /*<<string.ml:36:19>>*/ }
+   function init(n, f){
+     /*<<string.ml:38:2>>*/ return  /*<<string.ml:38:2>>*/ caml_call1
+            (bts,  /*<<string.ml:38:2>>*/ caml_call2(Stdlib_Bytes[2], n, f));
+    /*<<string.ml:38:19>>*/ }
+   var of_bytes = Stdlib_Bytes[6], to_bytes = Stdlib_Bytes[5];
+   function sub(s, ofs, len){
+     /*<<string.ml:43:2>>*/  /*<<string.ml:43:8>>*/ var
+     _X_ =  /*<<string.ml:43:8>>*/ caml_call1(bos, s);
+     /*<<string.ml:43:2>>*/ return  /*<<string.ml:43:2>>*/ caml_call1
+            (bts,
+              /*<<string.ml:43:2>>*/ caml_call3
+              (Stdlib_Bytes[7], _X_, ofs, len));
+    /*<<string.ml:43:30>>*/ }
+   var blit = Stdlib_Bytes[12];
+   function concat(sep, l){
+     /*<<?>>*/ if(! l)  /*<<string.ml:64:10>>*/ return cst;
+    var seplen = caml_ml_string_length(sep), acc = 0, param = l, pos$1 = 0;
+    for(;;){
+     if(param){
+      var hd = param[1];
+      if(param[2]){
+       var
+        tl = param[2],
+        x = (caml_ml_string_length(hd) + seplen | 0) + acc | 0,
+        acc$0 =
+          acc <= x
+           ? x
+           :  /*<<string.ml:47:48>>*/ caml_call1(Stdlib[1], cst_String_concat),
+        acc = acc$0,
+        param = tl;
+       continue;
+      }
+      var _W_ = caml_ml_string_length(hd) + acc | 0;
+     }
+     else
+      var _W_ = acc;
+      /*<<string.ml:67:12>>*/ var
+       /*<<string.ml:67:12>>*/ dst =
+         /*<<string.ml:67:12>>*/ runtime.caml_create_bytes(_W_),
+      pos = pos$1,
+      param$0 = l;
+     for(;;){
+      if(param$0){
+       var hd$0 = param$0[1];
+       if(param$0[2]){
+        var tl$0 = param$0[2];
+         /*<<string.ml:59:4>>*/  /*<<string.ml:59:4>>*/ caml_blit_string
+         (hd$0,
+          0,
+          dst,
+          pos,
+           /*<<string.ml:59:4>>*/ caml_ml_string_length(hd$0));
+         /*<<string.ml:60:4>>*/  /*<<string.ml:60:4>>*/ caml_blit_string
+         (sep, 0, dst, pos + caml_ml_string_length(hd$0) | 0, seplen);
+        var
+         pos$0 = (pos + caml_ml_string_length(hd$0) | 0) + seplen | 0,
+         pos = pos$0,
+         param$0 = tl$0;
+        continue;
+       }
+        /*<<string.ml:57:4>>*/  /*<<string.ml:57:4>>*/ caml_blit_string
+        (hd$0, 0, dst, pos, caml_ml_string_length(hd$0));
+      }
+       /*<<string.ml:66:10>>*/ return  /*<<string.ml:66:10>>*/ caml_call1
+              (bts, dst);
+     }
+    }
+   }
+   var cat = Stdlib[28];
+   function iter(f, s){
+     /*<<string.ml:74:2>>*/ var
+     _U_ = caml_ml_string_length(s) - 1 | 0,
+      /*<<string.ml:74:2>>*/ _T_ = 0;
+    if(_U_ >= 0){
+     var i = _T_;
+     for(;;){
+       /*<<string.ml:74:31>>*/  /*<<string.ml:74:31>>*/ caml_call1
+       (f, caml_string_unsafe_get(s, i));
+       /*<<string.ml:74:31>>*/  /*<<string.ml:74:31>>*/ var _V_ = i + 1 | 0;
+      if(_U_ === i) break;
+      var i = _V_;
+     }
+    }
+    return 0;
+    /*<<string.ml:74:54>>*/ }
+   function iteri(f, s){
+     /*<<string.ml:78:2>>*/ var
+     _R_ = caml_ml_string_length(s) - 1 | 0,
+      /*<<string.ml:78:2>>*/ _Q_ = 0;
+    if(_R_ >= 0){
+     var i = _Q_;
+     for(;;){
+       /*<<string.ml:78:31>>*/  /*<<string.ml:78:31>>*/ caml_call2
+       (f, i, caml_string_unsafe_get(s, i));
+       /*<<string.ml:78:31>>*/  /*<<string.ml:78:31>>*/ var _S_ = i + 1 | 0;
+      if(_R_ === i) break;
+      var i = _S_;
+     }
+    }
+    return 0;
+    /*<<string.ml:78:56>>*/ }
+   function map(f, s){
+     /*<<string.ml:81:2>>*/  /*<<string.ml:81:10>>*/ var
+     _P_ =  /*<<string.ml:81:10>>*/ caml_call1(bos, s);
+     /*<<string.ml:81:2>>*/ return  /*<<string.ml:81:2>>*/ caml_call1
+            (bts,
+              /*<<string.ml:81:2>>*/ caml_call2(Stdlib_Bytes[17], f, _P_));
+    /*<<string.ml:81:24>>*/ }
+   function mapi(f, s){
+     /*<<string.ml:83:2>>*/  /*<<string.ml:83:11>>*/ var
+     _O_ =  /*<<string.ml:83:11>>*/ caml_call1(bos, s);
+     /*<<string.ml:83:2>>*/ return  /*<<string.ml:83:2>>*/ caml_call1
+            (bts,
+              /*<<string.ml:83:2>>*/ caml_call2(Stdlib_Bytes[18], f, _O_));
+    /*<<string.ml:83:25>>*/ }
+   function fold_right(f, x, a){
+     /*<<string.ml:85:2>>*/  /*<<string.ml:85:17>>*/ var
+     _N_ =  /*<<string.ml:85:17>>*/ caml_call1(bos, x);
+     /*<<string.ml:85:2>>*/ return  /*<<string.ml:85:2>>*/ caml_call3
+            (Stdlib_Bytes[20], f, _N_, a);
+    /*<<string.ml:85:26>>*/ }
+   function fold_left(f, a, x){
+     /*<<string.ml:87:2>>*/  /*<<string.ml:87:18>>*/ var
+     _M_ =  /*<<string.ml:87:18>>*/ caml_call1(bos, x);
+     /*<<string.ml:87:18>>*/ return  /*<<string.ml:87:18>>*/ caml_call3
+            (Stdlib_Bytes[19], f, a, _M_);
+    /*<<string.ml:87:25>>*/ }
+   function exists(f, s){
+     /*<<string.ml:89:2>>*/  /*<<string.ml:89:13>>*/ var
+     _L_ =  /*<<string.ml:89:13>>*/ caml_call1(bos, s);
+     /*<<string.ml:89:13>>*/ return  /*<<string.ml:89:13>>*/ caml_call2
+            (Stdlib_Bytes[22], f, _L_);
+    /*<<string.ml:89:20>>*/ }
+   function for_all(f, s){
+     /*<<string.ml:91:2>>*/  /*<<string.ml:91:14>>*/ var
+     _K_ =  /*<<string.ml:91:14>>*/ caml_call1(bos, s);
+     /*<<string.ml:91:14>>*/ return  /*<<string.ml:91:14>>*/ caml_call2
+            (Stdlib_Bytes[21], f, _K_);
+    /*<<string.ml:91:21>>*/ }
+   function is_space(param){
+     /*<<string.ml:97:15>>*/  /*<<string.ml:97:15>>*/ var _J_ = param - 9 | 0;
+    a:
+    {
+     if(4 < _J_ >>> 0){if(23 !== _J_) break a;} else if(2 === _J_) break a;
+      /*<<string.ml:98:41>>*/ return 1;
+    }
+     /*<<string.ml:99:9>>*/ return 0;
+    /*<<string.ml:99:14>>*/ }
+   function trim(s){
+     /*<<string.ml:102:2>>*/ if
+     ( /*<<string.ml:102:5>>*/ caml_string_equal(s, cst$0))
+      /*<<string.ml:102:17>>*/ return s;
+     /*<<string.ml:103:39>>*/ if
+     (!
+      is_space(caml_string_unsafe_get(s, 0))
+      &&
+       !
+       is_space(caml_string_unsafe_get(s, caml_ml_string_length(s) - 1 | 0)))
+      /*<<string.ml:105:7>>*/ return s;
+     /*<<string.ml:104:21>>*/  /*<<string.ml:104:21>>*/ var
+     _I_ =  /*<<string.ml:104:21>>*/ caml_call1(bos, s);
+     /*<<string.ml:104:13>>*/ return  /*<<string.ml:104:13>>*/ caml_call1
+            (bts,  /*<<string.ml:104:13>>*/ caml_call1(Stdlib_Bytes[23], _I_));
+    /*<<string.ml:105:8>>*/ }
+   function escaped(s){
+     /*<<string.ml:108:2>>*/  /*<<string.ml:108:10>>*/ var
+     b =  /*<<string.ml:108:10>>*/ caml_call1(bos, s);
+     /*<<string.ml:111:6>>*/ return  /*<<string.ml:111:6>>*/ caml_call1
+            (bts,  /*<<string.ml:111:6>>*/ caml_call1(Stdlib_Bytes[87], b));
+    /*<<string.ml:111:25>>*/ }
+   function index_rec(s, lim, i, c){
+     /*<<string.ml:115:2>>*/ var i$0 = i;
+     /*<<string.ml:115:2>>*/ for(;;){
+     if(lim <= i$0)
+       /*<<string.ml:115:19>>*/ throw  /*<<string.ml:115:19>>*/ caml_maybe_attach_backtrace
+             (Stdlib[8], 1);
+     if(caml_string_unsafe_get(s, i$0) === c)
+       /*<<string.ml:116:29>>*/ return i$0;
+     var i$1 = i$0 + 1 | 0, i$0 = i$1;
+    }
+    /*<<string.ml:116:61>>*/ }
+   function index(s, c){
+     /*<<string.ml:119:16>>*/ return index_rec
+            (s, caml_ml_string_length(s), 0, c);
+    /*<<string.ml:119:42>>*/ }
+   function index_rec_opt(s, lim, i, c){
+     /*<<string.ml:123:2>>*/ var i$0 = i;
+     /*<<string.ml:123:2>>*/ for(;;){
+     if(lim <= i$0)  /*<<string.ml:123:19>>*/ return 0;
+     if(caml_string_unsafe_get(s, i$0) === c)
+       /*<<string.ml:124:29>>*/ return [0, i$0];
+     var i$1 = i$0 + 1 | 0, i$0 = i$1;
+    }
+    /*<<string.ml:124:70>>*/ }
+   function index_opt(s, c){
+     /*<<string.ml:127:20>>*/ return index_rec_opt
+            (s, caml_ml_string_length(s), 0, c);
+    /*<<string.ml:127:50>>*/ }
+   function index_from(s, i, c){
+     /*<<string.ml:131:2>>*/ var l = caml_ml_string_length(s);
+    if(0 <= i && l >= i)
+      /*<<string.ml:133:4>>*/ return index_rec(s, l, i, c);
+     /*<<string.ml:132:25>>*/ return  /*<<string.ml:132:25>>*/ caml_call1
+            (Stdlib[1], cst_String_index_from_Bytes_in);
+    /*<<string.ml:133:21>>*/ }
+   function index_from_opt(s, i, c){
+     /*<<string.ml:137:2>>*/ var l = caml_ml_string_length(s);
+    if(0 <= i && l >= i)
+      /*<<string.ml:141:4>>*/ return index_rec_opt(s, l, i, c);
+     /*<<string.ml:139:4>>*/ return  /*<<string.ml:139:4>>*/ caml_call1
+            (Stdlib[1], cst_String_index_from_opt_Byte);
+    /*<<string.ml:141:25>>*/ }
+   function rindex_rec(s, i, c){
+     /*<<string.ml:145:2>>*/ var i$0 = i;
+     /*<<string.ml:145:2>>*/ for(;;){
+     if(0 > i$0)
+       /*<<string.ml:145:16>>*/ throw  /*<<string.ml:145:16>>*/ caml_maybe_attach_backtrace
+             (Stdlib[8], 1);
+     if(caml_string_unsafe_get(s, i$0) === c)
+       /*<<string.ml:146:29>>*/ return i$0;
+     var i$1 = i$0 - 1 | 0, i$0 = i$1;
+    }
+    /*<<string.ml:146:58>>*/ }
+   function rindex(s, c){
+     /*<<string.ml:149:17>>*/ return rindex_rec
+            (s, caml_ml_string_length(s) - 1 | 0, c);
+    /*<<string.ml:149:46>>*/ }
+   function rindex_from(s, i, c){
+     /*<<string.ml:153:2>>*/ if(-1 <= i && caml_ml_string_length(s) > i)
+      /*<<string.ml:156:4>>*/ return rindex_rec(s, i, c);
+     /*<<string.ml:154:4>>*/ return  /*<<string.ml:154:4>>*/ caml_call1
+            (Stdlib[1], cst_String_rindex_from_Bytes_r);
+    /*<<string.ml:156:20>>*/ }
+   function rindex_rec_opt(s, i, c){
+     /*<<string.ml:160:2>>*/ var i$0 = i;
+     /*<<string.ml:160:2>>*/ for(;;){
+     if(0 > i$0)  /*<<string.ml:160:16>>*/ return 0;
+     if(caml_string_unsafe_get(s, i$0) === c)
+       /*<<string.ml:161:29>>*/ return [0, i$0];
+     var i$1 = i$0 - 1 | 0, i$0 = i$1;
+    }
+    /*<<string.ml:161:67>>*/ }
+   function rindex_opt(s, c){
+     /*<<string.ml:164:21>>*/ return rindex_rec_opt
+            (s, caml_ml_string_length(s) - 1 | 0, c);
+    /*<<string.ml:164:54>>*/ }
+   function rindex_from_opt(s, i, c){
+     /*<<string.ml:168:2>>*/ if(-1 <= i && caml_ml_string_length(s) > i)
+      /*<<string.ml:171:4>>*/ return rindex_rec_opt(s, i, c);
+     /*<<string.ml:169:4>>*/ return  /*<<string.ml:169:4>>*/ caml_call1
+            (Stdlib[1], cst_String_rindex_from_opt_Byt);
+    /*<<string.ml:171:24>>*/ }
+   function contains_from(s, i, c){
+     /*<<string.ml:175:2>>*/ var l = caml_ml_string_length(s);
+    if(0 <= i && l >= i)
+      /*<<string.ml:179:4>>*/ try{
+       /*<<string.ml:179:15>>*/ index_rec(s, l, i, c);
+       /*<<string.ml:179:36>>*/  /*<<string.ml:179:36>>*/ var _G_ = 1;
+       /*<<string.ml:179:36>>*/ return _G_;
+     }
+     catch(_H_){
+      var _F_ = caml_wrap_exception(_H_);
+      if(_F_ === Stdlib[8])  /*<<string.ml:179:59>>*/ return 0;
+      throw caml_maybe_attach_backtrace(_F_, 0);
+     }
+     /*<<string.ml:177:4>>*/ return  /*<<string.ml:177:4>>*/ caml_call1
+            (Stdlib[1], cst_String_contains_from_Bytes);
+    /*<<string.ml:179:64>>*/ }
+   function contains(s, c){
+     /*<<string.ml:182:19>>*/ return contains_from(s, 0, c);
+    /*<<string.ml:182:38>>*/ }
+   function rcontains_from(s, i, c){
+     /*<<string.ml:186:2>>*/ if(0 <= i && caml_ml_string_length(s) > i)
+      /*<<string.ml:189:4>>*/ try{
+       /*<<string.ml:189:15>>*/ rindex_rec(s, i, c);
+       /*<<string.ml:189:35>>*/  /*<<string.ml:189:35>>*/ var _D_ = 1;
+       /*<<string.ml:189:35>>*/ return _D_;
+     }
+     catch(_E_){
+      var _C_ = caml_wrap_exception(_E_);
+      if(_C_ === Stdlib[8])  /*<<string.ml:189:58>>*/ return 0;
+      throw caml_maybe_attach_backtrace(_C_, 0);
+     }
+     /*<<string.ml:187:4>>*/ return  /*<<string.ml:187:4>>*/ caml_call1
+            (Stdlib[1], cst_String_rcontains_from_Byte);
+    /*<<string.ml:189:63>>*/ }
+   function uppercase_ascii(s){
+     /*<<string.ml:192:2>>*/  /*<<string.ml:192:20>>*/ var
+     _B_ =  /*<<string.ml:192:20>>*/ caml_call1(bos, s);
+     /*<<string.ml:192:2>>*/ return  /*<<string.ml:192:2>>*/ caml_call1
+            (bts,  /*<<string.ml:192:2>>*/ caml_call1(Stdlib_Bytes[36], _B_));
+    /*<<string.ml:192:34>>*/ }
+   function lowercase_ascii(s){
+     /*<<string.ml:194:2>>*/  /*<<string.ml:194:20>>*/ var
+     _A_ =  /*<<string.ml:194:20>>*/ caml_call1(bos, s);
+     /*<<string.ml:194:2>>*/ return  /*<<string.ml:194:2>>*/ caml_call1
+            (bts,  /*<<string.ml:194:2>>*/ caml_call1(Stdlib_Bytes[37], _A_));
+    /*<<string.ml:194:34>>*/ }
+   function capitalize_ascii(s){
+     /*<<string.ml:196:2>>*/  /*<<string.ml:196:21>>*/ var
+     _z_ =  /*<<string.ml:196:21>>*/ caml_call1(bos, s);
+     /*<<string.ml:196:2>>*/ return  /*<<string.ml:196:2>>*/ caml_call1
+            (bts,  /*<<string.ml:196:2>>*/ caml_call1(Stdlib_Bytes[38], _z_));
+    /*<<string.ml:196:35>>*/ }
+   function uncapitalize_ascii(s){
+     /*<<string.ml:198:2>>*/  /*<<string.ml:198:23>>*/ var
+     _y_ =  /*<<string.ml:198:23>>*/ caml_call1(bos, s);
+     /*<<string.ml:198:2>>*/ return  /*<<string.ml:198:2>>*/ caml_call1
+            (bts,  /*<<string.ml:198:2>>*/ caml_call1(Stdlib_Bytes[39], _y_));
+    /*<<string.ml:198:37>>*/ }
+   function starts_with(prefix, s){
+     /*<<string.ml:202:2>>*/ var
+     len_s = caml_ml_string_length(s),
+     len_pre = caml_ml_string_length(prefix),
+     _x_ = len_pre <= len_s ? 1 : 0;
+    if(! _x_) return _x_;
+    var i = 0;
+     /*<<string.ml:205:4>>*/ for(;;){
+     if(i === len_pre)  /*<<string.ml:205:24>>*/ return 1;
+     if(caml_string_unsafe_get(s, i) !== caml_string_unsafe_get(prefix, i))
+       /*<<string.ml:206:55>>*/ return 0;
+      /*<<string.ml:207:9>>*/ var
+       /*<<string.ml:207:9>>*/ i$0 = i + 1 | 0,
+      i = i$0;
+    }
+    /*<<string.ml:208:30>>*/ }
+   function ends_with(suffix, s){
+     /*<<string.ml:212:2>>*/ var
+     len_s = caml_ml_string_length(s),
+     len_suf = caml_ml_string_length(suffix),
+     diff = len_s - len_suf | 0,
+     _w_ = 0 <= diff ? 1 : 0;
+    if(! _w_) return _w_;
+    var i = 0;
+     /*<<string.ml:216:4>>*/ for(;;){
+     if(i === len_suf)  /*<<string.ml:216:24>>*/ return 1;
+     if
+      (caml_string_unsafe_get(s, diff + i | 0)
+       !== caml_string_unsafe_get(suffix, i))
+       /*<<string.ml:217:64>>*/ return 0;
+      /*<<string.ml:218:9>>*/ var
+       /*<<string.ml:218:9>>*/ i$0 = i + 1 | 0,
+      i = i$0;
+    }
+    /*<<string.ml:219:23>>*/ }
+   function hash(x){
+     /*<<string.ml:222:13>>*/ return  /*<<string.ml:222:13>>*/ caml_string_hash
+            (0, x);
+    /*<<string.ml:222:28>>*/ }
+   function split_on_char(sep, s){
+     /*<<string.ml:226:2>>*/ var
+      /*<<string.ml:226:10>>*/ r = [0, 0],
+      /*<<string.ml:227:10>>*/ j =
+       [0,  /*<<string.ml:227:2>>*/ caml_ml_string_length(s)],
+      /*<<string.ml:228:2>>*/ _s_ =
+        /*<<string.ml:228:2>>*/ caml_ml_string_length(s) - 1 | 0;
+    if(_s_ >= 0){
+     var i = _s_;
+     for(;;){
+      if(caml_string_unsafe_get(s, i) === sep){
+       var _u_ = r[1];
+       r[1] = [0, sub(s, i + 1 | 0, (j[1] - i | 0) - 1 | 0), _u_];
+       j[1] = i;
+      }
+       /*<<string.ml:228:2>>*/  /*<<string.ml:228:2>>*/ var _v_ = i - 1 | 0;
+      if(0 === i) break;
+      var i = _v_;
+     }
+    }
+    var _t_ = r[1];
+     /*<<string.ml:234:2>>*/ return [0, sub(s, 0, j[1]), _t_];
+    /*<<string.ml:234:18>>*/ }
+   var compare = runtime.caml_string_compare;
+   function to_seq(s){
+     /*<<string.ml:243:15>>*/  /*<<string.ml:243:15>>*/ var
+     _r_ =  /*<<string.ml:243:15>>*/ caml_call1(bos, s);
+     /*<<string.ml:243:15>>*/ return  /*<<string.ml:243:15>>*/ caml_call1
+            (Stdlib_Bytes[47], _r_);
+    /*<<string.ml:243:32>>*/ }
+   function to_seqi(s){
+     /*<<string.ml:245:16>>*/  /*<<string.ml:245:16>>*/ var
+     _q_ =  /*<<string.ml:245:16>>*/ caml_call1(bos, s);
+     /*<<string.ml:245:16>>*/ return  /*<<string.ml:245:16>>*/ caml_call1
+            (Stdlib_Bytes[48], _q_);
+    /*<<string.ml:245:34>>*/ }
+   function of_seq(g){
+     /*<<string.ml:247:15>>*/ return  /*<<string.ml:247:15>>*/ caml_call1
+            (bts,  /*<<string.ml:247:15>>*/ caml_call1(Stdlib_Bytes[49], g));
+    /*<<string.ml:247:32>>*/ }
+   function get_utf_8_uchar(s, i){
+     /*<<string.ml:251:26>>*/  /*<<string.ml:251:44>>*/ var
+     _p_ =  /*<<string.ml:251:44>>*/ caml_call1(bos, s);
+     /*<<string.ml:251:26>>*/ return  /*<<string.ml:251:26>>*/ caml_call2
+            (Stdlib_Bytes[50], _p_, i);
+    /*<<string.ml:251:53>>*/ }
+   function is_valid_utf_8(s){
+     /*<<string.ml:252:23>>*/  /*<<string.ml:252:40>>*/ var
+     _o_ =  /*<<string.ml:252:40>>*/ caml_call1(bos, s);
+     /*<<string.ml:252:40>>*/ return  /*<<string.ml:252:40>>*/ caml_call1
+            (Stdlib_Bytes[52], _o_);
+    /*<<string.ml:252:47>>*/ }
+   function get_utf_16be_uchar(s, i){
+     /*<<string.ml:254:29>>*/  /*<<string.ml:254:50>>*/ var
+     _n_ =  /*<<string.ml:254:50>>*/ caml_call1(bos, s);
+     /*<<string.ml:254:29>>*/ return  /*<<string.ml:254:29>>*/ caml_call2
+            (Stdlib_Bytes[53], _n_, i);
+    /*<<string.ml:254:59>>*/ }
+   function is_valid_utf_16be(s){
+     /*<<string.ml:255:26>>*/  /*<<string.ml:255:46>>*/ var
+     _m_ =  /*<<string.ml:255:46>>*/ caml_call1(bos, s);
+     /*<<string.ml:255:46>>*/ return  /*<<string.ml:255:46>>*/ caml_call1
+            (Stdlib_Bytes[55], _m_);
+    /*<<string.ml:255:53>>*/ }
+   function get_utf_16le_uchar(s, i){
+     /*<<string.ml:257:29>>*/  /*<<string.ml:257:50>>*/ var
+     _l_ =  /*<<string.ml:257:50>>*/ caml_call1(bos, s);
+     /*<<string.ml:257:29>>*/ return  /*<<string.ml:257:29>>*/ caml_call2
+            (Stdlib_Bytes[56], _l_, i);
+    /*<<string.ml:257:59>>*/ }
+   function is_valid_utf_16le(s){
+     /*<<string.ml:258:26>>*/  /*<<string.ml:258:46>>*/ var
+     _k_ =  /*<<string.ml:258:46>>*/ caml_call1(bos, s);
+     /*<<string.ml:258:46>>*/ return  /*<<string.ml:258:46>>*/ caml_call1
+            (Stdlib_Bytes[58], _k_);
+    /*<<string.ml:258:53>>*/ }
+   function get_int8(s, i){
+     /*<<string.ml:267:19>>*/  /*<<string.ml:267:30>>*/ var
+     _j_ =  /*<<string.ml:267:30>>*/ caml_call1(bos, s);
+     /*<<string.ml:267:19>>*/ return  /*<<string.ml:267:19>>*/ caml_call2
+            (Stdlib_Bytes[60], _j_, i);
+    /*<<string.ml:267:39>>*/ }
+   function get_uint16_le(s, i){
+     /*<<string.ml:268:24>>*/  /*<<string.ml:268:40>>*/ var
+     _i_ =  /*<<string.ml:268:40>>*/ caml_call1(bos, s);
+     /*<<string.ml:268:24>>*/ return  /*<<string.ml:268:24>>*/ caml_call2
+            (Stdlib_Bytes[63], _i_, i);
+    /*<<string.ml:268:49>>*/ }
+   function get_uint16_be(s, i){
+     /*<<string.ml:269:24>>*/  /*<<string.ml:269:40>>*/ var
+     _h_ =  /*<<string.ml:269:40>>*/ caml_call1(bos, s);
+     /*<<string.ml:269:24>>*/ return  /*<<string.ml:269:24>>*/ caml_call2
+            (Stdlib_Bytes[62], _h_, i);
+    /*<<string.ml:269:49>>*/ }
+   function get_int16_ne(s, i){
+     /*<<string.ml:270:23>>*/  /*<<string.ml:270:38>>*/ var
+     _g_ =  /*<<string.ml:270:38>>*/ caml_call1(bos, s);
+     /*<<string.ml:270:23>>*/ return  /*<<string.ml:270:23>>*/ caml_call2
+            (Stdlib_Bytes[64], _g_, i);
+    /*<<string.ml:270:47>>*/ }
+   function get_int16_le(s, i){
+     /*<<string.ml:271:23>>*/  /*<<string.ml:271:38>>*/ var
+     _f_ =  /*<<string.ml:271:38>>*/ caml_call1(bos, s);
+     /*<<string.ml:271:23>>*/ return  /*<<string.ml:271:23>>*/ caml_call2
+            (Stdlib_Bytes[66], _f_, i);
+    /*<<string.ml:271:47>>*/ }
+   function get_int16_be(s, i){
+     /*<<string.ml:272:23>>*/  /*<<string.ml:272:38>>*/ var
+     _e_ =  /*<<string.ml:272:38>>*/ caml_call1(bos, s);
+     /*<<string.ml:272:23>>*/ return  /*<<string.ml:272:23>>*/ caml_call2
+            (Stdlib_Bytes[65], _e_, i);
+    /*<<string.ml:272:47>>*/ }
+   function get_int32_le(s, i){
+     /*<<string.ml:273:23>>*/  /*<<string.ml:273:38>>*/ var
+     _d_ =  /*<<string.ml:273:38>>*/ caml_call1(bos, s);
+     /*<<string.ml:273:23>>*/ return  /*<<string.ml:273:23>>*/ caml_call2
+            (Stdlib_Bytes[69], _d_, i);
+    /*<<string.ml:273:47>>*/ }
+   function get_int32_be(s, i){
+     /*<<string.ml:274:23>>*/  /*<<string.ml:274:38>>*/ var
+     _c_ =  /*<<string.ml:274:38>>*/ caml_call1(bos, s);
+     /*<<string.ml:274:23>>*/ return  /*<<string.ml:274:23>>*/ caml_call2
+            (Stdlib_Bytes[68], _c_, i);
+    /*<<string.ml:274:47>>*/ }
+   function get_int64_le(s, i){
+     /*<<string.ml:275:23>>*/  /*<<string.ml:275:38>>*/ var
+     _b_ =  /*<<string.ml:275:38>>*/ caml_call1(bos, s);
+     /*<<string.ml:275:23>>*/ return  /*<<string.ml:275:23>>*/ caml_call2
+            (Stdlib_Bytes[72], _b_, i);
+    /*<<string.ml:275:47>>*/ }
+   function get_int64_be(s, i){
+     /*<<string.ml:276:23>>*/  /*<<string.ml:276:38>>*/ var
+     _a_ =  /*<<string.ml:276:38>>*/ caml_call1(bos, s);
+     /*<<string.ml:276:23>>*/ return  /*<<string.ml:276:23>>*/ caml_call2
+            (Stdlib_Bytes[71], _a_, i);
+    /*<<string.ml:276:47>>*/ }
+   var
+    Stdlib_String =
+      [0,
+       make,
+       init,
+       empty,
+       of_bytes,
+       to_bytes,
+       concat,
+       cat,
+       caml_string_equal,
+       compare,
+       starts_with,
+       ends_with,
+       contains_from,
+       rcontains_from,
+       contains,
+       sub,
+       split_on_char,
+       map,
+       mapi,
+       fold_left,
+       fold_right,
+       for_all,
+       exists,
+       trim,
+       escaped,
+       uppercase_ascii,
+       lowercase_ascii,
+       capitalize_ascii,
+       uncapitalize_ascii,
+       iter,
+       iteri,
+       index_from,
+       index_from_opt,
+       rindex_from,
+       rindex_from_opt,
+       index,
+       index_opt,
+       rindex,
+       rindex_opt,
+       to_seq,
+       to_seqi,
+       of_seq,
+       get_utf_8_uchar,
+       is_valid_utf_8,
+       get_utf_16be_uchar,
+       is_valid_utf_16be,
+       get_utf_16le_uchar,
+       is_valid_utf_16le,
+       blit,
+       runtime.caml_string_get,
+       get_int8,
+       runtime.caml_string_get16,
+       get_uint16_be,
+       get_uint16_le,
+       get_int16_ne,
+       get_int16_be,
+       get_int16_le,
+       runtime.caml_string_get32,
+       hash,
+       caml_string_hash,
+       get_int32_be,
+       get_int32_le,
+       runtime.caml_string_get64,
+       get_int64_be,
+       get_int64_le];
+   runtime.caml_register_global(12, Stdlib_String, "Stdlib__String");
+   return;
+   /*<<?>>*/ }
+  (globalThis));
+
+//# unitInfo: Provides: Stdlib__Unit
+(function(globalThis){
+   "use strict";
+   var runtime = globalThis.jsoo_runtime, cst = "()";
+   function equal(param, _b_){
+     /*<<unit.ml:18:18>>*/ return 1;
+    /*<<unit.ml:18:22>>*/ }
+   function compare(param, _a_){
+     /*<<unit.ml:19:20>>*/ return 0;
+    /*<<unit.ml:19:21>>*/ }
+   function to_string(param){
+     /*<<unit.ml:20:19>>*/ return cst;
+    /*<<unit.ml:20:23>>*/ }
+   var Stdlib_Unit = [0, equal, compare, to_string];
+   runtime.caml_register_global(1, Stdlib_Unit, "Stdlib__Unit");
+   return;
+   /*<<?>>*/ }
+  (globalThis));
+
+//# unitInfo: Provides: Stdlib__Marshal
+//# unitInfo: Requires: Stdlib, Stdlib__Bytes
+(function
+  (globalThis){
+   "use strict";
+   var
+    runtime = globalThis.jsoo_runtime,
+    cst_Marshal_from_bytes$1 = "Marshal.from_bytes",
+    caml_marshal_data_size = runtime.caml_marshal_data_size,
+    caml_ml_bytes_length = runtime.caml_ml_bytes_length;
+    /*<<?>>*/ function caml_call1(f, a0){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 1
+            ? f(a0)
+            : runtime.caml_call_gen(f, [a0]);
+   }
+   var
+    global_data = runtime.caml_get_global_data(),
+    Stdlib_Bytes = global_data.Stdlib__Bytes,
+    Stdlib = global_data.Stdlib,
+    cst_Marshal_from_bytes = cst_Marshal_from_bytes$1,
+    cst_Marshal_from_bytes$0 = cst_Marshal_from_bytes$1,
+    cst_Marshal_data_size = "Marshal.data_size",
+    cst_Marshal_to_buffer_substrin =
+      "Marshal.to_buffer: substring out of bounds";
+   function to_buffer(buff, ofs, len, v, flags){
+     /*<<marshal.ml:33:2>>*/ if
+     (0 <= ofs && 0 <= len && (caml_ml_bytes_length(buff) - len | 0) >= ofs)
+      /*<<marshal.ml:35:7>>*/ return  /*<<marshal.ml:35:7>>*/ runtime.caml_output_value_to_buffer
+             (buff, ofs, len, v, flags);
+     /*<<marshal.ml:34:7>>*/ return  /*<<marshal.ml:34:7>>*/ caml_call1
+            (Stdlib[1], cst_Marshal_to_buffer_substrin);
+    /*<<marshal.ml:35:44>>*/ }
+   var header_size = 20;
+   function data_size(buff, ofs){
+     /*<<marshal.ml:49:2>>*/ if
+     (0 <= ofs && (caml_ml_bytes_length(buff) - 20 | 0) >= ofs)
+      /*<<marshal.ml:51:7>>*/ return  /*<<marshal.ml:51:7>>*/ caml_marshal_data_size
+             (buff, ofs);
+     /*<<marshal.ml:50:7>>*/ return  /*<<marshal.ml:50:7>>*/ caml_call1
+            (Stdlib[1], cst_Marshal_data_size);
+    /*<<marshal.ml:51:32>>*/ }
+   function total_size(buff, ofs){
+     /*<<marshal.ml:52:26>>*/ return 20 + data_size(buff, ofs) | 0;
+    /*<<marshal.ml:52:58>>*/ }
+   function from_bytes(buff, ofs){
+     /*<<marshal.ml:55:2>>*/ if
+     (0 <= ofs && (caml_ml_bytes_length(buff) - 20 | 0) >= ofs){
+      /*<<marshal.ml:58:14>>*/  /*<<marshal.ml:58:14>>*/ var
+      len =  /*<<marshal.ml:58:14>>*/ caml_marshal_data_size(buff, ofs);
+     return (caml_ml_bytes_length(buff) - (20 + len | 0) | 0) < ofs
+             ?  /*<<marshal.ml:60:9>>*/ caml_call1
+               (Stdlib[1], cst_Marshal_from_bytes$0)
+             :  /*<<marshal.ml:61:9>>*/ runtime.caml_input_value_from_bytes
+               (buff, ofs);
+    }
+     /*<<marshal.ml:56:7>>*/ return  /*<<marshal.ml:56:7>>*/ caml_call1
+            (Stdlib[1], cst_Marshal_from_bytes);
+    /*<<marshal.ml:62:5>>*/ }
+   function from_string(buff, ofs){
+     /*<<marshal.ml:67:2>>*/ return from_bytes
+            ( /*<<marshal.ml:67:13>>*/ caml_call1(Stdlib_Bytes[45], buff),
+             ofs);
+    /*<<marshal.ml:67:46>>*/ }
+   var
+    Stdlib_Marshal =
+      [0,
+       runtime.caml_output_value,
+       to_buffer,
+       runtime.caml_input_value,
+       from_bytes,
+       from_string,
+       header_size,
+       data_size,
+       total_size];
+   runtime.caml_register_global(6, Stdlib_Marshal, "Stdlib__Marshal");
+   return;
+   /*<<?>>*/ }
+  (globalThis));
+
+//# unitInfo: Provides: Stdlib__Array
+//# unitInfo: Requires: Assert_failure, Stdlib, Stdlib__Seq
+(function
+  (globalThis){
+   "use strict";
+   var
+    runtime = globalThis.jsoo_runtime,
+    caml_array_sub = runtime.caml_array_sub,
+    caml_check_bound = runtime.caml_check_bound,
+    caml_make_vect = runtime.caml_make_vect,
+    caml_maybe_attach_backtrace = runtime.caml_maybe_attach_backtrace,
+    caml_wrap_exception = runtime.caml_wrap_exception;
+    /*<<?>>*/ function caml_call1(f, a0){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 1
+            ? f(a0)
+            : runtime.caml_call_gen(f, [a0]);
+   }
+    /*<<?>>*/ function caml_call2(f, a0, a1){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 2
+            ? f(a0, a1)
+            : runtime.caml_call_gen(f, [a0, a1]);
+   }
+    /*<<?>>*/ function caml_call3(f, a0, a1, a2){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 3
+            ? f(a0, a1, a2)
+            : runtime.caml_call_gen(f, [a0, a1, a2]);
+   }
+    /*<<array.ml:37:20>>*/ var
+    global_data = runtime.caml_get_global_data(),
+    Stdlib_Seq = global_data.Stdlib__Seq,
+    Assert_failure = global_data.Assert_failure,
+    Stdlib = global_data.Stdlib,
+     /*<<array.ml:37:20>>*/ Floatarray = [0],
+    _a_ = [0, "array.ml", 319, 4],
+    cst_Array_combine = "Array.combine",
+    cst_Array_exists2 = "Array.exists2",
+    cst_Array_for_all2 = "Array.for_all2",
+    cst_Array_map2_arrays_must_hav =
+      "Array.map2: arrays must have the same length",
+    cst_Array_iter2_arrays_must_ha =
+      "Array.iter2: arrays must have the same length",
+    cst_Array_blit = "Array.blit",
+    cst_Array_fill = "Array.fill",
+    cst_Array_sub = "Array.sub",
+    cst_Array_init = "Array.init",
+    cst_Stdlib_Array_Bottom = "Stdlib.Array.Bottom";
+   function init(l, f){
+     /*<<array.ml:48:2>>*/ if(0 === l)  /*<<array.ml:48:16>>*/ return [0];
+    if(0 > l)
+      /*<<array.ml:49:16>>*/ return  /*<<array.ml:49:16>>*/ caml_call1
+             (Stdlib[1], cst_Array_init);
+     /*<<array.ml:53:13>>*/ var
+      /*<<array.ml:53:13>>*/ res =
+        /*<<array.ml:53:13>>*/ caml_make_vect
+        (l,  /*<<array.ml:53:22>>*/ caml_call1(f, 0)),
+      /*<<array.ml:54:3>>*/ _as_ = l - 1 | 0,
+      /*<<array.ml:53:13>>*/ _ar_ = 1;
+    if(_as_ >= 1){
+     var i = _ar_;
+     for(;;){
+       /*<<array.ml:55:5>>*/ res[1 + i] =
+        /*<<array.ml:55:22>>*/ caml_call1(f, i);
+       /*<<array.ml:55:5>>*/  /*<<array.ml:55:5>>*/ var _at_ = i + 1 | 0;
+      if(_as_ === i) break;
+      var i = _at_;
+     }
+    }
+     /*<<array.ml:57:3>>*/ return res;
+    /*<<array.ml:57:6>>*/ }
+   function make_matrix(sx, sy, init){
+     /*<<array.ml:60:2>>*/ var
+      /*<<array.ml:60:12>>*/ res =
+        /*<<array.ml:60:12>>*/ caml_make_vect(sx, [0]),
+      /*<<array.ml:61:2>>*/ _ap_ = sx - 1 | 0,
+      /*<<array.ml:60:12>>*/ _ao_ = 0;
+    if(_ap_ >= 0){
+     var x = _ao_;
+     for(;;){
+      res[1 + x] =  /*<<array.ml:62:21>>*/ caml_make_vect(sy, init);
+       /*<<array.ml:61:2>>*/  /*<<array.ml:61:2>>*/ var _aq_ = x + 1 | 0;
+      if(_ap_ === x) break;
+      var x = _aq_;
+     }
+    }
+     /*<<array.ml:64:2>>*/ return res;
+    /*<<array.ml:64:5>>*/ }
+   function copy(a){
+     /*<<array.ml:67:2>>*/ var l = a.length - 1;
+     /*<<array.ml:67:22>>*/ return 0 === l
+            ? [0]
+            :  /*<<array.ml:67:46>>*/ caml_array_sub(a, 0, l);
+    /*<<array.ml:67:62>>*/ }
+   function append(a1, a2){
+     /*<<array.ml:70:2>>*/ var l1 = a1.length - 1;
+     /*<<array.ml:71:2>>*/ return 0 === l1
+            ? copy(a2)
+            : 0
+              === a2.length - 1
+              ?  /*<<array.ml:72:29>>*/ caml_array_sub(a1, 0, l1)
+              :  /*<<array.ml:73:7>>*/ runtime.caml_array_append(a1, a2);
+    /*<<array.ml:73:24>>*/ }
+   function sub(a, ofs, len){
+     /*<<array.ml:76:2>>*/ if
+     (0 <= ofs && 0 <= len && (a.length - 1 - len | 0) >= ofs)
+      /*<<array.ml:78:7>>*/ return  /*<<array.ml:78:7>>*/ caml_array_sub
+             (a, ofs, len);
+     /*<<array.ml:77:7>>*/ return  /*<<array.ml:77:7>>*/ caml_call1
+            (Stdlib[1], cst_Array_sub);
+    /*<<array.ml:78:27>>*/ }
+   function fill(a, ofs, len, v){
+     /*<<array.ml:81:2>>*/ if
+     (0 <= ofs && 0 <= len && (a.length - 1 - len | 0) >= ofs)
+      /*<<array.ml:83:7>>*/ return  /*<<array.ml:83:7>>*/ runtime.caml_array_fill
+             (a, ofs, len, v);
+     /*<<array.ml:82:7>>*/ return  /*<<array.ml:82:7>>*/ caml_call1
+            (Stdlib[1], cst_Array_fill);
+    /*<<array.ml:83:30>>*/ }
+   function blit(a1, ofs1, a2, ofs2, len){
+     /*<<array.ml:86:2>>*/ if
+     (0 <= len
+      &&
+       0 <= ofs1
+       &&
+        (a1.length - 1 - len | 0) >= ofs1
+        && 0 <= ofs2 && (a2.length - 1 - len | 0) >= ofs2)
+      /*<<array.ml:89:7>>*/ return  /*<<array.ml:89:7>>*/ runtime.caml_array_blit
+             (a1, ofs1, a2, ofs2, len);
+     /*<<array.ml:88:7>>*/ return  /*<<array.ml:88:7>>*/ caml_call1
+            (Stdlib[1], cst_Array_blit);
+    /*<<array.ml:89:38>>*/ }
+   function iter(f, a){
+     /*<<array.ml:92:2>>*/ var
+     _am_ = a.length - 1 - 1 | 0,
+      /*<<array.ml:92:2>>*/ _al_ = 0;
+    if(_am_ >= 0){
+     var i = _al_;
+     for(;;){
+       /*<<array.ml:92:31>>*/  /*<<array.ml:92:31>>*/ caml_call1(f, a[1 + i]);
+       /*<<array.ml:92:31>>*/  /*<<array.ml:92:31>>*/ var _an_ = i + 1 | 0;
+      if(_am_ === i) break;
+      var i = _an_;
+     }
+    }
+    return 0;
+    /*<<array.ml:92:53>>*/ }
+   function iter2(f, a, b){
+     /*<<array.ml:95:2>>*/ if(a.length - 1 !== b.length - 1)
+      /*<<array.ml:96:4>>*/ return  /*<<array.ml:96:4>>*/ caml_call1
+             (Stdlib[1], cst_Array_iter2_arrays_must_ha);
+     /*<<array.ml:98:4>>*/ var
+     _aj_ = a.length - 1 - 1 | 0,
+      /*<<array.ml:98:4>>*/ _ai_ = 0;
+    if(_aj_ >= 0){
+     var i = _ai_;
+     for(;;){
+       /*<<array.ml:98:33>>*/  /*<<array.ml:98:33>>*/ caml_call2
+       (f, a[1 + i], b[1 + i]);
+       /*<<array.ml:98:33>>*/  /*<<array.ml:98:33>>*/ var _ak_ = i + 1 | 0;
+      if(_aj_ === i) break;
+      var i = _ak_;
+     }
+    }
+    return 0;
+    /*<<array.ml:98:73>>*/ }
+   function map(f, a){
+     /*<<array.ml:101:2>>*/ var l = a.length - 1;
+     /*<<array.ml:102:2>>*/ if(0 === l)  /*<<array.ml:102:16>>*/ return [0];
+     /*<<array.ml:103:12>>*/ var
+      /*<<array.ml:103:12>>*/ r =
+        /*<<array.ml:103:12>>*/ caml_make_vect
+        (l,  /*<<array.ml:103:21>>*/ caml_call1(f, a[1])),
+      /*<<array.ml:104:4>>*/ _ag_ = l - 1 | 0,
+      /*<<array.ml:103:12>>*/ _af_ = 1;
+    if(_ag_ >= 1){
+     var i = _af_;
+     for(;;){
+       /*<<array.ml:105:6>>*/ r[1 + i] =
+        /*<<array.ml:105:21>>*/ caml_call1(f, a[1 + i]);
+       /*<<array.ml:105:6>>*/  /*<<array.ml:105:6>>*/ var _ah_ = i + 1 | 0;
+      if(_ag_ === i) break;
+      var i = _ah_;
+     }
+    }
+     /*<<array.ml:107:4>>*/ return r;
+    /*<<array.ml:108:5>>*/ }
+   function map2(f, a, b){
+     /*<<array.ml:111:2>>*/ var
+     la = a.length - 1,
+      /*<<array.ml:112:2>>*/ lb = b.length - 1;
+    if(la !== lb)
+      /*<<array.ml:114:4>>*/ return  /*<<array.ml:114:4>>*/ caml_call1
+             (Stdlib[1], cst_Array_map2_arrays_must_hav);
+    if(0 === la)  /*<<array.ml:116:19>>*/ return [0];
+     /*<<array.ml:117:14>>*/ var
+      /*<<array.ml:117:14>>*/ r =
+        /*<<array.ml:117:14>>*/ caml_make_vect
+        (la,  /*<<array.ml:117:24>>*/ caml_call2(f, a[1], b[1])),
+      /*<<array.ml:118:6>>*/ _ad_ = la - 1 | 0,
+      /*<<array.ml:117:14>>*/ _ac_ = 1;
+    if(_ad_ >= 1){
+     var i = _ac_;
+     for(;;){
+       /*<<array.ml:119:8>>*/ r[1 + i] =
+        /*<<array.ml:119:23>>*/ caml_call2(f, a[1 + i], b[1 + i]);
+       /*<<array.ml:119:8>>*/  /*<<array.ml:119:8>>*/ var _ae_ = i + 1 | 0;
+      if(_ad_ === i) break;
+      var i = _ae_;
+     }
+    }
+     /*<<array.ml:121:6>>*/ return r;
+    /*<<array.ml:123:5>>*/ }
+   function iteri(f, a){
+     /*<<array.ml:126:2>>*/ var
+     _aa_ = a.length - 1 - 1 | 0,
+      /*<<array.ml:126:2>>*/ _$_ = 0;
+    if(_aa_ >= 0){
+     var i = _$_;
+     for(;;){
+       /*<<array.ml:126:31>>*/  /*<<array.ml:126:31>>*/ caml_call2
+       (f, i, a[1 + i]);
+       /*<<array.ml:126:31>>*/  /*<<array.ml:126:31>>*/ var _ab_ = i + 1 | 0;
+      if(_aa_ === i) break;
+      var i = _ab_;
+     }
+    }
+    return 0;
+    /*<<array.ml:126:56>>*/ }
+   function mapi(f, a){
+     /*<<array.ml:129:2>>*/ var l = a.length - 1;
+     /*<<array.ml:130:2>>*/ if(0 === l)  /*<<array.ml:130:16>>*/ return [0];
+     /*<<array.ml:131:12>>*/ var
+      /*<<array.ml:131:12>>*/ r =
+        /*<<array.ml:131:12>>*/ caml_make_vect
+        (l,  /*<<array.ml:131:21>>*/ caml_call2(f, 0, a[1])),
+      /*<<array.ml:132:4>>*/ _Z_ = l - 1 | 0,
+      /*<<array.ml:131:12>>*/ _Y_ = 1;
+    if(_Z_ >= 1){
+     var i = _Y_;
+     for(;;){
+       /*<<array.ml:133:6>>*/ r[1 + i] =
+        /*<<array.ml:133:21>>*/ caml_call2(f, i, a[1 + i]);
+       /*<<array.ml:133:6>>*/  /*<<array.ml:133:6>>*/ var ___ = i + 1 | 0;
+      if(_Z_ === i) break;
+      var i = ___;
+     }
+    }
+     /*<<array.ml:135:4>>*/ return r;
+    /*<<array.ml:136:5>>*/ }
+   function to_list(a){
+     /*<<array.ml:139:2>>*/ var i$1 = a.length - 1 - 1 | 0, i = i$1, res = 0;
+     /*<<array.ml:140:4>>*/ for(;;){
+     if(0 > i)  /*<<array.ml:140:18>>*/ return res;
+      /*<<array.ml:140:42>>*/ var
+       /*<<array.ml:140:42>>*/ res$0 = [0, a[1 + i], res],
+       /*<<array.ml:140:42>>*/ i$0 = i - 1 | 0,
+      i = i$0,
+      res = res$0;
+    }
+    /*<<array.ml:141:26>>*/ }
+   function list_length(accu, param){
+    var accu$0 = accu, param$0 = param;
+    for(;;){
+     if(! param$0)  /*<<array.ml:145:10>>*/ return accu$0;
+      /*<<array.ml:146:12>>*/ var
+      t = param$0[2],
+       /*<<array.ml:146:12>>*/ accu$1 = accu$0 + 1 | 0,
+      accu$0 = accu$1,
+      param$0 = t;
+    }
+   }
+   function of_list(l){
+     /*<<array.ml:148:14>>*/ if(! l)  /*<<array.ml:149:10>>*/ return [0];
+     /*<<array.ml:151:14>>*/ var
+     tl = l[2],
+     hd = l[1],
+      /*<<array.ml:151:14>>*/ a =
+        /*<<array.ml:151:14>>*/ caml_make_vect(list_length(0, l), hd),
+     i = 1,
+     param = tl;
+    for(;;){
+     if(! param)  /*<<array.ml:152:6>>*/ return a;
+     var tl$0 = param[2], hd$0 = param[1];
+      /*<<array.ml:154:20>>*/ a[1 + i] = hd$0;
+      /*<<array.ml:152:6>>*/ var
+       /*<<array.ml:152:6>>*/ i$0 = i + 1 | 0,
+      i = i$0,
+      param = tl$0;
+    }
+    /*<<array.ml:155:15>>*/ }
+   function fold_left(f, x, a){
+     /*<<array.ml:158:2>>*/ var
+      /*<<array.ml:158:10>>*/ r = [0, x],
+     _W_ = a.length - 1 - 1 | 0,
+      /*<<array.ml:158:10>>*/ _V_ = 0;
+    if(_W_ >= 0){
+     var i = _V_;
+     for(;;){
+      r[1] =  /*<<array.ml:160:9>>*/ caml_call2(f, r[1], a[1 + i]);
+       /*<<array.ml:159:2>>*/  /*<<array.ml:159:2>>*/ var _X_ = i + 1 | 0;
+      if(_W_ === i) break;
+      var i = _X_;
+     }
+    }
+    return r[1];
+    /*<<array.ml:162:4>>*/ }
+   function fold_left_map(f, acc, input_array){
+     /*<<array.ml:165:2>>*/ var len = input_array.length - 1;
+     /*<<array.ml:166:2>>*/ if(0 === len)
+      /*<<array.ml:166:18>>*/ return [0, acc, [0]];
+     /*<<array.ml:167:19>>*/ var
+      /*<<array.ml:167:19>>*/ match =
+        /*<<array.ml:167:19>>*/ caml_call2(f, acc, input_array[1]),
+     elt = match[2],
+     acc$0 = match[1],
+      /*<<array.ml:168:23>>*/ output_array =
+        /*<<array.ml:168:23>>*/ caml_make_vect(len, elt),
+      /*<<array.ml:169:14>>*/ acc$1 = [0, acc$0],
+      /*<<array.ml:170:4>>*/ _T_ = len - 1 | 0,
+      /*<<array.ml:169:14>>*/ _S_ = 1;
+    if(_T_ >= 1){
+     var i = _S_;
+     for(;;){
+       /*<<array.ml:171:22>>*/ var
+        /*<<array.ml:171:22>>*/ match$0 =
+          /*<<array.ml:171:22>>*/ caml_call2(f, acc$1[1], input_array[1 + i]),
+       elt$0 = match$0[2],
+       acc$2 = match$0[1];
+      acc$1[1] = acc$2;
+       /*<<array.ml:173:6>>*/ output_array[1 + i] = elt$0;
+       /*<<array.ml:170:4>>*/  /*<<array.ml:170:4>>*/ var _U_ = i + 1 | 0;
+      if(_T_ === i) break;
+      var i = _U_;
+     }
+    }
+     /*<<array.ml:175:4>>*/ return [0, acc$1[1], output_array];
+    /*<<array.ml:176:5>>*/ }
+   function fold_right(f, a, x){
+     /*<<array.ml:179:2>>*/ var
+      /*<<array.ml:179:10>>*/ r = [0, x],
+      /*<<array.ml:180:2>>*/ _Q_ = a.length - 1 - 1 | 0;
+    if(_Q_ >= 0){
+     var i = _Q_;
+     for(;;){
+      r[1] =  /*<<array.ml:181:9>>*/ caml_call2(f, a[1 + i], r[1]);
+       /*<<array.ml:180:2>>*/  /*<<array.ml:180:2>>*/ var _R_ = i - 1 | 0;
+      if(0 === i) break;
+      var i = _R_;
+     }
+    }
+    return r[1];
+    /*<<array.ml:183:4>>*/ }
+   function exists(p, a){
+     /*<<array.ml:186:2>>*/ var n = a.length - 1, i = 0;
+     /*<<array.ml:188:4>>*/ for(;;){
+     if(i === n)  /*<<array.ml:188:18>>*/ return 0;
+      /*<<array.ml:189:12>>*/ if
+      ( /*<<array.ml:189:12>>*/ caml_call1(p, a[1 + i]))
+       /*<<array.ml:189:36>>*/ return 1;
+      /*<<array.ml:190:9>>*/ var
+       /*<<array.ml:190:9>>*/ i$0 = i + 1 | 0,
+      i = i$0;
+    }
+    /*<<array.ml:191:8>>*/ }
+   function for_all(p, a){
+     /*<<array.ml:194:2>>*/ var n = a.length - 1, i = 0;
+     /*<<array.ml:196:4>>*/ for(;;){
+     if(i === n)  /*<<array.ml:196:18>>*/ return 1;
+      /*<<array.ml:197:12>>*/ if
+      (!  /*<<array.ml:197:12>>*/ caml_call1(p, a[1 + i]))
+       /*<<array.ml:198:9>>*/ return 0;
+      /*<<array.ml:197:36>>*/ var
+       /*<<array.ml:197:36>>*/ i$0 = i + 1 | 0,
+      i = i$0;
+    }
+    /*<<array.ml:199:8>>*/ }
+   function for_all2(p, l1, l2){
+     /*<<array.ml:202:2>>*/ var n1 = l1.length - 1, n2 = l2.length - 1;
+    if(n1 !== n2)
+      /*<<array.ml:204:19>>*/ return  /*<<array.ml:204:19>>*/ caml_call1
+             (Stdlib[1], cst_Array_for_all2);
+    var i = 0;
+     /*<<array.ml:206:4>>*/ for(;;){
+     if(i === n1)  /*<<array.ml:206:19>>*/ return 1;
+      /*<<array.ml:207:12>>*/ if
+      (!  /*<<array.ml:207:12>>*/ caml_call2(p, l1[1 + i], l2[1 + i]))
+       /*<<array.ml:208:9>>*/ return 0;
+      /*<<array.ml:207:55>>*/ var
+       /*<<array.ml:207:55>>*/ i$0 = i + 1 | 0,
+      i = i$0;
+    }
+    /*<<array.ml:209:8>>*/ }
+   function exists2(p, l1, l2){
+     /*<<array.ml:212:2>>*/ var n1 = l1.length - 1, n2 = l2.length - 1;
+    if(n1 !== n2)
+      /*<<array.ml:214:19>>*/ return  /*<<array.ml:214:19>>*/ caml_call1
+             (Stdlib[1], cst_Array_exists2);
+    var i = 0;
+     /*<<array.ml:216:4>>*/ for(;;){
+     if(i === n1)  /*<<array.ml:216:19>>*/ return 0;
+      /*<<array.ml:217:12>>*/ if
+      ( /*<<array.ml:217:12>>*/ caml_call2(p, l1[1 + i], l2[1 + i]))
+       /*<<array.ml:217:55>>*/ return 1;
+      /*<<array.ml:218:9>>*/ var
+       /*<<array.ml:218:9>>*/ i$0 = i + 1 | 0,
+      i = i$0;
+    }
+    /*<<array.ml:219:8>>*/ }
+   function mem(x, a){
+     /*<<array.ml:222:2>>*/ var n = a.length - 1, i = 0;
+     /*<<array.ml:224:4>>*/ for(;;){
+     if(i === n)  /*<<array.ml:224:18>>*/ return 0;
+      /*<<array.ml:225:12>>*/ if
+      (0 ===  /*<<array.ml:225:12>>*/ runtime.caml_compare(a[1 + i], x))
+       /*<<array.ml:225:48>>*/ return 1;
+      /*<<array.ml:226:9>>*/ var
+       /*<<array.ml:226:9>>*/ i$0 = i + 1 | 0,
+      i = i$0;
+    }
+    /*<<array.ml:227:8>>*/ }
+   function memq(x, a){
+     /*<<array.ml:230:2>>*/ var n = a.length - 1, i = 0;
+     /*<<array.ml:232:4>>*/ for(;;){
+     if(i === n)  /*<<array.ml:232:18>>*/ return 0;
+     if(x === a[1 + i])  /*<<array.ml:233:39>>*/ return 1;
+      /*<<array.ml:234:9>>*/ var
+       /*<<array.ml:234:9>>*/ i$0 = i + 1 | 0,
+      i = i$0;
+    }
+    /*<<array.ml:235:8>>*/ }
+   function find_opt(p, a){
+     /*<<array.ml:238:2>>*/ var n = a.length - 1, i = 0;
+     /*<<array.ml:240:4>>*/ for(;;){
+     if(i === n)  /*<<array.ml:240:18>>*/ return 0;
+      /*<<array.ml:242:14>>*/  /*<<array.ml:242:14>>*/ var x = a[1 + i];
+      /*<<array.ml:243:9>>*/ if( /*<<array.ml:243:9>>*/ caml_call1(p, x))
+       /*<<array.ml:243:18>>*/ return [0, x];
+      /*<<array.ml:244:11>>*/ var
+       /*<<array.ml:244:11>>*/ i$0 = i + 1 | 0,
+      i = i$0;
+    }
+    /*<<array.ml:246:8>>*/ }
+   function find_map(f, a){
+     /*<<array.ml:249:2>>*/ var n = a.length - 1, i = 0;
+     /*<<array.ml:251:4>>*/ for(;;){
+     if(i === n)  /*<<array.ml:251:18>>*/ return 0;
+      /*<<array.ml:253:12>>*/  /*<<array.ml:253:12>>*/ var
+      r =  /*<<array.ml:253:12>>*/ caml_call1(f, a[1 + i]);
+     if(r)  /*<<array.ml:255:23>>*/ return r;
+      /*<<array.ml:254:16>>*/ var
+       /*<<array.ml:254:16>>*/ i$0 = i + 1 | 0,
+      i = i$0;
+    }
+    /*<<array.ml:257:8>>*/ }
+   function split(x){
+     /*<<array.ml:260:2>>*/ if
+     ( /*<<array.ml:260:5>>*/ runtime.caml_equal(x, [0]))
+      /*<<array.ml:260:19>>*/ return [0, [0], [0]];
+     /*<<array.ml:263:4>>*/ var
+     match = x[1],
+     b0 = match[2],
+     a0 = match[1],
+      /*<<array.ml:263:4>>*/ n = x.length - 1,
+      /*<<array.ml:264:12>>*/ a =
+        /*<<array.ml:264:12>>*/ caml_make_vect(n, a0),
+      /*<<array.ml:265:12>>*/ b =
+        /*<<array.ml:265:12>>*/ caml_make_vect(n, b0),
+      /*<<array.ml:266:4>>*/ _O_ = n - 1 | 0,
+      /*<<array.ml:265:12>>*/ _N_ = 1;
+    if(_O_ >= 1){
+     var i = _N_;
+     for(;;){
+      var match$0 = x[1 + i], bi = match$0[2], ai = match$0[1];
+       /*<<array.ml:268:6>>*/ a[1 + i] = ai;
+       /*<<array.ml:269:6>>*/ b[1 + i] = bi;
+       /*<<array.ml:266:4>>*/  /*<<array.ml:266:4>>*/ var _P_ = i + 1 | 0;
+      if(_O_ === i) break;
+      var i = _P_;
+     }
+    }
+     /*<<array.ml:271:4>>*/ return [0, a, b];
+    /*<<array.ml:272:5>>*/ }
+   function combine(a, b){
+     /*<<array.ml:275:2>>*/ var
+     na = a.length - 1,
+      /*<<array.ml:276:2>>*/ nb = b.length - 1;
+    if(na !== nb)
+      /*<<array.ml:277:19>>*/  /*<<array.ml:277:19>>*/ caml_call1
+      (Stdlib[1], cst_Array_combine);
+    if(0 === na)  /*<<array.ml:278:17>>*/ return [0];
+     /*<<array.ml:280:12>>*/ var
+      /*<<array.ml:280:12>>*/ x =
+        /*<<array.ml:280:12>>*/ caml_make_vect(na, [0, a[1], b[1]]),
+      /*<<array.ml:281:4>>*/ _L_ = na - 1 | 0,
+      /*<<array.ml:280:12>>*/ _K_ = 1;
+    if(_L_ >= 1){
+     var i = _K_;
+     for(;;){
+      x[1 + i] = [0, a[1 + i], b[1 + i]];
+       /*<<array.ml:281:4>>*/  /*<<array.ml:281:4>>*/ var _M_ = i + 1 | 0;
+      if(_L_ === i) break;
+      var i = _M_;
+     }
+    }
+     /*<<array.ml:284:4>>*/ return x;
+    /*<<array.ml:285:5>>*/ }
+    /*<<array.ml:287:0>>*/  /*<<array.ml:287:0>>*/ var
+    Bottom = [248, cst_Stdlib_Array_Bottom, runtime.caml_fresh_oo_id(0)];
+   function sort(cmp, a){
+    function maxson(l, i){
+      /*<<array.ml:290:4>>*/ var
+      i31 = ((i + i | 0) + i | 0) + 1 | 0,
+       /*<<array.ml:291:12>>*/ x = [0, i31];
+     if((i31 + 2 | 0) < l){
+       /*<<array.ml:292:22>>*/ var
+        /*<<array.ml:292:22>>*/ _D_ = i31 + 1 | 0,
+        /*<<array.ml:293:25>>*/ _E_ = caml_check_bound(a, _D_)[1 + _D_];
+      if
+       ( /*<<array.ml:293:9>>*/ caml_call2
+         (cmp, caml_check_bound(a, i31)[1 + i31], _E_)
+        < 0)
+       x[1] = i31 + 1 | 0;
+       /*<<array.ml:294:6>>*/ var
+        /*<<array.ml:294:6>>*/ _F_ = i31 + 2 | 0,
+        /*<<array.ml:294:24>>*/ _G_ = caml_check_bound(a, _F_)[1 + _F_],
+       _H_ = x[1];
+      if
+       ( /*<<array.ml:294:9>>*/ caml_call2
+         (cmp, caml_check_bound(a, _H_)[1 + _H_], _G_)
+        < 0)
+       x[1] = i31 + 2 | 0;
+      return x[1];
+     }
+     if((i31 + 1 | 0) < l){
+       /*<<array.ml:297:38>>*/ var
+       _I_ = i31 + 1 | 0,
+        /*<<array.ml:297:38>>*/ _J_ = caml_check_bound(a, _I_)[1 + _I_];
+       /*<<array.ml:297:22>>*/ if
+       (0
+        >
+          /*<<array.ml:297:22>>*/ caml_call2
+          (cmp, caml_check_bound(a, i31)[1 + i31], _J_))
+        /*<<array.ml:298:11>>*/ return i31 + 1 | 0;
+     }
+     if(i31 < l)  /*<<array.ml:299:27>>*/ return i31;
+      /*<<array.ml:299:36>>*/ throw  /*<<array.ml:299:36>>*/ caml_maybe_attach_backtrace
+            ([0, Bottom, i], 1);
+     /*<<array.ml:299:52>>*/ }
+    var l = a.length - 1, _x_ = ((l + 1 | 0) / 3 | 0) - 1 | 0;
+    if(_x_ >= 0){
+     var i$6 = _x_;
+     for(;;){
+       /*<<array.ml:328:50>>*/  /*<<array.ml:328:50>>*/ var
+       e$1 = caml_check_bound(a, i$6)[1 + i$6];
+       /*<<array.ml:310:22>>*/ try{
+       var i = i$6;
+        /*<<array.ml:302:4>>*/ for(;;){
+         /*<<array.ml:302:12>>*/  /*<<array.ml:302:12>>*/ var
+         j = maxson(l, i);
+         /*<<array.ml:303:7>>*/ if
+         (0
+          >=
+            /*<<array.ml:303:7>>*/ caml_call2
+            (cmp, caml_check_bound(a, j)[1 + j], e$1)){
+          /*<<array.ml:306:13>>*/ caml_check_bound(a, i)[1 + i] = e$1;
+         break;
+        }
+         /*<<array.ml:304:14>>*/  /*<<array.ml:304:14>>*/ var
+         _u_ = caml_check_bound(a, j)[1 + j];
+         /*<<array.ml:304:6>>*/ caml_check_bound(a, i)[1 + i] = _u_;
+        var i = j;
+       }
+      }
+      catch(exn$0){
+       var exn = caml_wrap_exception(exn$0);
+       if(exn[1] !== Bottom) throw caml_maybe_attach_backtrace(exn, 0);
+       var i$0 = exn[2];
+        /*<<array.ml:310:61>>*/ caml_check_bound(a, i$0)[1 + i$0] = e$1;
+      }
+       /*<<array.ml:328:38>>*/  /*<<array.ml:328:38>>*/ var _C_ = i$6 - 1 | 0;
+      if(0 === i$6) break;
+      var i$6 = _C_;
+     }
+    }
+     /*<<array.ml:329:2>>*/  /*<<array.ml:329:2>>*/ var _y_ = l - 1 | 0;
+    if(_y_ >= 2){
+     var i$4 = _y_;
+     a:
+     for(;;){
+       /*<<array.ml:330:12>>*/  /*<<array.ml:330:12>>*/ var
+       e$0 = caml_check_bound(a, i$4)[1 + i$4];
+       /*<<array.ml:331:4>>*/ a[1 + i$4] = caml_check_bound(a, 0)[1];
+      var i$5 = 0;
+       /*<<array.ml:316:19>>*/ try{
+       var i$1 = i$5;
+        /*<<array.ml:312:4>>*/ for(;;){
+         /*<<array.ml:312:12>>*/ var
+          /*<<array.ml:312:12>>*/ j$0 = maxson(i$4, i$1),
+          /*<<array.ml:313:12>>*/ _v_ = caml_check_bound(a, j$0)[1 + j$0];
+         /*<<array.ml:313:4>>*/ caml_check_bound(a, i$1)[1 + i$1] = _v_;
+        var i$1 = j$0;
+       }
+      }
+      catch(exn){
+       var exn$0 = caml_wrap_exception(exn);
+       if(exn$0[1] !== Bottom) throw caml_maybe_attach_backtrace(exn$0, 0);
+       var i$2 = exn$0[2], i$3 = i$2;
+        /*<<array.ml:318:4>>*/ for(;;){
+        var father = (i$3 - 1 | 0) / 3 | 0;
+        if(i$3 === father)
+          /*<<array.ml:319:4>>*/ throw  /*<<array.ml:319:4>>*/ caml_maybe_attach_backtrace
+                ([0, Assert_failure, _a_], 1);
+         /*<<array.ml:320:7>>*/ if
+         (0
+          <=
+            /*<<array.ml:320:7>>*/ caml_call2
+            (cmp, caml_check_bound(a, father)[1 + father], e$0))
+          /*<<array.ml:323:13>>*/ caml_check_bound(a, i$3)[1 + i$3] = e$0;
+        else{
+          /*<<array.ml:321:14>>*/  /*<<array.ml:321:14>>*/ var
+          _w_ = caml_check_bound(a, father)[1 + father];
+          /*<<array.ml:321:6>>*/ caml_check_bound(a, i$3)[1 + i$3] = _w_;
+         if(0 < father){var i$3 = father; continue;}
+          /*<<array.ml:322:49>>*/ caml_check_bound(a, 0)[1] = e$0;
+        }
+         /*<<array.ml:329:2>>*/  /*<<array.ml:329:2>>*/ var _B_ = i$4 - 1 | 0;
+        if(2 === i$4) break a;
+        var i$4 = _B_;
+        break;
+       }
+      }
+     }
+    }
+    var _z_ = 1 < l ? 1 : 0;
+    if(_z_){
+      /*<<array.ml:334:25>>*/  /*<<array.ml:334:25>>*/ var
+      e = caml_check_bound(a, 1)[2];
+      /*<<array.ml:334:38>>*/ a[2] = caml_check_bound(a, 0)[1];
+      /*<<array.ml:334:57>>*/ a[1] = e;
+     var _A_ = 0;
+    }
+    else
+     var _A_ = _z_;
+     /*<<array.ml:334:57>>*/ return _A_;
+    /*<<array.ml:334:67>>*/ }
+   function stable_sort(cmp, a){
+    function merge(src1ofs, src1len, src2, src2ofs, src2len, dst, dstofs){
+      /*<<array.ml:340:4>>*/ var
+      src1r = src1ofs + src1len | 0,
+      src2r = src2ofs + src2len | 0,
+       /*<<array.ml:357:44>>*/ s2$1 =
+        caml_check_bound(src2, src2ofs)[1 + src2ofs],
+       /*<<array.ml:357:20>>*/ s1$1 =
+        caml_check_bound(a, src1ofs)[1 + src1ofs],
+      i1 = src1ofs,
+      s1 = s1$1,
+      i2 = src2ofs,
+      s2 = s2$1,
+      d = dstofs;
+      /*<<array.ml:342:6>>*/ for(;;)
+       /*<<array.ml:342:9>>*/ if
+       (0 <  /*<<array.ml:342:9>>*/ caml_call2(cmp, s1, s2)){
+        /*<<array.ml:350:8>>*/ caml_check_bound(dst, d)[1 + d] = s2;
+        /*<<array.ml:350:8>>*/  /*<<array.ml:350:8>>*/ var i2$0 = i2 + 1 | 0;
+       if(i2$0 >= src2r) return blit(a, i1, dst, d + 1 | 0, src1r - i1 | 0);
+        /*<<array.ml:353:10>>*/ var
+         /*<<array.ml:353:10>>*/ d$0 = d + 1 | 0,
+         /*<<array.ml:353:24>>*/ s2$0 = caml_check_bound(src2, i2$0)[1 + i2$0],
+        i2 = i2$0,
+        s2 = s2$0,
+        d = d$0;
+      }
+      else{
+        /*<<array.ml:343:8>>*/ caml_check_bound(dst, d)[1 + d] = s1;
+        /*<<array.ml:343:8>>*/  /*<<array.ml:343:8>>*/ var i1$0 = i1 + 1 | 0;
+       if(i1$0 >= src1r)
+        return blit(src2, i2, dst, d + 1 | 0, src2r - i2 | 0);
+        /*<<array.ml:346:10>>*/ var
+         /*<<array.ml:346:10>>*/ d$1 = d + 1 | 0,
+         /*<<array.ml:346:18>>*/ s1$0 = caml_check_bound(a, i1$0)[1 + i1$0],
+        i1 = i1$0,
+        s1 = s1$0,
+        d = d$1;
+      }
+     /*<<array.ml:357:70>>*/ }
+    function isortto(srcofs, dst, dstofs, len){
+      /*<<array.ml:360:4>>*/ var
+      _m_ = len - 1 | 0,
+       /*<<array.ml:360:4>>*/ _l_ = 0;
+     if(_m_ >= 0){
+      var i = _l_;
+      a:
+      for(;;){
+        /*<<array.ml:361:14>>*/ var
+        _n_ = srcofs + i | 0,
+         /*<<array.ml:361:14>>*/ e = caml_check_bound(a, _n_)[1 + _n_],
+         /*<<array.ml:362:14>>*/ j = [0, (dstofs + i | 0) - 1 | 0];
+       for(;;){
+        if(dstofs <= j[1]){
+         var _o_ = j[1];
+          /*<<array.ml:363:29>>*/ if
+          (0
+           <
+             /*<<array.ml:363:29>>*/ caml_call2
+             (cmp, caml_check_bound(dst, _o_)[1 + _o_], e)){
+           /*<<array.ml:364:25>>*/ var
+           _p_ = j[1],
+            /*<<array.ml:364:25>>*/ _q_ = caml_check_bound(dst, _p_)[1 + _p_],
+           _r_ = j[1] + 1 | 0;
+           /*<<array.ml:364:8>>*/ caml_check_bound(dst, _r_)[1 + _r_] = _q_;
+          j[1] += -1;
+          continue;
+         }
+        }
+        var _s_ = j[1] + 1 | 0;
+         /*<<array.ml:367:6>>*/ caml_check_bound(dst, _s_)[1 + _s_] = e;
+         /*<<array.ml:360:4>>*/  /*<<array.ml:360:4>>*/ var _t_ = i + 1 | 0;
+        if(_m_ === i) break a;
+        var i = _t_;
+        break;
+       }
+      }
+     }
+     return 0;
+     /*<<array.ml:368:8>>*/ }
+    function sortto(srcofs, dst, dstofs, len){
+      /*<<array.ml:371:4>>*/ if(len <= 5)
+       /*<<array.ml:371:26>>*/ return isortto(srcofs, dst, dstofs, len);
+     var l1 = len / 2 | 0, l2 = len - l1 | 0;
+      /*<<array.ml:374:6>>*/ sortto(srcofs + l1 | 0, dst, dstofs + l1 | 0, l2);
+      /*<<array.ml:375:6>>*/ sortto(srcofs, a, srcofs + l2 | 0, l1);
+      /*<<array.ml:375:6>>*/ return merge
+             (srcofs + l2 | 0, l1, dst, dstofs + l1 | 0, l2, dst, dstofs);
+     /*<<array.ml:377:7>>*/ }
+    var l = a.length - 1;
+    if(l <= 5)  /*<<array.ml:380:22>>*/ return isortto(0, a, 0, l);
+     /*<<array.ml:383:12>>*/ var
+     l1 = l / 2 | 0,
+     l2 = l - l1 | 0,
+      /*<<array.ml:383:12>>*/ t =
+        /*<<array.ml:383:12>>*/ caml_make_vect(l2, caml_check_bound(a, 0)[1]);
+     /*<<array.ml:384:4>>*/ sortto(l1, t, 0, l2);
+     /*<<array.ml:385:4>>*/ sortto(0, a, l2, l1);
+     /*<<array.ml:385:4>>*/ return merge(l2, l1, t, 0, l2, a, 0);
+    /*<<array.ml:387:5>>*/ }
+   function to_seq(a){
+    function aux(i, param){
+      /*<<array.ml:396:4>>*/ if(i >= a.length - 1)
+       /*<<array.ml:400:9>>*/ return 0;
+      /*<<array.ml:398:14>>*/ var
+       /*<<array.ml:398:14>>*/ x = a[1 + i],
+       /*<<array.ml:398:14>>*/ _j_ = i + 1 | 0;
+      /*<<array.ml:399:6>>*/ return [0,
+             x,
+             function(_k_){ /*<<?>>*/ return aux(_j_, _k_);}];
+     /*<<array.ml:400:16>>*/ }
+     /*<<array.ml:402:2>>*/  /*<<array.ml:402:2>>*/ var _h_ = 0;
+     /*<<array.ml:402:2>>*/ return function(_i_){
+      /*<<?>>*/ return aux(_h_, _i_);};
+    /*<<array.ml:402:7>>*/ }
+   function to_seqi(a){
+    function aux(i, param){
+      /*<<array.ml:406:4>>*/ if(i >= a.length - 1)
+       /*<<array.ml:410:9>>*/ return 0;
+      /*<<array.ml:408:14>>*/ var
+       /*<<array.ml:408:14>>*/ x = a[1 + i],
+       /*<<array.ml:408:14>>*/ _f_ = i + 1 | 0;
+      /*<<array.ml:409:6>>*/ return [0,
+             [0, i, x],
+             function(_g_){ /*<<?>>*/ return aux(_f_, _g_);}];
+     /*<<array.ml:410:16>>*/ }
+     /*<<array.ml:412:2>>*/  /*<<array.ml:412:2>>*/ var _d_ = 0;
+     /*<<array.ml:412:2>>*/ return function(_e_){
+      /*<<?>>*/ return aux(_d_, _e_);};
+    /*<<array.ml:412:7>>*/ }
+   function of_seq(i$2){
+     /*<<array.ml:426:2>>*/ var _b_ = 0;
+    function _c_(acc, x){
+      /*<<array.ml:426:38>>*/ return [0, x, acc];
+     /*<<array.ml:426:44>>*/ }
+     /*<<array.ml:426:10>>*/  /*<<array.ml:426:10>>*/ var
+     l =  /*<<array.ml:426:10>>*/ caml_call3(Stdlib_Seq[5], _c_, _b_, i$2);
+    if(! l)  /*<<array.ml:415:10>>*/ return [0];
+     /*<<array.ml:417:16>>*/ var
+     tl = l[2],
+     hd = l[1],
+      /*<<array.ml:417:16>>*/ len = list_length(0, l),
+      /*<<array.ml:418:14>>*/ a =
+        /*<<array.ml:418:14>>*/ caml_make_vect(len, hd),
+      /*<<array.ml:417:16>>*/ i$1 = len - 2 | 0,
+     i = i$1,
+     param = tl;
+    for(;;){
+     if(! param)  /*<<array.ml:419:6>>*/ return a;
+     var tl$0 = param[2], hd$0 = param[1];
+      /*<<array.ml:421:20>>*/ a[1 + i] = hd$0;
+      /*<<array.ml:419:6>>*/ var
+       /*<<array.ml:419:6>>*/ i$0 = i - 1 | 0,
+      i = i$0,
+      param = tl$0;
+    }
+    /*<<array.ml:427:15>>*/ }
+   var
+    Stdlib_Array =
+      [0,
+       init,
+       make_matrix,
+       append,
+       runtime.caml_array_concat,
+       sub,
+       copy,
+       fill,
+       blit,
+       to_list,
+       of_list,
+       iter,
+       iteri,
+       map,
+       mapi,
+       fold_left,
+       fold_left_map,
+       fold_right,
+       iter2,
+       map2,
+       for_all,
+       exists,
+       for_all2,
+       exists2,
+       mem,
+       memq,
+       find_opt,
+       find_map,
+       split,
+       combine,
+       sort,
+       stable_sort,
+       stable_sort,
+       to_seq,
+       to_seqi,
+       of_seq,
+       Floatarray];
+   runtime.caml_register_global(14, Stdlib_Array, "Stdlib__Array");
+   return;
+   /*<<?>>*/ }
+  (globalThis));
+
+//# unitInfo: Provides: Stdlib__Float
+//# unitInfo: Requires: Assert_failure, Stdlib, Stdlib__Array, Stdlib__List, Stdlib__Seq
+(function
+  (globalThis){
+   "use strict";
+   var
+    runtime = globalThis.jsoo_runtime,
+    cst_Float_array_blit$1 = "Float.array.blit",
+    cst_float_ml = "float.ml",
+    caml_array_get = runtime.caml_array_get,
+    caml_array_set = runtime.caml_array_set,
+    caml_float_compare = runtime.caml_float_compare,
+    caml_floatarray_blit = runtime.caml_floatarray_blit,
+    caml_floatarray_create = runtime.caml_floatarray_create,
+    caml_maybe_attach_backtrace = runtime.caml_maybe_attach_backtrace,
+    caml_nextafter_float = runtime.caml_nextafter_float,
+    caml_signbit_float = runtime.caml_signbit_float,
+    caml_wrap_exception = runtime.caml_wrap_exception;
+    /*<<?>>*/ function caml_call1(f, a0){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 1
+            ? f(a0)
+            : runtime.caml_call_gen(f, [a0]);
+   }
+    /*<<?>>*/ function caml_call2(f, a0, a1){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 2
+            ? f(a0, a1)
+            : runtime.caml_call_gen(f, [a0, a1]);
+   }
+    /*<<?>>*/ function caml_call3(f, a0, a1, a2){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 3
+            ? f(a0, a1, a2)
+            : runtime.caml_call_gen(f, [a0, a1, a2]);
+   }
+   var
+    global_data = runtime.caml_get_global_data(),
+    Stdlib_Seq = global_data.Stdlib__Seq,
+    Stdlib_List = global_data.Stdlib__List,
+    Assert_failure = global_data.Assert_failure,
+    Stdlib = global_data.Stdlib,
+    infinity = Stdlib[22],
+    neg_infinity = Stdlib[23],
+    nan = Stdlib[24],
+    _b_ = [0, cst_float_ml, 395, 6],
+    cst_Float_Array_map2_arrays_mu =
+      "Float.Array.map2: arrays must have the same length",
+    cst_Float_Array_iter2_arrays_m =
+      "Float.Array.iter2: arrays must have the same length",
+    cst_Float_array_blit = cst_Float_array_blit$1,
+    cst_Float_array_blit$0 = cst_Float_array_blit$1,
+    cst_Float_Array_fill = "Float.Array.fill",
+    cst_Float_Array_sub = "Float.Array.sub",
+    _a_ = [0, cst_float_ml, 222, 14],
+    cst_Float_Array_concat = "Float.Array.concat",
+    cst_Float_Array_init = "Float.Array.init",
+    cst_Stdlib_Float_Array_Bottom = "Stdlib.Float.Array.Bottom",
+    zero = 0.,
+    one = 1.,
+    minus_one = -1.;
+   function is_finite(x){
+     /*<<float.ml:34:27>>*/ return x - x == 0. ? 1 : 0;
+    /*<<float.ml:34:38>>*/ }
+   function is_infinite(x){
+     /*<<float.ml:35:29>>*/ return 1. / x == 0. ? 1 : 0;
+    /*<<float.ml:35:41>>*/ }
+   function is_nan(x){
+     /*<<float.ml:36:24>>*/ return x != x ? 1 : 0;
+    /*<<float.ml:36:30>>*/ }
+   var
+    max_float = Stdlib[25],
+    min_float = Stdlib[26],
+    epsilon = Stdlib[27],
+    of_string_opt = Stdlib[36],
+    to_string = Stdlib[35],
+    pi = 3.141592653589793;
+   function is_integer(x){
+     /*<<float.ml:111:19>>*/ var
+     _aq_ = x ==  /*<<float.ml:111:23>>*/ runtime.caml_trunc_float(x) ? 1 : 0;
+    return _aq_ ? is_finite(x) : _aq_;
+    /*<<float.ml:111:45>>*/ }
+   function succ(x){
+     /*<<float.ml:116:13>>*/ return  /*<<float.ml:116:13>>*/ caml_nextafter_float
+            (x, infinity);
+    /*<<float.ml:116:34>>*/ }
+   function pred(x){
+     /*<<float.ml:117:13>>*/ return  /*<<float.ml:117:13>>*/ caml_nextafter_float
+            (x, neg_infinity);
+    /*<<float.ml:117:38>>*/ }
+   function equal(x, y){
+     /*<<float.ml:131:16>>*/ return 0 === caml_float_compare(x, y) ? 1 : 0;
+    /*<<float.ml:131:31>>*/ }
+   function min(x, y){
+     /*<<float.ml:134:2>>*/ a:
+    if(! (x < y)){
+      /*<<float.ml:134:34>>*/ if
+      (!
+        /*<<float.ml:134:18>>*/ caml_signbit_float(y)
+       &&  /*<<float.ml:134:34>>*/ caml_signbit_float(x))
+      break a;
+      /*<<float.ml:136:10>>*/ return x != x ? x : y;
+    }
+     /*<<float.ml:135:7>>*/ return y != y ? y : x;
+    /*<<float.ml:136:32>>*/ }
+   function max(x, y){
+     /*<<float.ml:139:2>>*/ a:
+    if(! (x < y)){
+      /*<<float.ml:139:34>>*/ if
+      (!
+        /*<<float.ml:139:18>>*/ caml_signbit_float(y)
+       &&  /*<<float.ml:139:34>>*/ caml_signbit_float(x))
+      break a;
+      /*<<float.ml:141:10>>*/ return y != y ? y : x;
+    }
+     /*<<float.ml:140:7>>*/ return x != x ? x : y;
+    /*<<float.ml:141:32>>*/ }
+   function min_max(x, y){
+     /*<<float.ml:144:2>>*/ if(x == x && y == y){
+     a:
+     if(! (x < y)){
+       /*<<float.ml:145:39>>*/ if
+       (!
+         /*<<float.ml:145:23>>*/ caml_signbit_float(y)
+        &&  /*<<float.ml:145:39>>*/ caml_signbit_float(x))
+       break a;
+       /*<<float.ml:145:68>>*/ return [0, y, x];
+     }
+      /*<<float.ml:145:56>>*/ return [0, x, y];
+    }
+     /*<<float.ml:144:31>>*/ return [0, nan, nan];
+    /*<<float.ml:145:74>>*/ }
+   function min_num(x, y){
+     /*<<float.ml:148:2>>*/ a:
+    if(! (x < y)){
+      /*<<float.ml:148:34>>*/ if
+      (!
+        /*<<float.ml:148:18>>*/ caml_signbit_float(y)
+       &&  /*<<float.ml:148:34>>*/ caml_signbit_float(x))
+      break a;
+      /*<<float.ml:150:10>>*/ return y != y ? x : y;
+    }
+     /*<<float.ml:149:7>>*/ return x != x ? y : x;
+    /*<<float.ml:150:32>>*/ }
+   function max_num(x, y){
+     /*<<float.ml:153:2>>*/ a:
+    if(! (x < y)){
+      /*<<float.ml:153:34>>*/ if
+      (!
+        /*<<float.ml:153:18>>*/ caml_signbit_float(y)
+       &&  /*<<float.ml:153:34>>*/ caml_signbit_float(x))
+      break a;
+      /*<<float.ml:155:10>>*/ return x != x ? y : x;
+    }
+     /*<<float.ml:154:7>>*/ return y != y ? x : y;
+    /*<<float.ml:155:32>>*/ }
+   function min_max_num(x, y){
+     /*<<float.ml:158:2>>*/ if(x != x)
+      /*<<float.ml:158:19>>*/ return [0, y, y];
+     /*<<float.ml:159:10>>*/ if(y != y)
+      /*<<float.ml:159:24>>*/ return [0, x, x];
+    a:
+    if(! (x < y)){
+      /*<<float.ml:160:39>>*/ if
+      (!
+        /*<<float.ml:160:23>>*/ caml_signbit_float(y)
+       &&  /*<<float.ml:160:39>>*/ caml_signbit_float(x))
+      break a;
+      /*<<float.ml:160:67>>*/ return [0, y, x];
+    }
+     /*<<float.ml:160:56>>*/ return [0, x, y];
+    /*<<float.ml:160:72>>*/ }
+   function hash(x){
+     /*<<float.ml:164:13>>*/ return  /*<<float.ml:164:13>>*/ runtime.caml_hash
+            (10, 100, 0, x);
+    /*<<float.ml:164:41>>*/ }
+   function unsafe_fill(a, ofs, len, v){
+     /*<<float.ml:178:4>>*/ var _ao_ = (ofs + len | 0) - 1 | 0;
+    if(_ao_ >= ofs){
+     var i = ofs;
+     for(;;){
+       /*<<float.ml:178:36>>*/ a[1 + i] = v;
+       /*<<float.ml:178:36>>*/  /*<<float.ml:178:36>>*/ var _ap_ = i + 1 | 0;
+      if(_ao_ === i) break;
+      var i = _ap_;
+     }
+    }
+    return 0;
+    /*<<float.ml:178:57>>*/ }
+   function check(a, ofs, len, msg){
+     /*<<float.ml:184:4>>*/ var _ak_ = ofs < 0 ? 1 : 0;
+    if(_ak_)
+     var _al_ = _ak_;
+    else{
+     var _am_ = len < 0 ? 1 : 0;
+     if(_am_)
+      var _al_ = _am_;
+     else
+      var
+       _an_ = (ofs + len | 0) < 0 ? 1 : 0,
+       _al_ = _an_ || (a.length - 1 < (ofs + len | 0) ? 1 : 0);
+    }
+    return _al_ ?  /*<<float.ml:185:6>>*/ caml_call1(Stdlib[1], msg) : _al_;
+    /*<<float.ml:185:21>>*/ }
+   function make(n, v){
+     /*<<float.ml:188:4>>*/  /*<<float.ml:188:17>>*/ var
+     result =  /*<<float.ml:188:17>>*/ caml_floatarray_create(n);
+     /*<<float.ml:189:4>>*/ unsafe_fill(result, 0, n, v);
+     /*<<float.ml:189:4>>*/ return result;
+    /*<<float.ml:190:10>>*/ }
+   function init(l, f){
+     /*<<float.ml:193:4>>*/ if(0 > l)
+      /*<<float.ml:193:18>>*/ return  /*<<float.ml:193:18>>*/ caml_call1
+             (Stdlib[1], cst_Float_Array_init);
+     /*<<float.ml:195:16>>*/ var
+      /*<<float.ml:195:16>>*/ res =
+        /*<<float.ml:195:16>>*/ caml_floatarray_create(l),
+      /*<<float.ml:196:6>>*/ _ai_ = l - 1 | 0,
+      /*<<float.ml:195:16>>*/ _ah_ = 0;
+    if(_ai_ >= 0){
+     var i = _ah_;
+     for(;;){
+       /*<<float.ml:197:8>>*/ res[1 + i] =
+        /*<<float.ml:197:25>>*/ caml_call1(f, i);
+       /*<<float.ml:197:8>>*/  /*<<float.ml:197:8>>*/ var _aj_ = i + 1 | 0;
+      if(_ai_ === i) break;
+      var i = _aj_;
+     }
+    }
+     /*<<float.ml:199:6>>*/ return res;
+    /*<<float.ml:199:9>>*/ }
+   function append(a1, a2){
+     /*<<float.ml:202:4>>*/ var
+     l1 = a1.length - 1,
+      /*<<float.ml:203:4>>*/ l2 = a2.length - 1,
+      /*<<float.ml:204:17>>*/ result =
+        /*<<float.ml:204:17>>*/ caml_floatarray_create(l1 + l2 | 0);
+     /*<<float.ml:205:4>>*/  /*<<float.ml:205:4>>*/ caml_floatarray_blit
+     (a1, 0, result, 0, l1);
+     /*<<float.ml:206:4>>*/  /*<<float.ml:206:4>>*/ caml_floatarray_blit
+     (a2, 0, result, l1, l2);
+     /*<<float.ml:206:4>>*/ return result;
+    /*<<float.ml:207:10>>*/ }
+   function concat(l){
+     /*<<float.ml:218:4>>*/ var acc = 0, param = l;
+    for(;;)
+     if(param)
+      var
+       tl = param[2],
+       hd = param[1],
+       x = hd.length - 1 + acc | 0,
+       acc$0 =
+         acc <= x
+          ? x
+          :  /*<<float.ml:211:26>>*/ caml_call1
+            (Stdlib[1], cst_Float_Array_concat),
+       acc = acc$0,
+       param = tl;
+     else{
+       /*<<float.ml:219:17>>*/ var
+        /*<<float.ml:219:17>>*/ result =
+          /*<<float.ml:219:17>>*/ caml_floatarray_create(acc),
+       l$0 = l,
+       i = 0;
+       /*<<float.ml:221:6>>*/ for(;;){
+       if(! l$0){
+        if(i === acc)  /*<<float.ml:228:4>>*/ return result;
+         /*<<float.ml:222:14>>*/ throw  /*<<float.ml:222:14>>*/ caml_maybe_attach_backtrace
+               ([0, Assert_failure, _a_], 1);
+       }
+        /*<<float.ml:224:8>>*/ var
+        tl$0 = l$0[2],
+        hd$0 = l$0[1],
+         /*<<float.ml:224:8>>*/ hlen = hd$0.length - 1;
+        /*<<float.ml:225:8>>*/  /*<<float.ml:225:8>>*/ caml_floatarray_blit
+        (hd$0, 0, result, i, hlen);
+       var i$0 = i + hlen | 0, l$0 = tl$0, i = i$0;
+      }
+     }
+    /*<<float.ml:229:10>>*/ }
+   function sub(a, ofs, len){
+     /*<<float.ml:232:4>>*/ check(a, ofs, len, cst_Float_Array_sub);
+     /*<<float.ml:233:17>>*/  /*<<float.ml:233:17>>*/ var
+     result =  /*<<float.ml:233:17>>*/ caml_floatarray_create(len);
+     /*<<float.ml:234:4>>*/  /*<<float.ml:234:4>>*/ caml_floatarray_blit
+     (a, ofs, result, 0, len);
+     /*<<float.ml:234:4>>*/ return result;
+    /*<<float.ml:235:10>>*/ }
+   function copy(a){
+     /*<<float.ml:238:4>>*/ var
+     l = a.length - 1,
+      /*<<float.ml:239:17>>*/ result =
+        /*<<float.ml:239:17>>*/ caml_floatarray_create(l);
+     /*<<float.ml:240:4>>*/  /*<<float.ml:240:4>>*/ caml_floatarray_blit
+     (a, 0, result, 0, l);
+     /*<<float.ml:240:4>>*/ return result;
+    /*<<float.ml:241:10>>*/ }
+   function fill(a, ofs, len, v){
+     /*<<float.ml:244:4>>*/ check(a, ofs, len, cst_Float_Array_fill);
+     /*<<float.ml:244:4>>*/ return unsafe_fill(a, ofs, len, v);
+    /*<<float.ml:245:27>>*/ }
+   function blit(src, sofs, dst, dofs, len){
+     /*<<float.ml:248:4>>*/ check(src, sofs, len, cst_Float_array_blit);
+     /*<<float.ml:249:4>>*/ check(dst, dofs, len, cst_Float_array_blit$0);
+     /*<<float.ml:250:4>>*/ return  /*<<float.ml:250:4>>*/ caml_floatarray_blit
+            (src, sofs, dst, dofs, len);
+    /*<<float.ml:250:37>>*/ }
+   function to_list(a){
+     /*<<float.ml:253:25>>*/ function _af_(_ag_){
+      /*<<?>>*/ return a[1 + _ag_];
+    }
+     /*<<float.ml:253:25>>*/ return  /*<<float.ml:253:25>>*/ caml_call2
+            (Stdlib_List[10], a.length - 1, _af_);
+    /*<<float.ml:253:39>>*/ }
+   function of_list(l){
+     /*<<float.ml:256:4>>*/ var
+      /*<<float.ml:256:17>>*/ result =
+        /*<<float.ml:256:17>>*/ caml_floatarray_create
+        ( /*<<float.ml:256:24>>*/ caml_call1(Stdlib_List[1], l)),
+     i = 0,
+     l$0 = l;
+     /*<<float.ml:258:6>>*/ for(;;){
+     if(! l$0)  /*<<float.ml:257:4>>*/ return result;
+     var t = l$0[2], h = l$0[1];
+      /*<<float.ml:260:18>>*/ result[1 + i] = h;
+      /*<<float.ml:257:4>>*/ var
+       /*<<float.ml:257:4>>*/ i$0 = i + 1 | 0,
+      i = i$0,
+      l$0 = t;
+    }
+    /*<<float.ml:262:12>>*/ }
+   function iter(f, a){
+     /*<<float.ml:266:4>>*/ var
+     _ad_ = a.length - 1 - 1 | 0,
+      /*<<float.ml:266:4>>*/ _ac_ = 0;
+    if(_ad_ >= 0){
+     var i = _ac_;
+     for(;;){
+       /*<<float.ml:266:33>>*/  /*<<float.ml:266:33>>*/ caml_call1
+       (f, a[1 + i]);
+       /*<<float.ml:266:33>>*/  /*<<float.ml:266:33>>*/ var _ae_ = i + 1 | 0;
+      if(_ad_ === i) break;
+      var i = _ae_;
+     }
+    }
+    return 0;
+    /*<<float.ml:266:56>>*/ }
+   function iter2(f, a, b){
+     /*<<float.ml:270:4>>*/ if(a.length - 1 !== b.length - 1)
+      /*<<float.ml:271:6>>*/ return  /*<<float.ml:271:6>>*/ caml_call1
+             (Stdlib[1], cst_Float_Array_iter2_arrays_m);
+     /*<<float.ml:273:6>>*/ var
+     _aa_ = a.length - 1 - 1 | 0,
+      /*<<float.ml:273:6>>*/ _$_ = 0;
+    if(_aa_ >= 0){
+     var i = _$_;
+     for(;;){
+       /*<<float.ml:273:35>>*/  /*<<float.ml:273:35>>*/ caml_call2
+       (f, a[1 + i], b[1 + i]);
+       /*<<float.ml:273:35>>*/  /*<<float.ml:273:35>>*/ var _ab_ = i + 1 | 0;
+      if(_aa_ === i) break;
+      var i = _ab_;
+     }
+    }
+    return 0;
+    /*<<float.ml:273:75>>*/ }
+   function map(f, a){
+     /*<<float.ml:276:4>>*/ var
+     l = a.length - 1,
+      /*<<float.ml:277:12>>*/ r =
+        /*<<float.ml:277:12>>*/ caml_floatarray_create(l),
+      /*<<float.ml:278:4>>*/ _Z_ = l - 1 | 0,
+      /*<<float.ml:277:12>>*/ _Y_ = 0;
+    if(_Z_ >= 0){
+     var i = _Y_;
+     for(;;){
+       /*<<float.ml:279:6>>*/ r[1 + i] =
+        /*<<float.ml:279:21>>*/ caml_call1(f, a[1 + i]);
+       /*<<float.ml:279:6>>*/  /*<<float.ml:279:6>>*/ var ___ = i + 1 | 0;
+      if(_Z_ === i) break;
+      var i = ___;
+     }
+    }
+     /*<<float.ml:281:4>>*/ return r;
+    /*<<float.ml:281:5>>*/ }
+   function map2(f, a, b){
+     /*<<float.ml:284:4>>*/ var
+     la = a.length - 1,
+      /*<<float.ml:285:4>>*/ lb = b.length - 1;
+    if(la !== lb)
+      /*<<float.ml:287:6>>*/ return  /*<<float.ml:287:6>>*/ caml_call1
+             (Stdlib[1], cst_Float_Array_map2_arrays_mu);
+     /*<<float.ml:289:14>>*/ var
+      /*<<float.ml:289:14>>*/ r =
+        /*<<float.ml:289:14>>*/ caml_floatarray_create(la),
+      /*<<float.ml:290:6>>*/ _W_ = la - 1 | 0,
+      /*<<float.ml:289:14>>*/ _V_ = 0;
+    if(_W_ >= 0){
+     var i = _V_;
+     for(;;){
+       /*<<float.ml:291:8>>*/ r[1 + i] =
+        /*<<float.ml:291:23>>*/ caml_call2(f, a[1 + i], b[1 + i]);
+       /*<<float.ml:291:8>>*/  /*<<float.ml:291:8>>*/ var _X_ = i + 1 | 0;
+      if(_W_ === i) break;
+      var i = _X_;
+     }
+    }
+     /*<<float.ml:293:6>>*/ return r;
+    /*<<float.ml:294:7>>*/ }
+   function iteri(f, a){
+     /*<<float.ml:298:4>>*/ var
+     _T_ = a.length - 1 - 1 | 0,
+      /*<<float.ml:298:4>>*/ _S_ = 0;
+    if(_T_ >= 0){
+     var i = _S_;
+     for(;;){
+       /*<<float.ml:298:33>>*/  /*<<float.ml:298:33>>*/ caml_call2
+       (f, i, a[1 + i]);
+       /*<<float.ml:298:33>>*/  /*<<float.ml:298:33>>*/ var _U_ = i + 1 | 0;
+      if(_T_ === i) break;
+      var i = _U_;
+     }
+    }
+    return 0;
+    /*<<float.ml:298:58>>*/ }
+   function mapi(f, a){
+     /*<<float.ml:301:4>>*/ var
+     l = a.length - 1,
+      /*<<float.ml:302:12>>*/ r =
+        /*<<float.ml:302:12>>*/ caml_floatarray_create(l),
+      /*<<float.ml:303:4>>*/ _Q_ = l - 1 | 0,
+      /*<<float.ml:302:12>>*/ _P_ = 0;
+    if(_Q_ >= 0){
+     var i = _P_;
+     for(;;){
+       /*<<float.ml:304:6>>*/ r[1 + i] =
+        /*<<float.ml:304:21>>*/ caml_call2(f, i, a[1 + i]);
+       /*<<float.ml:304:6>>*/  /*<<float.ml:304:6>>*/ var _R_ = i + 1 | 0;
+      if(_Q_ === i) break;
+      var i = _R_;
+     }
+    }
+     /*<<float.ml:306:4>>*/ return r;
+    /*<<float.ml:306:5>>*/ }
+   function fold_left(f, x, a){
+     /*<<float.ml:310:4>>*/ var
+      /*<<float.ml:310:12>>*/ r = [0, x],
+     _N_ = a.length - 1 - 1 | 0,
+      /*<<float.ml:310:12>>*/ _M_ = 0;
+    if(_N_ >= 0){
+     var i = _M_;
+     for(;;){
+      r[1] =  /*<<float.ml:312:11>>*/ caml_call2(f, r[1], a[1 + i]);
+       /*<<float.ml:311:4>>*/  /*<<float.ml:311:4>>*/ var _O_ = i + 1 | 0;
+      if(_N_ === i) break;
+      var i = _O_;
+     }
+    }
+    return r[1];
+    /*<<float.ml:314:6>>*/ }
+   function fold_right(f, a, x){
+     /*<<float.ml:318:4>>*/ var
+      /*<<float.ml:318:12>>*/ r = [0, x],
+      /*<<float.ml:319:4>>*/ _K_ = a.length - 1 - 1 | 0;
+    if(_K_ >= 0){
+     var i = _K_;
+     for(;;){
+      r[1] =  /*<<float.ml:320:11>>*/ caml_call2(f, a[1 + i], r[1]);
+       /*<<float.ml:319:4>>*/  /*<<float.ml:319:4>>*/ var _L_ = i - 1 | 0;
+      if(0 === i) break;
+      var i = _L_;
+     }
+    }
+    return r[1];
+    /*<<float.ml:322:6>>*/ }
+   function exists(p, a){
+     /*<<float.ml:326:4>>*/ var n = a.length - 1, i = 0;
+     /*<<float.ml:328:6>>*/ for(;;){
+     if(i === n)  /*<<float.ml:328:20>>*/ return 0;
+      /*<<float.ml:329:14>>*/ if
+      ( /*<<float.ml:329:14>>*/ caml_call1(p, a[1 + i]))
+       /*<<float.ml:329:38>>*/ return 1;
+      /*<<float.ml:330:11>>*/ var
+       /*<<float.ml:330:11>>*/ i$0 = i + 1 | 0,
+      i = i$0;
+    }
+    /*<<float.ml:331:10>>*/ }
+   function for_all(p, a){
+     /*<<float.ml:335:4>>*/ var n = a.length - 1, i = 0;
+     /*<<float.ml:337:6>>*/ for(;;){
+     if(i === n)  /*<<float.ml:337:20>>*/ return 1;
+      /*<<float.ml:338:14>>*/ if
+      (!  /*<<float.ml:338:14>>*/ caml_call1(p, a[1 + i]))
+       /*<<float.ml:339:11>>*/ return 0;
+      /*<<float.ml:338:38>>*/ var
+       /*<<float.ml:338:38>>*/ i$0 = i + 1 | 0,
+      i = i$0;
+    }
+    /*<<float.ml:340:10>>*/ }
+   function mem(x, a){
+     /*<<float.ml:344:4>>*/ var n = a.length - 1, i = 0;
+     /*<<float.ml:346:6>>*/ for(;;){
+     if(i === n)  /*<<float.ml:346:20>>*/ return 0;
+     if(0 ===  /*<<float.ml:347:22>>*/ caml_float_compare(a[1 + i], x))
+       /*<<float.ml:347:50>>*/ return 1;
+      /*<<float.ml:348:11>>*/ var
+       /*<<float.ml:348:11>>*/ i$0 = i + 1 | 0,
+      i = i$0;
+    }
+    /*<<float.ml:350:10>>*/ }
+   function mem_ieee(x, a){
+     /*<<float.ml:354:4>>*/ var n = a.length - 1, i = 0;
+     /*<<float.ml:356:6>>*/ for(;;){
+     if(i === n)  /*<<float.ml:356:20>>*/ return 0;
+     if(x == a[1 + i])  /*<<float.ml:357:40>>*/ return 1;
+      /*<<float.ml:358:11>>*/ var
+       /*<<float.ml:358:11>>*/ i$0 = i + 1 | 0,
+      i = i$0;
+    }
+    /*<<float.ml:360:10>>*/ }
+    /*<<float.ml:363:2>>*/  /*<<float.ml:363:2>>*/ var
+    Bottom = [248, cst_Stdlib_Float_Array_Bottom, runtime.caml_fresh_oo_id(0)];
+   function sort(cmp, a){
+    function maxson(l, i){
+      /*<<float.ml:366:6>>*/ var
+      i31 = ((i + i | 0) + i | 0) + 1 | 0,
+       /*<<float.ml:367:14>>*/ x = [0, i31];
+     if((i31 + 2 | 0) < l){
+      if
+       ( /*<<float.ml:369:11>>*/ caml_call2
+         (cmp,
+           /*<<float.ml:369:15>>*/ caml_array_get(a, i31),
+           /*<<float.ml:369:27>>*/ caml_array_get(a, i31 + 1 | 0))
+        < 0)
+       x[1] = i31 + 1 | 0;
+      if
+       ( /*<<float.ml:370:11>>*/ caml_call2
+         (cmp,
+           /*<<float.ml:370:15>>*/ caml_array_get(a, x[1]),
+           /*<<float.ml:370:26>>*/ caml_array_get(a, i31 + 2 | 0))
+        < 0)
+       x[1] = i31 + 2 | 0;
+      return x[1];
+     }
+      /*<<float.ml:373:24>>*/ if
+      ((i31 + 1 | 0) < l
+       &&
+        0
+        >
+          /*<<float.ml:373:24>>*/ caml_call2
+          (cmp,
+            /*<<float.ml:373:28>>*/ caml_array_get(a, i31),
+            /*<<float.ml:373:40>>*/ caml_array_get(a, i31 + 1 | 0)))
+       /*<<float.ml:374:13>>*/ return i31 + 1 | 0;
+     if(i31 < l)  /*<<float.ml:375:29>>*/ return i31;
+      /*<<float.ml:375:38>>*/ throw  /*<<float.ml:375:38>>*/ caml_maybe_attach_backtrace
+            ([0, Bottom, i], 1);
+     /*<<float.ml:375:54>>*/ }
+    var l = a.length - 1, _E_ = ((l + 1 | 0) / 3 | 0) - 1 | 0;
+    if(_E_ >= 0){
+     var i$6 = _E_;
+     for(;;){
+       /*<<float.ml:404:52>>*/  /*<<float.ml:404:52>>*/ var
+       e$1 =  /*<<float.ml:404:52>>*/ caml_array_get(a, i$6);
+       /*<<float.ml:386:24>>*/ try{
+       var i = i$6;
+        /*<<float.ml:378:6>>*/ for(;;){
+         /*<<float.ml:378:14>>*/  /*<<float.ml:378:14>>*/ var
+         j = maxson(l, i);
+         /*<<float.ml:379:9>>*/ if
+         (0
+          >=
+            /*<<float.ml:379:9>>*/ caml_call2
+            (cmp,  /*<<float.ml:379:13>>*/ caml_array_get(a, j), e$1)){
+          /*<<float.ml:382:15>>*/  /*<<float.ml:382:15>>*/ caml_array_set
+          (a, i, e$1);
+         break;
+        }
+         /*<<float.ml:380:8>>*/  /*<<float.ml:380:8>>*/ caml_array_set
+         (a, i,  /*<<float.ml:380:16>>*/ caml_array_get(a, j));
+        var i = j;
+       }
+      }
+      catch(exn$0){
+       var exn = caml_wrap_exception(exn$0);
+       if(exn[1] !== Bottom) throw caml_maybe_attach_backtrace(exn, 0);
+       var i$0 = exn[2];
+        /*<<float.ml:386:63>>*/  /*<<float.ml:386:63>>*/ caml_array_set
+        (a, i$0, e$1);
+      }
+       /*<<float.ml:404:40>>*/  /*<<float.ml:404:40>>*/ var _J_ = i$6 - 1 | 0;
+      if(0 === i$6) break;
+      var i$6 = _J_;
+     }
+    }
+     /*<<float.ml:405:4>>*/  /*<<float.ml:405:4>>*/ var _F_ = l - 1 | 0;
+    if(_F_ >= 2){
+     var i$4 = _F_;
+     a:
+     for(;;){
+       /*<<float.ml:406:14>>*/  /*<<float.ml:406:14>>*/ var
+       e$0 =  /*<<float.ml:406:14>>*/ caml_array_get(a, i$4);
+       /*<<float.ml:407:6>>*/  /*<<float.ml:407:6>>*/ caml_array_set
+       (a, i$4,  /*<<float.ml:407:14>>*/ caml_array_get(a, 0));
+      var i$5 = 0;
+       /*<<float.ml:392:21>>*/ try{
+       var i$1 = i$5;
+        /*<<float.ml:388:6>>*/ for(;;){
+         /*<<float.ml:388:14>>*/  /*<<float.ml:388:14>>*/ var
+         j$0 = maxson(i$4, i$1);
+         /*<<float.ml:389:6>>*/  /*<<float.ml:389:6>>*/ caml_array_set
+         (a, i$1,  /*<<float.ml:389:14>>*/ caml_array_get(a, j$0));
+        var i$1 = j$0;
+       }
+      }
+      catch(exn){
+       var exn$0 = caml_wrap_exception(exn);
+       if(exn$0[1] !== Bottom) throw caml_maybe_attach_backtrace(exn$0, 0);
+       var i$2 = exn$0[2], i$3 = i$2;
+        /*<<float.ml:394:6>>*/ for(;;){
+        var father = (i$3 - 1 | 0) / 3 | 0;
+        if(i$3 === father)
+          /*<<float.ml:395:6>>*/ throw  /*<<float.ml:395:6>>*/ caml_maybe_attach_backtrace
+                ([0, Assert_failure, _b_], 1);
+         /*<<float.ml:396:9>>*/ if
+         (0
+          <=
+            /*<<float.ml:396:9>>*/ caml_call2
+            (cmp,  /*<<float.ml:396:13>>*/ caml_array_get(a, father), e$0))
+          /*<<float.ml:399:15>>*/  /*<<float.ml:399:15>>*/ caml_array_set
+          (a, i$3, e$0);
+        else{
+          /*<<float.ml:397:8>>*/  /*<<float.ml:397:8>>*/ caml_array_set
+          (a, i$3,  /*<<float.ml:397:16>>*/ caml_array_get(a, father));
+         if(0 < father){var i$3 = father; continue;}
+          /*<<float.ml:398:51>>*/  /*<<float.ml:398:51>>*/ caml_array_set
+          (a, 0, e$0);
+        }
+         /*<<float.ml:405:4>>*/  /*<<float.ml:405:4>>*/ var _I_ = i$4 - 1 | 0;
+        if(2 === i$4) break a;
+        var i$4 = _I_;
+        break;
+       }
+      }
+     }
+    }
+    var _G_ = 1 < l ? 1 : 0;
+    if(_G_){
+      /*<<float.ml:410:27>>*/  /*<<float.ml:410:27>>*/ var
+      e =  /*<<float.ml:410:27>>*/ caml_array_get(a, 1);
+      /*<<float.ml:410:40>>*/  /*<<float.ml:410:40>>*/ caml_array_set
+      (a, 1,  /*<<float.ml:410:48>>*/ caml_array_get(a, 0));
+     var _H_ =  /*<<float.ml:410:59>>*/ caml_array_set(a, 0, e);
+    }
+    else
+     var _H_ = _G_;
+     /*<<float.ml:410:59>>*/ return _H_;
+    /*<<float.ml:410:69>>*/ }
+   function stable_sort(cmp, a){
+    function merge(src1ofs, src1len, src2, src2ofs, src2len, dst, dstofs){
+      /*<<float.ml:416:6>>*/ var
+      src1r = src1ofs + src1len | 0,
+      src2r = src2ofs + src2len | 0,
+       /*<<float.ml:433:46>>*/ s2$1 =
+         /*<<float.ml:433:46>>*/ caml_array_get(src2, src2ofs),
+       /*<<float.ml:433:22>>*/ s1$1 =
+         /*<<float.ml:433:22>>*/ caml_array_get(a, src1ofs),
+      i1 = src1ofs,
+      s1 = s1$1,
+      i2 = src2ofs,
+      s2 = s2$1,
+      d = dstofs;
+      /*<<float.ml:418:8>>*/ for(;;)
+       /*<<float.ml:418:11>>*/ if
+       (0 <  /*<<float.ml:418:11>>*/ caml_call2(cmp, s1, s2)){
+        /*<<float.ml:426:10>>*/  /*<<float.ml:426:10>>*/ caml_array_set
+        (dst, d, s2);
+        /*<<float.ml:426:10>>*/  /*<<float.ml:426:10>>*/ var
+        i2$0 = i2 + 1 | 0;
+       if(i2$0 >= src2r) return blit(a, i1, dst, d + 1 | 0, src1r - i1 | 0);
+        /*<<float.ml:429:12>>*/ var
+         /*<<float.ml:429:12>>*/ d$0 = d + 1 | 0,
+         /*<<float.ml:429:26>>*/ s2$0 =
+           /*<<float.ml:429:26>>*/ caml_array_get(src2, i2$0),
+        i2 = i2$0,
+        s2 = s2$0,
+        d = d$0;
+      }
+      else{
+        /*<<float.ml:419:10>>*/  /*<<float.ml:419:10>>*/ caml_array_set
+        (dst, d, s1);
+        /*<<float.ml:419:10>>*/  /*<<float.ml:419:10>>*/ var
+        i1$0 = i1 + 1 | 0;
+       if(i1$0 >= src1r)
+        return blit(src2, i2, dst, d + 1 | 0, src2r - i2 | 0);
+        /*<<float.ml:422:12>>*/ var
+         /*<<float.ml:422:12>>*/ d$1 = d + 1 | 0,
+         /*<<float.ml:422:20>>*/ s1$0 =
+           /*<<float.ml:422:20>>*/ caml_array_get(a, i1$0),
+        i1 = i1$0,
+        s1 = s1$0,
+        d = d$1;
+      }
+     /*<<float.ml:433:72>>*/ }
+    function isortto(srcofs, dst, dstofs, len){
+      /*<<float.ml:436:6>>*/ var
+      _C_ = len - 1 | 0,
+       /*<<float.ml:436:6>>*/ _B_ = 0;
+     if(_C_ >= 0){
+      var i = _B_;
+      a:
+      for(;;){
+        /*<<float.ml:437:16>>*/ var
+         /*<<float.ml:437:16>>*/ e =
+           /*<<float.ml:437:16>>*/ caml_array_get(a, srcofs + i | 0),
+         /*<<float.ml:438:16>>*/ j = [0, (dstofs + i | 0) - 1 | 0];
+       for(;;){
+         /*<<float.ml:439:31>>*/ if
+         (dstofs <= j[1]
+          &&
+           0
+           <
+             /*<<float.ml:439:31>>*/ caml_call2
+             (cmp,  /*<<float.ml:439:35>>*/ caml_array_get(dst, j[1]), e)){
+          /*<<float.ml:440:10>>*/  /*<<float.ml:440:10>>*/ caml_array_set
+          (dst,
+           j[1] + 1 | 0,
+            /*<<float.ml:440:27>>*/ caml_array_get(dst, j[1]));
+         j[1] += -1;
+         continue;
+        }
+         /*<<float.ml:443:8>>*/  /*<<float.ml:443:8>>*/ caml_array_set
+         (dst, j[1] + 1 | 0, e);
+         /*<<float.ml:436:6>>*/  /*<<float.ml:436:6>>*/ var _D_ = i + 1 | 0;
+        if(_C_ === i) break a;
+        var i = _D_;
+        break;
+       }
+      }
+     }
+     return 0;
+     /*<<float.ml:444:10>>*/ }
+    function sortto(srcofs, dst, dstofs, len){
+      /*<<float.ml:447:6>>*/ if(len <= 5)
+       /*<<float.ml:447:28>>*/ return isortto(srcofs, dst, dstofs, len);
+     var l1 = len / 2 | 0, l2 = len - l1 | 0;
+      /*<<float.ml:450:8>>*/ sortto(srcofs + l1 | 0, dst, dstofs + l1 | 0, l2);
+      /*<<float.ml:451:8>>*/ sortto(srcofs, a, srcofs + l2 | 0, l1);
+      /*<<float.ml:451:8>>*/ return merge
+             (srcofs + l2 | 0, l1, dst, dstofs + l1 | 0, l2, dst, dstofs);
+     /*<<float.ml:453:9>>*/ }
+    var l = a.length - 1;
+    if(l <= 5)  /*<<float.ml:456:24>>*/ return isortto(0, a, 0, l);
+     /*<<float.ml:459:14>>*/ var
+     l1 = l / 2 | 0,
+     l2 = l - l1 | 0,
+      /*<<float.ml:459:14>>*/ t =
+        /*<<float.ml:459:14>>*/ caml_floatarray_create(l2);
+     /*<<float.ml:460:6>>*/ sortto(l1, t, 0, l2);
+     /*<<float.ml:461:6>>*/ sortto(0, a, l2, l1);
+     /*<<float.ml:461:6>>*/ return merge(l2, l1, t, 0, l2, a, 0);
+    /*<<float.ml:463:7>>*/ }
+   function to_seq(a){
+    function aux(i, param){
+      /*<<float.ml:470:6>>*/ if(i >= a.length - 1)
+       /*<<float.ml:474:11>>*/ return 0;
+      /*<<float.ml:472:16>>*/ var
+       /*<<float.ml:472:16>>*/ x = a[1 + i],
+       /*<<float.ml:472:16>>*/ _z_ = i + 1 | 0;
+      /*<<float.ml:473:8>>*/ return [0,
+             x,
+             function(_A_){ /*<<?>>*/ return aux(_z_, _A_);}];
+     /*<<float.ml:474:18>>*/ }
+     /*<<float.ml:476:4>>*/  /*<<float.ml:476:4>>*/ var _x_ = 0;
+     /*<<float.ml:476:4>>*/ return function(_y_){
+      /*<<?>>*/ return aux(_x_, _y_);};
+    /*<<float.ml:476:9>>*/ }
+   function to_seqi(a){
+    function aux(i, param){
+      /*<<float.ml:481:6>>*/ if(i >= a.length - 1)
+       /*<<float.ml:485:11>>*/ return 0;
+      /*<<float.ml:483:16>>*/ var
+       /*<<float.ml:483:16>>*/ x = a[1 + i],
+       /*<<float.ml:483:16>>*/ _v_ = i + 1 | 0;
+      /*<<float.ml:484:8>>*/ return [0,
+             [0, i, x],
+             function(_w_){ /*<<?>>*/ return aux(_v_, _w_);}];
+     /*<<float.ml:485:18>>*/ }
+     /*<<float.ml:487:4>>*/  /*<<float.ml:487:4>>*/ var _t_ = 0;
+     /*<<float.ml:487:4>>*/ return function(_u_){
+      /*<<?>>*/ return aux(_t_, _u_);};
+    /*<<float.ml:487:9>>*/ }
+   function of_seq(i$2){
+     /*<<float.ml:501:4>>*/ var _r_ = 0;
+    function _s_(acc, x){
+      /*<<float.ml:501:40>>*/ return [0, x, acc];
+     /*<<float.ml:501:46>>*/ }
+     /*<<float.ml:501:12>>*/ var
+      /*<<float.ml:501:12>>*/ l =
+        /*<<float.ml:501:12>>*/ caml_call3(Stdlib_Seq[5], _s_, _r_, i$2),
+      /*<<float.ml:491:14>>*/ len =
+        /*<<float.ml:491:14>>*/ caml_call1(Stdlib_List[1], l),
+      /*<<float.ml:492:12>>*/ a =
+        /*<<float.ml:492:12>>*/ caml_floatarray_create(len),
+      /*<<float.ml:491:14>>*/ i$1 = len - 1 | 0,
+     i = i$1,
+     param = l;
+    for(;;){
+     if(! param)  /*<<float.ml:493:4>>*/ return a;
+     var tl = param[2], hd = param[1];
+      /*<<float.ml:495:18>>*/ a[1 + i] = hd;
+      /*<<float.ml:493:4>>*/ var
+       /*<<float.ml:493:4>>*/ i$0 = i - 1 | 0,
+      i = i$0,
+      param = tl;
+    }
+    /*<<float.ml:502:17>>*/ }
+   function map_to_array(f, a){
+     /*<<float.ml:506:4>>*/ var l = a.length - 1;
+     /*<<float.ml:507:4>>*/ if(0 === l)  /*<<float.ml:507:18>>*/ return [0];
+     /*<<float.ml:508:14>>*/ var
+      /*<<float.ml:508:14>>*/ r =
+        /*<<float.ml:508:14>>*/ runtime.caml_make_vect
+        (l,  /*<<float.ml:508:27>>*/ caml_call1(f, a[1])),
+      /*<<float.ml:509:6>>*/ _p_ = l - 1 | 0,
+      /*<<float.ml:508:14>>*/ _o_ = 1;
+    if(_p_ >= 1){
+     var i = _o_;
+     for(;;){
+       /*<<float.ml:510:8>>*/ r[1 + i] =
+        /*<<float.ml:510:29>>*/ caml_call1(f, a[1 + i]);
+       /*<<float.ml:510:8>>*/  /*<<float.ml:510:8>>*/ var _q_ = i + 1 | 0;
+      if(_p_ === i) break;
+      var i = _q_;
+     }
+    }
+     /*<<float.ml:512:6>>*/ return r;
+    /*<<float.ml:513:7>>*/ }
+   function map_from_array(f, a){
+     /*<<float.ml:516:4>>*/ var
+     l = a.length - 1,
+      /*<<float.ml:517:12>>*/ r =
+        /*<<float.ml:517:12>>*/ caml_floatarray_create(l),
+      /*<<float.ml:518:4>>*/ _m_ = l - 1 | 0,
+      /*<<float.ml:517:12>>*/ _l_ = 0;
+    if(_m_ >= 0){
+     var i = _l_;
+     for(;;){
+       /*<<float.ml:519:6>>*/ r[1 + i] =
+        /*<<float.ml:519:21>>*/ caml_call1(f, a[1 + i]);
+       /*<<float.ml:519:6>>*/  /*<<float.ml:519:6>>*/ var _n_ = i + 1 | 0;
+      if(_m_ === i) break;
+      var i = _n_;
+     }
+    }
+     /*<<float.ml:521:4>>*/ return r;
+    /*<<float.ml:521:5>>*/ }
+   var
+    _c_ = caml_floatarray_create,
+    _d_ = caml_array_set,
+    _e_ = caml_array_get,
+    _f_ =
+      [0,
+       function(_k_){ /*<<?>>*/ return _k_.length - 1;},
+       _e_,
+       _d_,
+       make,
+       _c_,
+       init,
+       append,
+       concat,
+       sub,
+       copy,
+       fill,
+       blit,
+       to_list,
+       of_list,
+       iter,
+       iteri,
+       map,
+       mapi,
+       fold_left,
+       fold_right,
+       iter2,
+       map2,
+       for_all,
+       exists,
+       mem,
+       mem_ieee,
+       sort,
+       stable_sort,
+       stable_sort,
+       to_seq,
+       to_seqi,
+       of_seq,
+       map_to_array,
+       map_from_array],
+    _g_ = caml_floatarray_create,
+    _h_ = caml_array_set,
+    _i_ = caml_array_get,
+    Stdlib_Float =
+      [0,
+       zero,
+       one,
+       minus_one,
+       succ,
+       pred,
+       infinity,
+       neg_infinity,
+       nan,
+       pi,
+       max_float,
+       min_float,
+       epsilon,
+       is_finite,
+       is_infinite,
+       is_nan,
+       is_integer,
+       of_string_opt,
+       to_string,
+       caml_float_compare,
+       equal,
+       min,
+       max,
+       min_max,
+       min_num,
+       max_num,
+       min_max_num,
+       hash,
+       [0,
+        function(_j_){ /*<<?>>*/ return _j_.length - 1;},
+        _i_,
+        _h_,
+        make,
+        _g_,
+        init,
+        append,
+        concat,
+        sub,
+        copy,
+        fill,
+        blit,
+        to_list,
+        of_list,
+        iter,
+        iteri,
+        map,
+        mapi,
+        fold_left,
+        fold_right,
+        iter2,
+        map2,
+        for_all,
+        exists,
+        mem,
+        mem_ieee,
+        sort,
+        stable_sort,
+        stable_sort,
+        to_seq,
+        to_seqi,
+        of_seq,
+        map_to_array,
+        map_from_array],
+       _f_];
+   runtime.caml_register_global(22, Stdlib_Float, "Stdlib__Float");
+   return;
+   /*<<?>>*/ }
+  (globalThis));
+
+//# unitInfo: Provides: Stdlib__Int32
+//# unitInfo: Requires: Assert_failure, Stdlib, Stdlib__Sys
+(function
+  (globalThis){
+   "use strict";
+   var
+    runtime = globalThis.jsoo_runtime,
+    caml_greaterequal = runtime.caml_greaterequal,
+    caml_int_compare = runtime.caml_int_compare,
+    caml_maybe_attach_backtrace = runtime.caml_maybe_attach_backtrace,
+    caml_mul = runtime.caml_mul,
+    caml_wrap_exception = runtime.caml_wrap_exception,
+    global_data = runtime.caml_get_global_data(),
+    Stdlib = global_data.Stdlib,
+    Stdlib_Sys = global_data.Stdlib__Sys,
+    Assert_failure = global_data.Assert_failure,
+    _b_ = [0, "int32.ml", 69, 6],
+    zero = 0,
+    one = 1,
+    minus_one = -1;
+   function succ(n){
+     /*<<int32.ml:48:13>>*/ return n + 1 | 0;
+    /*<<int32.ml:48:21>>*/ }
+   function pred(n){
+     /*<<int32.ml:49:13>>*/ return n - 1 | 0;
+    /*<<int32.ml:49:21>>*/ }
+   function abs(n){
+     /*<<int32.ml:50:12>>*/ return  /*<<int32.ml:50:15>>*/ caml_greaterequal
+             (n, 0)
+            ? n
+            : - n | 0;
+    /*<<int32.ml:50:40>>*/ }
+   var min_int = -2147483648, max_int = 2147483647;
+   function lognot(n){
+     /*<<int32.ml:53:15>>*/ return n ^ -1;
+    /*<<int32.ml:53:29>>*/ }
+   var _a_ = Stdlib_Sys[9];
+   if(32 === _a_)
+     /*<<int32.ml:58:6>>*/ var
+      /*<<int32.ml:58:6>>*/ max_int$0 = Stdlib[19],
+     unsigned_to_int =
+       function(n){
+         /*<<int32.ml:60:8>>*/ if
+         (0 >=  /*<<int32.ml:60:11>>*/ caml_int_compare(0, n)
+          && 0 >=  /*<<int32.ml:60:34>>*/ caml_int_compare(n, max_int$0))
+          /*<<int32.ml:61:10>>*/ return [0, n];
+         /*<<int32.ml:63:10>>*/ return 0;
+        /*<<int32.ml:63:14>>*/ };
+   else{
+    if(64 !== _a_)
+      /*<<int32.ml:69:6>>*/ throw  /*<<int32.ml:69:6>>*/ caml_maybe_attach_backtrace
+            ([0, Assert_failure, _b_], 1);
+    var
+     unsigned_to_int =
+       function(n){
+         /*<<int32.ml:67:15>>*/ return [0, n & -1];
+        /*<<int32.ml:67:40>>*/ };
+   }
+   function to_string(n){
+     /*<<int32.ml:72:18>>*/ return  /*<<int32.ml:72:18>>*/ runtime.caml_format_int
+            ("%d", n);
+    /*<<int32.ml:72:31>>*/ }
+   function of_string_opt(s){
+     /*<<int32.ml:78:2>>*/ try{
+      /*<<int32.ml:78:6>>*/  /*<<int32.ml:78:6>>*/ var
+      _d_ = [0,  /*<<int32.ml:78:11>>*/ runtime.caml_int_of_string(s)];
+      /*<<int32.ml:78:6>>*/ return _d_;
+    }
+    catch(_e_){
+     var _c_ = caml_wrap_exception(_e_);
+     if(_c_[1] === Stdlib[7])  /*<<int32.ml:79:20>>*/ return 0;
+     throw caml_maybe_attach_backtrace(_c_, 0);
+    }
+    /*<<int32.ml:79:24>>*/ }
+   var compare = caml_int_compare;
+   function equal(x, y){
+     /*<<int32.ml:84:26>>*/ return 0
+            ===  /*<<int32.ml:84:26>>*/ caml_int_compare(x, y)
+            ? 1
+            : 0;
+    /*<<int32.ml:84:41>>*/ }
+   function unsigned_compare(n, m){
+     /*<<int32.ml:87:2>>*/ return  /*<<int32.ml:87:26>>*/ caml_int_compare
+            (n + 2147483648 | 0, m + 2147483648 | 0);
+    /*<<int32.ml:87:41>>*/ }
+   function min(x, y){
+     /*<<int32.ml:89:18>>*/ return  /*<<int32.ml:89:21>>*/ runtime.caml_lessequal
+             (x, y)
+            ? x
+            : y;
+    /*<<int32.ml:89:41>>*/ }
+   function max(x, y){
+     /*<<int32.ml:90:18>>*/ return  /*<<int32.ml:90:21>>*/ caml_greaterequal
+             (x, y)
+            ? x
+            : y;
+    /*<<int32.ml:90:41>>*/ }
+   function unsigned_div(n, d){
+     /*<<int32.ml:96:2>>*/ if
+     ( /*<<int32.ml:96:5>>*/ runtime.caml_lessthan(d, 0))
+      /*<<int32.ml:97:7>>*/ return 0 <= unsigned_compare(n, d) ? one : zero;
+     /*<<int32.ml:99:12>>*/ var
+      /*<<int32.ml:99:12>>*/ q =
+        /*<<int32.ml:99:23>>*/ runtime.caml_div(n >>> 1 | 0, d) << 1,
+      /*<<int32.ml:100:12>>*/ r =
+       n -  /*<<int32.ml:100:18>>*/ caml_mul(q, d) | 0;
+     /*<<int32.ml:101:7>>*/ return 0 <= unsigned_compare(r, d) ? q + 1 | 0 : q;
+    /*<<int32.ml:101:51>>*/ }
+   function unsigned_rem(n, d){
+     /*<<int32.ml:104:2>>*/ return n
+           -  /*<<int32.ml:104:8>>*/ caml_mul(unsigned_div(n, d), d)
+           | 0;
+    /*<<int32.ml:104:34>>*/ }
+   var
+    Stdlib_Int32 =
+      [0,
+       zero,
+       one,
+       minus_one,
+       unsigned_div,
+       unsigned_rem,
+       succ,
+       pred,
+       abs,
+       max_int,
+       min_int,
+       lognot,
+       unsigned_to_int,
+       of_string_opt,
+       to_string,
+       compare,
+       unsigned_compare,
+       equal,
+       min,
+       max];
+   runtime.caml_register_global(14, Stdlib_Int32, "Stdlib__Int32");
+   return;
+   /*<<?>>*/ }
+  (globalThis));
+
+//# unitInfo: Provides: Stdlib__Int64
+//# unitInfo: Requires: Stdlib
+(function
+  (globalThis){
+   "use strict";
+   var
+    runtime = globalThis.jsoo_runtime,
+    caml_greaterequal = runtime.caml_greaterequal,
+    caml_int64_compare = runtime.caml_int64_compare,
+    caml_int64_mul = runtime.caml_int64_mul,
+    caml_int64_sub = runtime.caml_int64_sub,
+    caml_maybe_attach_backtrace = runtime.caml_maybe_attach_backtrace,
+    caml_wrap_exception = runtime.caml_wrap_exception,
+    global_data = runtime.caml_get_global_data(),
+    zero = runtime.caml_int64_create_lo_mi_hi(0, 0, 0),
+    one = runtime.caml_int64_create_lo_mi_hi(1, 0, 0),
+    minus_one = runtime.caml_int64_create_lo_mi_hi(16777215, 16777215, 65535),
+    min_int = runtime.caml_int64_create_lo_mi_hi(0, 0, 32768),
+    max_int = runtime.caml_int64_create_lo_mi_hi(16777215, 16777215, 32767),
+    Stdlib = global_data.Stdlib,
+    _d_ = runtime.caml_int64_create_lo_mi_hi(16777215, 16777215, 65535),
+    _c_ = runtime.caml_int64_create_lo_mi_hi(0, 0, 0),
+    _b_ = runtime.caml_int64_create_lo_mi_hi(1, 0, 0),
+    _a_ = runtime.caml_int64_create_lo_mi_hi(1, 0, 0);
+   function succ(n){
+     /*<<int64.ml:46:13>>*/ return  /*<<int64.ml:46:13>>*/ runtime.caml_int64_add
+            (n, _a_);
+    /*<<int64.ml:46:21>>*/ }
+   function pred(n){
+     /*<<int64.ml:47:13>>*/ return  /*<<int64.ml:47:13>>*/ caml_int64_sub
+            (n, _b_);
+    /*<<int64.ml:47:21>>*/ }
+   function abs(n){
+     /*<<int64.ml:48:12>>*/ return  /*<<int64.ml:48:15>>*/ caml_greaterequal
+             (n, _c_)
+            ? n
+            :  /*<<int64.ml:48:35>>*/ runtime.caml_int64_neg(n);
+    /*<<int64.ml:48:40>>*/ }
+   function lognot(n){
+     /*<<int64.ml:51:15>>*/ return  /*<<int64.ml:51:15>>*/ runtime.caml_int64_xor
+            (n, _d_);
+    /*<<int64.ml:51:29>>*/ }
+    /*<<int64.ml:54:16>>*/  /*<<int64.ml:54:16>>*/ var
+    max_int$0 =
+       /*<<int64.ml:54:16>>*/ runtime.caml_int64_of_int32(Stdlib[19]);
+   function unsigned_to_int(n){
+     /*<<int64.ml:56:4>>*/ if
+     (0 >=  /*<<int64.ml:56:7>>*/ caml_int64_compare(zero, n)
+      && 0 >=  /*<<int64.ml:56:30>>*/ caml_int64_compare(n, max_int$0))
+      /*<<int64.ml:57:6>>*/ return [0, runtime.caml_int64_to_int32(n)];
+     /*<<int64.ml:59:6>>*/ return 0;
+    /*<<int64.ml:59:10>>*/ }
+   function to_string(n){
+     /*<<int64.ml:62:18>>*/ return  /*<<int64.ml:62:18>>*/ runtime.caml_int64_format
+            ("%d", n);
+    /*<<int64.ml:62:31>>*/ }
+   function of_string_opt(s){
+     /*<<int64.ml:68:2>>*/ try{
+      /*<<int64.ml:68:6>>*/  /*<<int64.ml:68:6>>*/ var
+      _f_ = [0,  /*<<int64.ml:68:11>>*/ runtime.caml_int64_of_string(s)];
+      /*<<int64.ml:68:6>>*/ return _f_;
+    }
+    catch(_g_){
+     var _e_ = caml_wrap_exception(_g_);
+     if(_e_[1] === Stdlib[7])  /*<<int64.ml:69:20>>*/ return 0;
+     throw caml_maybe_attach_backtrace(_e_, 0);
+    }
+    /*<<int64.ml:69:24>>*/ }
+   function compare(x, y){
+     /*<<int64.ml:82:28>>*/ return  /*<<int64.ml:82:28>>*/ caml_int64_compare
+            (x, y);
+    /*<<int64.ml:82:46>>*/ }
+   function equal(x, y){
+     /*<<int64.ml:83:26>>*/ return 0
+            ===  /*<<int64.ml:83:26>>*/ caml_int64_compare(x, y)
+            ? 1
+            : 0;
+    /*<<int64.ml:83:41>>*/ }
+   function unsigned_compare(n, m){
+     /*<<int64.ml:86:2>>*/ return  /*<<int64.ml:86:26>>*/ caml_int64_compare
+            ( /*<<int64.ml:86:10>>*/ caml_int64_sub(n, min_int),
+              /*<<int64.ml:86:26>>*/ caml_int64_sub(m, min_int));
+    /*<<int64.ml:86:41>>*/ }
+   function min(x, y){
+     /*<<int64.ml:88:18>>*/ return  /*<<int64.ml:88:21>>*/ runtime.caml_lessequal
+             (x, y)
+            ? x
+            : y;
+    /*<<int64.ml:88:41>>*/ }
+   function max(x, y){
+     /*<<int64.ml:89:18>>*/ return  /*<<int64.ml:89:21>>*/ caml_greaterequal
+             (x, y)
+            ? x
+            : y;
+    /*<<int64.ml:89:41>>*/ }
+   function unsigned_div(n, d){
+     /*<<int64.ml:95:2>>*/ if
+     ( /*<<int64.ml:95:5>>*/ runtime.caml_lessthan(d, zero))
+      /*<<int64.ml:96:7>>*/ return 0 <= unsigned_compare(n, d) ? one : zero;
+     /*<<int64.ml:98:12>>*/ var
+      /*<<int64.ml:98:12>>*/ q =
+        /*<<int64.ml:98:12>>*/ runtime.caml_int64_shift_left
+        ( /*<<int64.ml:98:23>>*/ runtime.caml_int64_div
+          ( /*<<int64.ml:98:28>>*/ runtime.caml_int64_shift_right_unsigned
+            (n, 1),
+           d),
+         1),
+      /*<<int64.ml:99:12>>*/ r =
+        /*<<int64.ml:99:12>>*/ caml_int64_sub
+        (n,  /*<<int64.ml:99:18>>*/ caml_int64_mul(q, d));
+     /*<<int64.ml:100:7>>*/ return 0 <= unsigned_compare(r, d) ? succ(q) : q;
+    /*<<int64.ml:100:51>>*/ }
+   function unsigned_rem(n, d){
+     /*<<int64.ml:103:2>>*/ return  /*<<int64.ml:103:2>>*/ caml_int64_sub
+            (n,  /*<<int64.ml:103:8>>*/ caml_int64_mul(unsigned_div(n, d), d));
+    /*<<int64.ml:103:34>>*/ }
+   var
+    Stdlib_Int64 =
+      [0,
+       zero,
+       one,
+       minus_one,
+       unsigned_div,
+       unsigned_rem,
+       succ,
+       pred,
+       abs,
+       max_int,
+       min_int,
+       lognot,
+       unsigned_to_int,
+       of_string_opt,
+       to_string,
+       compare,
+       unsigned_compare,
+       equal,
+       min,
+       max];
+   runtime.caml_register_global(11, Stdlib_Int64, "Stdlib__Int64");
+   return;
+   /*<<?>>*/ }
+  (globalThis));
+
+//# unitInfo: Provides: Stdlib__Nativeint
+//# unitInfo: Requires: Stdlib, Stdlib__Sys
+(function
+  (globalThis){
+   "use strict";
+   var
+    runtime = globalThis.jsoo_runtime,
+    caml_greaterequal = runtime.caml_greaterequal,
+    caml_int_compare = runtime.caml_int_compare,
+    caml_maybe_attach_backtrace = runtime.caml_maybe_attach_backtrace,
+    caml_mul = runtime.caml_mul,
+    caml_wrap_exception = runtime.caml_wrap_exception,
+    global_data = runtime.caml_get_global_data(),
+    Stdlib = global_data.Stdlib,
+    Stdlib_Sys = global_data.Stdlib__Sys,
+    zero = 0,
+    one = 1,
+    minus_one = -1;
+   function succ(n){
+     /*<<nativeint.ml:44:13>>*/ return n + 1 | 0;
+    /*<<nativeint.ml:44:21>>*/ }
+   function pred(n){
+     /*<<nativeint.ml:45:13>>*/ return n - 1 | 0;
+    /*<<nativeint.ml:45:21>>*/ }
+   function abs(n){
+     /*<<nativeint.ml:46:12>>*/ return  /*<<nativeint.ml:46:15>>*/ caml_greaterequal
+             (n, 0)
+            ? n
+            : - n | 0;
+    /*<<nativeint.ml:46:40>>*/ }
+    /*<<nativeint.ml:48:14>>*/ var
+    size = Stdlib_Sys[9],
+     /*<<nativeint.ml:48:14>>*/ min_int = 1 << (size - 1 | 0),
+     /*<<nativeint.ml:49:14>>*/ max_int = min_int - 1 | 0;
+   function lognot(n){
+     /*<<nativeint.ml:50:15>>*/ return n ^ -1;
+    /*<<nativeint.ml:50:29>>*/ }
+   var max_int$0 = Stdlib[19];
+   function unsigned_to_int(n){
+     /*<<nativeint.ml:55:4>>*/ if
+     (0 >=  /*<<nativeint.ml:55:7>>*/ caml_int_compare(0, n)
+      && 0 >=  /*<<nativeint.ml:55:30>>*/ caml_int_compare(n, max_int$0))
+      /*<<nativeint.ml:56:6>>*/ return [0, n];
+     /*<<nativeint.ml:58:6>>*/ return 0;
+    /*<<nativeint.ml:58:10>>*/ }
+   function to_string(n){
+     /*<<nativeint.ml:61:18>>*/ return  /*<<nativeint.ml:61:18>>*/ runtime.caml_format_int
+            ("%d", n);
+    /*<<nativeint.ml:61:31>>*/ }
+   function of_string_opt(s){
+     /*<<nativeint.ml:67:2>>*/ try{
+      /*<<nativeint.ml:67:6>>*/  /*<<nativeint.ml:67:6>>*/ var
+      _b_ = [0,  /*<<nativeint.ml:67:11>>*/ runtime.caml_int_of_string(s)];
+      /*<<nativeint.ml:67:6>>*/ return _b_;
+    }
+    catch(_c_){
+     var _a_ = caml_wrap_exception(_c_);
+     if(_a_[1] === Stdlib[7])  /*<<nativeint.ml:68:20>>*/ return 0;
+     throw caml_maybe_attach_backtrace(_a_, 0);
+    }
+    /*<<nativeint.ml:68:24>>*/ }
+   var compare = caml_int_compare;
+   function equal(x, y){
+     /*<<nativeint.ml:73:26>>*/ return 0
+            ===  /*<<nativeint.ml:73:26>>*/ caml_int_compare(x, y)
+            ? 1
+            : 0;
+    /*<<nativeint.ml:73:41>>*/ }
+   function unsigned_compare(n, m){
+     /*<<nativeint.ml:76:2>>*/ return  /*<<nativeint.ml:76:26>>*/ caml_int_compare
+            (n - min_int | 0, m - min_int | 0);
+    /*<<nativeint.ml:76:41>>*/ }
+   function min(x, y){
+     /*<<nativeint.ml:78:18>>*/ return  /*<<nativeint.ml:78:21>>*/ runtime.caml_lessequal
+             (x, y)
+            ? x
+            : y;
+    /*<<nativeint.ml:78:41>>*/ }
+   function max(x, y){
+     /*<<nativeint.ml:79:18>>*/ return  /*<<nativeint.ml:79:21>>*/ caml_greaterequal
+             (x, y)
+            ? x
+            : y;
+    /*<<nativeint.ml:79:41>>*/ }
+   function unsigned_div(n, d){
+     /*<<nativeint.ml:85:2>>*/ if
+     ( /*<<nativeint.ml:85:5>>*/ runtime.caml_lessthan(d, 0))
+      /*<<nativeint.ml:86:7>>*/ return 0 <= unsigned_compare(n, d)
+             ? one
+             : zero;
+     /*<<nativeint.ml:88:12>>*/ var
+      /*<<nativeint.ml:88:12>>*/ q =
+        /*<<nativeint.ml:88:23>>*/ runtime.caml_div(n >>> 1 | 0, d) << 1,
+      /*<<nativeint.ml:89:12>>*/ r =
+       n -  /*<<nativeint.ml:89:18>>*/ caml_mul(q, d) | 0;
+     /*<<nativeint.ml:90:7>>*/ return 0 <= unsigned_compare(r, d)
+            ? q + 1 | 0
+            : q;
+    /*<<nativeint.ml:90:51>>*/ }
+   function unsigned_rem(n, d){
+     /*<<nativeint.ml:93:2>>*/ return n
+           -  /*<<nativeint.ml:93:8>>*/ caml_mul(unsigned_div(n, d), d)
+           | 0;
+    /*<<nativeint.ml:93:34>>*/ }
+   var
+    Stdlib_Nativeint =
+      [0,
+       zero,
+       one,
+       minus_one,
+       unsigned_div,
+       unsigned_rem,
+       succ,
+       pred,
+       abs,
+       size,
+       max_int,
+       min_int,
+       lognot,
+       unsigned_to_int,
+       of_string_opt,
+       to_string,
+       compare,
+       unsigned_compare,
+       equal,
+       min,
+       max];
+   runtime.caml_register_global(12, Stdlib_Nativeint, "Stdlib__Nativeint");
+   return;
+   /*<<?>>*/ }
+  (globalThis));
+
+//# unitInfo: Provides: Stdlib__Lexing
+//# unitInfo: Requires: Stdlib, Stdlib__Bytes, Stdlib__Int, Stdlib__Sys
+(function
+  (globalThis){
+   "use strict";
+   var
+    runtime = globalThis.jsoo_runtime,
+    cst = "",
+    caml_bytes_get = runtime.caml_bytes_get,
+    caml_check_bound = runtime.caml_check_bound,
+    caml_create_bytes = runtime.caml_create_bytes,
+    caml_ml_bytes_length = runtime.caml_ml_bytes_length;
+    /*<<?>>*/ function caml_call1(f, a0){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 1
+            ? f(a0)
+            : runtime.caml_call_gen(f, [a0]);
+   }
+    /*<<?>>*/ function caml_call2(f, a0, a1){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 2
+            ? f(a0, a1)
+            : runtime.caml_call_gen(f, [a0, a1]);
+   }
+    /*<<?>>*/ function caml_call3(f, a0, a1, a2){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 3
+            ? f(a0, a1, a2)
+            : runtime.caml_call_gen(f, [a0, a1, a2]);
+   }
+    /*<<?>>*/ function caml_call4(f, a0, a1, a2, a3){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 4
+            ? f(a0, a1, a2, a3)
+            : runtime.caml_call_gen(f, [a0, a1, a2, a3]);
+   }
+    /*<<?>>*/ function caml_call5(f, a0, a1, a2, a3, a4){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 5
+            ? f(a0, a1, a2, a3, a4)
+            : runtime.caml_call_gen(f, [a0, a1, a2, a3, a4]);
+   }
+   var
+    global_data = runtime.caml_get_global_data(),
+    dummy_pos = [0, cst, 0, 0, -1],
+    zero_pos = [0, cst, 1, 0, 0],
+    Stdlib_Bytes = global_data.Stdlib__Bytes,
+    Stdlib = global_data.Stdlib,
+    Stdlib_Sys = global_data.Stdlib__Sys,
+    Stdlib_Int = global_data.Stdlib__Int,
+    cst_Lexing_lex_refill_cannot_g = "Lexing.lex_refill: cannot grow buffer";
+   function engine(tbl, state, buf){
+     /*<<lexing.ml:65:2>>*/ var
+      /*<<lexing.ml:65:15>>*/ result =
+        /*<<lexing.ml:65:15>>*/ runtime.caml_lex_engine(tbl, state, buf),
+     _F_ = 0 <= result ? 1 : 0,
+     _G_ = _F_ ? buf[12] !== dummy_pos ? 1 : 0 : _F_;
+    if(_G_){
+     buf[11] = buf[12];
+     var _H_ = buf[12];
+     buf[12] = [0, _H_[1], _H_[2], _H_[3], buf[4] + buf[6] | 0];
+    }
+     /*<<lexing.ml:71:2>>*/ return result;
+    /*<<lexing.ml:71:8>>*/ }
+   function new_engine(tbl, state, buf){
+     /*<<lexing.ml:75:2>>*/ var
+      /*<<lexing.ml:75:15>>*/ result =
+        /*<<lexing.ml:75:15>>*/ runtime.caml_new_lex_engine(tbl, state, buf),
+     _C_ = 0 <= result ? 1 : 0,
+     _D_ = _C_ ? buf[12] !== dummy_pos ? 1 : 0 : _C_;
+    if(_D_){
+     buf[11] = buf[12];
+     var _E_ = buf[12];
+     buf[12] = [0, _E_[1], _E_[2], _E_[3], buf[4] + buf[6] | 0];
+    }
+     /*<<lexing.ml:81:2>>*/ return result;
+    /*<<lexing.ml:81:8>>*/ }
+   function from_function(opt, read_fun){
+     /*<<lexing.ml:148:2>>*/ if(opt)
+     var sth = opt[1], with_positions = sth;
+    else
+     var with_positions = 1;
+     /*<<lexing.ml:148:2>>*/ var
+      /*<<lexing.ml:148:2>>*/ _o_ = with_positions ? zero_pos : dummy_pos,
+     _p_ = with_positions ? zero_pos : dummy_pos,
+      /*<<lexing.ml:148:31>>*/ aux_buffer =
+        /*<<lexing.ml:148:31>>*/ caml_create_bytes(512),
+     _q_ = [0],
+      /*<<lexing.ml:156:14>>*/ _r_ = 0,
+     _s_ = 0,
+     _t_ = 0,
+     _u_ = 0,
+     _v_ = 0,
+     _w_ = 0,
+     _x_ = 0,
+      /*<<lexing.ml:149:17>>*/ _y_ =
+        /*<<lexing.ml:149:17>>*/ caml_create_bytes(1024);
+     /*<<lexing.ml:148:2>>*/ return [0,
+            function(lexbuf){
+              /*<<lexing.ml:85:4>>*/ var
+               /*<<lexing.ml:85:4>>*/ read =
+                 /*<<lexing.ml:85:4>>*/ caml_call2
+                 (read_fun, aux_buffer, caml_ml_bytes_length(aux_buffer)),
+               /*<<lexing.ml:86:2>>*/ n = 0 < read ? read : (lexbuf[9] = 1, 0);
+             if(caml_ml_bytes_length(lexbuf[2]) < (lexbuf[3] + n | 0)){
+              if
+               (((lexbuf[3] - lexbuf[5] | 0) + n | 0)
+                <= caml_ml_bytes_length(lexbuf[2]))
+                /*<<lexing.ml:100:9>>*/  /*<<lexing.ml:100:9>>*/ caml_call5
+                (Stdlib_Bytes[11],
+                 lexbuf[2],
+                 lexbuf[5],
+                 lexbuf[2],
+                 0,
+                 lexbuf[3] - lexbuf[5] | 0);
+              else{
+                /*<<lexing.ml:111:8>>*/  /*<<lexing.ml:111:8>>*/ var
+                newlen =
+                   /*<<lexing.ml:111:8>>*/ caml_call2
+                   (Stdlib_Int[10],
+                    2 * caml_ml_bytes_length(lexbuf[2]) | 0,
+                    Stdlib_Sys[12]);
+               if(newlen < ((lexbuf[3] - lexbuf[5] | 0) + n | 0))
+                 /*<<lexing.ml:113:11>>*/  /*<<lexing.ml:113:11>>*/ caml_call1
+                 (Stdlib[2], cst_Lexing_lex_refill_cannot_g);
+                /*<<lexing.ml:114:19>>*/  /*<<lexing.ml:114:19>>*/ var
+                newbuf =  /*<<lexing.ml:114:19>>*/ caml_create_bytes(newlen);
+                /*<<lexing.ml:116:6>>*/  /*<<lexing.ml:116:6>>*/ caml_call5
+                (Stdlib_Bytes[11],
+                 lexbuf[2],
+                 lexbuf[5],
+                 newbuf,
+                 0,
+                 lexbuf[3] - lexbuf[5] | 0);
+               lexbuf[2] = newbuf;
+              }
+              var s = lexbuf[5];
+              lexbuf[4] = lexbuf[4] + s | 0;
+              lexbuf[6] = lexbuf[6] - s | 0;
+              lexbuf[5] = 0;
+              lexbuf[7] = lexbuf[7] - s | 0;
+              lexbuf[3] = lexbuf[3] - s | 0;
+              var t = lexbuf[10], _A_ = t.length - 1 - 1 | 0, _z_ = 0;
+              if(_A_ >= 0){
+               var i = _z_;
+               for(;;){
+                 /*<<lexing.ml:131:14>>*/  /*<<lexing.ml:131:14>>*/ var
+                 v = caml_check_bound(t, i)[1 + i];
+                if(0 <= v)
+                  /*<<lexing.ml:133:8>>*/ caml_check_bound(t, i)[1 + i] = v - s | 0;
+                 /*<<lexing.ml:130:4>>*/  /*<<lexing.ml:130:4>>*/ var
+                 _B_ = i + 1 | 0;
+                if(_A_ === i) break;
+                var i = _B_;
+               }
+              }
+             }
+              /*<<lexing.ml:137:2>>*/  /*<<lexing.ml:137:2>>*/ caml_call5
+              (Stdlib_Bytes[11], aux_buffer, 0, lexbuf[2], lexbuf[3], n);
+             lexbuf[3] = lexbuf[3] + n | 0;
+             return 0;
+            },
+            _y_,
+            _x_,
+            _w_,
+            _v_,
+            _u_,
+            _t_,
+            _s_,
+            _r_,
+            _q_,
+            _p_,
+            _o_];
+    /*<<lexing.ml:160:3>>*/ }
+   function from_channel(with_positions, ic){
+     /*<<lexing.ml:163:2>>*/ return from_function
+            (with_positions,
+             function(buf, n){
+               /*<<lexing.ml:163:46>>*/ return  /*<<lexing.ml:163:46>>*/ caml_call4
+                      (Stdlib[84], ic, buf, 0, n);
+              /*<<lexing.ml:163:62>>*/ });
+    /*<<lexing.ml:163:63>>*/ }
+   function from_string(opt, s){
+     /*<<lexing.ml:166:2>>*/ if(opt)
+     var sth = opt[1], with_positions = sth;
+    else
+     var with_positions = 1;
+     /*<<lexing.ml:166:2>>*/ var
+      /*<<lexing.ml:166:2>>*/ _d_ = with_positions ? zero_pos : dummy_pos,
+     _e_ = with_positions ? zero_pos : dummy_pos,
+     _f_ = [0],
+      /*<<lexing.ml:175:14>>*/ _g_ = 1,
+     _h_ = 0,
+     _i_ = 0,
+     _j_ = 0,
+     _k_ = 0,
+     _l_ = 0,
+     _m_ = runtime.caml_ml_string_length(s),
+      /*<<lexing.ml:167:17>>*/ _n_ =
+        /*<<lexing.ml:167:17>>*/ caml_call1(Stdlib_Bytes[5], s);
+     /*<<lexing.ml:166:2>>*/ return [0,
+            function(lexbuf){
+              /*<<lexing.ml:166:33>>*/ lexbuf[9] = 1;
+             return 0;
+             /*<<lexing.ml:166:63>>*/ },
+            _n_,
+            _m_,
+            _l_,
+            _k_,
+            _j_,
+            _i_,
+            _h_,
+            _g_,
+            _f_,
+            _e_,
+            _d_];
+    /*<<lexing.ml:179:3>>*/ }
+   function set_position(lexbuf, position){
+     /*<<lexing.ml:182:2>>*/ lexbuf[12] =
+     [0, lexbuf[12][1], position[2], position[3], position[4]];
+    lexbuf[4] = position[4];
+    return 0;
+    /*<<lexing.ml:183:41>>*/ }
+   function set_filename(lexbuf, fname){
+     /*<<lexing.ml:186:2>>*/ var _c_ = lexbuf[12];
+    lexbuf[12] = [0, fname, _c_[2], _c_[3], _c_[4]];
+    return 0;
+    /*<<lexing.ml:186:65>>*/ }
+   function with_positions(lexbuf){
+     /*<<lexing.ml:188:28>>*/ return lexbuf[12] !== dummy_pos ? 1 : 0;
+    /*<<lexing.ml:188:58>>*/ }
+   function lexeme(lexbuf){
+     /*<<lexing.ml:191:2>>*/ var len = lexbuf[6] - lexbuf[5] | 0;
+     /*<<lexing.ml:192:2>>*/ return  /*<<lexing.ml:192:2>>*/ caml_call3
+            (Stdlib_Bytes[8], lexbuf[2], lexbuf[5], len);
+    /*<<lexing.ml:192:61>>*/ }
+   function sub_lexeme(lexbuf, i1, i2){
+     /*<<lexing.ml:195:2>>*/ var len = i2 - i1 | 0;
+     /*<<lexing.ml:196:2>>*/ return  /*<<lexing.ml:196:2>>*/ caml_call3
+            (Stdlib_Bytes[8], lexbuf[2], i1, len);
+    /*<<lexing.ml:196:43>>*/ }
+   function sub_lexeme_opt(lexbuf, i1, i2){
+     /*<<lexing.ml:199:2>>*/ if(0 > i1)  /*<<lexing.ml:202:11>>*/ return 0;
+    var len = i2 - i1 | 0;
+     /*<<lexing.ml:201:4>>*/ return [0,
+             /*<<lexing.ml:201:9>>*/ caml_call3
+             (Stdlib_Bytes[8], lexbuf[2], i1, len)];
+    /*<<lexing.ml:204:5>>*/ }
+   function sub_lexeme_char(lexbuf, i){
+     /*<<lexing.ml:206:31>>*/ return  /*<<lexing.ml:206:31>>*/ caml_bytes_get
+            (lexbuf[2], i);
+    /*<<lexing.ml:206:60>>*/ }
+   function sub_lexeme_char_opt(lexbuf, i){
+     /*<<lexing.ml:209:2>>*/ return 0 <= i
+            ? [0,  /*<<lexing.ml:210:9>>*/ caml_bytes_get(lexbuf[2], i)]
+            : 0;
+    /*<<lexing.ml:212:8>>*/ }
+   function lexeme_char(lexbuf, i){
+     /*<<lexing.ml:216:2>>*/ return  /*<<lexing.ml:216:2>>*/ caml_bytes_get
+            (lexbuf[2], lexbuf[5] + i | 0);
+    /*<<lexing.ml:216:56>>*/ }
+   function lexeme_start(lexbuf){
+     /*<<lexing.ml:218:26>>*/ return lexbuf[11][4];
+    /*<<lexing.ml:218:53>>*/ }
+   function lexeme_end(lexbuf){
+     /*<<lexing.ml:219:24>>*/ return lexbuf[12][4];
+    /*<<lexing.ml:219:50>>*/ }
+   function lexeme_start_p(lexbuf){
+     /*<<lexing.ml:221:28>>*/ return lexbuf[11];
+    /*<<lexing.ml:221:46>>*/ }
+   function lexeme_end_p(lexbuf){
+     /*<<lexing.ml:222:26>>*/ return lexbuf[12];
+    /*<<lexing.ml:222:43>>*/ }
+   function new_line(lexbuf){
+     /*<<lexing.ml:225:2>>*/ var
+     lcp = lexbuf[12],
+     _a_ = lcp !== dummy_pos ? 1 : 0,
+     _b_ =
+       _a_
+        ? (lexbuf[12] = [0, lcp[1], lcp[2] + 1 | 0, lcp[4], lcp[4]], 0)
+        : _a_;
+    return _b_;
+    /*<<lexing.ml:231:7>>*/ }
+   function flush_input(lb){
+     /*<<lexing.ml:238:2>>*/ lb[6] = 0;
+    lb[4] = 0;
+    var lcp = lb[12];
+    if(lcp !== dummy_pos)
+     lb[12] = [0, lcp[1], zero_pos[2], zero_pos[3], zero_pos[4]];
+    lb[3] = 0;
+    return 0;
+    /*<<lexing.ml:243:25>>*/ }
+   var
+    Stdlib_Lexing =
+      [0,
+       dummy_pos,
+       from_channel,
+       from_string,
+       from_function,
+       set_position,
+       set_filename,
+       with_positions,
+       lexeme,
+       lexeme_char,
+       lexeme_start,
+       lexeme_end,
+       lexeme_start_p,
+       lexeme_end_p,
+       new_line,
+       flush_input,
+       sub_lexeme,
+       sub_lexeme_opt,
+       sub_lexeme_char,
+       sub_lexeme_char_opt,
+       engine,
+       new_engine];
+   runtime.caml_register_global(7, Stdlib_Lexing, "Stdlib__Lexing");
+   return;
+   /*<<?>>*/ }
+  (globalThis));
+
+//# unitInfo: Provides: Stdlib__Parsing
+//# unitInfo: Requires: Stdlib, Stdlib__Array, Stdlib__Lexing, Stdlib__Obj
+(function
+  (globalThis){
+   "use strict";
+   var
+    runtime = globalThis.jsoo_runtime,
+    caml_check_bound = runtime.caml_check_bound,
+    caml_fresh_oo_id = runtime.caml_fresh_oo_id,
+    caml_make_vect = runtime.caml_make_vect,
+    caml_maybe_attach_backtrace = runtime.caml_maybe_attach_backtrace,
+    caml_wrap_exception = runtime.caml_wrap_exception;
+    /*<<?>>*/ function caml_call1(f, a0){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 1
+            ? f(a0)
+            : runtime.caml_call_gen(f, [a0]);
+   }
+    /*<<?>>*/ function caml_call4(f, a0, a1, a2, a3){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 4
+            ? f(a0, a1, a2, a3)
+            : runtime.caml_call_gen(f, [a0, a1, a2, a3]);
+   }
+    /*<<?>>*/ function caml_call5(f, a0, a1, a2, a3, a4){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 5
+            ? f(a0, a1, a2, a3, a4)
+            : runtime.caml_call_gen(f, [a0, a1, a2, a3, a4]);
+   }
+    /*<<parsing.ml:59:0>>*/ var
+    global_data = runtime.caml_get_global_data(),
+    Stdlib_Obj = global_data.Stdlib__Obj,
+    Stdlib_Array = global_data.Stdlib__Array,
+    Stdlib_Lexing = global_data.Stdlib__Lexing,
+     /*<<parsing.ml:59:0>>*/ YYexit =
+      [248, "Stdlib.Parsing.YYexit", caml_fresh_oo_id(0)],
+     /*<<parsing.ml:60:0>>*/ Parse_error =
+      [248, "Stdlib.Parsing.Parse_error", caml_fresh_oo_id(0)],
+     /*<<parsing.ml:90:2>>*/ env =
+      [0,
+        /*<<parsing.ml:90:14>>*/ caml_make_vect(100, 0),
+        /*<<parsing.ml:91:14>>*/ caml_make_vect(100, 0),
+        /*<<parsing.ml:92:23>>*/ caml_make_vect(100, Stdlib_Lexing[1]),
+        /*<<parsing.ml:93:21>>*/ caml_make_vect(100, Stdlib_Lexing[1]),
+       100,
+       0,
+       0,
+       0,
+       Stdlib_Lexing[1],
+       Stdlib_Lexing[1],
+       0,
+       0,
+       0,
+       0,
+       0,
+       0],
+    cst_syntax_error = "syntax error";
+   function grow_stacks(param){
+     /*<<parsing.ml:108:2>>*/ var
+     oldsize = env[5],
+     newsize = oldsize * 2 | 0,
+      /*<<parsing.ml:110:14>>*/ new_s =
+        /*<<parsing.ml:110:14>>*/ caml_make_vect(newsize, 0),
+      /*<<parsing.ml:111:14>>*/ new_v =
+        /*<<parsing.ml:111:14>>*/ caml_make_vect(newsize, 0),
+      /*<<parsing.ml:112:18>>*/ new_start =
+        /*<<parsing.ml:112:18>>*/ caml_make_vect(newsize, Stdlib_Lexing[1]),
+      /*<<parsing.ml:113:16>>*/ new_end =
+        /*<<parsing.ml:113:16>>*/ caml_make_vect(newsize, Stdlib_Lexing[1]);
+     /*<<parsing.ml:114:4>>*/  /*<<parsing.ml:114:4>>*/ caml_call5
+     (Stdlib_Array[8], env[1], 0, new_s, 0, oldsize);
+    env[1] = new_s;
+     /*<<parsing.ml:116:4>>*/  /*<<parsing.ml:116:4>>*/ caml_call5
+     (Stdlib_Array[8], env[2], 0, new_v, 0, oldsize);
+    env[2] = new_v;
+     /*<<parsing.ml:118:4>>*/  /*<<parsing.ml:118:4>>*/ caml_call5
+     (Stdlib_Array[8], env[3], 0, new_start, 0, oldsize);
+    env[3] = new_start;
+     /*<<parsing.ml:120:4>>*/  /*<<parsing.ml:120:4>>*/ caml_call5
+     (Stdlib_Array[8], env[4], 0, new_end, 0, oldsize);
+    env[4] = new_end;
+    env[5] = newsize;
+    return 0;
+    /*<<parsing.ml:122:28>>*/ }
+   function clear_parser(param){
+     /*<<parsing.ml:125:2>>*/  /*<<parsing.ml:125:2>>*/ caml_call4
+     (Stdlib_Array[7], env[2], 0, env[5], 0);
+    env[8] = 0;
+    return 0;
+    /*<<parsing.ml:126:25>>*/ }
+    /*<<parsing.ml:128:28>>*/  /*<<parsing.ml:128:28>>*/ var
+    current_lookahead_fun =
+      [0,
+       function(param){
+         /*<<parsing.ml:128:52>>*/ return 0;
+        /*<<parsing.ml:128:57>>*/ }];
+   function yyparse(tables, start, lexer, lexbuf){
+     /*<<parsing.ml:131:2>>*/ var
+     init_asp = env[11],
+     init_sp = env[14],
+     init_stackbase = env[6],
+     init_state = env[15],
+     init_curr_char = env[7],
+     init_lval = env[8],
+     init_errflag = env[16];
+    env[6] = env[14] + 1 | 0;
+    env[7] = start;
+    env[10] = lexbuf[12];
+     /*<<parsing.ml:164:2>>*/ try{
+     var cmd = 0, arg = 0;
+      /*<<parsing.ml:132:4>>*/ for(;;)
+      switch
+       ( /*<<parsing.ml:132:10>>*/ runtime.caml_parse_engine
+         (tables, env, cmd, arg)){
+        case 0:
+          /*<<parsing.ml:134:24>>*/  /*<<parsing.ml:134:24>>*/ var
+          arg$0 =  /*<<parsing.ml:134:24>>*/ caml_call1(lexer, lexbuf);
+         env[9] = lexbuf[11];
+         env[10] = lexbuf[12];
+         var cmd = 1, arg = arg$0;
+         break;
+        case 1:
+          /*<<parsing.ml:139:8>>*/ throw  /*<<parsing.ml:139:8>>*/ caml_maybe_attach_backtrace
+                (Parse_error, 1);
+        case 2:
+          /*<<parsing.ml:148:8>>*/ grow_stacks(0);
+         var cmd = 2, arg = 0;
+         break;
+        case 3:
+          /*<<parsing.ml:150:8>>*/ grow_stacks(0);
+         var cmd = 3, arg = 0;
+         break;
+        case 4:
+         try{
+           /*<<parsing.ml:143:39>>*/ var
+           _i_ = env[13],
+            /*<<parsing.ml:143:39>>*/ _j_ =
+              /*<<parsing.ml:143:39>>*/ caml_call1
+              (caml_check_bound(tables[1], _i_)[1 + _i_], env),
+            /*<<parsing.ml:143:39>>*/ _k_ = 4,
+           value = _j_,
+           action = _k_;
+         }
+         catch(_m_){
+          var _h_ = caml_wrap_exception(_m_);
+          if(_h_ !== Parse_error) throw caml_maybe_attach_backtrace(_h_, 0);
+          var value = 0, action = 5;
+         }
+         var cmd = action, arg = value;
+         break;
+        default:
+          /*<<parsing.ml:152:8>>*/  /*<<parsing.ml:152:8>>*/ caml_call1
+          (tables[14], cst_syntax_error);
+         var cmd = 5, arg = 0;
+      }
+    }
+    catch(exn$0){
+      /*<<parsing.ml:167:4>>*/ var
+      exn = caml_wrap_exception(exn$0),
+       /*<<parsing.ml:167:4>>*/ curr_char = env[7];
+     env[11] = init_asp;
+     env[14] = init_sp;
+     env[6] = init_stackbase;
+     env[15] = init_state;
+     env[7] = init_curr_char;
+     env[8] = init_lval;
+     env[16] = init_errflag;
+     if(exn[1] === YYexit){
+      var v = exn[2];
+       /*<<parsing.ml:177:8>>*/ return v;
+     }
+     current_lookahead_fun[1] =
+      function(tok){
+        /*<<parsing.ml:181:12>>*/ if
+        (!  /*<<parsing.ml:181:15>>*/ caml_call1(Stdlib_Obj[1], tok))
+         /*<<parsing.ml:183:17>>*/ return caml_check_bound(tables[2], tok)
+                 [1 + tok]
+                === curr_char
+                ? 1
+                : 0;
+        /*<<parsing.ml:182:38>>*/  /*<<parsing.ml:182:38>>*/ var
+        _l_ =  /*<<parsing.ml:182:38>>*/ runtime.caml_obj_tag(tok);
+        /*<<parsing.ml:182:17>>*/ return caml_check_bound(tables[3], _l_)
+                [1 + _l_]
+               === curr_char
+               ? 1
+               : 0;
+       /*<<parsing.ml:183:64>>*/ };
+      /*<<parsing.ml:184:8>>*/ throw  /*<<parsing.ml:184:8>>*/ caml_maybe_attach_backtrace
+            (exn, 0);
+    }
+    /*<<parsing.ml:184:17>>*/ }
+   function peek_val(env, n){
+     /*<<parsing.ml:187:2>>*/ var _g_ = env[11] - n | 0;
+     /*<<parsing.ml:187:12>>*/ return caml_check_bound(env[2], _g_)[1 + _g_];
+    /*<<parsing.ml:187:37>>*/ }
+   function symbol_start_pos(param){
+     /*<<parsing.ml:190:2>>*/ var i$1 = env[12], i = i$1;
+     /*<<parsing.ml:191:4>>*/ for(;;){
+     if(0 >= i){
+      var _f_ = env[11];
+       /*<<parsing.ml:191:19>>*/ return caml_check_bound(env[4], _f_)[1 + _f_];
+     }
+      /*<<parsing.ml:193:15>>*/ var
+      _d_ = (env[11] - i | 0) + 1 | 0,
+       /*<<parsing.ml:193:15>>*/ st = caml_check_bound(env[3], _d_)[1 + _d_],
+      _e_ = (env[11] - i | 0) + 1 | 0,
+       /*<<parsing.ml:194:15>>*/ en = caml_check_bound(env[4], _e_)[1 + _e_];
+      /*<<parsing.ml:195:9>>*/ if
+      ( /*<<parsing.ml:195:9>>*/ runtime.caml_notequal(st, en))
+       /*<<parsing.ml:195:23>>*/ return st;
+      /*<<parsing.ml:195:31>>*/ var
+       /*<<parsing.ml:195:31>>*/ i$0 = i - 1 | 0,
+      i = i$0;
+    }
+    /*<<parsing.ml:198:19>>*/ }
+   function symbol_end_pos(param){
+     /*<<parsing.ml:200:24>>*/ var _c_ = env[11];
+     /*<<parsing.ml:200:24>>*/ return caml_check_bound(env[4], _c_)[1 + _c_];
+    /*<<parsing.ml:200:52>>*/ }
+   function rhs_start_pos(n){
+     /*<<parsing.ml:201:22>>*/ var _b_ = env[11] - (env[12] - n | 0) | 0;
+     /*<<parsing.ml:201:22>>*/ return caml_check_bound(env[3], _b_)[1 + _b_];
+    /*<<parsing.ml:201:73>>*/ }
+   function rhs_end_pos(n){
+     /*<<parsing.ml:202:20>>*/ var _a_ = env[11] - (env[12] - n | 0) | 0;
+     /*<<parsing.ml:202:20>>*/ return caml_check_bound(env[4], _a_)[1 + _a_];
+    /*<<parsing.ml:202:69>>*/ }
+   function symbol_start(param){
+     /*<<parsing.ml:204:22>>*/ return symbol_start_pos(0)[4];
+    /*<<parsing.ml:204:52>>*/ }
+   function symbol_end(param){
+     /*<<parsing.ml:205:20>>*/ return symbol_end_pos(0)[4];
+    /*<<parsing.ml:205:48>>*/ }
+   function rhs_start(n){
+     /*<<parsing.ml:206:18>>*/ return rhs_start_pos(n)[4];
+    /*<<parsing.ml:206:44>>*/ }
+   function rhs_end(n){
+     /*<<parsing.ml:207:16>>*/ return rhs_end_pos(n)[4];
+    /*<<parsing.ml:207:40>>*/ }
+   function is_current_lookahead(tok){
+     /*<<parsing.ml:210:2>>*/ return  /*<<parsing.ml:210:2>>*/ caml_call1
+            (current_lookahead_fun[1], tok);
+    /*<<parsing.ml:210:40>>*/ }
+   function parse_error(param){
+     /*<<parsing.ml:212:31>>*/ return 0;
+    /*<<parsing.ml:212:33>>*/ }
+   var
+    Stdlib_Parsing =
+      [0,
+       symbol_start,
+       symbol_end,
+       rhs_start,
+       rhs_end,
+       symbol_start_pos,
+       symbol_end_pos,
+       rhs_start_pos,
+       rhs_end_pos,
+       clear_parser,
+       Parse_error,
+       runtime.caml_set_parser_trace,
+       YYexit,
+       yyparse,
+       peek_val,
+       is_current_lookahead,
+       parse_error];
+   runtime.caml_register_global(7, Stdlib_Parsing, "Stdlib__Parsing");
+   return;
+   /*<<?>>*/ }
+  (globalThis));
+
+//# unitInfo: Provides: Stdlib__Set
+//# unitInfo: Requires: Assert_failure, Stdlib, Stdlib__List, Stdlib__Seq
+(function
+  (globalThis){
+   "use strict";
+   var
+    runtime = globalThis.jsoo_runtime,
+    cst_Set_bal$3 = "Set.bal",
+    caml_maybe_attach_backtrace = runtime.caml_maybe_attach_backtrace;
+    /*<<?>>*/ function caml_call1(f, a0){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 1
+            ? f(a0)
+            : runtime.caml_call_gen(f, [a0]);
+   }
+    /*<<?>>*/ function caml_call2(f, a0, a1){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 2
+            ? f(a0, a1)
+            : runtime.caml_call_gen(f, [a0, a1]);
+   }
+    /*<<?>>*/ function caml_call3(f, a0, a1, a2){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 3
+            ? f(a0, a1, a2)
+            : runtime.caml_call_gen(f, [a0, a1, a2]);
+   }
+   var
+    global_data = runtime.caml_get_global_data(),
+    Stdlib = global_data.Stdlib,
+    Stdlib_Seq = global_data.Stdlib__Seq,
+    Stdlib_List = global_data.Stdlib__List,
+    Assert_failure = global_data.Assert_failure,
+    cst_Set_remove_min_elt = "Set.remove_min_elt",
+    _a_ = [0, 0, 0, 0],
+    _b_ = [0, 0, 0],
+    _c_ = [0, "set.ml", 570, 18],
+    cst_Set_bal = cst_Set_bal$3,
+    cst_Set_bal$0 = cst_Set_bal$3,
+    cst_Set_bal$1 = cst_Set_bal$3,
+    cst_Set_bal$2 = cst_Set_bal$3,
+    Stdlib_Set =
+      [0,
+       function(Ord){
+        function height(param){
+          /*<<set.ml:80:17>>*/ if(! param)  /*<<set.ml:81:17>>*/ return 0;
+         var h = param[4];
+          /*<<set.ml:82:20>>*/ return h;
+         /*<<set.ml:82:21>>*/ }
+        function create(l, v, r){
+          /*<<set.ml:90:6>>*/ if(l) var h = l[4], hl = h; else var hl = 0;
+          /*<<set.ml:91:6>>*/ if(r) var h$0 = r[4], hr = h$0; else var hr = 0;
+         var _Z_ = hr <= hl ? hl + 1 | 0 : hr + 1 | 0;
+          /*<<set.ml:92:10>>*/ return [0, l, v, r, _Z_];
+         /*<<set.ml:92:60>>*/ }
+        function bal(l, v, r){
+          /*<<set.ml:100:6>>*/ if(l) var h = l[4], hl = h; else var hl = 0;
+          /*<<set.ml:101:6>>*/ if(r)
+          var h$0 = r[4], hr = h$0;
+         else
+          var hr = 0;
+         if((hr + 2 | 0) < hl){
+          if(! l)
+            /*<<set.ml:104:19>>*/ return  /*<<set.ml:104:19>>*/ caml_call1
+                   (Stdlib[1], cst_Set_bal$0);
+           /*<<set.ml:106:28>>*/ var
+           lr = l[3],
+           lv = l[2],
+           ll = l[1],
+            /*<<set.ml:106:28>>*/ _U_ = height(lr);
+          if(_U_ <= height(ll))
+            /*<<set.ml:107:27>>*/ return create(ll, lv, create(lr, v, r));
+          if(! lr)
+            /*<<set.ml:110:25>>*/ return  /*<<set.ml:110:25>>*/ caml_call1
+                   (Stdlib[1], cst_Set_bal);
+           /*<<set.ml:112:48>>*/ var
+           lrr = lr[3],
+           lrv = lr[2],
+           lrl = lr[1],
+            /*<<set.ml:112:48>>*/ _V_ = create(lrr, v, r);
+           /*<<set.ml:112:48>>*/ return create(create(ll, lv, lrl), lrv, _V_);
+         }
+         if((hl + 2 | 0) >= hr){
+          var _Y_ = hr <= hl ? hl + 1 | 0 : hr + 1 | 0;
+           /*<<set.ml:127:12>>*/ return [0, l, v, r, _Y_];
+         }
+         if(! r)
+           /*<<set.ml:116:19>>*/ return  /*<<set.ml:116:19>>*/ caml_call1
+                  (Stdlib[1], cst_Set_bal$2);
+          /*<<set.ml:118:28>>*/ var
+          rr = r[3],
+          rv = r[2],
+          rl = r[1],
+           /*<<set.ml:118:28>>*/ _W_ = height(rl);
+         if(_W_ <= height(rr))
+           /*<<set.ml:119:14>>*/ return create(create(l, v, rl), rv, rr);
+         if(! rl)
+           /*<<set.ml:122:25>>*/ return  /*<<set.ml:122:25>>*/ caml_call1
+                  (Stdlib[1], cst_Set_bal$1);
+          /*<<set.ml:124:46>>*/ var
+          rlr = rl[3],
+          rlv = rl[2],
+          rll = rl[1],
+           /*<<set.ml:124:46>>*/ _X_ = create(rlr, rv, rr);
+          /*<<set.ml:124:46>>*/ return create(create(l, v, rll), rlv, _X_);
+         /*<<set.ml:127:62>>*/ }
+        function add(x, t){
+          /*<<?>>*/ if(! t)  /*<<set.ml:132:21>>*/ return [0, 0, x, 0, 1];
+          /*<<set.ml:134:18>>*/ var
+          r = t[3],
+          v = t[2],
+          l = t[1],
+           /*<<set.ml:134:18>>*/ c =
+             /*<<set.ml:134:18>>*/ caml_call2(Ord[1], x, v);
+          /*<<set.ml:135:10>>*/ if(0 === c)  /*<<set.ml:135:24>>*/ return t;
+         if(0 <= c){
+           /*<<set.ml:140:21>>*/  /*<<set.ml:140:21>>*/ var rr = add(x, r);
+          return r === rr ? t : bal(l, v, rr);
+         }
+          /*<<set.ml:137:21>>*/  /*<<set.ml:137:21>>*/ var ll = add(x, l);
+         return l === ll ? t : bal(ll, v, r);
+        }
+        function singleton(x){
+          /*<<set.ml:143:22>>*/ return [0, 0, x, 0, 1];
+         /*<<set.ml:143:54>>*/ }
+        function add_min_element(x, param){
+          /*<<?>>*/ if(! param)  /*<<set.ml:153:17>>*/ return singleton(x);
+         var r = param[3], v = param[2], l = param[1];
+          /*<<set.ml:155:8>>*/ return bal(add_min_element(x, l), v, r);
+        }
+        function add_max_element(x, param){
+          /*<<?>>*/ if(! param)  /*<<set.ml:158:17>>*/ return singleton(x);
+         var r = param[3], v = param[2], l = param[1];
+          /*<<set.ml:160:16>>*/ return bal(l, v, add_max_element(x, r));
+        }
+        function join(l, v, r){
+          /*<<set.ml:166:6>>*/ if(! l)
+           /*<<set.ml:167:22>>*/ return add_min_element(v, r);
+         if(! r)  /*<<set.ml:168:22>>*/ return add_max_element(v, l);
+         var
+          rh = r[4],
+          rr = r[3],
+          rv = r[2],
+          rl = r[1],
+          lh = l[4],
+          lr = l[3],
+          lv = l[2],
+          ll = l[1];
+         return (rh + 2 | 0) < lh
+                 ? bal(ll, lv, join(lr, v, r))
+                 : (lh
+                   + 2
+                   | 0)
+                   < rh
+                   ? bal(join(l, v, rl), rv, rr)
+                   : create(l, v, r);
+         /*<<set.ml:172:22>>*/ }
+        function min_elt(param){
+          /*<<set.ml:176:22>>*/ var param$0 = param;
+          /*<<set.ml:176:22>>*/ for(;;){
+          if(! param$0)
+            /*<<set.ml:177:17>>*/ throw  /*<<set.ml:177:17>>*/ caml_maybe_attach_backtrace
+                  (Stdlib[8], 1);
+          var l = param$0[1];
+          if(! l){var v = param$0[2];  /*<<set.ml:178:28>>*/ return v;}
+          var param$0 = l;
+         }
+         /*<<set.ml:179:28>>*/ }
+        function min_elt_opt(param){
+          /*<<set.ml:181:26>>*/ var param$0 = param;
+          /*<<set.ml:181:26>>*/ for(;;){
+          if(! param$0)  /*<<set.ml:182:17>>*/ return 0;
+          var l = param$0[1];
+          if(! l){var v = param$0[2];  /*<<set.ml:183:28>>*/ return [0, v];}
+          var param$0 = l;
+         }
+         /*<<set.ml:184:32>>*/ }
+        function max_elt(param){
+          /*<<set.ml:186:22>>*/ var param$0 = param;
+          /*<<set.ml:186:22>>*/ for(;;){
+          if(! param$0)
+            /*<<set.ml:187:17>>*/ throw  /*<<set.ml:187:17>>*/ caml_maybe_attach_backtrace
+                  (Stdlib[8], 1);
+          if(! param$0[3]){
+           var v = param$0[2];
+            /*<<set.ml:188:28>>*/ return v;
+          }
+          var r = param$0[3], param$0 = r;
+         }
+         /*<<set.ml:189:28>>*/ }
+        function max_elt_opt(param){
+          /*<<set.ml:191:26>>*/ var param$0 = param;
+          /*<<set.ml:191:26>>*/ for(;;){
+          if(! param$0)  /*<<set.ml:192:17>>*/ return 0;
+          if(! param$0[3]){
+           var v = param$0[2];
+            /*<<set.ml:193:28>>*/ return [0, v];
+          }
+          var r = param$0[3], param$0 = r;
+         }
+         /*<<set.ml:194:32>>*/ }
+        function remove_min_elt(param){
+          /*<<set.ml:198:29>>*/ if(! param)
+           /*<<set.ml:199:17>>*/ return  /*<<set.ml:199:17>>*/ caml_call1
+                  (Stdlib[1], cst_Set_remove_min_elt);
+         var l = param[1];
+         if(l){
+          var r = param[3], v = param[2];
+           /*<<set.ml:201:25>>*/ return bal(remove_min_elt(l), v, r);
+         }
+         var r$0 = param[3];
+          /*<<set.ml:200:28>>*/ return r$0;
+         /*<<set.ml:201:51>>*/ }
+        function concat(t1, t2){
+          /*<<set.ml:218:6>>*/ if(! t1)  /*<<set.ml:219:22>>*/ return t2;
+         if(! t2)  /*<<set.ml:220:22>>*/ return t1;
+          /*<<set.ml:221:39>>*/  /*<<set.ml:221:39>>*/ var
+          _T_ = remove_min_elt(t2);
+          /*<<set.ml:221:39>>*/ return join(t1, min_elt(t2), _T_);
+         /*<<set.ml:221:58>>*/ }
+        function split(x, param){
+          /*<<?>>*/ if(! param)  /*<<set.ml:231:10>>*/ return _a_;
+          /*<<set.ml:233:18>>*/ var
+          r = param[3],
+          v = param[2],
+          l = param[1],
+           /*<<set.ml:233:18>>*/ c =
+             /*<<set.ml:233:18>>*/ caml_call2(Ord[1], x, v);
+          /*<<set.ml:234:10>>*/ if(0 === c)
+           /*<<set.ml:234:24>>*/ return [0, l, 1, r];
+         if(0 <= c){
+           /*<<set.ml:238:33>>*/ var
+            /*<<set.ml:238:33>>*/ match = split(x, r),
+           rr = match[3],
+           pres = match[2],
+           lr = match[1];
+           /*<<set.ml:238:46>>*/ return [0, join(l, v, lr), pres, rr];
+         }
+          /*<<set.ml:236:33>>*/ var
+           /*<<set.ml:236:33>>*/ match$0 = split(x, l),
+          rl = match$0[3],
+          pres$0 = match$0[2],
+          ll = match$0[1];
+          /*<<set.ml:236:46>>*/ return [0, ll, pres$0, join(rl, v, r)];
+        }
+        var empty = 0;
+        function is_empty(param){
+          /*<<set.ml:244:19>>*/ return param ? 0 : 1;
+         /*<<set.ml:244:54>>*/ }
+        function mem(x, param){
+         var param$0 = param;
+         for(;;){
+          if(! param$0)  /*<<set.ml:247:17>>*/ return 0;
+           /*<<set.ml:249:18>>*/ var
+           r = param$0[3],
+           v = param$0[2],
+           l = param$0[1],
+            /*<<set.ml:249:18>>*/ c =
+              /*<<set.ml:249:18>>*/ caml_call2(Ord[1], x, v),
+           _S_ = 0 === c ? 1 : 0;
+          if(_S_) return _S_;
+          var r$0 = 0 <= c ? r : l, param$0 = r$0;
+         }
+        }
+        function remove(x, t){
+          /*<<?>>*/ if(! t)  /*<<set.ml:253:17>>*/ return 0;
+          /*<<set.ml:255:18>>*/ var
+          t2 = t[3],
+          v = t[2],
+          t1 = t[1],
+           /*<<set.ml:255:18>>*/ c =
+             /*<<set.ml:255:18>>*/ caml_call2(Ord[1], x, v);
+          /*<<set.ml:256:10>>*/ if(0 === c){
+          if(! t1)  /*<<set.ml:209:22>>*/ return t2;
+          if(! t2)  /*<<set.ml:210:22>>*/ return t1;
+           /*<<set.ml:211:38>>*/  /*<<set.ml:211:38>>*/ var
+           _R_ = remove_min_elt(t2);
+           /*<<set.ml:211:38>>*/ return bal(t1, min_elt(t2), _R_);
+         }
+         if(0 <= c){
+           /*<<set.ml:263:23>>*/  /*<<set.ml:263:23>>*/ var
+           rr = remove(x, t2);
+          return t2 === rr ? t : bal(t1, v, rr);
+         }
+          /*<<set.ml:259:23>>*/  /*<<set.ml:259:23>>*/ var ll = remove(x, t1);
+         return t1 === ll ? t : bal(ll, v, t2);
+        }
+        function union(s1, s2){
+          /*<<set.ml:268:6>>*/ if(! s1)  /*<<set.ml:269:23>>*/ return s2;
+         if(! s2)  /*<<set.ml:270:23>>*/ return s1;
+         var
+          h2 = s2[4],
+          r2 = s2[3],
+          v2 = s2[2],
+          l2 = s2[1],
+          h1 = s1[4],
+          r1 = s1[3],
+          v1 = s1[2],
+          l1 = s1[1];
+         if(h2 <= h1){
+          if(1 === h2)  /*<<set.ml:273:27>>*/ return add(v2, s1);
+           /*<<set.ml:274:32>>*/ var
+            /*<<set.ml:274:32>>*/ match = split(v1, s2),
+           r2$0 = match[3],
+           l2$0 = match[1],
+            /*<<set.ml:275:36>>*/ _P_ = union(r1, r2$0);
+           /*<<set.ml:275:36>>*/ return join(union(l1, l2$0), v1, _P_);
+         }
+         if(1 === h1)  /*<<set.ml:278:27>>*/ return add(v1, s2);
+          /*<<set.ml:279:32>>*/ var
+           /*<<set.ml:279:32>>*/ match$0 = split(v2, s1),
+          r1$0 = match$0[3],
+          l1$0 = match$0[1],
+           /*<<set.ml:280:36>>*/ _Q_ = union(r1$0, r2);
+          /*<<set.ml:280:36>>*/ return join(union(l1$0, l2), v2, _Q_);
+         /*<<set.ml:281:15>>*/ }
+        function inter(s1, s2){
+          /*<<set.ml:284:6>>*/ if(! s1)  /*<<set.ml:285:22>>*/ return 0;
+         if(! s2)  /*<<set.ml:286:22>>*/ return 0;
+          /*<<set.ml:288:16>>*/ var
+          r1 = s1[3],
+          v1 = s1[2],
+          l1 = s1[1],
+           /*<<set.ml:288:16>>*/ _M_ = split(v1, s2),
+          l2 = _M_[1];
+         if(_M_[2]){
+           /*<<set.ml:292:36>>*/ var
+           r2 = _M_[3],
+            /*<<set.ml:292:36>>*/ _N_ = inter(r1, r2);
+           /*<<set.ml:292:36>>*/ return join(inter(l1, l2), v1, _N_);
+         }
+          /*<<set.ml:290:35>>*/ var
+          r2$0 = _M_[3],
+           /*<<set.ml:290:35>>*/ _O_ = inter(r1, r2$0);
+          /*<<set.ml:290:35>>*/ return concat(inter(l1, l2), _O_);
+         /*<<set.ml:292:49>>*/ }
+        function split_bis(x, param){
+          /*<<?>>*/ if(! param)
+           /*<<set.ml:304:10>>*/ return [0,
+                  0,
+                  function(param){
+                    /*<<set.ml:304:38>>*/ return 0;
+                   /*<<set.ml:304:43>>*/ }];
+          /*<<set.ml:306:18>>*/ var
+          r = param[3],
+          v = param[2],
+          l = param[1],
+           /*<<set.ml:306:18>>*/ c =
+             /*<<set.ml:306:18>>*/ caml_call2(Ord[1], x, v);
+          /*<<set.ml:307:10>>*/ if(0 === c)  /*<<set.ml:307:24>>*/ return 0;
+         if(0 <= c){
+           /*<<set.ml:313:18>>*/  /*<<set.ml:313:18>>*/ var
+           match = split_bis(x, r);
+          if(! match)  /*<<set.ml:314:23>>*/ return 0;
+          var rr = match[2], lr = match[1];
+           /*<<set.ml:315:35>>*/ return [0, join(l, v, lr), rr];
+         }
+          /*<<set.ml:309:18>>*/  /*<<set.ml:309:18>>*/ var
+          match$0 = split_bis(x, l);
+         if(! match$0)  /*<<set.ml:310:23>>*/ return 0;
+         var rl = match$0[2], ll = match$0[1];
+          /*<<set.ml:311:35>>*/ return [0,
+                 ll,
+                 function(param){
+                   /*<<set.ml:311:60>>*/ return join(rl(0), v, r);
+                  /*<<set.ml:311:76>>*/ }];
+        }
+        function disjoint(s1, s2){
+          /*<<set.ml:318:6>>*/ var s1$0 = s1, s2$0 = s2;
+          /*<<set.ml:318:6>>*/ for(;;){
+          if(s1$0 && s2$0){
+           var r1 = s1$0[3], v1 = s1$0[2], l1 = s1$0[1];
+           if(s1$0 === s2$0)  /*<<set.ml:321:27>>*/ return 0;
+            /*<<set.ml:322:21>>*/  /*<<set.ml:322:21>>*/ var
+            match = split_bis(v1, s2$0);
+           if(! match)  /*<<set.ml:324:23>>*/ return 0;
+            /*<<set.ml:323:34>>*/ var
+            r2 = match[2],
+            l2 = match[1],
+             /*<<set.ml:323:34>>*/ _L_ = disjoint(l1, l2);
+            /*<<set.ml:323:34>>*/ if(! _L_)  /*<<set.ml:323:34>>*/ return _L_;
+            /*<<set.ml:323:64>>*/ var
+             /*<<set.ml:323:64>>*/ s2$1 = r2(0),
+            s1$0 = r1,
+            s2$0 = s2$1;
+           continue;
+          }
+           /*<<set.ml:319:35>>*/ return 1;
+         }
+         /*<<set.ml:324:28>>*/ }
+        function diff(s1, s2){
+          /*<<set.ml:327:6>>*/ if(! s1)  /*<<set.ml:328:22>>*/ return 0;
+         if(! s2)  /*<<set.ml:329:23>>*/ return s1;
+          /*<<set.ml:331:16>>*/ var
+          r1 = s1[3],
+          v1 = s1[2],
+          l1 = s1[1],
+           /*<<set.ml:331:16>>*/ _I_ = split(v1, s2),
+          l2 = _I_[1];
+         if(_I_[2]){
+           /*<<set.ml:335:34>>*/ var
+           r2 = _I_[3],
+            /*<<set.ml:335:34>>*/ _J_ = diff(r1, r2);
+           /*<<set.ml:335:34>>*/ return concat(diff(l1, l2), _J_);
+         }
+          /*<<set.ml:333:35>>*/ var
+          r2$0 = _I_[3],
+           /*<<set.ml:333:35>>*/ _K_ = diff(r1, r2$0);
+          /*<<set.ml:333:35>>*/ return join(diff(l1, l2), v1, _K_);
+         /*<<set.ml:335:46>>*/ }
+        function cons_enum(s, e){
+          /*<<set.ml:340:6>>*/ var s$0 = s, e$0 = e;
+          /*<<set.ml:340:6>>*/ for(;;){
+          if(! s$0)  /*<<set.ml:341:17>>*/ return e$0;
+           /*<<set.ml:342:37>>*/ var
+           r = s$0[3],
+           v = s$0[2],
+           l = s$0[1],
+            /*<<set.ml:342:37>>*/ e$1 = [0, v, r, e$0],
+           s$0 = l,
+           e$0 = e$1;
+         }
+         /*<<set.ml:342:52>>*/ }
+        function compare(s1, s2){
+          /*<<set.ml:356:6>>*/ var
+           /*<<set.ml:356:37>>*/ e2$2 = cons_enum(s2, 0),
+           /*<<set.ml:356:18>>*/ e1$2 = cons_enum(s1, 0),
+          e1 = e1$2,
+          e2 = e2$2;
+          /*<<set.ml:345:8>>*/ for(;;){
+          if(! e1) return e2 ? -1 : 0;
+          if(! e2)  /*<<set.ml:348:20>>*/ return 1;
+           /*<<set.ml:350:18>>*/ var
+           e2$0 = e2[3],
+           r2 = e2[2],
+           v2 = e2[1],
+           e1$0 = e1[3],
+           r1 = e1[2],
+           v1 = e1[1],
+            /*<<set.ml:350:18>>*/ c =
+              /*<<set.ml:350:18>>*/ caml_call2(Ord[1], v1, v2);
+           /*<<set.ml:351:10>>*/ if(0 !== c)  /*<<set.ml:352:15>>*/ return c;
+           /*<<set.ml:353:45>>*/ var
+            /*<<set.ml:353:45>>*/ e2$1 = cons_enum(r2, e2$0),
+            /*<<set.ml:353:27>>*/ e1$1 = cons_enum(r1, e1$0),
+           e1 = e1$1,
+           e2 = e2$1;
+         }
+         /*<<set.ml:356:55>>*/ }
+        function equal(s1, s2){
+          /*<<set.ml:359:6>>*/ return 0 === compare(s1, s2) ? 1 : 0;
+         /*<<set.ml:359:23>>*/ }
+        function subset(s1, s2){
+          /*<<set.ml:362:6>>*/ var s1$0 = s1, s2$0 = s2;
+          /*<<set.ml:362:6>>*/ for(;;){
+          if(! s1$0)  /*<<set.ml:364:10>>*/ return 1;
+          if(! s2$0)  /*<<set.ml:366:10>>*/ return 0;
+           /*<<set.ml:368:18>>*/ var
+           r2 = s2$0[3],
+           v2 = s2$0[2],
+           l2 = s2$0[1],
+           r1 = s1$0[3],
+           v1 = s1$0[2],
+           l1 = s1$0[1],
+            /*<<set.ml:368:18>>*/ c =
+              /*<<set.ml:368:18>>*/ caml_call2(Ord[1], v1, v2);
+           /*<<set.ml:369:10>>*/ if(0 === c){
+            /*<<set.ml:370:12>>*/  /*<<set.ml:370:12>>*/ var
+            _F_ = subset(l1, l2);
+            /*<<set.ml:370:12>>*/ if(! _F_)  /*<<set.ml:370:12>>*/ return _F_;
+           var s1$0 = r1, s2$0 = r2;
+          }
+          else if(0 <= c){
+            /*<<set.ml:374:12>>*/  /*<<set.ml:374:12>>*/ var
+            _G_ = subset([0, 0, v1, r1, 0], r2);
+            /*<<set.ml:374:12>>*/ if(! _G_)  /*<<set.ml:374:12>>*/ return _G_;
+           var s1$0 = l1;
+          }
+          else{
+            /*<<set.ml:372:12>>*/  /*<<set.ml:372:12>>*/ var
+            _H_ = subset([0, l1, v1, 0, 0], l2);
+            /*<<set.ml:372:12>>*/ if(! _H_)  /*<<set.ml:372:12>>*/ return _H_;
+           var s1$0 = r1;
+          }
+         }
+         /*<<set.ml:374:71>>*/ }
+        function iter(f, param){
+         var param$0 = param;
+         for(;;){
+          if(! param$0)  /*<<set.ml:377:17>>*/ return 0;
+          var r = param$0[3], v = param$0[2], l = param$0[1];
+           /*<<set.ml:378:25>>*/ iter(f, l);
+           /*<<set.ml:378:35>>*/  /*<<set.ml:378:35>>*/ caml_call1(f, v);
+          var param$0 = r;
+         }
+        }
+        function fold(f, s, accu){
+          /*<<set.ml:381:6>>*/ var s$0 = s, accu$0 = accu;
+          /*<<set.ml:381:6>>*/ for(;;){
+          if(! s$0)  /*<<set.ml:382:17>>*/ return accu$0;
+           /*<<set.ml:383:34>>*/ var
+           r = s$0[3],
+           v = s$0[2],
+           l = s$0[1],
+            /*<<set.ml:383:34>>*/ accu$1 =
+              /*<<set.ml:383:34>>*/ caml_call2(f, v, fold(f, l, accu$0)),
+           s$0 = r,
+           accu$0 = accu$1;
+         }
+         /*<<set.ml:383:55>>*/ }
+        function for_all(p, param){
+         var param$0 = param;
+         for(;;){
+          if(! param$0)  /*<<set.ml:386:17>>*/ return 1;
+           /*<<set.ml:387:25>>*/ var
+           r = param$0[3],
+           v = param$0[2],
+           l = param$0[1],
+            /*<<set.ml:387:25>>*/ _C_ =
+              /*<<set.ml:387:25>>*/ caml_call1(p, v);
+           /*<<set.ml:387:25>>*/ if(_C_){
+            /*<<set.ml:387:32>>*/  /*<<set.ml:387:32>>*/ var
+            _D_ = for_all(p, l);
+            /*<<set.ml:387:32>>*/ if(_D_){var param$0 = r; continue;}
+           var _E_ = _D_;
+          }
+          else
+           var _E_ = _C_;
+           /*<<set.ml:387:32>>*/ return _E_;
+         }
+        }
+        function exists(p, param){
+         var param$0 = param;
+         for(;;){
+          if(! param$0)  /*<<set.ml:390:17>>*/ return 0;
+           /*<<set.ml:391:25>>*/ var
+           r = param$0[3],
+           v = param$0[2],
+           l = param$0[1],
+            /*<<set.ml:391:25>>*/ _z_ =
+              /*<<set.ml:391:25>>*/ caml_call1(p, v);
+           /*<<set.ml:391:25>>*/ if(_z_)
+           var _A_ = _z_;
+          else{
+            /*<<set.ml:391:32>>*/  /*<<set.ml:391:32>>*/ var
+            _B_ = exists(p, l);
+            /*<<set.ml:391:32>>*/ if(! _B_){var param$0 = r; continue;}
+           var _A_ = _B_;
+          }
+           /*<<set.ml:391:25>>*/ return _A_;
+         }
+        }
+        function filter(p, t){
+          /*<<?>>*/ if(! t)  /*<<set.ml:394:17>>*/ return 0;
+          /*<<set.ml:397:19>>*/ var
+          r = t[3],
+          v = t[2],
+          l = t[1],
+           /*<<set.ml:397:19>>*/ l$0 = filter(p, l),
+           /*<<set.ml:398:19>>*/ pv =  /*<<set.ml:398:19>>*/ caml_call1(p, v),
+           /*<<set.ml:399:19>>*/ r$0 = filter(p, r);
+          /*<<set.ml:400:10>>*/ if(! pv)
+           /*<<set.ml:402:15>>*/ return concat(l$0, r$0);
+         if(l === l$0 && r === r$0)  /*<<set.ml:401:35>>*/ return t;
+          /*<<set.ml:401:42>>*/ return join(l$0, v, r$0);
+        }
+        function partition(p, param){
+          /*<<?>>*/ if(! param)  /*<<set.ml:405:17>>*/ return _b_;
+          /*<<set.ml:408:25>>*/ var
+          r = param[3],
+          v = param[2],
+          l = param[1],
+           /*<<set.ml:408:25>>*/ match = partition(p, l),
+          lf = match[2],
+          lt = match[1],
+           /*<<set.ml:409:19>>*/ pv =  /*<<set.ml:409:19>>*/ caml_call1(p, v),
+           /*<<set.ml:410:25>>*/ match$0 = partition(p, r),
+          rf = match$0[2],
+          rt = match$0[1];
+          /*<<set.ml:411:10>>*/ if(pv){
+           /*<<set.ml:412:30>>*/  /*<<set.ml:412:30>>*/ var
+           _x_ = concat(lf, rf);
+           /*<<set.ml:412:15>>*/ return [0, join(lt, v, rt), _x_];
+         }
+          /*<<set.ml:413:30>>*/  /*<<set.ml:413:30>>*/ var
+          _y_ = join(lf, v, rf);
+          /*<<set.ml:413:15>>*/ return [0, concat(lt, rt), _y_];
+        }
+        function cardinal(param){
+          /*<<set.ml:415:23>>*/ if(! param)  /*<<set.ml:416:17>>*/ return 0;
+          /*<<set.ml:417:39>>*/ var
+          r = param[3],
+          l = param[1],
+           /*<<set.ml:417:39>>*/ _w_ = cardinal(r);
+         return (cardinal(l) + 1 | 0) + _w_ | 0;
+         /*<<set.ml:417:49>>*/ }
+        function elements_aux(accu, param){
+         var accu$0 = accu, param$0 = param;
+         for(;;){
+          if(! param$0)  /*<<set.ml:420:17>>*/ return accu$0;
+           /*<<set.ml:421:38>>*/ var
+           r = param$0[3],
+           v = param$0[2],
+           l = param$0[1],
+            /*<<set.ml:421:38>>*/ accu$1 = [0, v, elements_aux(accu$0, r)],
+           accu$0 = accu$1,
+           param$0 = l;
+         }
+        }
+        function elements(s){
+          /*<<set.ml:424:6>>*/ return elements_aux(0, s);
+         /*<<set.ml:424:23>>*/ }
+        function find(x, param){
+         var param$0 = param;
+         for(;;){
+          if(! param$0)
+            /*<<set.ml:431:17>>*/ throw  /*<<set.ml:431:17>>*/ caml_maybe_attach_backtrace
+                  (Stdlib[8], 1);
+           /*<<set.ml:433:18>>*/ var
+           r = param$0[3],
+           v = param$0[2],
+           l = param$0[1],
+            /*<<set.ml:433:18>>*/ c =
+              /*<<set.ml:433:18>>*/ caml_call2(Ord[1], x, v);
+           /*<<set.ml:434:10>>*/ if(0 === c)  /*<<set.ml:434:24>>*/ return v;
+          var r$0 = 0 <= c ? r : l, param$0 = r$0;
+         }
+        }
+        function find_first(f, param$0){
+         var param$1 = param$0;
+         for(;;){
+          if(! param$1)
+            /*<<set.ml:448:10>>*/ throw  /*<<set.ml:448:10>>*/ caml_maybe_attach_backtrace
+                  (Stdlib[8], 1);
+          var r$0 = param$1[3], v0$1 = param$1[2], l$0 = param$1[1];
+           /*<<set.ml:450:13>>*/ if
+           ( /*<<set.ml:450:13>>*/ caml_call1(f, v0$1)){
+           var v0 = v0$1, param = l$0;
+           for(;;){
+            if(! param)  /*<<set.ml:439:10>>*/ return v0;
+            var r = param[3], v0$0 = param[2], l = param[1];
+             /*<<set.ml:441:13>>*/ if
+             ( /*<<set.ml:441:13>>*/ caml_call1(f, v0$0))
+             var v0 = v0$0, param = l;
+            else
+             var param = r;
+           }
+          }
+          else
+           var param$1 = r$0;
+         }
+        }
+        function find_first_opt(f, param$0){
+         var param$1 = param$0;
+         for(;;){
+          if(! param$1)  /*<<set.ml:466:10>>*/ return 0;
+          var r$0 = param$1[3], v0$1 = param$1[2], l$0 = param$1[1];
+           /*<<set.ml:468:13>>*/ if
+           ( /*<<set.ml:468:13>>*/ caml_call1(f, v0$1)){
+           var v0 = v0$1, param = l$0;
+           for(;;){
+            if(! param)  /*<<set.ml:457:10>>*/ return [0, v0];
+            var r = param[3], v0$0 = param[2], l = param[1];
+             /*<<set.ml:459:13>>*/ if
+             ( /*<<set.ml:459:13>>*/ caml_call1(f, v0$0))
+             var v0 = v0$0, param = l;
+            else
+             var param = r;
+           }
+          }
+          else
+           var param$1 = r$0;
+         }
+        }
+        function find_last(f, param$0){
+         var param$1 = param$0;
+         for(;;){
+          if(! param$1)
+            /*<<set.ml:484:10>>*/ throw  /*<<set.ml:484:10>>*/ caml_maybe_attach_backtrace
+                  (Stdlib[8], 1);
+          var r$0 = param$1[3], v0$1 = param$1[2], l$0 = param$1[1];
+           /*<<set.ml:486:13>>*/ if
+           ( /*<<set.ml:486:13>>*/ caml_call1(f, v0$1)){
+           var v0 = v0$1, param = r$0;
+           for(;;){
+            if(! param)  /*<<set.ml:475:10>>*/ return v0;
+            var r = param[3], v0$0 = param[2], l = param[1];
+             /*<<set.ml:477:13>>*/ if
+             ( /*<<set.ml:477:13>>*/ caml_call1(f, v0$0))
+             var v0 = v0$0, param = r;
+            else
+             var param = l;
+           }
+          }
+          else
+           var param$1 = l$0;
+         }
+        }
+        function find_last_opt(f, param$0){
+         var param$1 = param$0;
+         for(;;){
+          if(! param$1)  /*<<set.ml:502:10>>*/ return 0;
+          var r$0 = param$1[3], v0$1 = param$1[2], l$0 = param$1[1];
+           /*<<set.ml:504:13>>*/ if
+           ( /*<<set.ml:504:13>>*/ caml_call1(f, v0$1)){
+           var v0 = v0$1, param = r$0;
+           for(;;){
+            if(! param)  /*<<set.ml:493:10>>*/ return [0, v0];
+            var r = param[3], v0$0 = param[2], l = param[1];
+             /*<<set.ml:495:13>>*/ if
+             ( /*<<set.ml:495:13>>*/ caml_call1(f, v0$0))
+             var v0 = v0$0, param = r;
+            else
+             var param = l;
+           }
+          }
+          else
+           var param$1 = l$0;
+         }
+        }
+        function find_opt(x, param){
+         var param$0 = param;
+         for(;;){
+          if(! param$0)  /*<<set.ml:510:17>>*/ return 0;
+           /*<<set.ml:512:18>>*/ var
+           r = param$0[3],
+           v = param$0[2],
+           l = param$0[1],
+            /*<<set.ml:512:18>>*/ c =
+              /*<<set.ml:512:18>>*/ caml_call2(Ord[1], x, v);
+           /*<<set.ml:513:10>>*/ if(0 === c)
+            /*<<set.ml:513:24>>*/ return [0, v];
+          var r$0 = 0 <= c ? r : l, param$0 = r$0;
+         }
+        }
+        function try_join(l, v, r){
+          /*<<set.ml:520:6>>*/ a:
+         {
+          if(0 !== l){
+            /*<<set.ml:520:35>>*/  /*<<set.ml:520:35>>*/ var _v_ = max_elt(l);
+            /*<<set.ml:520:23>>*/ if
+            (0 <=  /*<<set.ml:520:23>>*/ caml_call2(Ord[1], _v_, v))
+            break a;
+          }
+          if(0 !== r){
+            /*<<set.ml:521:37>>*/  /*<<set.ml:521:37>>*/ var _u_ = min_elt(r);
+            /*<<set.ml:521:23>>*/ if
+            (0 <=  /*<<set.ml:521:23>>*/ caml_call2(Ord[1], v, _u_))
+            break a;
+          }
+           /*<<set.ml:522:11>>*/ return join(l, v, r);
+         }
+          /*<<set.ml:523:19>>*/ return union(l, add(v, r));
+         /*<<set.ml:523:28>>*/ }
+        function map(f, t){
+          /*<<?>>*/ if(! t)  /*<<set.ml:526:17>>*/ return 0;
+          /*<<set.ml:529:18>>*/ var
+          r = t[3],
+          v = t[2],
+          l = t[1],
+           /*<<set.ml:529:18>>*/ l$0 = map(f, l),
+           /*<<set.ml:530:18>>*/ v$0 =  /*<<set.ml:530:18>>*/ caml_call1(f, v),
+           /*<<set.ml:531:18>>*/ r$0 = map(f, r);
+         if(l === l$0 && v === v$0 && r === r$0)
+           /*<<set.ml:532:47>>*/ return t;
+          /*<<set.ml:533:14>>*/ return try_join(l$0, v$0, r$0);
+        }
+        function filter_map(f, t){
+          /*<<?>>*/ if(! t)  /*<<set.ml:542:17>>*/ return 0;
+          /*<<set.ml:545:18>>*/ var
+          r = t[3],
+          v = t[2],
+          l = t[1],
+           /*<<set.ml:545:18>>*/ t1 = filter_map(f, l),
+           /*<<set.ml:546:18>>*/ v$0 =  /*<<set.ml:546:18>>*/ caml_call1(f, v),
+           /*<<set.ml:547:18>>*/ t2 = filter_map(f, r);
+          /*<<set.ml:548:9>>*/ if(v$0){
+          var v$1 = v$0[1];
+          if(l === t1 && v === v$1 && r === t2)
+            /*<<set.ml:550:52>>*/ return t;
+           /*<<set.ml:551:19>>*/ return try_join(t1, v$1, t2);
+         }
+         if(! t1)  /*<<set.ml:537:22>>*/ return t2;
+         if(! t2)  /*<<set.ml:538:22>>*/ return t1;
+          /*<<set.ml:539:43>>*/  /*<<set.ml:539:43>>*/ var
+          _t_ = remove_min_elt(t2);
+          /*<<set.ml:539:43>>*/ return try_join(t1, min_elt(t2), _t_);
+        }
+        function of_list(l){
+          /*<<set.ml:578:6>>*/ if(! l) return empty;
+         var _o_ = l[2], x0 = l[1];
+         if(! _o_)  /*<<set.ml:580:16>>*/ return singleton(x0);
+         var _p_ = _o_[2], x1 = _o_[1];
+         if(! _p_)  /*<<set.ml:581:27>>*/ return add(x1, singleton(x0));
+         var _q_ = _p_[2], x2 = _p_[1];
+         if(! _q_)
+           /*<<set.ml:582:31>>*/ return add(x2, add(x1, singleton(x0)));
+         var _r_ = _q_[2], x3 = _q_[1];
+         if(! _r_)
+           /*<<set.ml:583:35>>*/ return add
+                  (x3, add(x2, add(x1, singleton(x0))));
+         if(_r_[2]){
+           /*<<set.ml:585:28>>*/ var
+            /*<<set.ml:585:28>>*/ l$0 =
+              /*<<set.ml:585:28>>*/ caml_call2(Stdlib_List[59], Ord[1], l),
+           sub =
+             function(n, l){
+               /*<<set.ml:558:8>>*/ if(3 >= n >>> 0)
+               switch(n){
+                 case 0:
+                   /*<<set.ml:559:18>>*/ return [0, 0, l];
+                 case 1:
+                  if(l){
+                   var l$3 = l[2], x0 = l[1];
+                    /*<<set.ml:560:24>>*/ return [0, [0, 0, x0, 0, 1], l$3];
+                  }
+                  break;
+                 case 2:
+                  if(l){
+                   var match$1 = l[2];
+                   if(match$1){
+                    var l$4 = match$1[2], x1 = match$1[1], x0$0 = l[1];
+                     /*<<set.ml:562:12>>*/ return [0,
+                            [0, [0, 0, x0$0, 0, 1], x1, 0, 2],
+                            l$4];
+                   }
+                  }
+                  break;
+                 default:
+                  if(l){
+                   var _s_ = l[2];
+                   if(_s_){
+                    var match$2 = _s_[2];
+                    if(match$2){
+                     var
+                      l$5 = match$2[2],
+                      x2 = match$2[1],
+                      x1$0 = _s_[1],
+                      x0$1 = l[1];
+                      /*<<set.ml:564:12>>*/ return [0,
+                             [0, [0, 0, x0$1, 0, 1], x1$0, [0, 0, x2, 0, 1], 2],
+                             l$5];
+                    }
+                   }
+                  }
+               }
+               /*<<set.ml:568:24>>*/ var
+               nl = n / 2 | 0,
+                /*<<set.ml:568:24>>*/ match = sub(nl, l),
+               l$0 = match[2],
+               left = match[1];
+               /*<<set.ml:569:10>>*/ if(! l$0)
+                /*<<set.ml:570:18>>*/ throw  /*<<set.ml:570:18>>*/ caml_maybe_attach_backtrace
+                      ([0, Assert_failure, _c_], 1);
+               /*<<set.ml:572:27>>*/ var
+               l$1 = l$0[2],
+               mid = l$0[1],
+                /*<<set.ml:572:27>>*/ match$0 = sub((n - nl | 0) - 1 | 0, l$1),
+               l$2 = match$0[2],
+               right = match$0[1];
+               /*<<set.ml:573:12>>*/ return [0, create(left, mid, right), l$2];
+              /*<<set.ml:573:36>>*/ };
+           /*<<set.ml:575:10>>*/ return sub
+                   ( /*<<set.ml:575:15>>*/ caml_call1(Stdlib_List[1], l$0),
+                    l$0)
+                  [1];
+         }
+         var x4 = _r_[1];
+          /*<<set.ml:584:39>>*/ return add
+                 (x4, add(x3, add(x2, add(x1, singleton(x0)))));
+         /*<<set.ml:585:58>>*/ }
+        function add_seq(i, m){
+         function _n_(s, x){
+           /*<<set.ml:588:32>>*/ return add(x, s);
+          /*<<set.ml:588:39>>*/ }
+          /*<<set.ml:588:6>>*/ return  /*<<set.ml:588:6>>*/ caml_call3
+                 (Stdlib_Seq[5], _n_, m, i);
+         /*<<set.ml:588:44>>*/ }
+        function of_seq(i){
+          /*<<set.ml:590:19>>*/ return add_seq(i, empty);
+         /*<<set.ml:590:34>>*/ }
+        function seq_of_enum(c, param){
+          /*<<set.ml:592:32>>*/ if(! c)  /*<<set.ml:593:15>>*/ return 0;
+          /*<<set.ml:594:55>>*/ var
+          rest = c[3],
+          t = c[2],
+          x = c[1],
+           /*<<set.ml:594:55>>*/ _l_ = cons_enum(t, rest);
+          /*<<set.ml:594:29>>*/ return [0,
+                 x,
+                 function(_m_){ /*<<?>>*/ return seq_of_enum(_l_, _m_);}];
+         /*<<set.ml:594:74>>*/ }
+        function to_seq(c){
+          /*<<set.ml:596:19>>*/  /*<<set.ml:596:32>>*/ var
+          _j_ = cons_enum(c, 0);
+          /*<<set.ml:596:32>>*/ return function(_k_){
+           /*<<?>>*/ return seq_of_enum(_j_, _k_);};
+         /*<<set.ml:596:49>>*/ }
+        function snoc_enum(s, e){
+          /*<<set.ml:599:6>>*/ var s$0 = s, e$0 = e;
+          /*<<set.ml:599:6>>*/ for(;;){
+          if(! s$0)  /*<<set.ml:600:17>>*/ return e$0;
+           /*<<set.ml:601:37>>*/ var
+           r = s$0[3],
+           v = s$0[2],
+           l = s$0[1],
+            /*<<set.ml:601:37>>*/ e$1 = [0, v, l, e$0],
+           s$0 = r,
+           e$0 = e$1;
+         }
+         /*<<set.ml:601:52>>*/ }
+        function rev_seq_of_enum(c, param){
+          /*<<set.ml:603:36>>*/ if(! c)  /*<<set.ml:604:15>>*/ return 0;
+          /*<<set.ml:605:59>>*/ var
+          rest = c[3],
+          t = c[2],
+          x = c[1],
+           /*<<set.ml:605:59>>*/ _h_ = snoc_enum(t, rest);
+          /*<<set.ml:605:29>>*/ return [0,
+                 x,
+                 function(_i_){ /*<<?>>*/ return rev_seq_of_enum(_h_, _i_);}];
+         /*<<set.ml:605:78>>*/ }
+        function to_rev_seq(c){
+          /*<<set.ml:607:23>>*/  /*<<set.ml:607:40>>*/ var
+          _f_ = snoc_enum(c, 0);
+          /*<<set.ml:607:40>>*/ return function(_g_){
+           /*<<?>>*/ return rev_seq_of_enum(_f_, _g_);};
+         /*<<set.ml:607:57>>*/ }
+        function to_seq_from(low, s){
+          /*<<set.ml:610:6>>*/ var s$0 = s, c = 0;
+          /*<<set.ml:610:28>>*/ for(;;){
+          if(s$0){
+            /*<<set.ml:613:24>>*/ var
+            r = s$0[3],
+            v = s$0[2],
+            l = s$0[1],
+             /*<<set.ml:613:24>>*/ n =
+               /*<<set.ml:613:24>>*/ caml_call2(Ord[1], v, low);
+           if(0 !== n){
+            if(0 <= n){
+              /*<<set.ml:616:31>>*/ var
+               /*<<set.ml:616:31>>*/ c$0 = [0, v, r, c],
+              s$0 = l,
+              c = c$0;
+             continue;
+            }
+            var s$0 = r;
+            continue;
+           }
+           var _d_ = [0, v, r, c];
+          }
+          else
+           var _d_ = c;
+           /*<<set.ml:619:19>>*/ return function(_e_){
+            /*<<?>>*/ return seq_of_enum(_d_, _e_);};
+         }
+         /*<<set.ml:619:34>>*/ }
+        return [0,
+                empty,
+                is_empty,
+                mem,
+                add,
+                singleton,
+                remove,
+                union,
+                inter,
+                disjoint,
+                diff,
+                compare,
+                equal,
+                subset,
+                iter,
+                map,
+                fold,
+                for_all,
+                exists,
+                filter,
+                filter_map,
+                partition,
+                cardinal,
+                elements,
+                min_elt,
+                min_elt_opt,
+                max_elt,
+                max_elt_opt,
+                min_elt,
+                min_elt_opt,
+                split,
+                find,
+                find_opt,
+                find_first,
+                find_first_opt,
+                find_last,
+                find_last_opt,
+                of_list,
+                to_seq_from,
+                to_seq,
+                to_rev_seq,
+                add_seq,
+                of_seq];
+       }];
+   runtime.caml_register_global(12, Stdlib_Set, "Stdlib__Set");
+   return;
+   /*<<?>>*/ }
+  (globalThis));
+
+//# unitInfo: Provides: Stdlib__Map
+//# unitInfo: Requires: Assert_failure, Stdlib, Stdlib__Seq
+(function
+  (globalThis){
+   "use strict";
+   var
+    runtime = globalThis.jsoo_runtime,
+    cst_Map_bal$3 = "Map.bal",
+    caml_maybe_attach_backtrace = runtime.caml_maybe_attach_backtrace;
+    /*<<?>>*/ function caml_call1(f, a0){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 1
+            ? f(a0)
+            : runtime.caml_call_gen(f, [a0]);
+   }
+    /*<<?>>*/ function caml_call2(f, a0, a1){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 2
+            ? f(a0, a1)
+            : runtime.caml_call_gen(f, [a0, a1]);
+   }
+    /*<<?>>*/ function caml_call3(f, a0, a1, a2){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 3
+            ? f(a0, a1, a2)
+            : runtime.caml_call_gen(f, [a0, a1, a2]);
+   }
+   var
+    global_data = runtime.caml_get_global_data(),
+    Stdlib = global_data.Stdlib,
+    Assert_failure = global_data.Assert_failure,
+    Stdlib_Seq = global_data.Stdlib__Seq,
+    cst_Map_remove_min_elt = "Map.remove_min_elt",
+    _a_ = [0, 0, 0, 0],
+    _b_ = [0, "map.ml", 400, 10],
+    _c_ = [0, 0, 0],
+    cst_Map_bal = cst_Map_bal$3,
+    cst_Map_bal$0 = cst_Map_bal$3,
+    cst_Map_bal$1 = cst_Map_bal$3,
+    cst_Map_bal$2 = cst_Map_bal$3,
+    Stdlib_Map =
+      [0,
+       function(Ord){
+        function height(param){
+          /*<<map.ml:77:17>>*/ if(! param)  /*<<map.ml:78:17>>*/ return 0;
+         var h = param[5];
+          /*<<map.ml:79:20>>*/ return h;
+         /*<<map.ml:79:21>>*/ }
+        function create(l, x, d, r){
+          /*<<map.ml:82:6>>*/ var
+           /*<<map.ml:82:15>>*/ hl = height(l),
+           /*<<map.ml:82:33>>*/ hr = height(r),
+          _L_ = hr <= hl ? hl + 1 | 0 : hr + 1 | 0;
+          /*<<map.ml:83:10>>*/ return [0, l, x, d, r, _L_];
+         /*<<map.ml:83:65>>*/ }
+        function singleton(x, d){
+          /*<<map.ml:85:24>>*/ return [0, 0, x, d, 0, 1];
+         /*<<map.ml:85:59>>*/ }
+        function bal(l, x, d, r){
+          /*<<map.ml:88:6>>*/ if(l) var h = l[5], hl = h; else var hl = 0;
+          /*<<map.ml:89:6>>*/ if(r) var h$0 = r[5], hr = h$0; else var hr = 0;
+         if((hr + 2 | 0) < hl){
+          if(! l)
+            /*<<map.ml:92:19>>*/ return  /*<<map.ml:92:19>>*/ caml_call1
+                   (Stdlib[1], cst_Map_bal$0);
+           /*<<map.ml:94:28>>*/ var
+           lr = l[4],
+           ld = l[3],
+           lv = l[2],
+           ll = l[1],
+            /*<<map.ml:94:28>>*/ _G_ = height(lr);
+          if(_G_ <= height(ll))
+            /*<<map.ml:95:30>>*/ return create
+                   (ll, lv, ld, create(lr, x, d, r));
+          if(! lr)
+            /*<<map.ml:98:25>>*/ return  /*<<map.ml:98:25>>*/ caml_call1
+                   (Stdlib[1], cst_Map_bal);
+           /*<<map.ml:100:55>>*/ var
+           lrr = lr[4],
+           lrd = lr[3],
+           lrv = lr[2],
+           lrl = lr[1],
+            /*<<map.ml:100:55>>*/ _H_ = create(lrr, x, d, r);
+           /*<<map.ml:100:55>>*/ return create
+                  (create(ll, lv, ld, lrl), lrv, lrd, _H_);
+         }
+         if((hl + 2 | 0) >= hr){
+          var _K_ = hr <= hl ? hl + 1 | 0 : hr + 1 | 0;
+           /*<<map.ml:115:12>>*/ return [0, l, x, d, r, _K_];
+         }
+         if(! r)
+           /*<<map.ml:104:19>>*/ return  /*<<map.ml:104:19>>*/ caml_call1
+                  (Stdlib[1], cst_Map_bal$2);
+          /*<<map.ml:106:28>>*/ var
+          rr = r[4],
+          rd = r[3],
+          rv = r[2],
+          rl = r[1],
+           /*<<map.ml:106:28>>*/ _I_ = height(rl);
+         if(_I_ <= height(rr))
+           /*<<map.ml:107:14>>*/ return create
+                  (create(l, x, d, rl), rv, rd, rr);
+         if(! rl)
+           /*<<map.ml:110:25>>*/ return  /*<<map.ml:110:25>>*/ caml_call1
+                  (Stdlib[1], cst_Map_bal$1);
+          /*<<map.ml:112:52>>*/ var
+          rlr = rl[4],
+          rld = rl[3],
+          rlv = rl[2],
+          rll = rl[1],
+           /*<<map.ml:112:52>>*/ _J_ = create(rlr, rv, rd, rr);
+          /*<<map.ml:112:52>>*/ return create
+                 (create(l, x, d, rll), rlv, rld, _J_);
+         /*<<map.ml:115:67>>*/ }
+        var empty = 0;
+        function is_empty(param){
+          /*<<map.ml:119:19>>*/ return param ? 0 : 1;
+         /*<<map.ml:119:54>>*/ }
+        function add(x, data, m){
+          /*<<?>>*/ if(! m)
+           /*<<map.ml:123:14>>*/ return [0, 0, x, data, 0, 1];
+          /*<<map.ml:125:18>>*/ var
+          h = m[5],
+          r = m[4],
+          d = m[3],
+          v = m[2],
+          l = m[1],
+           /*<<map.ml:125:18>>*/ c =
+             /*<<map.ml:125:18>>*/ caml_call2(Ord[1], x, v);
+          /*<<map.ml:126:10>>*/ if(0 === c)
+          return d === data ? m : [0, l, x, data, r, h];
+         if(0 <= c){
+           /*<<map.ml:132:21>>*/  /*<<map.ml:132:21>>*/ var
+           rr = add(x, data, r);
+          return r === rr ? m : bal(l, v, d, rr);
+         }
+          /*<<map.ml:129:21>>*/  /*<<map.ml:129:21>>*/ var
+          ll = add(x, data, l);
+         return l === ll ? m : bal(ll, v, d, r);
+        }
+        function find(x, param){
+         var param$0 = param;
+         for(;;){
+          if(! param$0)
+            /*<<map.ml:137:10>>*/ throw  /*<<map.ml:137:10>>*/ caml_maybe_attach_backtrace
+                  (Stdlib[8], 1);
+           /*<<map.ml:139:18>>*/ var
+           r = param$0[4],
+           d = param$0[3],
+           v = param$0[2],
+           l = param$0[1],
+            /*<<map.ml:139:18>>*/ c =
+              /*<<map.ml:139:18>>*/ caml_call2(Ord[1], x, v);
+           /*<<map.ml:140:10>>*/ if(0 === c)  /*<<map.ml:140:24>>*/ return d;
+          var r$0 = 0 <= c ? r : l, param$0 = r$0;
+         }
+        }
+        function find_first(f, param$0){
+         var param$1 = param$0;
+         for(;;){
+          if(! param$1)
+            /*<<map.ml:154:10>>*/ throw  /*<<map.ml:154:10>>*/ caml_maybe_attach_backtrace
+                  (Stdlib[8], 1);
+          var
+           r$0 = param$1[4],
+           d0$1 = param$1[3],
+           v0$1 = param$1[2],
+           l$0 = param$1[1];
+           /*<<map.ml:156:13>>*/ if
+           ( /*<<map.ml:156:13>>*/ caml_call1(f, v0$1)){
+           var v0 = v0$1, d0 = d0$1, param = l$0;
+           for(;;){
+            if(! param)  /*<<map.ml:145:10>>*/ return [0, v0, d0];
+            var r = param[4], d0$0 = param[3], v0$0 = param[2], l = param[1];
+             /*<<map.ml:147:13>>*/ if
+             ( /*<<map.ml:147:13>>*/ caml_call1(f, v0$0))
+             var v0 = v0$0, d0 = d0$0, param = l;
+            else
+             var param = r;
+           }
+          }
+          else
+           var param$1 = r$0;
+         }
+        }
+        function find_first_opt(f, param$0){
+         var param$1 = param$0;
+         for(;;){
+          if(! param$1)  /*<<map.ml:172:10>>*/ return 0;
+          var
+           r$0 = param$1[4],
+           d0$1 = param$1[3],
+           v0$1 = param$1[2],
+           l$0 = param$1[1];
+           /*<<map.ml:174:13>>*/ if
+           ( /*<<map.ml:174:13>>*/ caml_call1(f, v0$1)){
+           var v0 = v0$1, d0 = d0$1, param = l$0;
+           for(;;){
+            if(! param)  /*<<map.ml:163:10>>*/ return [0, [0, v0, d0]];
+            var r = param[4], d0$0 = param[3], v0$0 = param[2], l = param[1];
+             /*<<map.ml:165:13>>*/ if
+             ( /*<<map.ml:165:13>>*/ caml_call1(f, v0$0))
+             var v0 = v0$0, d0 = d0$0, param = l;
+            else
+             var param = r;
+           }
+          }
+          else
+           var param$1 = r$0;
+         }
+        }
+        function find_last(f, param$0){
+         var param$1 = param$0;
+         for(;;){
+          if(! param$1)
+            /*<<map.ml:190:10>>*/ throw  /*<<map.ml:190:10>>*/ caml_maybe_attach_backtrace
+                  (Stdlib[8], 1);
+          var
+           r$0 = param$1[4],
+           d0$1 = param$1[3],
+           v0$1 = param$1[2],
+           l$0 = param$1[1];
+           /*<<map.ml:192:13>>*/ if
+           ( /*<<map.ml:192:13>>*/ caml_call1(f, v0$1)){
+           var v0 = v0$1, d0 = d0$1, param = r$0;
+           for(;;){
+            if(! param)  /*<<map.ml:181:10>>*/ return [0, v0, d0];
+            var r = param[4], d0$0 = param[3], v0$0 = param[2], l = param[1];
+             /*<<map.ml:183:13>>*/ if
+             ( /*<<map.ml:183:13>>*/ caml_call1(f, v0$0))
+             var v0 = v0$0, d0 = d0$0, param = r;
+            else
+             var param = l;
+           }
+          }
+          else
+           var param$1 = l$0;
+         }
+        }
+        function find_last_opt(f, param$0){
+         var param$1 = param$0;
+         for(;;){
+          if(! param$1)  /*<<map.ml:208:10>>*/ return 0;
+          var
+           r$0 = param$1[4],
+           d0$1 = param$1[3],
+           v0$1 = param$1[2],
+           l$0 = param$1[1];
+           /*<<map.ml:210:13>>*/ if
+           ( /*<<map.ml:210:13>>*/ caml_call1(f, v0$1)){
+           var v0 = v0$1, d0 = d0$1, param = r$0;
+           for(;;){
+            if(! param)  /*<<map.ml:199:10>>*/ return [0, [0, v0, d0]];
+            var r = param[4], d0$0 = param[3], v0$0 = param[2], l = param[1];
+             /*<<map.ml:201:13>>*/ if
+             ( /*<<map.ml:201:13>>*/ caml_call1(f, v0$0))
+             var v0 = v0$0, d0 = d0$0, param = r;
+            else
+             var param = l;
+           }
+          }
+          else
+           var param$1 = l$0;
+         }
+        }
+        function find_opt(x, param){
+         var param$0 = param;
+         for(;;){
+          if(! param$0)  /*<<map.ml:217:10>>*/ return 0;
+           /*<<map.ml:219:18>>*/ var
+           r = param$0[4],
+           d = param$0[3],
+           v = param$0[2],
+           l = param$0[1],
+            /*<<map.ml:219:18>>*/ c =
+              /*<<map.ml:219:18>>*/ caml_call2(Ord[1], x, v);
+           /*<<map.ml:220:10>>*/ if(0 === c)
+            /*<<map.ml:220:24>>*/ return [0, d];
+          var r$0 = 0 <= c ? r : l, param$0 = r$0;
+         }
+        }
+        function mem(x, param){
+         var param$0 = param;
+         for(;;){
+          if(! param$0)  /*<<map.ml:225:10>>*/ return 0;
+           /*<<map.ml:227:18>>*/ var
+           r = param$0[4],
+           v = param$0[2],
+           l = param$0[1],
+            /*<<map.ml:227:18>>*/ c =
+              /*<<map.ml:227:18>>*/ caml_call2(Ord[1], x, v),
+           _F_ = 0 === c ? 1 : 0;
+          if(_F_) return _F_;
+          var r$0 = 0 <= c ? r : l, param$0 = r$0;
+         }
+        }
+        function min_binding(param){
+          /*<<map.ml:230:26>>*/ var param$0 = param;
+          /*<<map.ml:230:26>>*/ for(;;){
+          if(! param$0)
+            /*<<map.ml:231:17>>*/ throw  /*<<map.ml:231:17>>*/ caml_maybe_attach_backtrace
+                  (Stdlib[8], 1);
+          var l = param$0[1];
+          if(! l){
+           var d = param$0[3], v = param$0[2];
+            /*<<map.ml:232:32>>*/ return [0, v, d];
+          }
+          var param$0 = l;
+         }
+         /*<<map.ml:233:33>>*/ }
+        function min_binding_opt(param){
+          /*<<map.ml:235:30>>*/ var param$0 = param;
+          /*<<map.ml:235:30>>*/ for(;;){
+          if(! param$0)  /*<<map.ml:236:17>>*/ return 0;
+          var l = param$0[1];
+          if(! l){
+           var d = param$0[3], v = param$0[2];
+            /*<<map.ml:237:32>>*/ return [0, [0, v, d]];
+          }
+          var param$0 = l;
+         }
+         /*<<map.ml:238:36>>*/ }
+        function max_binding(param){
+          /*<<map.ml:240:26>>*/ var param$0 = param;
+          /*<<map.ml:240:26>>*/ for(;;){
+          if(! param$0)
+            /*<<map.ml:241:17>>*/ throw  /*<<map.ml:241:17>>*/ caml_maybe_attach_backtrace
+                  (Stdlib[8], 1);
+          if(! param$0[4]){
+           var d = param$0[3], v = param$0[2];
+            /*<<map.ml:242:32>>*/ return [0, v, d];
+          }
+          var r = param$0[4], param$0 = r;
+         }
+         /*<<map.ml:243:33>>*/ }
+        function max_binding_opt(param){
+          /*<<map.ml:245:30>>*/ var param$0 = param;
+          /*<<map.ml:245:30>>*/ for(;;){
+          if(! param$0)  /*<<map.ml:246:17>>*/ return 0;
+          if(! param$0[4]){
+           var d = param$0[3], v = param$0[2];
+            /*<<map.ml:247:32>>*/ return [0, [0, v, d]];
+          }
+          var r = param$0[4], param$0 = r;
+         }
+         /*<<map.ml:248:37>>*/ }
+        function remove_min_binding(param){
+          /*<<map.ml:250:33>>*/ if(! param)
+           /*<<map.ml:251:17>>*/ return  /*<<map.ml:251:17>>*/ caml_call1
+                  (Stdlib[1], cst_Map_remove_min_elt);
+         var l = param[1];
+         if(l){
+          var r = param[4], d = param[3], v = param[2];
+           /*<<map.ml:253:29>>*/ return bal(remove_min_binding(l), v, d, r);
+         }
+         var r$0 = param[4];
+          /*<<map.ml:252:29>>*/ return r$0;
+         /*<<map.ml:253:61>>*/ }
+        function _d_(t1, t2){
+          /*<<map.ml:256:6>>*/ if(! t1)  /*<<map.ml:257:22>>*/ return t2;
+         if(! t2)  /*<<map.ml:258:22>>*/ return t1;
+          /*<<map.ml:260:23>>*/ var
+           /*<<map.ml:260:23>>*/ match = min_binding(t2),
+          d = match[2],
+          x = match[1];
+          /*<<map.ml:261:21>>*/ return bal(t1, x, d, remove_min_binding(t2));
+         /*<<map.ml:261:44>>*/ }
+        function remove(x, m){
+          /*<<?>>*/ if(! m)  /*<<map.ml:265:10>>*/ return 0;
+          /*<<map.ml:267:18>>*/ var
+          r = m[4],
+          d = m[3],
+          v = m[2],
+          l = m[1],
+           /*<<map.ml:267:18>>*/ c =
+             /*<<map.ml:267:18>>*/ caml_call2(Ord[1], x, v);
+          /*<<map.ml:268:10>>*/ if(0 === c)
+           /*<<map.ml:268:24>>*/ return _d_(l, r);
+         if(0 <= c){
+           /*<<map.ml:272:21>>*/  /*<<map.ml:272:21>>*/ var rr = remove(x, r);
+          return r === rr ? m : bal(l, v, d, rr);
+         }
+          /*<<map.ml:270:21>>*/  /*<<map.ml:270:21>>*/ var ll = remove(x, l);
+         return l === ll ? m : bal(ll, v, d, r);
+        }
+        function update(x, f, m){
+          /*<<?>>*/ if(! m){
+           /*<<map.ml:276:22>>*/  /*<<map.ml:276:22>>*/ var
+           match$0 =  /*<<map.ml:276:22>>*/ caml_call1(f, 0);
+          if(! match$0)  /*<<map.ml:277:20>>*/ return 0;
+          var data$0 = match$0[1];
+           /*<<map.ml:278:29>>*/ return [0, 0, x, data$0, 0, 1];
+         }
+          /*<<map.ml:281:18>>*/ var
+          h = m[5],
+          r = m[4],
+          d = m[3],
+          v = m[2],
+          l = m[1],
+           /*<<map.ml:281:18>>*/ c =
+             /*<<map.ml:281:18>>*/ caml_call2(Ord[1], x, v);
+          /*<<map.ml:282:10>>*/ if(0 === c){
+           /*<<map.ml:283:18>>*/  /*<<map.ml:283:18>>*/ var
+           match =  /*<<map.ml:283:18>>*/ caml_call1(f, [0, d]);
+          if(! match)  /*<<map.ml:284:22>>*/ return _d_(l, r);
+          var data = match[1];
+          return d === data ? m : [0, l, x, data, r, h];
+         }
+         if(0 <= c){
+           /*<<map.ml:291:21>>*/  /*<<map.ml:291:21>>*/ var
+           rr = update(x, f, r);
+          return r === rr ? m : bal(l, v, d, rr);
+         }
+          /*<<map.ml:288:21>>*/  /*<<map.ml:288:21>>*/ var
+          ll = update(x, f, l);
+         return l === ll ? m : bal(ll, v, d, r);
+        }
+        function iter(f, param){
+         var param$0 = param;
+         for(;;){
+          if(! param$0)  /*<<map.ml:295:17>>*/ return 0;
+          var r = param$0[4], d = param$0[3], v = param$0[2], l = param$0[1];
+           /*<<map.ml:297:10>>*/ iter(f, l);
+           /*<<map.ml:297:20>>*/  /*<<map.ml:297:20>>*/ caml_call2(f, v, d);
+          var param$0 = r;
+         }
+        }
+        function map(f, param){
+          /*<<?>>*/ if(! param)  /*<<map.ml:301:10>>*/ return 0;
+          /*<<map.ml:303:19>>*/ var
+          h = param[5],
+          r = param[4],
+          d = param[3],
+          v = param[2],
+          l = param[1],
+           /*<<map.ml:303:19>>*/ l$0 = map(f, l),
+           /*<<map.ml:304:19>>*/ d$0 =  /*<<map.ml:304:19>>*/ caml_call1(f, d),
+           /*<<map.ml:305:19>>*/ r$0 = map(f, r);
+          /*<<map.ml:306:14>>*/ return [0, l$0, v, d$0, r$0, h];
+        }
+        function mapi(f, param){
+          /*<<?>>*/ if(! param)  /*<<map.ml:310:10>>*/ return 0;
+          /*<<map.ml:312:19>>*/ var
+          h = param[5],
+          r = param[4],
+          d = param[3],
+          v = param[2],
+          l = param[1],
+           /*<<map.ml:312:19>>*/ l$0 = mapi(f, l),
+           /*<<map.ml:313:19>>*/ d$0 =
+             /*<<map.ml:313:19>>*/ caml_call2(f, v, d),
+           /*<<map.ml:314:19>>*/ r$0 = mapi(f, r);
+          /*<<map.ml:315:14>>*/ return [0, l$0, v, d$0, r$0, h];
+        }
+        function fold(f, m, accu){
+          /*<<map.ml:318:6>>*/ var m$0 = m, accu$0 = accu;
+          /*<<map.ml:318:6>>*/ for(;;){
+          if(! m$0)  /*<<map.ml:319:17>>*/ return accu$0;
+           /*<<map.ml:321:19>>*/ var
+           r = m$0[4],
+           d = m$0[3],
+           v = m$0[2],
+           l = m$0[1],
+            /*<<map.ml:321:19>>*/ accu$1 =
+              /*<<map.ml:321:19>>*/ caml_call3(f, v, d, fold(f, l, accu$0)),
+           m$0 = r,
+           accu$0 = accu$1;
+         }
+         /*<<map.ml:321:42>>*/ }
+        function for_all(p, param){
+         var param$0 = param;
+         for(;;){
+          if(! param$0)  /*<<map.ml:324:17>>*/ return 1;
+           /*<<map.ml:325:29>>*/ var
+           r = param$0[4],
+           d = param$0[3],
+           v = param$0[2],
+           l = param$0[1],
+            /*<<map.ml:325:29>>*/ _C_ =
+              /*<<map.ml:325:29>>*/ caml_call2(p, v, d);
+           /*<<map.ml:325:29>>*/ if(_C_){
+            /*<<map.ml:325:38>>*/  /*<<map.ml:325:38>>*/ var
+            _D_ = for_all(p, l);
+            /*<<map.ml:325:38>>*/ if(_D_){var param$0 = r; continue;}
+           var _E_ = _D_;
+          }
+          else
+           var _E_ = _C_;
+           /*<<map.ml:325:38>>*/ return _E_;
+         }
+        }
+        function exists(p, param){
+         var param$0 = param;
+         for(;;){
+          if(! param$0)  /*<<map.ml:328:17>>*/ return 0;
+           /*<<map.ml:329:29>>*/ var
+           r = param$0[4],
+           d = param$0[3],
+           v = param$0[2],
+           l = param$0[1],
+            /*<<map.ml:329:29>>*/ _z_ =
+              /*<<map.ml:329:29>>*/ caml_call2(p, v, d);
+           /*<<map.ml:329:29>>*/ if(_z_)
+           var _A_ = _z_;
+          else{
+            /*<<map.ml:329:38>>*/  /*<<map.ml:329:38>>*/ var
+            _B_ = exists(p, l);
+            /*<<map.ml:329:38>>*/ if(! _B_){var param$0 = r; continue;}
+           var _A_ = _B_;
+          }
+           /*<<map.ml:329:29>>*/ return _A_;
+         }
+        }
+        function add_min_binding(k, x, param){
+          /*<<?>>*/ if(! param)  /*<<map.ml:340:17>>*/ return singleton(k, x);
+         var r = param[4], d = param[3], v = param[2], l = param[1];
+          /*<<map.ml:342:8>>*/ return bal(add_min_binding(k, x, l), v, d, r);
+        }
+        function add_max_binding(k, x, param){
+          /*<<?>>*/ if(! param)  /*<<map.ml:345:17>>*/ return singleton(k, x);
+         var r = param[4], d = param[3], v = param[2], l = param[1];
+          /*<<map.ml:347:18>>*/ return bal(l, v, d, add_max_binding(k, x, r));
+        }
+        function join(l, v, d, r){
+          /*<<map.ml:353:6>>*/ if(! l)
+           /*<<map.ml:354:22>>*/ return add_min_binding(v, d, r);
+         if(! r)  /*<<map.ml:355:22>>*/ return add_max_binding(v, d, l);
+         var
+          rh = r[5],
+          rr = r[4],
+          rd = r[3],
+          rv = r[2],
+          rl = r[1],
+          lh = l[5],
+          lr = l[4],
+          ld = l[3],
+          lv = l[2],
+          ll = l[1];
+         return (rh + 2 | 0) < lh
+                 ? bal(ll, lv, ld, join(lr, v, d, r))
+                 : (lh
+                   + 2
+                   | 0)
+                   < rh
+                   ? bal(join(l, v, d, rl), rv, rd, rr)
+                   : create(l, v, d, r);
+         /*<<map.ml:360:24>>*/ }
+        function concat(t1, t2){
+          /*<<map.ml:367:6>>*/ if(! t1)  /*<<map.ml:368:22>>*/ return t2;
+         if(! t2)  /*<<map.ml:369:22>>*/ return t1;
+          /*<<map.ml:371:23>>*/ var
+           /*<<map.ml:371:23>>*/ match = min_binding(t2),
+          d = match[2],
+          x = match[1];
+          /*<<map.ml:372:22>>*/ return join(t1, x, d, remove_min_binding(t2));
+         /*<<map.ml:372:45>>*/ }
+        function concat_or_join(t1, v, d, t2){
+          /*<<map.ml:375:6>>*/ if(! d)
+           /*<<map.ml:377:16>>*/ return concat(t1, t2);
+         var d$0 = d[1];
+          /*<<map.ml:376:18>>*/ return join(t1, v, d$0, t2);
+         /*<<map.ml:377:28>>*/ }
+        function split(x, param){
+          /*<<?>>*/ if(! param)  /*<<map.ml:381:10>>*/ return _a_;
+          /*<<map.ml:383:18>>*/ var
+          r = param[4],
+          d = param[3],
+          v = param[2],
+          l = param[1],
+           /*<<map.ml:383:18>>*/ c =
+             /*<<map.ml:383:18>>*/ caml_call2(Ord[1], x, v);
+          /*<<map.ml:384:10>>*/ if(0 === c)
+           /*<<map.ml:384:24>>*/ return [0, l, [0, d], r];
+         if(0 <= c){
+           /*<<map.ml:388:33>>*/ var
+            /*<<map.ml:388:33>>*/ match = split(x, r),
+           rr = match[3],
+           pres = match[2],
+           lr = match[1];
+           /*<<map.ml:388:46>>*/ return [0, join(l, v, d, lr), pres, rr];
+         }
+          /*<<map.ml:386:33>>*/ var
+           /*<<map.ml:386:33>>*/ match$0 = split(x, l),
+          rl = match$0[3],
+          pres$0 = match$0[2],
+          ll = match$0[1];
+          /*<<map.ml:386:46>>*/ return [0, ll, pres$0, join(rl, v, d, r)];
+        }
+        function merge(f, s1, s2){
+          /*<<map.ml:391:6>>*/ if(s1){
+          var h1 = s1[5], r1 = s1[4], d1 = s1[3], v1 = s1[2], l1 = s1[1];
+          if(height(s2) <= h1){
+            /*<<map.ml:394:29>>*/ var
+             /*<<map.ml:394:29>>*/ match = split(v1, s2),
+            r2 = match[3],
+            d2 = match[2],
+            l2 = match[1],
+             /*<<map.ml:395:64>>*/ _v_ = merge(f, r1, r2),
+             /*<<map.ml:395:44>>*/ _w_ =
+               /*<<map.ml:395:44>>*/ caml_call3(f, v1, [0, d1], d2);
+            /*<<map.ml:395:64>>*/ return concat_or_join
+                   (merge(f, l1, l2), v1, _w_, _v_);
+          }
+         }
+         else if(! s2)  /*<<map.ml:392:26>>*/ return 0;
+         if(! s2)
+           /*<<map.ml:400:10>>*/ throw  /*<<map.ml:400:10>>*/ caml_maybe_attach_backtrace
+                 ([0, Assert_failure, _b_], 1);
+          /*<<map.ml:397:29>>*/ var
+          r2$0 = s2[4],
+          d2$0 = s2[3],
+          v2 = s2[2],
+          l2$0 = s2[1],
+           /*<<map.ml:397:29>>*/ match$0 = split(v2, s1),
+          r1$0 = match$0[3],
+          d1$0 = match$0[2],
+          l1$0 = match$0[1],
+           /*<<map.ml:398:64>>*/ _x_ = merge(f, r1$0, r2$0),
+           /*<<map.ml:398:44>>*/ _y_ =
+             /*<<map.ml:398:44>>*/ caml_call3(f, v2, d1$0, [0, d2$0]);
+          /*<<map.ml:398:64>>*/ return concat_or_join
+                 (merge(f, l1$0, l2$0), v2, _y_, _x_);
+         /*<<map.ml:400:22>>*/ }
+        function union(f, s1, s2){
+          /*<<map.ml:403:6>>*/ if(s1){
+          if(s2){
+           var
+            h2 = s2[5],
+            r2 = s2[4],
+            d2 = s2[3],
+            v2 = s2[2],
+            l2 = s2[1],
+            h1 = s1[5],
+            r1 = s1[4],
+            d1 = s1[3],
+            v1 = s1[2],
+            l1 = s1[1];
+           if(h2 <= h1){
+             /*<<map.ml:408:31>>*/ var
+              /*<<map.ml:408:31>>*/ match = split(v1, s2),
+             r2$0 = match[3],
+             d2$0 = match[2],
+             l2$0 = match[1],
+              /*<<map.ml:409:20>>*/ l = union(f, l1, l2$0),
+              /*<<map.ml:409:42>>*/ r = union(f, r1, r2$0);
+             /*<<map.ml:410:12>>*/ if(! d2$0)
+              /*<<map.ml:411:22>>*/ return join(l, v1, d1, r);
+            var d2$1 = d2$0[1];
+             /*<<map.ml:412:25>>*/ return concat_or_join
+                    (l,
+                     v1,
+                      /*<<map.ml:412:45>>*/ caml_call3(f, v1, d1, d2$1),
+                     r);
+           }
+            /*<<map.ml:414:31>>*/ var
+             /*<<map.ml:414:31>>*/ match$0 = split(v2, s1),
+            r1$0 = match$0[3],
+            d1$0 = match$0[2],
+            l1$0 = match$0[1],
+             /*<<map.ml:415:20>>*/ l$0 = union(f, l1$0, l2),
+             /*<<map.ml:415:42>>*/ r$0 = union(f, r1$0, r2);
+            /*<<map.ml:416:12>>*/ if(! d1$0)
+             /*<<map.ml:417:22>>*/ return join(l$0, v2, d2, r$0);
+           var d1$1 = d1$0[1];
+            /*<<map.ml:418:25>>*/ return concat_or_join
+                   (l$0,
+                    v2,
+                     /*<<map.ml:418:45>>*/ caml_call3(f, v2, d1$1, d2),
+                    r$0);
+          }
+          var s = s1;
+         }
+         else
+          var s = s2;
+          /*<<map.ml:404:35>>*/ return s;
+         /*<<map.ml:418:59>>*/ }
+        function filter(p, m){
+          /*<<?>>*/ if(! m)  /*<<map.ml:421:17>>*/ return 0;
+          /*<<map.ml:424:19>>*/ var
+          r = m[4],
+          d = m[3],
+          v = m[2],
+          l = m[1],
+           /*<<map.ml:424:19>>*/ l$0 = filter(p, l),
+           /*<<map.ml:425:20>>*/ pvd =
+             /*<<map.ml:425:20>>*/ caml_call2(p, v, d),
+           /*<<map.ml:426:19>>*/ r$0 = filter(p, r);
+          /*<<map.ml:427:10>>*/ if(! pvd)
+           /*<<map.ml:428:15>>*/ return concat(l$0, r$0);
+         if(l === l$0 && r === r$0)  /*<<map.ml:427:45>>*/ return m;
+          /*<<map.ml:427:52>>*/ return join(l$0, v, d, r$0);
+        }
+        function filter_map(f, param){
+          /*<<?>>*/ if(! param)  /*<<map.ml:431:17>>*/ return 0;
+          /*<<map.ml:434:19>>*/ var
+          r = param[4],
+          d = param[3],
+          v = param[2],
+          l = param[1],
+           /*<<map.ml:434:19>>*/ l$0 = filter_map(f, l),
+           /*<<map.ml:435:20>>*/ fvd =
+             /*<<map.ml:435:20>>*/ caml_call2(f, v, d),
+           /*<<map.ml:436:19>>*/ r$0 = filter_map(f, r);
+          /*<<map.ml:437:10>>*/ if(! fvd)
+           /*<<map.ml:439:22>>*/ return concat(l$0, r$0);
+         var d$0 = fvd[1];
+          /*<<map.ml:438:25>>*/ return join(l$0, v, d$0, r$0);
+        }
+        function partition(p, param){
+          /*<<?>>*/ if(! param)  /*<<map.ml:443:17>>*/ return _c_;
+          /*<<map.ml:446:25>>*/ var
+          r = param[4],
+          d = param[3],
+          v = param[2],
+          l = param[1],
+           /*<<map.ml:446:25>>*/ match = partition(p, l),
+          lf = match[2],
+          lt = match[1],
+           /*<<map.ml:447:20>>*/ pvd =
+             /*<<map.ml:447:20>>*/ caml_call2(p, v, d),
+           /*<<map.ml:448:25>>*/ match$0 = partition(p, r),
+          rf = match$0[2],
+          rt = match$0[1];
+          /*<<map.ml:449:10>>*/ if(pvd){
+           /*<<map.ml:450:32>>*/  /*<<map.ml:450:32>>*/ var
+           _t_ = concat(lf, rf);
+           /*<<map.ml:450:15>>*/ return [0, join(lt, v, d, rt), _t_];
+         }
+          /*<<map.ml:451:30>>*/  /*<<map.ml:451:30>>*/ var
+          _u_ = join(lf, v, d, rf);
+          /*<<map.ml:451:15>>*/ return [0, concat(lt, rt), _u_];
+        }
+        function cons_enum(m, e){
+          /*<<map.ml:456:6>>*/ var m$0 = m, e$0 = e;
+          /*<<map.ml:456:6>>*/ for(;;){
+          if(! m$0)  /*<<map.ml:457:17>>*/ return e$0;
+           /*<<map.ml:458:41>>*/ var
+           r = m$0[4],
+           d = m$0[3],
+           v = m$0[2],
+           l = m$0[1],
+            /*<<map.ml:458:41>>*/ e$1 = [0, v, d, r, e$0],
+           m$0 = l,
+           e$0 = e$1;
+         }
+         /*<<map.ml:458:59>>*/ }
+        function compare(cmp, m1, m2){
+          /*<<map.ml:461:6>>*/ var
+           /*<<map.ml:472:40>>*/ e2$2 = cons_enum(m2, 0),
+           /*<<map.ml:472:21>>*/ e1$2 = cons_enum(m1, 0),
+          e1 = e1$2,
+          e2 = e2$2;
+          /*<<map.ml:462:10>>*/ for(;;){
+          if(! e1) return e2 ? -1 : 0;
+          if(! e2)  /*<<map.ml:465:22>>*/ return 1;
+           /*<<map.ml:467:20>>*/ var
+           e2$0 = e2[4],
+           r2 = e2[3],
+           d2 = e2[2],
+           v2 = e2[1],
+           e1$0 = e1[4],
+           r1 = e1[3],
+           d1 = e1[2],
+           v1 = e1[1],
+            /*<<map.ml:467:20>>*/ c =
+              /*<<map.ml:467:20>>*/ caml_call2(Ord[1], v1, v2);
+           /*<<map.ml:468:12>>*/ if(0 !== c)  /*<<map.ml:468:27>>*/ return c;
+           /*<<map.ml:469:20>>*/  /*<<map.ml:469:20>>*/ var
+           c$0 =  /*<<map.ml:469:20>>*/ caml_call2(cmp, d1, d2);
+           /*<<map.ml:470:12>>*/ if(0 !== c$0)
+            /*<<map.ml:470:27>>*/ return c$0;
+           /*<<map.ml:471:42>>*/ var
+            /*<<map.ml:471:42>>*/ e2$1 = cons_enum(r2, e2$0),
+            /*<<map.ml:471:24>>*/ e1$1 = cons_enum(r1, e1$0),
+           e1 = e1$1,
+           e2 = e2$1;
+         }
+         /*<<map.ml:472:58>>*/ }
+        function equal(cmp, m1, m2){
+          /*<<map.ml:475:6>>*/ var
+           /*<<map.ml:483:38>>*/ e2$2 = cons_enum(m2, 0),
+           /*<<map.ml:483:19>>*/ e1$2 = cons_enum(m1, 0),
+          e1 = e1$2,
+          e2 = e2$2;
+          /*<<map.ml:476:10>>*/ for(;;){
+          if(! e1) return e2 ? 0 : 1;
+          if(! e2)  /*<<map.ml:479:22>>*/ return 0;
+          var
+           e2$0 = e2[4],
+           r2 = e2[3],
+           d2 = e2[2],
+           v2 = e2[1],
+           e1$0 = e1[4],
+           r1 = e1[3],
+           d1 = e1[2],
+           v1 = e1[1],
+           _q_ =
+             0 ===  /*<<map.ml:481:12>>*/ caml_call2(Ord[1], v1, v2) ? 1 : 0;
+          if(_q_){
+            /*<<map.ml:481:37>>*/  /*<<map.ml:481:37>>*/ var
+            _r_ =  /*<<map.ml:481:37>>*/ caml_call2(cmp, d1, d2);
+            /*<<map.ml:481:37>>*/ if(_r_){
+             /*<<map.ml:482:40>>*/ var
+              /*<<map.ml:482:40>>*/ e2$1 = cons_enum(r2, e2$0),
+              /*<<map.ml:482:22>>*/ e1$1 = cons_enum(r1, e1$0),
+             e1 = e1$1,
+             e2 = e2$1;
+            continue;
+           }
+           var _s_ = _r_;
+          }
+          else
+           var _s_ = _q_;
+           /*<<map.ml:481:37>>*/ return _s_;
+         }
+         /*<<map.ml:483:56>>*/ }
+        function cardinal(param){
+          /*<<map.ml:485:23>>*/ if(! param)  /*<<map.ml:486:17>>*/ return 0;
+          /*<<map.ml:487:40>>*/ var
+          r = param[4],
+          l = param[1],
+           /*<<map.ml:487:40>>*/ _p_ = cardinal(r);
+         return (cardinal(l) + 1 | 0) + _p_ | 0;
+         /*<<map.ml:487:50>>*/ }
+        function bindings_aux(accu, param){
+         var accu$0 = accu, param$0 = param;
+         for(;;){
+          if(! param$0)  /*<<map.ml:490:17>>*/ return accu$0;
+           /*<<map.ml:491:42>>*/ var
+           r = param$0[4],
+           d = param$0[3],
+           v = param$0[2],
+           l = param$0[1],
+            /*<<map.ml:491:42>>*/ accu$1 =
+             [0, [0, v, d], bindings_aux(accu$0, r)],
+           accu$0 = accu$1,
+           param$0 = l;
+         }
+        }
+        function bindings(s){
+          /*<<map.ml:494:6>>*/ return bindings_aux(0, s);
+         /*<<map.ml:494:23>>*/ }
+        function add_seq(i, m){
+         function _o_(m, param){
+           /*<<map.ml:501:20>>*/ var v = param[2], k = param[1];
+           /*<<map.ml:501:36>>*/ return add(k, v, m);
+          /*<<map.ml:501:46>>*/ }
+          /*<<map.ml:501:6>>*/ return  /*<<map.ml:501:6>>*/ caml_call3
+                 (Stdlib_Seq[5], _o_, m, i);
+         /*<<map.ml:501:50>>*/ }
+        function of_seq(i){
+          /*<<map.ml:503:19>>*/ return add_seq(i, empty);
+         /*<<map.ml:503:34>>*/ }
+        function seq_of_enum(c, param){
+          /*<<map.ml:505:32>>*/ if(! c)  /*<<map.ml:506:15>>*/ return 0;
+          /*<<map.ml:507:59>>*/ var
+          rest = c[4],
+          t = c[3],
+          v = c[2],
+          k = c[1],
+           /*<<map.ml:507:59>>*/ _m_ = cons_enum(t, rest);
+          /*<<map.ml:507:29>>*/ return [0,
+                 [0, k, v],
+                 function(_n_){ /*<<?>>*/ return seq_of_enum(_m_, _n_);}];
+         /*<<map.ml:507:78>>*/ }
+        function to_seq(m){
+          /*<<map.ml:510:6>>*/  /*<<map.ml:510:19>>*/ var
+          _k_ = cons_enum(m, 0);
+          /*<<map.ml:510:19>>*/ return function(_l_){
+           /*<<?>>*/ return seq_of_enum(_k_, _l_);};
+         /*<<map.ml:510:36>>*/ }
+        function snoc_enum(s, e){
+          /*<<map.ml:513:6>>*/ var s$0 = s, e$0 = e;
+          /*<<map.ml:513:6>>*/ for(;;){
+          if(! s$0)  /*<<map.ml:514:17>>*/ return e$0;
+           /*<<map.ml:515:40>>*/ var
+           r = s$0[4],
+           d = s$0[3],
+           v = s$0[2],
+           l = s$0[1],
+            /*<<map.ml:515:40>>*/ e$1 = [0, v, d, l, e$0],
+           s$0 = r,
+           e$0 = e$1;
+         }
+         /*<<map.ml:515:58>>*/ }
+        function rev_seq_of_enum(c, param){
+          /*<<map.ml:517:36>>*/ if(! c)  /*<<map.ml:518:15>>*/ return 0;
+          /*<<map.ml:520:44>>*/ var
+          rest = c[4],
+          t = c[3],
+          v = c[2],
+          k = c[1],
+           /*<<map.ml:520:44>>*/ _i_ = snoc_enum(t, rest);
+          /*<<map.ml:520:10>>*/ return [0,
+                 [0, k, v],
+                 function(_j_){ /*<<?>>*/ return rev_seq_of_enum(_i_, _j_);}];
+         /*<<map.ml:520:63>>*/ }
+        function to_rev_seq(c){
+          /*<<map.ml:523:6>>*/  /*<<map.ml:523:23>>*/ var
+          _g_ = snoc_enum(c, 0);
+          /*<<map.ml:523:23>>*/ return function(_h_){
+           /*<<?>>*/ return rev_seq_of_enum(_g_, _h_);};
+         /*<<map.ml:523:40>>*/ }
+        function to_seq_from(low, m){
+          /*<<map.ml:526:6>>*/ var m$0 = m, c = 0;
+          /*<<map.ml:526:28>>*/ for(;;){
+          if(m$0){
+            /*<<map.ml:529:24>>*/ var
+            r = m$0[4],
+            d = m$0[3],
+            v = m$0[2],
+            l = m$0[1],
+             /*<<map.ml:529:24>>*/ n =
+               /*<<map.ml:529:24>>*/ caml_call2(Ord[1], v, low);
+           if(0 !== n){
+            if(0 <= n){
+              /*<<map.ml:532:31>>*/ var
+               /*<<map.ml:532:31>>*/ c$0 = [0, v, d, r, c],
+              m$0 = l,
+              c = c$0;
+             continue;
+            }
+            var m$0 = r;
+            continue;
+           }
+           var _e_ = [0, v, d, r, c];
+          }
+          else
+           var _e_ = c;
+           /*<<map.ml:535:19>>*/ return function(_f_){
+            /*<<?>>*/ return seq_of_enum(_e_, _f_);};
+         }
+         /*<<map.ml:535:34>>*/ }
+        return [0,
+                empty,
+                is_empty,
+                mem,
+                add,
+                update,
+                singleton,
+                remove,
+                merge,
+                union,
+                compare,
+                equal,
+                iter,
+                fold,
+                for_all,
+                exists,
+                filter,
+                filter_map,
+                partition,
+                cardinal,
+                bindings,
+                min_binding,
+                min_binding_opt,
+                max_binding,
+                max_binding_opt,
+                min_binding,
+                min_binding_opt,
+                split,
+                find,
+                find_opt,
+                find_first,
+                find_first_opt,
+                find_last,
+                find_last_opt,
+                map,
+                mapi,
+                to_seq,
+                to_rev_seq,
+                to_seq_from,
+                add_seq,
+                of_seq];
+       }];
+   runtime.caml_register_global(11, Stdlib_Map, "Stdlib__Map");
+   return;
+   /*<<?>>*/ }
+  (globalThis));
+
+//# unitInfo: Provides: Stdlib__Stack
+//# unitInfo: Requires: Stdlib__List, Stdlib__Seq
+(function
+  (globalThis){
+   "use strict";
+   var
+    runtime = globalThis.jsoo_runtime,
+    caml_maybe_attach_backtrace = runtime.caml_maybe_attach_backtrace;
+    /*<<?>>*/ function caml_call1(f, a0){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 1
+            ? f(a0)
+            : runtime.caml_call_gen(f, [a0]);
+   }
+    /*<<?>>*/ function caml_call2(f, a0, a1){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 2
+            ? f(a0, a1)
+            : runtime.caml_call_gen(f, [a0, a1]);
+   }
+    /*<<?>>*/ function caml_call3(f, a0, a1, a2){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 3
+            ? f(a0, a1, a2)
+            : runtime.caml_call_gen(f, [a0, a1, a2]);
+   }
+    /*<<stack.ml:18:0>>*/ var
+    global_data = runtime.caml_get_global_data(),
+    Stdlib_Seq = global_data.Stdlib__Seq,
+    Stdlib_List = global_data.Stdlib__List,
+     /*<<stack.ml:18:0>>*/ Empty =
+      [248, "Stdlib.Stack.Empty", runtime.caml_fresh_oo_id(0)];
+   function create(param){
+     /*<<stack.ml:20:16>>*/ return [0, 0, 0];
+    /*<<stack.ml:20:36>>*/ }
+   function clear(s){
+     /*<<stack.ml:22:14>>*/ s[1] = 0;
+    s[2] = 0;
+    return 0;
+    /*<<stack.ml:22:35>>*/ }
+   function copy(s){
+     /*<<stack.ml:24:13>>*/ return [0, s[1], s[2]];
+    /*<<stack.ml:24:38>>*/ }
+   function push(x, s){
+     /*<<stack.ml:26:15>>*/ s[1] = [0, x, s[1]];
+    s[2] = s[2] + 1 | 0;
+    return 0;
+    /*<<stack.ml:26:50>>*/ }
+   function pop(s){
+     /*<<stack.ml:29:2>>*/ var match = s[1];
+    if(! match)
+      /*<<stack.ml:31:14>>*/ throw  /*<<stack.ml:31:14>>*/ caml_maybe_attach_backtrace
+            (Empty, 1);
+    var tl = match[2], hd = match[1];
+    s[1] = tl;
+    s[2] = s[2] - 1 | 0;
+     /*<<stack.ml:30:45>>*/ return hd;
+    /*<<stack.ml:31:25>>*/ }
+   function pop_opt(s){
+     /*<<stack.ml:34:2>>*/ var match = s[1];
+    if(! match)  /*<<stack.ml:36:14>>*/ return 0;
+    var tl = match[2], hd = match[1];
+    s[1] = tl;
+    s[2] = s[2] - 1 | 0;
+     /*<<stack.ml:35:45>>*/ return [0, hd];
+    /*<<stack.ml:36:18>>*/ }
+   function top(s){
+     /*<<stack.ml:39:2>>*/ var match = s[1];
+    if(! match)
+      /*<<stack.ml:41:13>>*/ throw  /*<<stack.ml:41:13>>*/ caml_maybe_attach_backtrace
+            (Empty, 1);
+    var hd = match[1];
+     /*<<stack.ml:40:13>>*/ return hd;
+    /*<<stack.ml:41:24>>*/ }
+   function top_opt(s){
+     /*<<stack.ml:44:2>>*/ var match = s[1];
+    if(! match)  /*<<stack.ml:46:13>>*/ return 0;
+    var hd = match[1];
+     /*<<stack.ml:45:13>>*/ return [0, hd];
+    /*<<stack.ml:46:17>>*/ }
+   function is_empty(s){
+     /*<<stack.ml:48:17>>*/ return 0 === s[1] ? 1 : 0;
+    /*<<stack.ml:48:27>>*/ }
+   function length(s){
+     /*<<stack.ml:50:15>>*/ return s[2];
+    /*<<stack.ml:50:20>>*/ }
+   function iter(f, s){
+     /*<<stack.ml:52:15>>*/ return caml_call2(Stdlib_List[17], f, s[1]);
+    /*<<stack.ml:52:30>>*/ }
+   function fold(f, acc, s){
+     /*<<stack.ml:54:19>>*/ return caml_call3(Stdlib_List[25], f, acc, s[1]);
+    /*<<stack.ml:54:43>>*/ }
+   function to_seq(s){
+     /*<<stack.ml:58:15>>*/ return caml_call1(Stdlib_List[61], s[1]);
+    /*<<stack.ml:58:30>>*/ }
+   function add_seq(q, i){
+    function _a_(x){
+      /*<<stack.ml:60:37>>*/ return push(x, q);
+     /*<<stack.ml:60:45>>*/ }
+     /*<<stack.ml:60:18>>*/ return  /*<<stack.ml:60:18>>*/ caml_call2
+            (Stdlib_Seq[4], _a_, i);
+    /*<<stack.ml:60:48>>*/ }
+   function of_seq(g){
+     /*<<stack.ml:63:2>>*/  /*<<stack.ml:63:10>>*/ var s = create(0);
+     /*<<stack.ml:64:2>>*/ add_seq(s, g);
+     /*<<stack.ml:64:2>>*/ return s;
+    /*<<stack.ml:65:3>>*/ }
+   var
+    Stdlib_Stack =
+      [0,
+       Empty,
+       create,
+       push,
+       pop,
+       pop_opt,
+       top,
+       top_opt,
+       clear,
+       copy,
+       is_empty,
+       length,
+       iter,
+       fold,
+       to_seq,
+       add_seq,
+       of_seq];
+   runtime.caml_register_global(3, Stdlib_Stack, "Stdlib__Stack");
+   return;
+   /*<<?>>*/ }
+  (globalThis));
+
+//# unitInfo: Provides: Stdlib__Queue
+//# unitInfo: Requires: Stdlib__Seq
+(function
+  (globalThis){
+   "use strict";
+   var
+    runtime = globalThis.jsoo_runtime,
+    caml_maybe_attach_backtrace = runtime.caml_maybe_attach_backtrace;
+    /*<<?>>*/ function caml_call1(f, a0){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 1
+            ? f(a0)
+            : runtime.caml_call_gen(f, [a0]);
+   }
+    /*<<?>>*/ function caml_call2(f, a0, a1){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 2
+            ? f(a0, a1)
+            : runtime.caml_call_gen(f, [a0, a1]);
+   }
+    /*<<queue.ml:17:0>>*/ var
+    global_data = runtime.caml_get_global_data(),
+    Stdlib_Seq = global_data.Stdlib__Seq,
+     /*<<queue.ml:17:0>>*/ Empty =
+      [248, "Stdlib.Queue.Empty", runtime.caml_fresh_oo_id(0)];
+   function create(param){
+     /*<<queue.ml:29:16>>*/ return [0, 0, 0, 0];
+    /*<<queue.ml:33:1>>*/ }
+   function clear(q){
+     /*<<queue.ml:36:2>>*/ q[1] = 0;
+    q[2] = 0;
+    q[3] = 0;
+    return 0;
+    /*<<queue.ml:38:15>>*/ }
+   function add(x, q){
+     /*<<queue.ml:41:2>>*/ var
+      /*<<queue.ml:41:18>>*/ cell = [0, x, 0],
+      /*<<queue.ml:45:2>>*/ match = q[3];
+    return match
+            ? (q[1] = q[1] + 1 | 0, match[2] = cell, q[3] = cell, 0)
+            : (q[1] = 1, q[2] = cell, q[3] = cell, 0);
+    /*<<queue.ml:53:18>>*/ }
+   function peek(q){
+     /*<<queue.ml:59:2>>*/ var match = q[2];
+    if(! match)
+      /*<<queue.ml:60:11>>*/ throw  /*<<queue.ml:60:11>>*/ caml_maybe_attach_backtrace
+            (Empty, 1);
+    var content = match[1];
+     /*<<queue.ml:61:24>>*/ return content;
+    /*<<queue.ml:61:31>>*/ }
+   function peek_opt(q){
+     /*<<queue.ml:64:2>>*/ var match = q[2];
+    if(! match)  /*<<queue.ml:65:11>>*/ return 0;
+    var content = match[1];
+     /*<<queue.ml:66:24>>*/ return [0, content];
+    /*<<queue.ml:66:36>>*/ }
+   function take(q){
+     /*<<queue.ml:72:2>>*/ var _g_ = q[2];
+    if(! _g_)
+      /*<<queue.ml:73:11>>*/ throw  /*<<queue.ml:73:11>>*/ caml_maybe_attach_backtrace
+            (Empty, 1);
+    var content = _g_[1];
+    if(_g_[2]){
+     var next = _g_[2];
+     q[1] = q[1] - 1 | 0;
+     q[2] = next;
+      /*<<queue.ml:80:4>>*/ return content;
+    }
+     /*<<queue.ml:75:4>>*/ clear(q);
+     /*<<queue.ml:75:4>>*/ return content;
+    /*<<queue.ml:80:11>>*/ }
+   function take_opt(q){
+     /*<<queue.ml:83:2>>*/ var _f_ = q[2];
+    if(! _f_)  /*<<queue.ml:84:11>>*/ return 0;
+    var content = _f_[1];
+    if(_f_[2]){
+     var next = _f_[2];
+     q[1] = q[1] - 1 | 0;
+     q[2] = next;
+      /*<<queue.ml:91:4>>*/ return [0, content];
+    }
+     /*<<queue.ml:86:4>>*/ clear(q);
+     /*<<queue.ml:87:4>>*/ return [0, content];
+    /*<<queue.ml:91:16>>*/ }
+   function copy(q){
+     /*<<queue.ml:108:11>>*/ var
+     cell$0 = q[2],
+      /*<<queue.ml:108:16>>*/ q_res = [0, q[1], 0, 0],
+     prev = 0,
+     cell = cell$0;
+     /*<<queue.ml:98:4>>*/ for(;;){
+     if(! cell){q_res[3] = prev;  /*<<queue.ml:99:33>>*/ return q_res;}
+      /*<<queue.ml:101:21>>*/ var
+      content = cell[1],
+      next = cell[2],
+       /*<<queue.ml:101:21>>*/ prev$0 = [0, content, 0];
+      /*<<queue.ml:102:6>>*/ if(prev)
+      prev[2] = prev$0;
+     else
+      q_res[2] = prev$0;
+     var prev = prev$0, cell = next;
+    }
+    /*<<queue.ml:108:74>>*/ }
+   function is_empty(q){
+     /*<<queue.ml:111:2>>*/ return 0 === q[1] ? 1 : 0;
+    /*<<queue.ml:111:14>>*/ }
+   function length(q){
+     /*<<queue.ml:114:2>>*/ return q[1];
+    /*<<queue.ml:114:10>>*/ }
+   function iter(f, q){
+     /*<<queue.ml:124:13>>*/ var cell$0 = q[2], cell = cell$0;
+     /*<<queue.ml:118:4>>*/ for(;;){
+     if(! cell)  /*<<queue.ml:119:13>>*/ return 0;
+     var content = cell[1], next = cell[2];
+      /*<<queue.ml:121:6>>*/  /*<<queue.ml:121:6>>*/ caml_call1(f, content);
+     var cell = next;
+    }
+    /*<<queue.ml:124:27>>*/ }
+   function fold(f, accu$1, q){
+     /*<<queue.ml:134:18>>*/ var cell$0 = q[2], accu = accu$1, cell = cell$0;
+     /*<<queue.ml:128:4>>*/ for(;;){
+     if(! cell)  /*<<queue.ml:129:13>>*/ return accu;
+      /*<<queue.ml:131:17>>*/ var
+      content = cell[1],
+      next = cell[2],
+       /*<<queue.ml:131:17>>*/ accu$0 =
+         /*<<queue.ml:131:17>>*/ caml_call2(f, accu, content),
+      accu = accu$0,
+      cell = next;
+    }
+    /*<<queue.ml:134:37>>*/ }
+   function transfer(q1, q2){
+     /*<<queue.ml:137:2>>*/ var _e_ = 0 < q1[1] ? 1 : 0;
+    if(! _e_) return _e_;
+    var match = q2[3];
+    return match
+            ? (q2
+               [1]
+              = q2[1] + q1[1] | 0,
+              match[2] = q1[2],
+              q2[3] = q1[3],
+              clear(q1))
+            : (q2[1] = q1[1], q2[2] = q1[2], q2[3] = q1[3], clear(q1));
+    /*<<queue.ml:148:14>>*/ }
+   function to_seq(q){
+     /*<<queue.ml:153:2>>*/ function aux(c, param){
+      /*<<queue.ml:153:21>>*/ if(! c)  /*<<queue.ml:154:13>>*/ return 0;
+     var x = c[1], next = c[2];
+      /*<<queue.ml:155:35>>*/ return [0,
+             x,
+             function(_d_){ /*<<?>>*/ return aux(next, _d_);}];
+     /*<<queue.ml:155:57>>*/ }
+    var _b_ = q[2];
+     /*<<queue.ml:153:2>>*/ return function(_c_){
+      /*<<?>>*/ return aux(_b_, _c_);};
+    /*<<queue.ml:157:13>>*/ }
+   function add_seq(q, i){
+    function _a_(x){
+      /*<<queue.ml:159:37>>*/ return add(x, q);
+     /*<<queue.ml:159:45>>*/ }
+     /*<<queue.ml:159:18>>*/ return  /*<<queue.ml:159:18>>*/ caml_call2
+            (Stdlib_Seq[4], _a_, i);
+    /*<<queue.ml:159:48>>*/ }
+   function of_seq(g){
+     /*<<queue.ml:162:2>>*/  /*<<queue.ml:162:10>>*/ var q = create(0);
+     /*<<queue.ml:163:2>>*/ add_seq(q, g);
+     /*<<queue.ml:163:2>>*/ return q;
+    /*<<queue.ml:164:3>>*/ }
+   var
+    Stdlib_Queue =
+      [0,
+       Empty,
+       create,
+       add,
+       add,
+       take,
+       take_opt,
+       take,
+       peek,
+       peek_opt,
+       peek,
+       clear,
+       copy,
+       is_empty,
+       length,
+       iter,
+       fold,
+       transfer,
+       to_seq,
+       add_seq,
+       of_seq];
+   runtime.caml_register_global(2, Stdlib_Queue, "Stdlib__Queue");
+   return;
+   /*<<?>>*/ }
+  (globalThis));
+
+//# unitInfo: Provides: Stdlib__Buffer
+//# unitInfo: Requires: Assert_failure, Stdlib, Stdlib__Bytes, Stdlib__Seq, Stdlib__String, Stdlib__Sys
+(function
+  (globalThis){
+   "use strict";
+   var
+    runtime = globalThis.jsoo_runtime,
+    caml_blit_string = runtime.caml_blit_string,
+    caml_bswap16 = runtime.caml_bswap16,
+    caml_bytes_get = runtime.caml_bytes_get,
+    caml_bytes_set = runtime.caml_bytes_set,
+    caml_bytes_set16 = runtime.caml_bytes_set16,
+    caml_bytes_set32 = runtime.caml_bytes_set32,
+    caml_bytes_set64 = runtime.caml_bytes_set64,
+    caml_bytes_unsafe_set = runtime.caml_bytes_unsafe_set,
+    caml_create_bytes = runtime.caml_create_bytes,
+    caml_int32_bswap = runtime.caml_int32_bswap,
+    caml_int64_bswap = runtime.caml_int64_bswap,
+    caml_maybe_attach_backtrace = runtime.caml_maybe_attach_backtrace,
+    caml_ml_bytes_length = runtime.caml_ml_bytes_length,
+    caml_ml_string_length = runtime.caml_ml_string_length,
+    caml_string_get = runtime.caml_string_get;
+    /*<<?>>*/ function caml_call1(f, a0){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 1
+            ? f(a0)
+            : runtime.caml_call_gen(f, [a0]);
+   }
+    /*<<?>>*/ function caml_call2(f, a0, a1){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 2
+            ? f(a0, a1)
+            : runtime.caml_call_gen(f, [a0, a1]);
+   }
+    /*<<?>>*/ function caml_call3(f, a0, a1, a2){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 3
+            ? f(a0, a1, a2)
+            : runtime.caml_call_gen(f, [a0, a1, a2]);
+   }
+    /*<<?>>*/ function caml_call4(f, a0, a1, a2, a3){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 4
+            ? f(a0, a1, a2, a3)
+            : runtime.caml_call_gen(f, [a0, a1, a2, a3]);
+   }
+    /*<<?>>*/ function caml_call5(f, a0, a1, a2, a3, a4){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 5
+            ? f(a0, a1, a2, a3, a4)
+            : runtime.caml_call_gen(f, [a0, a1, a2, a3, a4]);
+   }
+   var
+    global_data = runtime.caml_get_global_data(),
+    Stdlib_Bytes = global_data.Stdlib__Bytes,
+    Stdlib_Sys = global_data.Stdlib__Sys,
+    Stdlib_Seq = global_data.Stdlib__Seq,
+    Stdlib = global_data.Stdlib,
+    Stdlib_String = global_data.Stdlib__String,
+    Assert_failure = global_data.Assert_failure,
+    cst_Buffer_truncate = "Buffer.truncate",
+    _a_ = [0, "buffer.ml", 220, 9],
+    cst_Buffer_add_channel = "Buffer.add_channel",
+    cst_Buffer_add_substring_add_s = "Buffer.add_substring/add_subbytes",
+    cst_Buffer_add_cannot_grow_buf = "Buffer.add: cannot grow buffer",
+    cst_Buffer_nth = "Buffer.nth",
+    cst_Buffer_blit = "Buffer.blit",
+    cst_Buffer_sub = "Buffer.sub";
+   function create(n){
+     /*<<buffer.ml:41:1>>*/ var
+     n$0 = 1 <= n ? n : 1,
+     n$1 = Stdlib_Sys[12] < n$0 ? Stdlib_Sys[12] : n$0,
+      /*<<buffer.ml:43:9>>*/ s =
+        /*<<buffer.ml:43:9>>*/ caml_create_bytes(n$1);
+     /*<<buffer.ml:44:1>>*/ return [0, [0, s, n$1], 0, s];
+    /*<<buffer.ml:44:71>>*/ }
+   function contents(b){
+     /*<<buffer.ml:46:17>>*/ return caml_call3
+            (Stdlib_Bytes[8], b[1][1], 0, b[2]);
+    /*<<buffer.ml:46:61>>*/ }
+   function to_bytes(b){
+     /*<<buffer.ml:47:17>>*/ return caml_call3
+            (Stdlib_Bytes[7], b[1][1], 0, b[2]);
+    /*<<buffer.ml:47:54>>*/ }
+   function sub(b, ofs, len){
+     /*<<buffer.ml:50:2>>*/ if
+     (0 <= ofs && 0 <= len && (b[2] - len | 0) >= ofs)
+      /*<<buffer.ml:52:7>>*/ return  /*<<buffer.ml:52:7>>*/ caml_call3
+             (Stdlib_Bytes[8], b[1][1], ofs, len);
+     /*<<buffer.ml:51:7>>*/ return  /*<<buffer.ml:51:7>>*/ caml_call1
+            (Stdlib[1], cst_Buffer_sub);
+    /*<<buffer.ml:52:46>>*/ }
+   function blit(src, srcoff, dst, dstoff, len){
+     /*<<buffer.ml:56:2>>*/ if
+     (0 <= len
+      &&
+       0 <= srcoff
+       &&
+        (src[2] - len | 0) >= srcoff
+        && 0 <= dstoff && (caml_ml_bytes_length(dst) - len | 0) >= dstoff)
+      /*<<buffer.ml:60:4>>*/ return  /*<<buffer.ml:60:4>>*/ caml_call5
+             (Stdlib_Bytes[11], src[1][1], srcoff, dst, dstoff, len);
+     /*<<buffer.ml:58:7>>*/ return  /*<<buffer.ml:58:7>>*/ caml_call1
+            (Stdlib[1], cst_Buffer_blit);
+    /*<<buffer.ml:60:53>>*/ }
+   function nth(b, ofs){
+     /*<<buffer.ml:64:2>>*/ var
+     position = b[2],
+      /*<<buffer.ml:65:2>>*/ match = b[1],
+     length = match[2],
+     buffer = match[1];
+    if(0 <= ofs && position > ofs && length >= position)
+     return runtime.caml_bytes_unsafe_get(buffer, ofs);
+     /*<<buffer.ml:67:3>>*/ return  /*<<buffer.ml:67:3>>*/ caml_call1
+            (Stdlib[1], cst_Buffer_nth);
+    /*<<buffer.ml:68:34>>*/ }
+   function length(b){
+     /*<<buffer.ml:71:15>>*/ return b[2];
+    /*<<buffer.ml:71:25>>*/ }
+   function clear(b){
+     /*<<buffer.ml:73:14>>*/ b[2] = 0;
+    return 0;
+    /*<<buffer.ml:73:29>>*/ }
+   function reset(b){
+     /*<<buffer.ml:76:2>>*/ b[2] = 0;
+     /*<<buffer.ml:78:4>>*/  /*<<buffer.ml:78:4>>*/ var
+     inner = [0, b[3], caml_ml_bytes_length(b[3])];
+    b[1] = inner;
+    return 0;
+    /*<<buffer.ml:80:18>>*/ }
+   function resize(b, more){
+     /*<<buffer.ml:87:2>>*/ var
+     old_pos = b[2],
+     old_len = b[1][2],
+      /*<<buffer.ml:89:16>>*/ new_len = [0, old_len];
+    for(;;){
+     if(new_len[1] >= (old_pos + more | 0)){
+      if(Stdlib_Sys[12] < new_len[1])
+       if((old_pos + more | 0) <= Stdlib_Sys[12])
+        new_len[1] = Stdlib_Sys[12];
+       else
+         /*<<buffer.ml:94:9>>*/  /*<<buffer.ml:94:9>>*/ caml_call1
+         (Stdlib[2], cst_Buffer_add_cannot_grow_buf);
+       /*<<buffer.ml:96:19>>*/  /*<<buffer.ml:96:19>>*/ var
+       new_buffer =  /*<<buffer.ml:96:19>>*/ caml_create_bytes(new_len[1]);
+       /*<<buffer.ml:99:2>>*/  /*<<buffer.ml:99:2>>*/ caml_call5
+       (Stdlib_Bytes[11], b[1][1], 0, new_buffer, 0, b[2]);
+      b[1] = [0, new_buffer, new_len[1]];
+      return 0;
+     }
+     new_len[1] = 2 * new_len[1] | 0;
+    }
+    /*<<buffer.ml:100:55>>*/ }
+   function add_char(b, c){
+     /*<<buffer.ml:113:2>>*/ var
+     pos = b[2],
+      /*<<buffer.ml:114:2>>*/ match = b[1],
+     length = match[2],
+     buffer = match[1];
+    if(length <= pos){
+      /*<<buffer.ml:116:4>>*/ resize(b, 1);
+      /*<<buffer.ml:117:4>>*/  /*<<buffer.ml:117:4>>*/ caml_bytes_set
+      (b[1][1], b[2], c);
+    }
+    else
+     caml_bytes_unsafe_set(buffer, pos, c);
+    b[2] = pos + 1 | 0;
+    return 0;
+    /*<<buffer.ml:120:23>>*/ }
+   var uchar_utf_8_byte_length_max = 4, uchar_utf_16_byte_length_max = 4;
+   function add_utf_8_uchar(b, u){
+     /*<<buffer.ml:126:2>>*/ for(;;){
+     var pos = b[2];
+     if(b[1][2] <= pos)
+       /*<<buffer.ml:127:32>>*/ resize(b, uchar_utf_8_byte_length_max);
+      /*<<buffer.ml:128:10>>*/  /*<<buffer.ml:128:10>>*/ var
+      n =
+         /*<<buffer.ml:128:10>>*/ caml_call3
+         (Stdlib_Bytes[51], b[1][1], pos, u);
+      /*<<buffer.ml:129:2>>*/ if(0 !== n){b[2] = pos + n | 0; return 0;}
+      /*<<buffer.ml:130:8>>*/ resize(b, uchar_utf_8_byte_length_max);
+    }
+    /*<<buffer.ml:131:30>>*/ }
+   function add_utf_16be_uchar(b, u){
+     /*<<buffer.ml:134:2>>*/ for(;;){
+     var pos = b[2];
+     if(b[1][2] <= pos)
+       /*<<buffer.ml:135:32>>*/ resize(b, uchar_utf_16_byte_length_max);
+      /*<<buffer.ml:136:10>>*/  /*<<buffer.ml:136:10>>*/ var
+      n =
+         /*<<buffer.ml:136:10>>*/ caml_call3
+         (Stdlib_Bytes[54], b[1][1], pos, u);
+      /*<<buffer.ml:137:2>>*/ if(0 !== n){b[2] = pos + n | 0; return 0;}
+      /*<<buffer.ml:138:8>>*/ resize(b, uchar_utf_16_byte_length_max);
+    }
+    /*<<buffer.ml:139:30>>*/ }
+   function add_utf_16le_uchar(b, u){
+     /*<<buffer.ml:142:2>>*/ for(;;){
+     var pos = b[2];
+     if(b[1][2] <= pos)
+       /*<<buffer.ml:143:32>>*/ resize(b, uchar_utf_16_byte_length_max);
+      /*<<buffer.ml:144:10>>*/  /*<<buffer.ml:144:10>>*/ var
+      n =
+         /*<<buffer.ml:144:10>>*/ caml_call3
+         (Stdlib_Bytes[57], b[1][1], pos, u);
+      /*<<buffer.ml:145:2>>*/ if(0 !== n){b[2] = pos + n | 0; return 0;}
+      /*<<buffer.ml:146:8>>*/ resize(b, uchar_utf_16_byte_length_max);
+    }
+    /*<<buffer.ml:147:30>>*/ }
+   function add_substring(b, s, offset, len){
+     /*<<buffer.ml:150:2>>*/ var _r_ = offset < 0 ? 1 : 0;
+    if(_r_)
+     var _s_ = _r_;
+    else
+     var
+      _t_ = len < 0 ? 1 : 0,
+      _s_ = _t_ || ((caml_ml_string_length(s) - len | 0) < offset ? 1 : 0);
+    if(_s_)
+      /*<<buffer.ml:151:7>>*/  /*<<buffer.ml:151:7>>*/ caml_call1
+      (Stdlib[1], cst_Buffer_add_substring_add_s);
+     /*<<buffer.ml:153:2>>*/ var
+     position = b[2],
+      /*<<buffer.ml:153:2>>*/ match = b[1],
+     length = match[2],
+     buffer = match[1],
+     new_position = position + len | 0;
+    if(length < new_position){
+      /*<<buffer.ml:156:4>>*/ resize(b, len);
+      /*<<buffer.ml:157:4>>*/  /*<<buffer.ml:157:4>>*/ caml_call5
+      (Stdlib_Bytes[12], s, offset, b[1][1], b[2], len);
+    }
+    else
+      /*<<buffer.ml:159:4>>*/  /*<<buffer.ml:159:4>>*/ caml_blit_string
+      (s, offset, buffer, position, len);
+    b[2] = new_position;
+    return 0;
+    /*<<buffer.ml:160:28>>*/ }
+   function add_subbytes(b, s, offset, len){
+     /*<<buffer.ml:163:2>>*/ return add_substring
+            (b,
+              /*<<buffer.ml:163:18>>*/ caml_call1(Stdlib_Bytes[44], s),
+             offset,
+             len);
+    /*<<buffer.ml:163:55>>*/ }
+   function add_string(b, s){
+     /*<<buffer.ml:166:2>>*/ var
+     len = caml_ml_string_length(s),
+      /*<<buffer.ml:167:2>>*/ position = b[2],
+      /*<<buffer.ml:168:2>>*/ match = b[1],
+     length = match[2],
+     buffer = match[1],
+     new_position = b[2] + len | 0;
+    if(length < new_position){
+      /*<<buffer.ml:171:4>>*/ resize(b, len);
+      /*<<buffer.ml:172:4>>*/  /*<<buffer.ml:172:4>>*/ caml_call5
+      (Stdlib_Bytes[12], s, 0, b[1][1], b[2], len);
+    }
+    else
+      /*<<buffer.ml:174:4>>*/  /*<<buffer.ml:174:4>>*/ caml_blit_string
+      (s, 0, buffer, position, len);
+    b[2] = new_position;
+    return 0;
+    /*<<buffer.ml:175:28>>*/ }
+   function add_bytes(b, s){
+     /*<<buffer.ml:177:20>>*/ return add_string
+            (b,  /*<<buffer.ml:177:33>>*/ caml_call1(Stdlib_Bytes[44], s));
+    /*<<buffer.ml:177:59>>*/ }
+   function add_buffer(b, bs){
+     /*<<buffer.ml:180:2>>*/ return add_subbytes(b, bs[1][1], 0, bs[2]);
+    /*<<buffer.ml:180:46>>*/ }
+   function add_channel(b, ic, to_read$1){
+     /*<<buffer.ml:206:2>>*/ var
+     _p_ = to_read$1 < 0 ? 1 : 0,
+     _q_ = _p_ || (Stdlib_Sys[12] < to_read$1 ? 1 : 0);
+    if(_q_)
+      /*<<buffer.ml:207:4>>*/  /*<<buffer.ml:207:4>>*/ caml_call1
+      (Stdlib[1], cst_Buffer_add_channel);
+    if(b[1][2] < (b[2] + to_read$1 | 0))
+      /*<<buffer.ml:200:44>>*/ resize(b, to_read$1);
+    var
+     ofs$1 = b[2],
+     buf = b[1][1],
+     already_read = 0,
+     ofs = ofs$1,
+     to_read = to_read$1;
+     /*<<buffer.ml:185:4>>*/ for(;;){
+     if(0 !== to_read){
+       /*<<buffer.ml:187:14>>*/  /*<<buffer.ml:187:14>>*/ var
+       r =
+          /*<<buffer.ml:187:14>>*/ caml_call4
+          (Stdlib[84], ic, buf, ofs, to_read);
+       /*<<buffer.ml:188:6>>*/ if(0 !== r){
+       var
+        already_read$0 = already_read + r | 0,
+        ofs$0 = ofs + r | 0,
+        to_read$0 = to_read - r | 0,
+        already_read = already_read$0,
+        ofs = ofs$0,
+        to_read = to_read$0;
+       continue;
+      }
+     }
+     b[2] = b[2] + already_read | 0;
+     if(already_read < to_read$1)
+       /*<<buffer.ml:211:18>>*/ throw  /*<<buffer.ml:211:18>>*/ caml_maybe_attach_backtrace
+             (Stdlib[12], 1);
+      /*<<buffer.ml:212:2>>*/ return 0;
+    }
+    /*<<buffer.ml:212:4>>*/ }
+   function output_buffer(oc, b){
+     /*<<buffer.ml:215:2>>*/ return caml_call4
+            (Stdlib[68], oc, b[1][1], 0, b[2]);
+    /*<<buffer.ml:215:39>>*/ }
+   function add_substitute(b, f, s){
+     /*<<buffer.ml:260:2>>*/ var
+     lim$1 = caml_ml_string_length(s),
+     previous = 32,
+     i$4 = 0;
+     /*<<buffer.ml:262:4>>*/ for(;;){
+     if(i$4 >= lim$1){
+      var _o_ = 92 === previous ? 1 : 0;
+      return _o_ ? add_char(b, previous) : _o_;
+     }
+      /*<<buffer.ml:263:12>>*/  /*<<buffer.ml:263:12>>*/ var
+      previous$0 =  /*<<buffer.ml:263:12>>*/ caml_string_get(s, i$4);
+     if(36 === previous$0)
+      if(92 === previous){
+        /*<<buffer.ml:265:9>>*/ add_char(b, previous$0);
+        /*<<buffer.ml:265:9>>*/ var
+         /*<<buffer.ml:265:9>>*/ i$5 = i$4 + 1 | 0,
+        previous = 32,
+        i$4 = i$5;
+      }
+      else{
+        /*<<buffer.ml:268:9>>*/  /*<<buffer.ml:268:9>>*/ var
+        start$0 = i$4 + 1 | 0;
+       if(lim$1 <= start$0)
+         /*<<buffer.ml:245:23>>*/ throw  /*<<buffer.ml:245:23>>*/ caml_maybe_attach_backtrace
+               (Stdlib[8], 1);
+        /*<<buffer.ml:246:8>>*/  /*<<buffer.ml:246:8>>*/ var
+        opening =  /*<<buffer.ml:246:8>>*/ caml_string_get(s, start$0);
+       a:
+       {
+        if(40 !== opening && 123 !== opening){
+          /*<<buffer.ml:254:5>>*/ var
+           /*<<buffer.ml:254:5>>*/ start = start$0 + 1 | 0,
+          lim$0 = caml_ml_string_length(s),
+          i$2 = start;
+          /*<<buffer.ml:237:4>>*/ for(;;){
+          b:
+          {
+           if(lim$0 > i$2){
+             /*<<buffer.ml:238:10>>*/  /*<<buffer.ml:238:10>>*/ var
+             match =  /*<<buffer.ml:238:10>>*/ caml_string_get(s, i$2);
+            c:
+            {
+             if(91 <= match){
+              if(97 <= match){
+               if(123 > match) break c;
+              }
+              else if(95 === match) break c;
+             }
+             else
+              if(58 <= match){
+               if(65 <= match) break c;
+              }
+              else if(48 <= match) break c;
+             var stop$0 = i$2;
+             break b;
+            }
+            var i$3 = i$2 + 1 | 0, i$2 = i$3;
+            continue;
+           }
+           var stop$0 = lim$0;
+          }
+          var
+           match$0 =
+             [0,
+               /*<<buffer.ml:255:5>>*/ caml_call3
+               (Stdlib_String[15], s, start$0, stop$0 - start$0 | 0),
+              stop$0];
+          break a;
+         }
+        }
+         /*<<buffer.ml:249:5>>*/ var
+          /*<<buffer.ml:249:5>>*/ new_start = start$0 + 1 | 0,
+         k$2 = 0;
+        if(40 === opening)
+         var closing = 41;
+        else{
+         if(123 !== opening)
+           /*<<buffer.ml:220:9>>*/ throw  /*<<buffer.ml:220:9>>*/ caml_maybe_attach_backtrace
+                 ([0, Assert_failure, _a_], 1);
+         var closing = 125;
+        }
+        var lim = caml_ml_string_length(s), k = k$2, stop = new_start;
+         /*<<buffer.ml:228:4>>*/ for(;;){
+         if(lim <= stop)
+           /*<<buffer.ml:228:21>>*/ throw  /*<<buffer.ml:228:21>>*/ caml_maybe_attach_backtrace
+                 (Stdlib[8], 1);
+         if( /*<<buffer.ml:229:7>>*/ caml_string_get(s, stop) === opening)
+          var i = stop + 1 | 0, k$0 = k + 1 | 0, k = k$0, stop = i;
+         else if
+          ( /*<<buffer.ml:230:7>>*/ caml_string_get(s, stop) === closing){
+          if(0 === k){
+           var
+            match$0 =
+              [0,
+                /*<<buffer.ml:251:5>>*/ caml_call3
+                (Stdlib_String[15],
+                 s,
+                 new_start,
+                 (stop - start$0 | 0) - 1 | 0),
+               stop + 1 | 0];
+           break;
+          }
+          var i$0 = stop + 1 | 0, k$1 = k - 1 | 0, k = k$1, stop = i$0;
+         }
+         else
+          var i$1 = stop + 1 | 0, stop = i$1;
+        }
+       }
+       var next_i = match$0[2], ident = match$0[1];
+        /*<<buffer.ml:270:9>>*/ add_string
+        (b,  /*<<buffer.ml:270:22>>*/ caml_call1(f, ident));
+       var previous = 32, i$4 = next_i;
+      }
+     else if(92 === previous){
+       /*<<buffer.ml:273:9>>*/ add_char(b, 92);
+       /*<<buffer.ml:274:9>>*/ add_char(b, previous$0);
+       /*<<buffer.ml:274:9>>*/ var
+        /*<<buffer.ml:274:9>>*/ i$6 = i$4 + 1 | 0,
+       previous = 32,
+       i$4 = i$6;
+     }
+     else if(92 === previous$0)
+       /*<<buffer.ml:277:9>>*/ var
+        /*<<buffer.ml:277:9>>*/ i$7 = i$4 + 1 | 0,
+       previous = previous$0,
+       i$4 = i$7;
+     else{
+       /*<<buffer.ml:279:9>>*/ add_char(b, previous$0);
+       /*<<buffer.ml:279:9>>*/ var
+        /*<<buffer.ml:279:9>>*/ i$8 = i$4 + 1 | 0,
+       previous = previous$0,
+       i$4 = i$8;
+     }
+    }
+    /*<<buffer.ml:283:13>>*/ }
+   function truncate(b, len){
+     /*<<buffer.ml:286:4>>*/ if(0 <= len && b[2] >= len){b[2] = len; return 0;}
+     /*<<buffer.ml:287:6>>*/ return  /*<<buffer.ml:287:6>>*/ caml_call1
+            (Stdlib[1], cst_Buffer_truncate);
+    /*<<buffer.ml:289:23>>*/ }
+   function to_seq(b){
+    function aux(i, param){
+      /*<<buffer.ml:296:4>>*/ if(b[2] <= i)
+       /*<<buffer.ml:296:28>>*/ return 0;
+      /*<<buffer.ml:298:14>>*/ var
+       /*<<buffer.ml:298:14>>*/ x =
+         /*<<buffer.ml:298:14>>*/ caml_bytes_get(b[1][1], i),
+       /*<<buffer.ml:298:14>>*/ _m_ = i + 1 | 0;
+      /*<<buffer.ml:299:6>>*/ return [0,
+             x,
+             function(_n_){ /*<<?>>*/ return aux(_m_, _n_);}];
+     /*<<buffer.ml:299:29>>*/ }
+     /*<<buffer.ml:301:2>>*/  /*<<buffer.ml:301:2>>*/ var _k_ = 0;
+     /*<<buffer.ml:301:2>>*/ return function(_l_){
+      /*<<?>>*/ return aux(_k_, _l_);};
+    /*<<buffer.ml:301:7>>*/ }
+   function to_seqi(b){
+    function aux(i, param){
+      /*<<buffer.ml:306:4>>*/ if(b[2] <= i)
+       /*<<buffer.ml:306:28>>*/ return 0;
+      /*<<buffer.ml:308:14>>*/ var
+       /*<<buffer.ml:308:14>>*/ x =
+         /*<<buffer.ml:308:14>>*/ caml_bytes_get(b[1][1], i),
+       /*<<buffer.ml:308:14>>*/ _i_ = i + 1 | 0;
+      /*<<buffer.ml:309:6>>*/ return [0,
+             [0, i, x],
+             function(_j_){ /*<<?>>*/ return aux(_i_, _j_);}];
+     /*<<buffer.ml:309:33>>*/ }
+     /*<<buffer.ml:311:2>>*/  /*<<buffer.ml:311:2>>*/ var _g_ = 0;
+     /*<<buffer.ml:311:2>>*/ return function(_h_){
+      /*<<?>>*/ return aux(_g_, _h_);};
+    /*<<buffer.ml:311:7>>*/ }
+   function add_seq(b, seq){
+     /*<<buffer.ml:313:29>>*/ function _e_(_f_){
+      /*<<?>>*/ return add_char(b, _f_);
+    }
+     /*<<buffer.ml:313:20>>*/ return  /*<<buffer.ml:313:20>>*/ caml_call2
+            (Stdlib_Seq[4], _e_, seq);
+    /*<<buffer.ml:313:45>>*/ }
+   function of_seq(i){
+     /*<<buffer.ml:316:2>>*/  /*<<buffer.ml:316:10>>*/ var b = create(32);
+     /*<<buffer.ml:317:2>>*/ add_seq(b, i);
+     /*<<buffer.ml:317:2>>*/ return b;
+    /*<<buffer.ml:318:3>>*/ }
+   function add_int8(b, x){
+     /*<<buffer.ml:337:2>>*/ var
+     position = b[2],
+      /*<<buffer.ml:338:2>>*/ match = b[1],
+     length = match[2],
+     buffer = match[1],
+      /*<<buffer.ml:339:2>>*/ new_position = position + 1 | 0;
+    if(length < new_position){
+      /*<<buffer.ml:341:4>>*/ resize(b, 1);
+      /*<<buffer.ml:342:4>>*/  /*<<buffer.ml:342:4>>*/ caml_bytes_set
+      (b[1][1], b[2], x);
+    }
+    else
+     caml_bytes_unsafe_set(buffer, position, x);
+    b[2] = new_position;
+    return 0;
+    /*<<buffer.ml:345:28>>*/ }
+   function add_int16_ne(b, x){
+     /*<<buffer.ml:348:2>>*/ var
+     position = b[2],
+      /*<<buffer.ml:349:2>>*/ match = b[1],
+     length = match[2],
+     buffer = match[1],
+      /*<<buffer.ml:350:2>>*/ new_position = position + 2 | 0;
+    if(length < new_position){
+      /*<<buffer.ml:352:4>>*/ resize(b, 2);
+      /*<<buffer.ml:353:4>>*/  /*<<buffer.ml:353:4>>*/ caml_bytes_set16
+      (b[1][1], b[2], x);
+    }
+    else
+      /*<<buffer.ml:355:4>>*/  /*<<buffer.ml:355:4>>*/ caml_bytes_set16
+      (buffer, position, x);
+    b[2] = new_position;
+    return 0;
+    /*<<buffer.ml:356:28>>*/ }
+   function add_int32_ne(b, x){
+     /*<<buffer.ml:359:2>>*/ var
+     position = b[2],
+      /*<<buffer.ml:360:2>>*/ match = b[1],
+     length = match[2],
+     buffer = match[1],
+      /*<<buffer.ml:361:2>>*/ new_position = position + 4 | 0;
+    if(length < new_position){
+      /*<<buffer.ml:363:4>>*/ resize(b, 4);
+      /*<<buffer.ml:364:4>>*/  /*<<buffer.ml:364:4>>*/ caml_bytes_set32
+      (b[1][1], b[2], x);
+    }
+    else
+      /*<<buffer.ml:366:4>>*/  /*<<buffer.ml:366:4>>*/ caml_bytes_set32
+      (buffer, position, x);
+    b[2] = new_position;
+    return 0;
+    /*<<buffer.ml:367:28>>*/ }
+   function add_int64_ne(b, x){
+     /*<<buffer.ml:370:2>>*/ var
+     position = b[2],
+      /*<<buffer.ml:371:2>>*/ match = b[1],
+     length = match[2],
+     buffer = match[1],
+      /*<<buffer.ml:372:2>>*/ new_position = position + 8 | 0;
+    if(length < new_position){
+      /*<<buffer.ml:374:4>>*/ resize(b, 8);
+      /*<<buffer.ml:375:4>>*/  /*<<buffer.ml:375:4>>*/ caml_bytes_set64
+      (b[1][1], b[2], x);
+    }
+    else
+      /*<<buffer.ml:377:4>>*/  /*<<buffer.ml:377:4>>*/ caml_bytes_set64
+      (buffer, position, x);
+    b[2] = new_position;
+    return 0;
+    /*<<buffer.ml:378:28>>*/ }
+   function add_int16_le(b, x){
+     /*<<buffer.ml:381:2>>*/ var _d_ = Stdlib_Sys[11] ? caml_bswap16(x) : x;
+    return add_int16_ne(b, _d_);
+    /*<<buffer.ml:381:57>>*/ }
+   function add_int16_be(b, x){
+     /*<<buffer.ml:384:2>>*/ var x$0 = Stdlib_Sys[11] ? x : caml_bswap16(x);
+     /*<<buffer.ml:384:41>>*/ return add_int16_ne(b, x$0);
+    /*<<buffer.ml:384:57>>*/ }
+   function add_int32_le(b, x){
+     /*<<buffer.ml:387:2>>*/ var
+     _c_ = Stdlib_Sys[11] ?  /*<<buffer.ml:387:41>>*/ caml_int32_bswap(x) : x;
+     /*<<buffer.ml:387:41>>*/ return add_int32_ne(b, _c_);
+    /*<<buffer.ml:387:57>>*/ }
+   function add_int32_be(b, x){
+     /*<<buffer.ml:390:2>>*/ var
+     x$0 = Stdlib_Sys[11] ? x :  /*<<buffer.ml:390:48>>*/ caml_int32_bswap(x);
+     /*<<buffer.ml:390:48>>*/ return add_int32_ne(b, x$0);
+    /*<<buffer.ml:390:57>>*/ }
+   function add_int64_le(b, x){
+     /*<<buffer.ml:393:2>>*/ var
+     _b_ = Stdlib_Sys[11] ?  /*<<buffer.ml:393:41>>*/ caml_int64_bswap(x) : x;
+     /*<<buffer.ml:393:41>>*/ return add_int64_ne(b, _b_);
+    /*<<buffer.ml:393:57>>*/ }
+   function add_int64_be(b, x){
+     /*<<buffer.ml:396:2>>*/ var
+     x$0 = Stdlib_Sys[11] ? x :  /*<<buffer.ml:396:48>>*/ caml_int64_bswap(x);
+     /*<<buffer.ml:396:48>>*/ return add_int64_ne(b, x$0);
+    /*<<buffer.ml:396:57>>*/ }
+   var
+    Stdlib_Buffer =
+      [0,
+       create,
+       contents,
+       to_bytes,
+       sub,
+       blit,
+       nth,
+       length,
+       clear,
+       reset,
+       output_buffer,
+       truncate,
+       add_char,
+       add_utf_8_uchar,
+       add_utf_16le_uchar,
+       add_utf_16be_uchar,
+       add_string,
+       add_bytes,
+       add_substring,
+       add_subbytes,
+       add_substitute,
+       add_buffer,
+       add_channel,
+       to_seq,
+       to_seqi,
+       add_seq,
+       of_seq,
+       add_int8,
+       add_int8,
+       add_int16_ne,
+       add_int16_be,
+       add_int16_le,
+       add_int16_ne,
+       add_int16_be,
+       add_int16_le,
+       add_int32_ne,
+       add_int32_be,
+       add_int32_le,
+       add_int64_ne,
+       add_int64_be,
+       add_int64_le];
+   runtime.caml_register_global(14, Stdlib_Buffer, "Stdlib__Buffer");
+   return;
+   /*<<?>>*/ }
+  (globalThis));
+
+//# unitInfo: Provides: Stdlib__Mutex
+(function(globalThis){
+   "use strict";
+   var
+    runtime = globalThis.jsoo_runtime,
+    Stdlib_Mutex =
+      [0,
+       runtime.caml_ml_mutex_new,
+       runtime.caml_ml_mutex_lock,
+       runtime.caml_ml_mutex_try_lock,
+       runtime.caml_ml_mutex_unlock];
+   runtime.caml_register_global(0, Stdlib_Mutex, "Stdlib__Mutex");
+   return;
+   /*<<?>>*/ }
+  (globalThis));
+
+//# unitInfo: Provides: Stdlib__Condition
+(function(globalThis){
+   "use strict";
+   var
+    runtime = globalThis.jsoo_runtime,
+    Stdlib_Condition =
+      [0,
+       runtime.caml_ml_condition_new,
+       runtime.caml_ml_condition_wait,
+       runtime.caml_ml_condition_signal,
+       runtime.caml_ml_condition_broadcast];
+   runtime.caml_register_global(0, Stdlib_Condition, "Stdlib__Condition");
+   return;
+   /*<<?>>*/ }
+  (globalThis));
+
+//# unitInfo: Provides: Stdlib__Semaphore
+//# unitInfo: Requires: Stdlib, Stdlib__Condition, Stdlib__Mutex
+(function
+  (globalThis){
+   "use strict";
+   var
+    runtime = globalThis.jsoo_runtime,
+    caml_maybe_attach_backtrace = runtime.caml_maybe_attach_backtrace;
+    /*<<?>>*/ function caml_call1(f, a0){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 1
+            ? f(a0)
+            : runtime.caml_call_gen(f, [a0]);
+   }
+    /*<<?>>*/ function caml_call2(f, a0, a1){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 2
+            ? f(a0, a1)
+            : runtime.caml_call_gen(f, [a0, a1]);
+   }
+   var
+    global_data = runtime.caml_get_global_data(),
+    Stdlib_Mutex = global_data.Stdlib__Mutex,
+    Stdlib_Condition = global_data.Stdlib__Condition,
+    Stdlib = global_data.Stdlib,
+    cst_Semaphore_Counting_release = "Semaphore.Counting.release: overflow",
+    cst_Semaphore_Counting_init_wr =
+      "Semaphore.Counting.init: wrong initial value";
+   function make(v){
+     /*<<semaphore.ml:29:2>>*/ if(v < 0)
+      /*<<semaphore.ml:29:16>>*/  /*<<semaphore.ml:29:16>>*/ caml_call1
+      (Stdlib[1], cst_Semaphore_Counting_init_wr);
+     /*<<semaphore.ml:30:39>>*/  /*<<semaphore.ml:30:39>>*/ var
+     _c_ =  /*<<semaphore.ml:30:39>>*/ caml_call1(Stdlib_Condition[1], 0);
+     /*<<semaphore.ml:30:2>>*/ return [0,
+             /*<<semaphore.ml:30:10>>*/ caml_call1(Stdlib_Mutex[1], 0),
+            v,
+            _c_];
+    /*<<semaphore.ml:30:59>>*/ }
+   function release(s){
+     /*<<semaphore.ml:33:2>>*/  /*<<semaphore.ml:33:2>>*/ caml_call1
+     (Stdlib_Mutex[2], s[1]);
+    if(s[2] < Stdlib[19]){
+     s[2] = s[2] + 1 | 0;
+      /*<<semaphore.ml:36:4>>*/  /*<<semaphore.ml:36:4>>*/ caml_call1
+      (Stdlib_Condition[3], s[3]);
+     return caml_call1(Stdlib_Mutex[4], s[1]);
+    }
+     /*<<semaphore.ml:39:4>>*/  /*<<semaphore.ml:39:4>>*/ caml_call1
+     (Stdlib_Mutex[4], s[1]);
+     /*<<semaphore.ml:40:4>>*/ throw  /*<<semaphore.ml:40:4>>*/ caml_maybe_attach_backtrace
+           ([0, Stdlib[11], cst_Semaphore_Counting_release], 1);
+    /*<<semaphore.ml:41:5>>*/ }
+   function acquire(s){
+     /*<<semaphore.ml:44:2>>*/  /*<<semaphore.ml:44:2>>*/ caml_call1
+     (Stdlib_Mutex[2], s[1]);
+     /*<<semaphore.ml:45:19>>*/ for(;;){
+     if(0 !== s[2]){
+      s[2] = s[2] - 1 | 0;
+      return caml_call1(Stdlib_Mutex[4], s[1]);
+     }
+      /*<<semaphore.ml:45:19>>*/  /*<<semaphore.ml:45:19>>*/ caml_call2
+      (Stdlib_Condition[2], s[3], s[1]);
+    }
+    /*<<semaphore.ml:47:20>>*/ }
+   function try_acquire(s){
+     /*<<semaphore.ml:50:2>>*/  /*<<semaphore.ml:50:2>>*/ caml_call1
+     (Stdlib_Mutex[2], s[1]);
+    var ret = 0 === s[2] ? 0 : (s[2] = s[2] - 1 | 0, 1);
+     /*<<semaphore.ml:52:2>>*/  /*<<semaphore.ml:52:2>>*/ caml_call1
+     (Stdlib_Mutex[4], s[1]);
+     /*<<semaphore.ml:52:2>>*/ return ret;
+    /*<<semaphore.ml:53:5>>*/ }
+   function get_value(s){
+     /*<<semaphore.ml:55:18>>*/ return s[2];
+    /*<<semaphore.ml:55:21>>*/ }
+    /*<<semaphore.ml:24:18>>*/  /*<<semaphore.ml:24:18>>*/ var
+    Counting = [0, make, release, acquire, try_acquire, get_value];
+   function make$0(b){
+     /*<<semaphore.ml:64:2>>*/ var
+      /*<<semaphore.ml:66:14>>*/ _a_ =
+        /*<<semaphore.ml:66:14>>*/ caml_call1(Stdlib_Condition[1], 0),
+     _b_ = b ? 1 : 0;
+     /*<<semaphore.ml:64:2>>*/ return [0,
+             /*<<semaphore.ml:64:10>>*/ caml_call1(Stdlib_Mutex[1], 0),
+            _b_,
+            _a_];
+    /*<<semaphore.ml:66:34>>*/ }
+   function release$0(s){
+     /*<<semaphore.ml:69:2>>*/  /*<<semaphore.ml:69:2>>*/ caml_call1
+     (Stdlib_Mutex[2], s[1]);
+    s[2] = 1;
+     /*<<semaphore.ml:71:2>>*/  /*<<semaphore.ml:71:2>>*/ caml_call1
+     (Stdlib_Condition[3], s[3]);
+    return caml_call1(Stdlib_Mutex[4], s[1]);
+    /*<<semaphore.ml:72:20>>*/ }
+   function acquire$0(s){
+     /*<<semaphore.ml:75:2>>*/  /*<<semaphore.ml:75:2>>*/ caml_call1
+     (Stdlib_Mutex[2], s[1]);
+     /*<<semaphore.ml:76:19>>*/ for(;;){
+     if(0 !== s[2]){s[2] = 0; return caml_call1(Stdlib_Mutex[4], s[1]);}
+      /*<<semaphore.ml:76:19>>*/  /*<<semaphore.ml:76:19>>*/ caml_call2
+      (Stdlib_Condition[2], s[3], s[1]);
+    }
+    /*<<semaphore.ml:78:20>>*/ }
+   function try_acquire$0(s){
+     /*<<semaphore.ml:81:2>>*/  /*<<semaphore.ml:81:2>>*/ caml_call1
+     (Stdlib_Mutex[2], s[1]);
+    var ret = 0 === s[2] ? 0 : (s[2] = 0, 1);
+     /*<<semaphore.ml:83:2>>*/  /*<<semaphore.ml:83:2>>*/ caml_call1
+     (Stdlib_Mutex[4], s[1]);
+     /*<<semaphore.ml:83:2>>*/ return ret;
+    /*<<semaphore.ml:84:5>>*/ }
+    /*<<semaphore.ml:59:16>>*/ var
+     /*<<semaphore.ml:59:16>>*/ Binary =
+      [0, make$0, release$0, acquire$0, try_acquire$0],
+    Stdlib_Semaphore = [0, Counting, Binary];
+   runtime.caml_register_global(5, Stdlib_Semaphore, "Stdlib__Semaphore");
+   return;
+   /*<<?>>*/ }
+  (globalThis));
+
+//# unitInfo: Provides: Stdlib__Domain
+//# unitInfo: Requires: Stdlib, Stdlib__Array, Stdlib__Atomic, Stdlib__Condition, Stdlib__List, Stdlib__Mutex
+(function
+  (globalThis){
+   "use strict";
+   var
+    runtime = globalThis.jsoo_runtime,
+    caml_check_bound = runtime.caml_check_bound,
+    caml_domain_dls_set = runtime.caml_domain_dls_set,
+    caml_make_vect = runtime.caml_make_vect,
+    caml_maybe_attach_backtrace = runtime.caml_maybe_attach_backtrace,
+    caml_ml_domain_id = runtime.caml_ml_domain_id,
+    caml_wrap_exception = runtime.caml_wrap_exception;
+    /*<<?>>*/ function caml_call1(f, a0){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 1
+            ? f(a0)
+            : runtime.caml_call_gen(f, [a0]);
+   }
+    /*<<?>>*/ function caml_call2(f, a0, a1){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 2
+            ? f(a0, a1)
+            : runtime.caml_call_gen(f, [a0, a1]);
+   }
+    /*<<?>>*/ function caml_call3(f, a0, a1, a2){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 3
+            ? f(a0, a1, a2)
+            : runtime.caml_call_gen(f, [a0, a1, a2]);
+   }
+    /*<<?>>*/ function caml_call5(f, a0, a1, a2, a3, a4){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 5
+            ? f(a0, a1, a2, a3, a4)
+            : runtime.caml_call_gen(f, [a0, a1, a2, a3, a4]);
+   }
+   var
+    global_data = runtime.caml_get_global_data(),
+    Stdlib_Mutex = global_data.Stdlib__Mutex,
+    Stdlib_Condition = global_data.Stdlib__Condition,
+    Stdlib = global_data.Stdlib,
+    Stdlib_Atomic = global_data.Stdlib__Atomic,
+    Stdlib_List = global_data.Stdlib__List,
+    Stdlib_Array = global_data.Stdlib__Array,
+    cst_internal_error_Am_I_alread = "internal error: Am I already finished?",
+    cst_first_domain_already_spawn = "first domain already spawned";
+   function cpu_relax(param){
+     /*<<domain.ml:32:19>>*/ return  /*<<domain.ml:32:19>>*/ runtime.caml_ml_domain_cpu_relax
+            (0);
+    /*<<domain.ml:32:35>>*/ }
+    /*<<domain.ml:51:30>>*/  /*<<domain.ml:51:30>>*/ var
+    unique_value = [0, 0];
+   function create_dls(param){
+     /*<<domain.ml:59:4>>*/  /*<<domain.ml:59:13>>*/ var
+     st =  /*<<domain.ml:59:13>>*/ caml_make_vect(8, unique_value);
+     /*<<domain.ml:60:4>>*/ return  /*<<domain.ml:60:4>>*/ caml_domain_dls_set
+            (st);
+    /*<<domain.ml:60:20>>*/ }
+    /*<<domain.ml:62:10>>*/ create_dls(0);
+    /*<<domain.ml:66:20>>*/ var
+     /*<<domain.ml:66:20>>*/ key_counter =
+       /*<<domain.ml:66:20>>*/ caml_call1(Stdlib_Atomic[1], 0),
+     /*<<domain.ml:71:20>>*/ parent_keys =
+       /*<<domain.ml:71:20>>*/ caml_call1(Stdlib_Atomic[1], 0);
+   function new_key(split_from_parent, init_orphan){
+     /*<<domain.ml:79:4>>*/ var
+      /*<<domain.ml:79:14>>*/ idx =
+        /*<<domain.ml:79:14>>*/ caml_call2(Stdlib_Atomic[6], key_counter, 1),
+      /*<<domain.ml:80:12>>*/ k = [0, idx, init_orphan];
+     /*<<domain.ml:81:4>>*/ if(split_from_parent){
+      /*<<domain.ml:83:35>>*/ var
+      split = split_from_parent[1],
+       /*<<domain.ml:83:35>>*/ ki = [0, k, split];
+      /*<<domain.ml:74:4>>*/ for(;;){
+       /*<<domain.ml:74:12>>*/  /*<<domain.ml:74:12>>*/ var
+       l =  /*<<domain.ml:74:12>>*/ caml_call1(Stdlib_Atomic[2], parent_keys);
+      if
+       (!
+        (1
+        -
+          /*<<domain.ml:75:11>>*/ caml_call3
+          (Stdlib_Atomic[5], parent_keys, l, [0, ki, l])))
+       break;
+     }
+    }
+     /*<<domain.ml:85:4>>*/ return k;
+    /*<<domain.ml:85:5>>*/ }
+   function maybe_grow(idx){
+     /*<<domain.ml:90:4>>*/ var
+     st = runtime.caml_domain_dls_get(0),
+      /*<<domain.ml:91:4>>*/ sz = st.length - 1;
+    if(idx < sz)  /*<<domain.ml:92:21>>*/ return st;
+    var new_sz = sz;
+     /*<<domain.ml:95:8>>*/ for(;;){
+     if(idx < new_sz){
+       /*<<domain.ml:98:19>>*/  /*<<domain.ml:98:19>>*/ var
+       new_st =  /*<<domain.ml:98:19>>*/ caml_make_vect(new_sz, unique_value);
+       /*<<domain.ml:99:6>>*/  /*<<domain.ml:99:6>>*/ caml_call5
+       (Stdlib_Array[8], st, 0, new_st, 0, sz);
+       /*<<domain.ml:100:6>>*/  /*<<domain.ml:100:6>>*/ caml_domain_dls_set
+       (new_st);
+       /*<<domain.ml:100:6>>*/ return new_st;
+     }
+     var s = 2 * new_sz | 0, new_sz = s;
+    }
+    /*<<domain.ml:102:7>>*/ }
+   function set(param, x){
+     /*<<domain.ml:105:13>>*/ var
+     idx = param[1],
+      /*<<domain.ml:105:13>>*/ st = maybe_grow(idx);
+     /*<<domain.ml:109:4>>*/ caml_check_bound(st, idx)[1 + idx] = x;
+     /*<<domain.ml:109:4>>*/ return 0;
+   }
+   function get(param){
+     /*<<domain.ml:112:13>>*/ var
+     init = param[2],
+     idx = param[1],
+      /*<<domain.ml:112:13>>*/ st = maybe_grow(idx),
+      /*<<domain.ml:113:12>>*/ v = caml_check_bound(st, idx)[1 + idx];
+    if(v !== unique_value)  /*<<domain.ml:118:9>>*/ return v;
+     /*<<domain.ml:115:24>>*/  /*<<domain.ml:115:24>>*/ var
+     v$0 =  /*<<domain.ml:115:24>>*/ caml_call1(init, 0);
+     /*<<domain.ml:116:6>>*/ caml_check_bound(st, idx)[1 + idx] = v$0;
+     /*<<domain.ml:116:6>>*/ return v$0;
+   }
+   function get_id(param){
+    var domain = param[1];
+     /*<<domain.ml:136:27>>*/ return domain;
+   }
+   function self(param){
+     /*<<domain.ml:138:14>>*/ return  /*<<domain.ml:138:14>>*/ caml_ml_domain_id
+            (0);
+    /*<<domain.ml:138:25>>*/ }
+   function is_main_domain(param){
+     /*<<domain.ml:140:24>>*/ return 0
+            ===  /*<<domain.ml:140:25>>*/ caml_ml_domain_id(0)
+            ? 1
+            : 0;
+    /*<<domain.ml:140:44>>*/ }
+    /*<<domain.ml:145:27>>*/ var
+     /*<<domain.ml:145:27>>*/ first_domain_spawned =
+       /*<<domain.ml:145:27>>*/ caml_call1(Stdlib_Atomic[1], 0),
+     /*<<domain.ml:147:27>>*/ first_spawn_function =
+      [0,
+       function(param){
+         /*<<domain.ml:147:42>>*/ return 0;
+        /*<<domain.ml:147:44>>*/ }];
+   function before_first_spawn(f){
+     /*<<domain.ml:150:2>>*/ if
+     ( /*<<domain.ml:150:5>>*/ caml_call1
+       (Stdlib_Atomic[2], first_domain_spawned))
+      /*<<domain.ml:151:4>>*/ throw  /*<<domain.ml:151:4>>*/ caml_maybe_attach_backtrace
+            ([0, Stdlib[6], cst_first_domain_already_spawn], 1);
+    var old_f = first_spawn_function[1];
+    function new_f(param){
+      /*<<domain.ml:154:19>>*/  /*<<domain.ml:154:19>>*/ caml_call1(old_f, 0);
+      /*<<domain.ml:154:19>>*/ return  /*<<domain.ml:154:19>>*/ caml_call1
+             (f, 0);
+     /*<<domain.ml:154:33>>*/ }
+    first_spawn_function[1] = new_f;
+    return 0;
+    /*<<domain.ml:156:5>>*/ }
+    /*<<domain.ml:166:18>>*/  /*<<domain.ml:166:18>>*/ var
+    at_exit_key =
+      new_key
+       (0,
+        function(param, _e_){
+          /*<<domain.ml:166:52>>*/ return 0;
+         /*<<domain.ml:166:54>>*/ });
+   function at_exit(f){
+     /*<<domain.ml:169:2>>*/  /*<<domain.ml:169:32>>*/ var
+     old_exit = get(at_exit_key);
+    function new_exit(param){
+      /*<<domain.ml:175:4>>*/  /*<<domain.ml:175:4>>*/ caml_call1(f, 0);
+      /*<<domain.ml:175:4>>*/ return  /*<<domain.ml:175:4>>*/ caml_call1
+             (old_exit, 0);
+     /*<<domain.ml:175:21>>*/ }
+     /*<<domain.ml:177:2>>*/ return set(at_exit_key, new_exit);
+    /*<<domain.ml:177:30>>*/ }
+   function do_at_exit(param){
+     /*<<domain.ml:180:2>>*/  /*<<domain.ml:180:25>>*/ var
+     f = get(at_exit_key);
+     /*<<domain.ml:181:2>>*/ return  /*<<domain.ml:181:2>>*/ caml_call1(f, 0);
+    /*<<domain.ml:181:6>>*/ }
+   Stdlib[104][1] = do_at_exit;
+   function spawn(f){
+     /*<<domain.ml:188:2>>*/ if
+     (1
+      -
+        /*<<domain.ml:159:9>>*/ caml_call1
+        (Stdlib_Atomic[2], first_domain_spawned)){
+      /*<<domain.ml:160:4>>*/  /*<<domain.ml:160:4>>*/ caml_call2
+      (Stdlib_Atomic[3], first_domain_spawned, 1);
+      /*<<domain.ml:161:4>>*/  /*<<domain.ml:161:4>>*/ caml_call1
+      (first_spawn_function[1], 0);
+     first_spawn_function[1] =
+      function(param){
+        /*<<domain.ml:163:39>>*/ return 0;
+       /*<<domain.ml:163:41>>*/ };
+    }
+     /*<<domain.ml:124:6>>*/  /*<<domain.ml:124:6>>*/ var
+     _a_ =  /*<<domain.ml:124:6>>*/ caml_call1(Stdlib_Atomic[2], parent_keys);
+    function _b_(param){
+      /*<<domain.ml:122:6>>*/ var split = param[2], k = param[1], idx = k[1];
+      /*<<domain.ml:123:11>>*/ return [0,
+             idx,
+              /*<<domain.ml:123:26>>*/ caml_call1(split, get(k))];
+     /*<<domain.ml:123:43>>*/ }
+     /*<<domain.ml:124:6>>*/ var
+      /*<<domain.ml:124:6>>*/ pk =
+        /*<<domain.ml:124:6>>*/ caml_call2(Stdlib_List[19], _b_, _a_),
+      /*<<domain.ml:193:19>>*/ term_mutex =
+        /*<<domain.ml:193:19>>*/ caml_call1(Stdlib_Mutex[1], 0),
+      /*<<domain.ml:194:23>>*/ term_condition =
+        /*<<domain.ml:194:23>>*/ caml_call1(Stdlib_Condition[1], 0),
+      /*<<domain.ml:195:19>>*/ term_state = [0, 0];
+    function body(param){
+      /*<<domain.ml:198:4>>*/ a:
+     {
+       /*<<domain.ml:198:4>>*/ try{
+        /*<<domain.ml:200:8>>*/ create_dls(0);
+       var
+        _c_ =
+          function(param){
+            /*<<domain.ml:128:6>>*/ var
+            v = param[2],
+            idx = param[1],
+             /*<<domain.ml:129:17>>*/ st = maybe_grow(idx);
+            /*<<domain.ml:129:35>>*/ caml_check_bound(st, idx)[1 + idx] = v;
+            /*<<domain.ml:129:35>>*/ return 0;
+           /*<<domain.ml:129:49>>*/ };
+        /*<<domain.ml:127:4>>*/  /*<<domain.ml:127:4>>*/ caml_call2
+        (Stdlib_List[17], _c_, pk);
+        /*<<domain.ml:202:18>>*/  /*<<domain.ml:202:18>>*/ var
+        res =  /*<<domain.ml:202:18>>*/ caml_call1(f, 0);
+      }
+      catch(ex$0){
+       var ex = caml_wrap_exception(ex$0), result = [1, ex];
+       break a;
+      }
+      var result = [0, res];
+     }
+      /*<<domain.ml:209:4>>*/ try{
+       /*<<domain.ml:212:12>>*/ do_at_exit(0);
+      var result$0 = result;
+     }
+     catch(ex){
+       /*<<domain.ml:215:10>>*/ var
+       ex$0 = caml_wrap_exception(ex),
+        /*<<domain.ml:215:10>>*/ _d_ = 0 === result[0] ? [1, ex$0] : result,
+       result$0 = _d_;
+     }
+      /*<<domain.ml:230:4>>*/  /*<<domain.ml:230:4>>*/ caml_call1
+      (Stdlib_Mutex[2], term_mutex);
+     return term_state[1]
+             ?  /*<<domain.ml:236:8>>*/ caml_call1
+               (Stdlib[2], cst_internal_error_Am_I_alread)
+             : (term_state
+                [1]
+               = [0, result$0],
+                /*<<domain.ml:197:2>>*/ caml_call1
+                (Stdlib_Condition[4], term_condition));
+     /*<<domain.ml:236:57>>*/ }
+     /*<<domain.ml:240:2>>*/ return [0,
+             /*<<domain.ml:240:13>>*/ runtime.caml_domain_spawn
+             (body, term_mutex),
+            term_mutex,
+            term_condition,
+            term_state];
+    /*<<domain.ml:243:16>>*/ }
+   function join(param){
+    var
+     term_state = param[4],
+     term_condition = param[3],
+     term_mutex = param[2];
+     /*<<domain.ml:246:2>>*/  /*<<domain.ml:246:2>>*/ caml_call1
+     (Stdlib_Mutex[2], term_mutex);
+     /*<<domain.ml:248:4>>*/ for(;;){
+     var match = term_state[1];
+     if(match){
+      var res = match[1];
+       /*<<domain.ml:253:8>>*/  /*<<domain.ml:253:8>>*/ caml_call1
+       (Stdlib_Mutex[4], term_mutex);
+      if(0 === res[0]){var x = res[1];  /*<<domain.ml:257:12>>*/ return x;}
+      var ex = res[1];
+       /*<<domain.ml:258:16>>*/ throw  /*<<domain.ml:258:16>>*/ caml_maybe_attach_backtrace
+             (ex, 1);
+     }
+      /*<<domain.ml:250:8>>*/  /*<<domain.ml:250:8>>*/ caml_call2
+      (Stdlib_Condition[2], term_condition, term_mutex);
+    }
+   }
+   var
+    recommended_domain_count = runtime.caml_recommended_domain_count,
+    Stdlib_Domain =
+      [0,
+       spawn,
+       join,
+       get_id,
+       self,
+       before_first_spawn,
+       at_exit,
+       cpu_relax,
+       is_main_domain,
+       recommended_domain_count,
+       [0, new_key, get, set]];
+   runtime.caml_register_global(8, Stdlib_Domain, "Stdlib__Domain");
+   return;
+   /*<<?>>*/ }
+  (globalThis));
+
+//# unitInfo: Provides: CamlinternalFormat
+//# unitInfo: Requires: Assert_failure, CamlinternalFormatBasics, Stdlib, Stdlib__Buffer, Stdlib__Bytes, Stdlib__Char, Stdlib__Int, Stdlib__String, Stdlib__Sys
+(function
+  (globalThis){
+   "use strict";
+   var
+    runtime = globalThis.jsoo_runtime,
+    cst$43 = "",
+    cst_and = " and ",
+    cst_Li$3 = "%Li",
+    cst_i$3 = "%i",
+    cst_li$3 = "%li",
+    cst_ni$3 = "%ni",
+    cst_u$0 = "%u",
+    cst$42 = "' '",
+    cst$41 = "'#'",
+    cst$39 = "'*'",
+    cst$40 = "'+'",
+    cst$44 = ", ",
+    cst_0$3 = "0",
+    cst_at_character_number = ": at character number ",
+    cst$38 = "@[",
+    cst$37 = "@{",
+    cst_bad_input_format_type_mism =
+      "bad input: format type mismatch between ",
+    cst_bad_input_format_type_mism$0 =
+      "bad input: format type mismatch between %S and %S",
+    cst_camlinternalFormat_ml = "camlinternalFormat.ml",
+    cst_invalid_format = "invalid format ",
+    cst_precision$3 = "precision",
+    caml_blit_string = runtime.caml_blit_string,
+    caml_bytes_set = runtime.caml_bytes_set,
+    caml_create_bytes = runtime.caml_create_bytes,
+    caml_format_float = runtime.caml_format_float,
+    caml_format_int = runtime.caml_format_int,
+    caml_maybe_attach_backtrace = runtime.caml_maybe_attach_backtrace,
+    caml_ml_string_length = runtime.caml_ml_string_length,
+    caml_notequal = runtime.caml_notequal,
+    caml_string_get = runtime.caml_string_get,
+    caml_string_notequal = runtime.caml_string_notequal,
+    caml_string_unsafe_get = runtime.caml_string_unsafe_get,
+    caml_trampoline = runtime.caml_trampoline,
+    caml_trampoline_return = runtime.caml_trampoline_return,
+    caml_wrap_exception = runtime.caml_wrap_exception;
+    /*<<?>>*/ function caml_call1(f, a0){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 1
+            ? f(a0)
+            : runtime.caml_call_gen(f, [a0]);
+   }
+    /*<<?>>*/ function caml_call2(f, a0, a1){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 2
+            ? f(a0, a1)
+            : runtime.caml_call_gen(f, [a0, a1]);
+   }
+    /*<<?>>*/ function caml_call3(f, a0, a1, a2){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 3
+            ? f(a0, a1, a2)
+            : runtime.caml_call_gen(f, [a0, a1, a2]);
+   }
+    /*<<?>>*/ function caml_call4(f, a0, a1, a2, a3){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 4
+            ? f(a0, a1, a2, a3)
+            : runtime.caml_call_gen(f, [a0, a1, a2, a3]);
+   }
+    /*<<?>>*/ function caml_call5(f, a0, a1, a2, a3, a4){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 5
+            ? f(a0, a1, a2, a3, a4)
+            : runtime.caml_call_gen(f, [a0, a1, a2, a3, a4]);
+   }
+   var
+    global_data = runtime.caml_get_global_data(),
+    cst$9 = "%{",
+    cst$10 = "%}",
+    cst$11 = "%(",
+    cst$12 = "%)",
+    cst$13 = "%?",
+    cst$18 = cst$37,
+    cst$19 = cst$38,
+    cst$20 = cst$37,
+    cst$21 = cst$38,
+    cst$22 = cst$37,
+    cst$23 = cst$38,
+    cst$26 = cst$39,
+    cst$24 = "'-'",
+    cst$25 = cst$39,
+    cst$27 = cst$40,
+    cst$28 = cst$41,
+    cst$29 = cst$42,
+    cst$30 = cst$40,
+    cst$31 = "'_'",
+    sub_format = [0, 0, cst$43],
+    formatting_lit = [0, "@;", 1, 0],
+    cst$35 = cst$41,
+    cst$32 = cst$40,
+    cst$33 = cst$40,
+    cst$34 = cst$42,
+    cst$36 = cst$40,
+    cst$17 = ".",
+    cst$14 = "%!",
+    cst$15 = cst$37,
+    cst$16 = cst$38,
+    cst$8 = "%%",
+    cst$0 = "@]",
+    cst$1 = "@}",
+    cst$2 = "@?",
+    cst$3 = "@\n",
+    cst$4 = "@.",
+    cst$5 = "@@",
+    cst$6 = "@%",
+    cst$7 = "@",
+    cst = ".*",
+    Assert_failure = global_data.Assert_failure,
+    CamlinternalFormatBasics = global_data.CamlinternalFormatBasics,
+    Stdlib = global_data.Stdlib,
+    Stdlib_Buffer = global_data.Stdlib__Buffer,
+    Stdlib_String = global_data.Stdlib__String,
+    Stdlib_Sys = global_data.Stdlib__Sys,
+    Stdlib_Char = global_data.Stdlib__Char,
+    Stdlib_Bytes = global_data.Stdlib__Bytes,
+    Stdlib_Int = global_data.Stdlib__Int,
+    cst_c = "%c",
+    cst_s = "%s",
+    cst_i = cst_i$3,
+    cst_li = cst_li$3,
+    cst_ni = cst_ni$3,
+    cst_Li = cst_Li$3,
+    cst_f = "%f",
+    cst_B = "%B",
+    cst_a = "%a",
+    cst_t = "%t",
+    cst_r = "%r",
+    cst_r$0 = "%_r",
+    _b_ = [0, cst_camlinternalFormat_ml, 850, 23],
+    _m_ = [0, cst_camlinternalFormat_ml, 814, 21],
+    _e_ = [0, cst_camlinternalFormat_ml, 815, 21],
+    _n_ = [0, cst_camlinternalFormat_ml, 818, 21],
+    _f_ = [0, cst_camlinternalFormat_ml, 819, 21],
+    _o_ = [0, cst_camlinternalFormat_ml, 822, 19],
+    _g_ = [0, cst_camlinternalFormat_ml, 823, 19],
+    _p_ = [0, cst_camlinternalFormat_ml, 826, 22],
+    _h_ = [0, cst_camlinternalFormat_ml, 827, 22],
+    _q_ = [0, cst_camlinternalFormat_ml, 831, 30],
+    _i_ = [0, cst_camlinternalFormat_ml, 832, 30],
+    _k_ = [0, cst_camlinternalFormat_ml, 836, 26],
+    _c_ = [0, cst_camlinternalFormat_ml, 837, 26],
+    _l_ = [0, cst_camlinternalFormat_ml, 846, 28],
+    _d_ = [0, cst_camlinternalFormat_ml, 847, 28],
+    _j_ = [0, cst_camlinternalFormat_ml, 851, 23],
+    _s_ = [0, cst_camlinternalFormat_ml, 1558, 4],
+    cst_Printf_bad_conversion = "Printf: bad conversion %[",
+    _t_ = [0, cst_camlinternalFormat_ml, 1626, 39],
+    _u_ = [0, cst_camlinternalFormat_ml, 1649, 31],
+    _v_ = [0, cst_camlinternalFormat_ml, 1650, 31],
+    cst_Printf_bad_conversion$0 = "Printf: bad conversion %_",
+    _w_ = [0, cst_camlinternalFormat_ml, 1830, 8],
+    ___ =
+      [0,
+       [11, cst_bad_input_format_type_mism, [3, 0, [11, cst_and, [3, 0, 0]]]],
+       cst_bad_input_format_type_mism$0],
+    _Z_ =
+      [0,
+       [11, cst_bad_input_format_type_mism, [3, 0, [11, cst_and, [3, 0, 0]]]],
+       cst_bad_input_format_type_mism$0],
+    _C_ =
+      [0,
+       [11,
+        cst_invalid_format,
+        [3,
+         0,
+         [11,
+          cst_at_character_number,
+          [4, 0, 0, 0, [11, ", duplicate flag ", [1, 0]]]]]],
+       "invalid format %S: at character number %d, duplicate flag %C"],
+    cst_0 = cst_0$3,
+    cst_padding = "padding",
+    _D_ = [0, 1, 0],
+    _E_ = [0, 0],
+    cst_precision = cst_precision$3,
+    _F_ = [1, 0],
+    _G_ = [1, 1],
+    cst_0$2 = "'0'",
+    cst_0$0 = cst_0$3,
+    _I_ = [1, 1],
+    cst_0$1 = cst_0$3,
+    cst_precision$0 = cst_precision$3,
+    _H_ = [1, 1],
+    cst_precision$1 = cst_precision$3,
+    _M_ =
+      [0,
+       [11,
+        cst_invalid_format,
+        [3,
+         0,
+         [11,
+          cst_at_character_number,
+          [4,
+           0,
+           0,
+           0,
+           [11,
+            ", flag ",
+            [1,
+             [11,
+              " is only allowed after the '",
+              [12, 37, [11, "', before padding and precision", 0]]]]]]]]],
+       "invalid format %S: at character number %d, flag %C is only allowed after the '%%', before padding and precision"],
+    _J_ =
+      [0,
+       [11,
+        cst_invalid_format,
+        [3,
+         0,
+         [11,
+          cst_at_character_number,
+          [4,
+           0,
+           0,
+           0,
+           [11, ', invalid conversion "', [12, 37, [0, [12, 34, 0]]]]]]]],
+       'invalid format %S: at character number %d, invalid conversion "%%%c"'],
+    _K_ = [0, 0],
+    cst_padding$0 = "`padding'",
+    _L_ = [0, 0],
+    cst_precision$2 = "`precision'",
+    _N_ = [0, [12, 64, 0]],
+    _O_ = [0, "@ ", 1, 0],
+    _P_ = [0, "@,", 0, 0],
+    _Q_ = [2, 60],
+    _R_ =
+      [0,
+       [11,
+        cst_invalid_format,
+        [3,
+         0,
+         [11,
+          ": '",
+          [12,
+           37,
+           [11,
+            "' alone is not accepted in character sets, use ",
+            [12,
+             37,
+             [12,
+              37,
+              [11, " instead at position ", [4, 0, 0, 0, [12, 46, 0]]]]]]]]]],
+       "invalid format %S: '%%' alone is not accepted in character sets, use %%%% instead at position %d."],
+    _S_ =
+      [0,
+       [11,
+        cst_invalid_format,
+        [3,
+         0,
+         [11,
+          ": integer ",
+          [4, 0, 0, 0, [11, " is greater than the limit ", [4, 0, 0, 0, 0]]]]]],
+       "invalid format %S: integer %d is greater than the limit %d"],
+    cst_digit = "digit",
+    _T_ = [0, cst_camlinternalFormat_ml, 2837, 11],
+    _U_ =
+      [0,
+       [11,
+        cst_invalid_format,
+        [3,
+         0,
+         [11,
+          ': unclosed sub-format, expected "',
+          [12, 37, [0, [11, '" at character number ', [4, 0, 0, 0, 0]]]]]]],
+       'invalid format %S: unclosed sub-format, expected "%%%c" at character number %d'],
+    cst_character = "character ')'",
+    cst_character$0 = "character '}'",
+    _V_ = [0, cst_camlinternalFormat_ml, 2899, 34],
+    _W_ = [0, cst_camlinternalFormat_ml, 2935, 28],
+    _X_ = [0, cst_camlinternalFormat_ml, 2957, 11],
+    _Y_ =
+      [0,
+       [11,
+        cst_invalid_format,
+        [3,
+         0,
+         [11,
+          cst_at_character_number,
+          [4,
+           0,
+           0,
+           0,
+           [11,
+            cst$44,
+            [2,
+             0,
+             [11,
+              " is incompatible with '",
+              [0, [11, "' in sub-format ", [3, 0, 0]]]]]]]]]],
+       "invalid format %S: at character number %d, %s is incompatible with '%c' in sub-format %S"],
+    _B_ =
+      [0,
+       [11,
+        cst_invalid_format,
+        [3,
+         0,
+         [11,
+          cst_at_character_number,
+          [4, 0, 0, 0, [11, cst$44, [2, 0, [11, " expected, read ", [1, 0]]]]]]]],
+       "invalid format %S: at character number %d, %s expected, read %C"],
+    _A_ =
+      [0,
+       [11,
+        cst_invalid_format,
+        [3,
+         0,
+         [11,
+          cst_at_character_number,
+          [4, 0, 0, 0, [11, ", '", [0, [11, "' without ", [2, 0, 0]]]]]]]],
+       "invalid format %S: at character number %d, '%c' without %s"],
+    cst_non_zero_widths_are_unsupp =
+      "non-zero widths are unsupported for %c conversions",
+    cst_unexpected_end_of_format = "unexpected end of format",
+    _z_ =
+      [0,
+       [11,
+        cst_invalid_format,
+        [3,
+         0,
+         [11, cst_at_character_number, [4, 0, 0, 0, [11, cst$44, [2, 0, 0]]]]]],
+       "invalid format %S: at character number %d, %s"],
+    _y_ =
+      [0,
+       [11, "invalid box description ", [3, 0, 0]],
+       "invalid box description %S"],
+    _x_ = [0, 0, 4],
+    cst_nan = "nan",
+    cst_neg_infinity = "neg_infinity",
+    cst_infinity = "infinity",
+    _r_ = [0, 103],
+    cst_nd$0 = "%+nd",
+    cst_nd$1 = "% nd",
+    cst_ni$1 = "%+ni",
+    cst_ni$2 = "% ni",
+    cst_nx = "%nx",
+    cst_nx$0 = "%#nx",
+    cst_nX = "%nX",
+    cst_nX$0 = "%#nX",
+    cst_no = "%no",
+    cst_no$0 = "%#no",
+    cst_nd = "%nd",
+    cst_ni$0 = cst_ni$3,
+    cst_nu = "%nu",
+    cst_ld$0 = "%+ld",
+    cst_ld$1 = "% ld",
+    cst_li$1 = "%+li",
+    cst_li$2 = "% li",
+    cst_lx = "%lx",
+    cst_lx$0 = "%#lx",
+    cst_lX = "%lX",
+    cst_lX$0 = "%#lX",
+    cst_lo = "%lo",
+    cst_lo$0 = "%#lo",
+    cst_ld = "%ld",
+    cst_li$0 = cst_li$3,
+    cst_lu = "%lu",
+    cst_Ld$0 = "%+Ld",
+    cst_Ld$1 = "% Ld",
+    cst_Li$1 = "%+Li",
+    cst_Li$2 = "% Li",
+    cst_Lx = "%Lx",
+    cst_Lx$0 = "%#Lx",
+    cst_LX = "%LX",
+    cst_LX$0 = "%#LX",
+    cst_Lo = "%Lo",
+    cst_Lo$0 = "%#Lo",
+    cst_Ld = "%Ld",
+    cst_Li$0 = cst_Li$3,
+    cst_Lu = "%Lu",
+    cst_d$0 = "%+d",
+    cst_d$1 = "% d",
+    cst_i$1 = "%+i",
+    cst_i$2 = "% i",
+    cst_x = "%x",
+    cst_x$0 = "%#x",
+    cst_X = "%X",
+    cst_X$0 = "%#X",
+    cst_o = "%o",
+    cst_o$0 = "%#o",
+    cst_d = "%d",
+    cst_i$0 = cst_i$3,
+    cst_u = cst_u$0,
+    cst_0c = "0c",
+    _a_ = [0, 0, 0],
+    cst_CamlinternalFormat_Type_mi = "CamlinternalFormat.Type_mismatch";
+   function create_char_set(param){
+     /*<<camlinternalFormat.ml:24:25>>*/ return  /*<<camlinternalFormat.ml:24:25>>*/ caml_call2
+            (Stdlib_Bytes[1], 32, 0);
+    /*<<camlinternalFormat.ml:24:45>>*/ }
+   function add_in_char_set(char_set, c){
+     /*<<camlinternalFormat.ml:28:2>>*/ var
+     str_ind = c >>> 3 | 0,
+     mask = 1 << (c & 7),
+      /*<<camlinternalFormat.ml:31:30>>*/ _dU_ =
+        /*<<camlinternalFormat.ml:31:30>>*/ runtime.caml_bytes_get
+        (char_set, str_ind)
+       | mask;
+     /*<<camlinternalFormat.ml:30:2>>*/ return  /*<<camlinternalFormat.ml:30:2>>*/ caml_bytes_set
+            (char_set,
+             str_ind,
+              /*<<camlinternalFormat.ml:31:4>>*/ caml_call1(Stdlib[29], _dU_));
+    /*<<camlinternalFormat.ml:31:69>>*/ }
+   function freeze_char_set(char_set){
+     /*<<camlinternalFormat.ml:34:2>>*/ return  /*<<camlinternalFormat.ml:34:2>>*/ caml_call1
+            (Stdlib_Bytes[6], char_set);
+    /*<<camlinternalFormat.ml:34:26>>*/ }
+   function rev_char_set(char_set){
+     /*<<camlinternalFormat.ml:38:2>>*/ var
+      /*<<camlinternalFormat.ml:38:18>>*/ char_set$0 = create_char_set(0),
+     i = 0;
+    for(;;){
+      /*<<camlinternalFormat.ml:41:32>>*/  /*<<camlinternalFormat.ml:41:32>>*/ var
+      _dS_ =
+         /*<<camlinternalFormat.ml:41:32>>*/ caml_string_get(char_set, i)
+        ^ 255;
+      /*<<camlinternalFormat.ml:40:4>>*/  /*<<camlinternalFormat.ml:40:4>>*/ caml_bytes_set
+      (char_set$0,
+       i,
+        /*<<camlinternalFormat.ml:41:6>>*/ caml_call1(Stdlib[29], _dS_));
+      /*<<camlinternalFormat.ml:40:4>>*/  /*<<camlinternalFormat.ml:40:4>>*/ var
+      _dT_ = i + 1 | 0;
+     if(31 === i)
+       /*<<camlinternalFormat.ml:43:2>>*/ return  /*<<camlinternalFormat.ml:43:2>>*/ caml_call1
+              (Stdlib_Bytes[44], char_set$0);
+     var i = _dT_;
+    }
+    /*<<camlinternalFormat.ml:43:34>>*/ }
+   function is_in_char_set(char_set, c){
+     /*<<camlinternalFormat.ml:47:2>>*/ var
+     str_ind = c >>> 3 | 0,
+     mask = 1 << (c & 7);
+    return 0
+            !==
+             ( /*<<camlinternalFormat.ml:49:15>>*/ caml_string_get
+              (char_set, str_ind)
+             & mask)
+            ? 1
+            : 0;
+    /*<<camlinternalFormat.ml:49:60>>*/ }
+   function pad_of_pad_opt(pad_opt){
+     /*<<camlinternalFormat.ml:62:29>>*/ if(! pad_opt)
+      /*<<camlinternalFormat.ml:63:12>>*/ return 0;
+    var width = pad_opt[1];
+     /*<<camlinternalFormat.ml:64:18>>*/ return [0, 1, width];
+    /*<<camlinternalFormat.ml:64:44>>*/ }
+   function param_format_of_ignored_format(ign, fmt){
+     /*<<camlinternalFormat.ml:76:15>>*/ if(typeof ign === "number")
+     switch(ign){
+       case 0:
+         /*<<camlinternalFormat.ml:78:4>>*/ return [0, [0, fmt]];
+       case 1:
+         /*<<camlinternalFormat.ml:80:4>>*/ return [0, [1, fmt]];
+       case 2:
+         /*<<camlinternalFormat.ml:108:4>>*/ return [0, [19, fmt]];
+       default:  /*<<camlinternalFormat.ml:114:4>>*/ return [0, [22, fmt]];
+     }
+    switch(ign[0]){
+      case 0:
+       var pad_opt = ign[1];
+        /*<<camlinternalFormat.ml:82:4>>*/ return [0,
+               [2, pad_of_pad_opt(pad_opt), fmt]];
+      case 1:
+       var pad_opt$0 = ign[1];
+        /*<<camlinternalFormat.ml:84:4>>*/ return [0,
+               [3, pad_of_pad_opt(pad_opt$0), fmt]];
+      case 2:
+       var pad_opt$1 = ign[2], iconv = ign[1];
+        /*<<camlinternalFormat.ml:86:4>>*/ return [0,
+               [4, iconv, pad_of_pad_opt(pad_opt$1), 0, fmt]];
+      case 3:
+       var pad_opt$2 = ign[2], iconv$0 = ign[1];
+        /*<<camlinternalFormat.ml:88:4>>*/ return [0,
+               [5, iconv$0, pad_of_pad_opt(pad_opt$2), 0, fmt]];
+      case 4:
+       var pad_opt$3 = ign[2], iconv$1 = ign[1];
+        /*<<camlinternalFormat.ml:91:4>>*/ return [0,
+               [6, iconv$1, pad_of_pad_opt(pad_opt$3), 0, fmt]];
+      case 5:
+       var pad_opt$4 = ign[2], iconv$2 = ign[1];
+        /*<<camlinternalFormat.ml:94:4>>*/ return [0,
+               [7, iconv$2, pad_of_pad_opt(pad_opt$4), 0, fmt]];
+      case 6:
+       var prec_opt = ign[2], pad_opt$5 = ign[1];
+       if(prec_opt)
+        var ndec = prec_opt[1], _dR_ = [0, ndec];
+       else
+        var _dR_ = 0;
+        /*<<camlinternalFormat.ml:97:4>>*/ return [0,
+               [8, _a_, pad_of_pad_opt(pad_opt$5), _dR_, fmt]];
+      case 7:
+       var pad_opt$6 = ign[1];
+        /*<<camlinternalFormat.ml:101:4>>*/ return [0,
+               [9, pad_of_pad_opt(pad_opt$6), fmt]];
+      case 8:
+       var fmtty = ign[2], pad_opt$7 = ign[1];
+        /*<<camlinternalFormat.ml:103:4>>*/ return [0,
+               [13, pad_opt$7, fmtty, fmt]];
+      case 9:
+       var fmtty$0 = ign[2], pad_opt$8 = ign[1];
+        /*<<camlinternalFormat.ml:105:4>>*/ return [0,
+               [14, pad_opt$8, fmtty$0, fmt]];
+      case 10:
+       var char_set = ign[2], width_opt = ign[1];
+        /*<<camlinternalFormat.ml:110:4>>*/ return [0,
+               [20, width_opt, char_set, fmt]];
+      default:
+       var counter = ign[1];
+        /*<<camlinternalFormat.ml:112:4>>*/ return [0, [21, counter, fmt]];
+    }
+    /*<<camlinternalFormat.ml:114:41>>*/ }
+   function default_float_precision(fconv){
+     /*<<camlinternalFormat.ml:221:2>>*/ return 5 === fconv[2] ? 12 : -6;
+    /*<<camlinternalFormat.ml:227:17>>*/ }
+   function buffer_create(init_size){
+     /*<<camlinternalFormat.ml:256:30>>*/ return [0,
+            0,
+             /*<<camlinternalFormat.ml:256:49>>*/ caml_create_bytes(init_size)];
+    /*<<camlinternalFormat.ml:256:73>>*/ }
+   function buffer_check_size(buf, overhead){
+     /*<<camlinternalFormat.ml:260:2>>*/ var
+     len = runtime.caml_ml_bytes_length(buf[2]),
+     min_len = buf[1] + overhead | 0,
+     _dP_ = len < min_len ? 1 : 0;
+    if(_dP_){
+      /*<<camlinternalFormat.ml:263:18>>*/ var
+       /*<<camlinternalFormat.ml:263:18>>*/ new_len =
+         /*<<camlinternalFormat.ml:263:18>>*/ caml_call2
+         (Stdlib_Int[11], len * 2 | 0, min_len),
+       /*<<camlinternalFormat.ml:264:18>>*/ new_str =
+         /*<<camlinternalFormat.ml:264:18>>*/ caml_create_bytes(new_len);
+      /*<<camlinternalFormat.ml:265:4>>*/  /*<<camlinternalFormat.ml:265:4>>*/ caml_call5
+      (Stdlib_Bytes[11], buf[2], 0, new_str, 0, len);
+     buf[2] = new_str;
+     var _dQ_ = 0;
+    }
+    else
+     var _dQ_ = _dP_;
+    return _dQ_;
+    /*<<camlinternalFormat.ml:267:3>>*/ }
+   function buffer_add_char(buf, c){
+     /*<<camlinternalFormat.ml:271:2>>*/ buffer_check_size(buf, 1);
+     /*<<camlinternalFormat.ml:272:2>>*/  /*<<camlinternalFormat.ml:272:2>>*/ caml_bytes_set
+     (buf[2], buf[1], c);
+    buf[1] = buf[1] + 1 | 0;
+    return 0;
+    /*<<camlinternalFormat.ml:273:24>>*/ }
+   function buffer_add_string(buf, s){
+     /*<<camlinternalFormat.ml:277:2>>*/ var
+     str_len = caml_ml_string_length(s);
+     /*<<camlinternalFormat.ml:278:2>>*/ buffer_check_size(buf, str_len);
+     /*<<camlinternalFormat.ml:279:2>>*/  /*<<camlinternalFormat.ml:279:2>>*/ caml_call5
+     (Stdlib_String[48], s, 0, buf[2], buf[1], str_len);
+    buf[1] = buf[1] + str_len | 0;
+    return 0;
+    /*<<camlinternalFormat.ml:280:30>>*/ }
+   function buffer_contents(buf){
+     /*<<camlinternalFormat.ml:284:2>>*/ return caml_call3
+            (Stdlib_Bytes[8], buf[2], 0, buf[1]);
+    /*<<camlinternalFormat.ml:284:38>>*/ }
+   function char_of_iconv(iconv){
+     /*<<camlinternalFormat.ml:289:26>>*/ switch(iconv){
+      case 6:
+      case 7:
+        /*<<camlinternalFormat.ml:291:38>>*/ return 120;
+      case 8:
+      case 9:
+        /*<<camlinternalFormat.ml:291:62>>*/ return 88;
+      case 10:
+      case 11:
+        /*<<camlinternalFormat.ml:292:14>>*/ return 111;
+      case 12:
+      case 15:
+        /*<<camlinternalFormat.ml:292:38>>*/ return 117;
+      case 0:
+      case 1:
+      case 2:
+      case 13:
+        /*<<camlinternalFormat.ml:290:40>>*/ return 100;
+      default:  /*<<camlinternalFormat.ml:291:14>>*/ return 105;
+    }
+    /*<<camlinternalFormat.ml:292:41>>*/ }
+   function char_of_fconv(opt, fconv){
+     /*<<camlinternalFormat.ml:296:36>>*/ if(opt)
+     var sth = opt[1], cF = sth;
+    else
+     var cF = 70;
+    switch(fconv[2]){
+      case 0:
+        /*<<camlinternalFormat.ml:297:15>>*/ return 102;
+      case 1:
+        /*<<camlinternalFormat.ml:297:32>>*/ return 101;
+      case 2:
+        /*<<camlinternalFormat.ml:298:15>>*/ return 69;
+      case 3:
+        /*<<camlinternalFormat.ml:298:32>>*/ return 103;
+      case 4:
+        /*<<camlinternalFormat.ml:299:15>>*/ return 71;
+      case 5:
+        /*<<camlinternalFormat.ml:299:32>>*/ return cF;
+      case 6:
+        /*<<camlinternalFormat.ml:300:15>>*/ return 104;
+      case 7:
+        /*<<camlinternalFormat.ml:300:32>>*/ return 72;
+      default:  /*<<camlinternalFormat.ml:301:16>>*/ return 70;
+    }
+    /*<<camlinternalFormat.ml:301:19>>*/ }
+   function bprint_padty(buf, padty){
+     /*<<camlinternalFormat.ml:374:29>>*/ switch(padty){
+      case 0:
+        /*<<camlinternalFormat.ml:375:13>>*/ return buffer_add_char(buf, 45);
+      case 1:
+        /*<<camlinternalFormat.ml:376:13>>*/ return 0;
+      default:
+        /*<<camlinternalFormat.ml:377:13>>*/ return buffer_add_char(buf, 48);
+    }
+    /*<<camlinternalFormat.ml:377:36>>*/ }
+   function bprint_ignored_flag(buf, ign_flag){
+     /*<<camlinternalFormat.ml:381:2>>*/ return ign_flag
+            ? buffer_add_char(buf, 95)
+            : ign_flag;
+    /*<<camlinternalFormat.ml:381:42>>*/ }
+   function bprint_pad_opt(buf, pad_opt){
+     /*<<camlinternalFormat.ml:385:33>>*/ if(! pad_opt)
+      /*<<camlinternalFormat.ml:386:12>>*/ return 0;
+    var width = pad_opt[1];
+     /*<<camlinternalFormat.ml:387:40>>*/ return buffer_add_string
+            (buf,
+              /*<<camlinternalFormat.ml:387:40>>*/ caml_call1
+              (Stdlib_Int[12], width));
+    /*<<camlinternalFormat.ml:387:61>>*/ }
+   function bprint_padding(buf, pad){
+     /*<<camlinternalFormat.ml:393:15>>*/ if(typeof pad === "number")
+      /*<<camlinternalFormat.ml:394:18>>*/ return 0;
+    if(0 === pad[0]){
+     var n = pad[2], padty = pad[1];
+      /*<<camlinternalFormat.ml:396:4>>*/ bprint_padty(buf, padty);
+      /*<<camlinternalFormat.ml:397:26>>*/ return buffer_add_string
+             (buf,
+               /*<<camlinternalFormat.ml:397:26>>*/ caml_call1
+               (Stdlib_Int[12], n));
+    }
+    var padty$0 = pad[1];
+     /*<<camlinternalFormat.ml:399:4>>*/ bprint_padty(buf, padty$0);
+     /*<<camlinternalFormat.ml:399:4>>*/ return buffer_add_char(buf, 42);
+    /*<<camlinternalFormat.ml:400:27>>*/ }
+   function bprint_precision(buf, prec){
+     /*<<camlinternalFormat.ml:404:18>>*/ if(typeof prec === "number")
+     return prec ? buffer_add_string(buf, cst) : 0;
+    var n = prec[1];
+     /*<<camlinternalFormat.ml:407:4>>*/ buffer_add_char(buf, 46);
+     /*<<camlinternalFormat.ml:408:26>>*/ return buffer_add_string
+            (buf,
+              /*<<camlinternalFormat.ml:408:26>>*/ caml_call1
+              (Stdlib_Int[12], n));
+    /*<<camlinternalFormat.ml:410:30>>*/ }
+   function bprint_iconv_flag(buf, iconv){
+     /*<<camlinternalFormat.ml:415:34>>*/ switch(iconv){
+      case 1:
+      case 4:
+        /*<<camlinternalFormat.ml:416:23>>*/ return buffer_add_char(buf, 43);
+      case 2:
+      case 5:
+        /*<<camlinternalFormat.ml:417:23>>*/ return buffer_add_char(buf, 32);
+      case 7:
+      case 9:
+      case 11:
+      case 13:
+      case 14:
+      case 15:
+        /*<<camlinternalFormat.ml:419:6>>*/ return buffer_add_char(buf, 35);
+      default:  /*<<camlinternalFormat.ml:420:53>>*/ return 0;
+    }
+    /*<<camlinternalFormat.ml:420:55>>*/ }
+   function bprint_altint_fmt(buf, ign_flag, iconv, pad, prec, c){
+     /*<<camlinternalFormat.ml:433:2>>*/ buffer_add_char(buf, 37);
+     /*<<camlinternalFormat.ml:434:2>>*/ bprint_ignored_flag(buf, ign_flag);
+     /*<<camlinternalFormat.ml:435:2>>*/ bprint_iconv_flag(buf, iconv);
+     /*<<camlinternalFormat.ml:436:2>>*/ bprint_padding(buf, pad);
+     /*<<camlinternalFormat.ml:437:2>>*/ bprint_precision(buf, prec);
+     /*<<camlinternalFormat.ml:438:2>>*/ buffer_add_char(buf, c);
+     /*<<camlinternalFormat.ml:439:22>>*/ return buffer_add_char
+            (buf, char_of_iconv(iconv));
+    /*<<camlinternalFormat.ml:439:43>>*/ }
+   function bprint_fconv_flag(buf, fconv){
+     /*<<camlinternalFormat.ml:445:2>>*/ switch(fconv[1]){
+      case 0: break;
+      case 1:
+        /*<<camlinternalFormat.ml:446:20>>*/ buffer_add_char(buf, 43); break;
+      default:  /*<<camlinternalFormat.ml:447:20>>*/ buffer_add_char(buf, 32);
+    }
+    return 8 <= fconv[2] ? buffer_add_char(buf, 35) : 0;
+    /*<<camlinternalFormat.ml:452:37>>*/ }
+   function string_of_formatting_lit(formatting_lit){
+     /*<<camlinternalFormat.ml:465:46>>*/ if
+     (typeof formatting_lit === "number")
+     switch(formatting_lit){
+       case 0:
+         /*<<camlinternalFormat.ml:466:28>>*/ return cst$0;
+       case 1:
+         /*<<camlinternalFormat.ml:467:28>>*/ return cst$1;
+       case 2:
+         /*<<camlinternalFormat.ml:469:28>>*/ return cst$2;
+       case 3:
+         /*<<camlinternalFormat.ml:470:28>>*/ return cst$3;
+       case 4:
+         /*<<camlinternalFormat.ml:471:28>>*/ return cst$4;
+       case 5:
+         /*<<camlinternalFormat.ml:473:28>>*/ return cst$5;
+       default:  /*<<camlinternalFormat.ml:474:28>>*/ return cst$6;
+     }
+    switch(formatting_lit[0]){
+      case 0:
+       var str = formatting_lit[1];
+        /*<<camlinternalFormat.ml:468:28>>*/ return str;
+      case 1:
+       var str$0 = formatting_lit[1];
+        /*<<camlinternalFormat.ml:472:28>>*/ return str$0;
+      default:
+        /*<<camlinternalFormat.ml:475:26>>*/ var
+        c = formatting_lit[1],
+         /*<<camlinternalFormat.ml:475:26>>*/ _dO_ =
+           /*<<camlinternalFormat.ml:475:26>>*/ caml_call2
+           (Stdlib_String[1], 1, c);
+        /*<<camlinternalFormat.ml:475:26>>*/ return  /*<<camlinternalFormat.ml:475:26>>*/ caml_call2
+               (Stdlib[28], cst$7, _dO_);
+    }
+    /*<<camlinternalFormat.ml:475:43>>*/ }
+   function bprint_char_literal(buf, chr){
+     /*<<camlinternalFormat.ml:480:34>>*/ return 37 === chr
+            ? buffer_add_string(buf, cst$8)
+            : buffer_add_char(buf, chr);
+    /*<<camlinternalFormat.ml:482:32>>*/ }
+   function bprint_string_literal(buf, str){
+     /*<<camlinternalFormat.ml:486:2>>*/ var
+     _dM_ = caml_ml_string_length(str) - 1 | 0,
+      /*<<camlinternalFormat.ml:486:2>>*/ _dL_ = 0;
+    if(_dM_ >= 0){
+     var i = _dL_;
+     for(;;){
+       /*<<camlinternalFormat.ml:487:4>>*/ bprint_char_literal
+       (buf,  /*<<camlinternalFormat.ml:487:28>>*/ caml_string_get(str, i));
+       /*<<camlinternalFormat.ml:487:4>>*/  /*<<camlinternalFormat.ml:487:4>>*/ var
+       _dN_ = i + 1 | 0;
+      if(_dM_ === i) break;
+      var i = _dN_;
+     }
+    }
+    return 0;
+    /*<<camlinternalFormat.ml:488:6>>*/ }
+   function bprint_fmtty(buf, fmtty){
+     /*<<camlinternalFormat.ml:496:17>>*/ var fmtty$0 = fmtty;
+     /*<<camlinternalFormat.ml:496:17>>*/ for(;;){
+     if(typeof fmtty$0 === "number")
+       /*<<camlinternalFormat.ml:521:20>>*/ return 0;
+     switch(fmtty$0[0]){
+       case 0:
+        var fmtty$1 = fmtty$0[1];
+         /*<<camlinternalFormat.ml:497:25>>*/ buffer_add_string(buf, cst_c);
+        var fmtty$0 = fmtty$1;
+        break;
+       case 1:
+        var fmtty$2 = fmtty$0[1];
+         /*<<camlinternalFormat.ml:498:25>>*/ buffer_add_string(buf, cst_s);
+        var fmtty$0 = fmtty$2;
+        break;
+       case 2:
+        var fmtty$3 = fmtty$0[1];
+         /*<<camlinternalFormat.ml:499:25>>*/ buffer_add_string(buf, cst_i);
+        var fmtty$0 = fmtty$3;
+        break;
+       case 3:
+        var fmtty$4 = fmtty$0[1];
+         /*<<camlinternalFormat.ml:500:25>>*/ buffer_add_string(buf, cst_li);
+        var fmtty$0 = fmtty$4;
+        break;
+       case 4:
+        var fmtty$5 = fmtty$0[1];
+         /*<<camlinternalFormat.ml:501:25>>*/ buffer_add_string(buf, cst_ni);
+        var fmtty$0 = fmtty$5;
+        break;
+       case 5:
+        var fmtty$6 = fmtty$0[1];
+         /*<<camlinternalFormat.ml:502:25>>*/ buffer_add_string(buf, cst_Li);
+        var fmtty$0 = fmtty$6;
+        break;
+       case 6:
+        var fmtty$7 = fmtty$0[1];
+         /*<<camlinternalFormat.ml:503:25>>*/ buffer_add_string(buf, cst_f);
+        var fmtty$0 = fmtty$7;
+        break;
+       case 7:
+        var fmtty$8 = fmtty$0[1];
+         /*<<camlinternalFormat.ml:504:25>>*/ buffer_add_string(buf, cst_B);
+        var fmtty$0 = fmtty$8;
+        break;
+       case 8:
+        var fmtty$9 = fmtty$0[2], sub_fmtty = fmtty$0[1];
+         /*<<camlinternalFormat.ml:515:4>>*/ buffer_add_string(buf, cst$9);
+         /*<<camlinternalFormat.ml:515:32>>*/ bprint_fmtty(buf, sub_fmtty);
+         /*<<camlinternalFormat.ml:516:4>>*/ buffer_add_string(buf, cst$10);
+        var fmtty$0 = fmtty$9;
+        break;
+       case 9:
+        var fmtty$10 = fmtty$0[3], sub_fmtty$0 = fmtty$0[1];
+         /*<<camlinternalFormat.ml:518:4>>*/ buffer_add_string(buf, cst$11);
+         /*<<camlinternalFormat.ml:518:32>>*/ bprint_fmtty(buf, sub_fmtty$0);
+         /*<<camlinternalFormat.ml:519:4>>*/ buffer_add_string(buf, cst$12);
+        var fmtty$0 = fmtty$10;
+        break;
+       case 10:
+        var fmtty$11 = fmtty$0[1];
+         /*<<camlinternalFormat.ml:505:25>>*/ buffer_add_string(buf, cst_a);
+        var fmtty$0 = fmtty$11;
+        break;
+       case 11:
+        var fmtty$12 = fmtty$0[1];
+         /*<<camlinternalFormat.ml:506:25>>*/ buffer_add_string(buf, cst_t);
+        var fmtty$0 = fmtty$12;
+        break;
+       case 12:
+        var fmtty$13 = fmtty$0[1];
+         /*<<camlinternalFormat.ml:507:25>>*/ buffer_add_string(buf, cst$13);
+        var fmtty$0 = fmtty$13;
+        break;
+       case 13:
+        var fmtty$14 = fmtty$0[1];
+         /*<<camlinternalFormat.ml:508:25>>*/ buffer_add_string(buf, cst_r);
+        var fmtty$0 = fmtty$14;
+        break;
+       default:
+        var fmtty$15 = fmtty$0[1];
+         /*<<camlinternalFormat.ml:511:4>>*/ buffer_add_string(buf, cst_r$0);
+        var fmtty$0 = fmtty$15;
+     }
+    }
+    /*<<camlinternalFormat.ml:521:22>>*/ }
+   function int_of_custom_arity(param){
+     /*<<camlinternalFormat.ml:525:8>>*/ if(! param)
+      /*<<camlinternalFormat.ml:528:19>>*/ return 0;
+    var x = param[1];
+    return 1 + int_of_custom_arity(x) | 0;
+    /*<<camlinternalFormat.ml:529:46>>*/ }
+   function string_of_fmt(fmt){
+     /*<<camlinternalFormat.ml:644:2>>*/  /*<<camlinternalFormat.ml:644:12>>*/ var
+     buf = buffer_create(16);
+    function fmtiter(fmt, ign_flag){
+      /*<<camlinternalFormat.ml:535:22>>*/ var
+      fmt$0 = fmt,
+      ign_flag$0 = ign_flag;
+      /*<<camlinternalFormat.ml:535:22>>*/ for(;;){
+      if(typeof fmt$0 === "number")
+        /*<<camlinternalFormat.ml:636:23>>*/ return 0;
+      switch(fmt$0[0]){
+        case 0:
+         var rest = fmt$0[1];
+          /*<<camlinternalFormat.ml:562:6>>*/ buffer_add_char(buf, 37);
+          /*<<camlinternalFormat.ml:562:31>>*/ bprint_ignored_flag
+          (buf, ign_flag$0);
+          /*<<camlinternalFormat.ml:563:6>>*/ buffer_add_char(buf, 99);
+         var fmt$0 = rest, ign_flag$0 = 0;
+         break;
+        case 1:
+         var rest$0 = fmt$0[1];
+          /*<<camlinternalFormat.ml:565:6>>*/ buffer_add_char(buf, 37);
+          /*<<camlinternalFormat.ml:565:31>>*/ bprint_ignored_flag
+          (buf, ign_flag$0);
+          /*<<camlinternalFormat.ml:566:6>>*/ buffer_add_char(buf, 67);
+         var fmt$0 = rest$0, ign_flag$0 = 0;
+         break;
+        case 2:
+         var rest$1 = fmt$0[2], pad = fmt$0[1];
+          /*<<camlinternalFormat.ml:537:6>>*/ buffer_add_char(buf, 37);
+          /*<<camlinternalFormat.ml:537:31>>*/ bprint_ignored_flag
+          (buf, ign_flag$0);
+          /*<<camlinternalFormat.ml:538:6>>*/ bprint_padding(buf, pad);
+          /*<<camlinternalFormat.ml:538:30>>*/ buffer_add_char(buf, 115);
+         var fmt$0 = rest$1, ign_flag$0 = 0;
+         break;
+        case 3:
+         var rest$2 = fmt$0[2], pad$0 = fmt$0[1];
+          /*<<camlinternalFormat.ml:541:6>>*/ buffer_add_char(buf, 37);
+          /*<<camlinternalFormat.ml:541:31>>*/ bprint_ignored_flag
+          (buf, ign_flag$0);
+          /*<<camlinternalFormat.ml:542:6>>*/ bprint_padding(buf, pad$0);
+          /*<<camlinternalFormat.ml:542:30>>*/ buffer_add_char(buf, 83);
+         var fmt$0 = rest$2, ign_flag$0 = 0;
+         break;
+        case 4:
+         var
+          rest$3 = fmt$0[4],
+          prec = fmt$0[3],
+          pad$1 = fmt$0[2],
+          iconv = fmt$0[1];
+          /*<<camlinternalFormat.ml:424:2>>*/ buffer_add_char(buf, 37);
+          /*<<camlinternalFormat.ml:425:2>>*/ bprint_ignored_flag
+          (buf, ign_flag$0);
+          /*<<camlinternalFormat.ml:426:2>>*/ bprint_iconv_flag(buf, iconv);
+          /*<<camlinternalFormat.ml:427:2>>*/ bprint_padding(buf, pad$1);
+          /*<<camlinternalFormat.ml:428:2>>*/ bprint_precision(buf, prec);
+          /*<<camlinternalFormat.ml:429:22>>*/ buffer_add_char
+          (buf, char_of_iconv(iconv));
+         var fmt$0 = rest$3, ign_flag$0 = 0;
+         break;
+        case 5:
+         var
+          rest$4 = fmt$0[4],
+          prec$0 = fmt$0[3],
+          pad$2 = fmt$0[2],
+          iconv$0 = fmt$0[1];
+          /*<<camlinternalFormat.ml:549:6>>*/ bprint_altint_fmt
+          (buf, ign_flag$0, iconv$0, pad$2, prec$0, 108);
+         var fmt$0 = rest$4, ign_flag$0 = 0;
+         break;
+        case 6:
+         var
+          rest$5 = fmt$0[4],
+          prec$1 = fmt$0[3],
+          pad$3 = fmt$0[2],
+          iconv$1 = fmt$0[1];
+          /*<<camlinternalFormat.ml:552:6>>*/ bprint_altint_fmt
+          (buf, ign_flag$0, iconv$1, pad$3, prec$1, 110);
+         var fmt$0 = rest$5, ign_flag$0 = 0;
+         break;
+        case 7:
+         var
+          rest$6 = fmt$0[4],
+          prec$2 = fmt$0[3],
+          pad$4 = fmt$0[2],
+          iconv$2 = fmt$0[1];
+          /*<<camlinternalFormat.ml:555:6>>*/ bprint_altint_fmt
+          (buf, ign_flag$0, iconv$2, pad$4, prec$2, 76);
+         var fmt$0 = rest$6, ign_flag$0 = 0;
+         break;
+        case 8:
+         var
+          rest$7 = fmt$0[4],
+          prec$3 = fmt$0[3],
+          pad$5 = fmt$0[2],
+          fconv = fmt$0[1];
+          /*<<camlinternalFormat.ml:456:2>>*/ buffer_add_char(buf, 37);
+          /*<<camlinternalFormat.ml:457:2>>*/ bprint_ignored_flag
+          (buf, ign_flag$0);
+          /*<<camlinternalFormat.ml:458:2>>*/ bprint_fconv_flag(buf, fconv);
+          /*<<camlinternalFormat.ml:459:2>>*/ bprint_padding(buf, pad$5);
+          /*<<camlinternalFormat.ml:460:2>>*/ bprint_precision(buf, prec$3);
+          /*<<camlinternalFormat.ml:461:22>>*/ buffer_add_char
+          (buf, char_of_fconv(0, fconv));
+         var fmt$0 = rest$7, ign_flag$0 = 0;
+         break;
+        case 9:
+         var rest$8 = fmt$0[2], pad$6 = fmt$0[1];
+          /*<<camlinternalFormat.ml:568:6>>*/ buffer_add_char(buf, 37);
+          /*<<camlinternalFormat.ml:568:31>>*/ bprint_ignored_flag
+          (buf, ign_flag$0);
+          /*<<camlinternalFormat.ml:569:6>>*/ bprint_padding(buf, pad$6);
+          /*<<camlinternalFormat.ml:569:30>>*/ buffer_add_char(buf, 66);
+         var fmt$0 = rest$8, ign_flag$0 = 0;
+         break;
+        case 10:
+         var rest$9 = fmt$0[1];
+          /*<<camlinternalFormat.ml:587:6>>*/ buffer_add_string(buf, cst$14);
+         var fmt$0 = rest$9;
+         break;
+        case 11:
+         var rest$10 = fmt$0[2], str = fmt$0[1];
+          /*<<camlinternalFormat.ml:591:6>>*/ bprint_string_literal(buf, str);
+         var fmt$0 = rest$10;
+         break;
+        case 12:
+         var rest$11 = fmt$0[2], chr = fmt$0[1];
+          /*<<camlinternalFormat.ml:594:6>>*/ bprint_char_literal(buf, chr);
+         var fmt$0 = rest$11;
+         break;
+        case 13:
+         var rest$12 = fmt$0[3], fmtty = fmt$0[2], pad_opt = fmt$0[1];
+          /*<<camlinternalFormat.ml:598:6>>*/ buffer_add_char(buf, 37);
+          /*<<camlinternalFormat.ml:598:31>>*/ bprint_ignored_flag
+          (buf, ign_flag$0);
+          /*<<camlinternalFormat.ml:599:6>>*/ bprint_pad_opt(buf, pad_opt);
+          /*<<camlinternalFormat.ml:599:34>>*/ buffer_add_char(buf, 123);
+          /*<<camlinternalFormat.ml:600:6>>*/ bprint_fmtty(buf, fmtty);
+          /*<<camlinternalFormat.ml:600:30>>*/ buffer_add_char(buf, 37);
+          /*<<camlinternalFormat.ml:600:55>>*/ buffer_add_char(buf, 125);
+         var fmt$0 = rest$12, ign_flag$0 = 0;
+         break;
+        case 14:
+         var rest$13 = fmt$0[3], fmtty$0 = fmt$0[2], pad_opt$0 = fmt$0[1];
+          /*<<camlinternalFormat.ml:603:6>>*/ buffer_add_char(buf, 37);
+          /*<<camlinternalFormat.ml:603:31>>*/ bprint_ignored_flag
+          (buf, ign_flag$0);
+          /*<<camlinternalFormat.ml:604:6>>*/ bprint_pad_opt(buf, pad_opt$0);
+          /*<<camlinternalFormat.ml:604:34>>*/ buffer_add_char(buf, 40);
+          /*<<camlinternalFormat.ml:605:6>>*/ bprint_fmtty(buf, fmtty$0);
+          /*<<camlinternalFormat.ml:605:30>>*/ buffer_add_char(buf, 37);
+          /*<<camlinternalFormat.ml:605:55>>*/ buffer_add_char(buf, 41);
+         var fmt$0 = rest$13, ign_flag$0 = 0;
+         break;
+        case 15:
+         var rest$14 = fmt$0[1];
+          /*<<camlinternalFormat.ml:572:6>>*/ buffer_add_char(buf, 37);
+          /*<<camlinternalFormat.ml:572:31>>*/ bprint_ignored_flag
+          (buf, ign_flag$0);
+          /*<<camlinternalFormat.ml:573:6>>*/ buffer_add_char(buf, 97);
+         var fmt$0 = rest$14, ign_flag$0 = 0;
+         break;
+        case 16:
+         var rest$15 = fmt$0[1];
+          /*<<camlinternalFormat.ml:575:6>>*/ buffer_add_char(buf, 37);
+          /*<<camlinternalFormat.ml:575:31>>*/ bprint_ignored_flag
+          (buf, ign_flag$0);
+          /*<<camlinternalFormat.ml:576:6>>*/ buffer_add_char(buf, 116);
+         var fmt$0 = rest$15, ign_flag$0 = 0;
+         break;
+        case 17:
+         var rest$16 = fmt$0[2], fmting_lit = fmt$0[1];
+          /*<<camlinternalFormat.ml:625:6>>*/ bprint_string_literal
+          (buf, string_of_formatting_lit(fmting_lit));
+         var fmt$0 = rest$16;
+         break;
+        case 18:
+         var rest$17 = fmt$0[2], fmting_gen = fmt$0[1];
+          /*<<camlinternalFormat.ml:628:6>>*/ if(0 === fmting_gen[0]){
+          var str$0 = fmting_gen[1][2];
+           /*<<camlinternalFormat.ml:630:8>>*/ buffer_add_string(buf, cst$15);
+           /*<<camlinternalFormat.ml:630:36>>*/ buffer_add_string(buf, str$0);
+         }
+         else{
+          var str$1 = fmting_gen[1][2];
+           /*<<camlinternalFormat.ml:632:8>>*/ buffer_add_string(buf, cst$16);
+           /*<<camlinternalFormat.ml:632:36>>*/ buffer_add_string(buf, str$1);
+         }
+         var fmt$0 = rest$17;
+         break;
+        case 19:
+         var rest$18 = fmt$0[1];
+          /*<<camlinternalFormat.ml:584:6>>*/ buffer_add_char(buf, 37);
+          /*<<camlinternalFormat.ml:584:31>>*/ bprint_ignored_flag
+          (buf, ign_flag$0);
+          /*<<camlinternalFormat.ml:585:6>>*/ buffer_add_char(buf, 114);
+         var fmt$0 = rest$18, ign_flag$0 = 0;
+         break;
+        case 20:
+         var rest$19 = fmt$0[3], char_set = fmt$0[2], width_opt = fmt$0[1];
+          /*<<camlinternalFormat.ml:609:6>>*/ buffer_add_char(buf, 37);
+          /*<<camlinternalFormat.ml:609:31>>*/ bprint_ignored_flag
+          (buf, ign_flag$0);
+          /*<<camlinternalFormat.ml:610:6>>*/ bprint_pad_opt(buf, width_opt);
+         var
+          print_char =
+            function(buf, i){
+              /*<<camlinternalFormat.ml:358:25>>*/  /*<<camlinternalFormat.ml:358:31>>*/ var
+              c =
+                 /*<<camlinternalFormat.ml:358:31>>*/ caml_call1
+                 (Stdlib[29], i);
+             return 37 === c
+                     ? (buffer_add_char(buf, 37), buffer_add_char(buf, 37))
+                     : 64
+                       === c
+                       ? (buffer_add_char(buf, 37), buffer_add_char(buf, 64))
+                       : buffer_add_char(buf, c);
+             /*<<camlinternalFormat.ml:361:35>>*/ };
+          /*<<camlinternalFormat.ml:363:2>>*/ buffer_add_char(buf, 91);
+          /*<<camlinternalFormat.ml:365:7>>*/ var
+           /*<<camlinternalFormat.ml:365:7>>*/ set =
+            is_in_char_set(char_set, 0)
+             ? (buffer_add_char(buf, 94), rev_char_set(char_set))
+             : char_set,
+          is_alone$0 =
+            function(set){
+             function is_alone(c){
+               /*<<camlinternalFormat.ml:316:6>>*/ var
+                /*<<camlinternalFormat.ml:316:50>>*/ after =
+                  /*<<camlinternalFormat.ml:316:50>>*/ caml_call1
+                  (Stdlib_Char[1], c + 1 | 0),
+                /*<<camlinternalFormat.ml:316:32>>*/ before =
+                  /*<<camlinternalFormat.ml:316:32>>*/ caml_call1
+                  (Stdlib_Char[1], c - 1 | 0),
+                /*<<camlinternalFormat.ml:317:6>>*/ _dH_ =
+                 is_in_char_set(set, c);
+               /*<<camlinternalFormat.ml:317:6>>*/ if(_dH_)
+                /*<<camlinternalFormat.ml:318:14>>*/ var
+                 /*<<camlinternalFormat.ml:318:14>>*/ _dI_ =
+                  is_in_char_set(set, before),
+                 /*<<camlinternalFormat.ml:318:14>>*/ _dJ_ =
+                  _dI_ ? is_in_char_set(set, after) : _dI_,
+                _dK_ = 1 - _dJ_;
+              else
+               var _dK_ = _dH_;
+               /*<<camlinternalFormat.ml:318:43>>*/ return _dK_;
+              /*<<camlinternalFormat.ml:318:68>>*/ }
+             return is_alone;
+            },
+          is_alone = is_alone$0(set);
+          /*<<camlinternalFormat.ml:319:7>>*/ if(is_alone(93))
+           /*<<camlinternalFormat.ml:319:25>>*/ buffer_add_char(buf, 93);
+         var i = 1;
+         a:
+          /*<<camlinternalFormat.ml:323:4>>*/ for(;;){
+          b:
+          if(i < 256){
+            /*<<camlinternalFormat.ml:324:9>>*/ if
+            (!
+             is_in_char_set
+              (set,
+                /*<<camlinternalFormat.ml:324:28>>*/ caml_call1(Stdlib[29], i))){
+             /*<<camlinternalFormat.ml:325:11>>*/ var
+              /*<<camlinternalFormat.ml:325:11>>*/ i$0 = i + 1 | 0,
+             i = i$0;
+            continue;
+           }
+            /*<<camlinternalFormat.ml:327:10>>*/  /*<<camlinternalFormat.ml:327:10>>*/ var
+            switcher =
+               /*<<camlinternalFormat.ml:327:10>>*/ caml_call1(Stdlib[29], i)
+              - 45
+              | 0;
+           if(48 < switcher >>> 0){
+            if(210 <= switcher){
+              /*<<camlinternalFormat.ml:328:16>>*/ print_char(buf, 255);
+             break b;
+            }
+           }
+           else if(46 < switcher - 1 >>> 0){
+             /*<<camlinternalFormat.ml:329:19>>*/ var
+              /*<<camlinternalFormat.ml:329:19>>*/ i$2 = i + 1 | 0,
+             i = i$2;
+            continue;
+           }
+            /*<<camlinternalFormat.ml:330:11>>*/  /*<<camlinternalFormat.ml:330:11>>*/ var
+            i$1 = i + 1 | 0;
+            /*<<camlinternalFormat.ml:332:7>>*/ if
+            (!
+             is_in_char_set
+              (set,
+                /*<<camlinternalFormat.ml:332:26>>*/ caml_call1
+                (Stdlib[29], i$1))){
+             /*<<camlinternalFormat.ml:347:6>>*/ print_char(buf, i$1 - 1 | 0);
+             /*<<camlinternalFormat.ml:347:6>>*/ var
+              /*<<camlinternalFormat.ml:347:6>>*/ i$6 = i$1 + 1 | 0,
+             i = i$6;
+            continue;
+           }
+            /*<<camlinternalFormat.ml:333:12>>*/  /*<<camlinternalFormat.ml:333:12>>*/ var
+            switcher$0 =
+               /*<<camlinternalFormat.ml:333:12>>*/ caml_call1
+               (Stdlib[29], i$1)
+              - 45
+              | 0;
+           if(48 < switcher$0 >>> 0){
+            if(210 <= switcher$0){
+              /*<<camlinternalFormat.ml:335:8>>*/ print_char(buf, 254);
+              /*<<camlinternalFormat.ml:335:8>>*/ print_char(buf, 255);
+             break b;
+            }
+           }
+           else if
+            (46 < switcher$0 - 1 >>> 0
+             &&
+              !
+              is_in_char_set
+               (set,
+                 /*<<camlinternalFormat.ml:337:47>>*/ caml_call1
+                 (Stdlib[29], i$1 + 1 | 0))){
+             /*<<camlinternalFormat.ml:338:8>>*/ print_char(buf, i$1 - 1 | 0);
+             /*<<camlinternalFormat.ml:338:8>>*/ var
+              /*<<camlinternalFormat.ml:338:8>>*/ i$5 = i$1 + 1 | 0,
+             i = i$5;
+            continue;
+           }
+            /*<<camlinternalFormat.ml:340:19>>*/ if
+            (!
+             is_in_char_set
+              (set,
+                /*<<camlinternalFormat.ml:340:39>>*/ caml_call1
+                (Stdlib[29], i$1 + 1 | 0))){
+             /*<<camlinternalFormat.ml:341:8>>*/ print_char(buf, i$1 - 1 | 0);
+             /*<<camlinternalFormat.ml:342:8>>*/ print_char(buf, i$1);
+             /*<<camlinternalFormat.ml:342:8>>*/ var
+              /*<<camlinternalFormat.ml:342:8>>*/ i$4 = i$1 + 2 | 0,
+             i = i$4;
+            continue;
+           }
+            /*<<camlinternalFormat.ml:345:8>>*/ var
+             /*<<camlinternalFormat.ml:345:8>>*/ j = i$1 + 2 | 0,
+            i$3 = i$1 - 1 | 0,
+            j$0 = j;
+            /*<<camlinternalFormat.ml:351:4>>*/ for(;;){
+             /*<<camlinternalFormat.ml:351:22>>*/ if
+             (256 !== j$0
+              &&
+               is_in_char_set
+                (set,
+                  /*<<camlinternalFormat.ml:351:42>>*/ caml_call1
+                  (Stdlib[29], j$0))){
+              /*<<camlinternalFormat.ml:357:6>>*/ var
+               /*<<camlinternalFormat.ml:357:6>>*/ j$1 = j$0 + 1 | 0,
+              j$0 = j$1;
+             continue;
+            }
+             /*<<camlinternalFormat.ml:352:6>>*/ print_char(buf, i$3);
+             /*<<camlinternalFormat.ml:353:6>>*/ print_char(buf, 45);
+             /*<<camlinternalFormat.ml:354:6>>*/ print_char(buf, j$0 - 1 | 0);
+            if(j$0 >= 256) break;
+             /*<<camlinternalFormat.ml:355:22>>*/ var
+              /*<<camlinternalFormat.ml:355:22>>*/ i$7 = j$0 + 1 | 0,
+             i = i$7;
+            continue a;
+           }
+          }
+           /*<<camlinternalFormat.ml:321:7>>*/ if(is_alone(45))
+            /*<<camlinternalFormat.ml:321:25>>*/ buffer_add_char(buf, 45);
+           /*<<camlinternalFormat.ml:364:2>>*/ buffer_add_char(buf, 93);
+          var fmt$0 = rest$19, ign_flag$0 = 0;
+          break;
+         }
+         break;
+        case 21:
+         var rest$20 = fmt$0[2], counter = fmt$0[1];
+          /*<<camlinternalFormat.ml:613:6>>*/ buffer_add_char(buf, 37);
+          /*<<camlinternalFormat.ml:613:31>>*/ bprint_ignored_flag
+          (buf, ign_flag$0);
+         switch(counter){
+           case 0:
+            var _dD_ = 108; break;
+           case 1:
+            var _dD_ = 110; break;
+           default: var _dD_ = 78;
+         }
+          /*<<camlinternalFormat.ml:614:6>>*/ buffer_add_char(buf, _dD_);
+         var fmt$0 = rest$20, ign_flag$0 = 0;
+         break;
+        case 22:
+         var rest$21 = fmt$0[1];
+          /*<<camlinternalFormat.ml:617:6>>*/ buffer_add_char(buf, 37);
+          /*<<camlinternalFormat.ml:617:31>>*/ bprint_ignored_flag
+          (buf, ign_flag$0);
+          /*<<camlinternalFormat.ml:618:6>>*/ bprint_string_literal
+          (buf, cst_0c);
+         var fmt$0 = rest$21, ign_flag$0 = 0;
+         break;
+        case 23:
+         var
+          rest$22 = fmt$0[2],
+          ign = fmt$0[1],
+          fmt$1 = param_format_of_ignored_format(ign, rest$22)[1],
+          fmt$0 = fmt$1,
+          ign_flag$0 = 1;
+         break;
+        default:
+          /*<<camlinternalFormat.ml:578:20>>*/ var
+          rest$23 = fmt$0[3],
+          arity = fmt$0[1],
+           /*<<camlinternalFormat.ml:578:20>>*/ _dF_ =
+            int_of_custom_arity(arity),
+          _dE_ = 1;
+         if(_dF_ >= 1){
+          var i$8 = _dE_;
+          for(;;){
+            /*<<camlinternalFormat.ml:579:8>>*/ buffer_add_char(buf, 37);
+            /*<<camlinternalFormat.ml:579:33>>*/ bprint_ignored_flag
+            (buf, ign_flag$0);
+            /*<<camlinternalFormat.ml:580:8>>*/ buffer_add_char(buf, 63);
+            /*<<camlinternalFormat.ml:580:8>>*/  /*<<camlinternalFormat.ml:580:8>>*/ var
+            _dG_ = i$8 + 1 | 0;
+           if(_dF_ === i$8) break;
+           var i$8 = _dG_;
+          }
+         }
+         var fmt$0 = rest$23, ign_flag$0 = 0;
+      }
+     }
+     /*<<camlinternalFormat.ml:636:25>>*/ }
+     /*<<camlinternalFormat.ml:638:5>>*/ fmtiter(fmt, 0);
+     /*<<camlinternalFormat.ml:645:2>>*/ return buffer_contents(buf);
+    /*<<camlinternalFormat.ml:646:21>>*/ }
+   function symm(param){
+     /*<<camlinternalFormat.ml:657:8>>*/ if(typeof param === "number")
+      /*<<camlinternalFormat.ml:680:20>>*/ return 0;
+    switch(param[0]){
+      case 0:
+       var rest = param[1];
+        /*<<camlinternalFormat.ml:663:20>>*/ return [0, symm(rest)];
+      case 1:
+       var rest$0 = param[1];
+        /*<<camlinternalFormat.ml:670:22>>*/ return [1, symm(rest$0)];
+      case 2:
+       var rest$1 = param[1];
+        /*<<camlinternalFormat.ml:664:19>>*/ return [2, symm(rest$1)];
+      case 3:
+       var rest$2 = param[1];
+        /*<<camlinternalFormat.ml:665:21>>*/ return [3, symm(rest$2)];
+      case 4:
+       var rest$3 = param[1];
+        /*<<camlinternalFormat.ml:667:25>>*/ return [4, symm(rest$3)];
+      case 5:
+       var rest$4 = param[1];
+        /*<<camlinternalFormat.ml:666:21>>*/ return [5, symm(rest$4)];
+      case 6:
+       var rest$5 = param[1];
+        /*<<camlinternalFormat.ml:668:21>>*/ return [6, symm(rest$5)];
+      case 7:
+       var rest$6 = param[1];
+        /*<<camlinternalFormat.ml:669:20>>*/ return [7, symm(rest$6)];
+      case 8:
+       var rest$7 = param[2], ty = param[1];
+        /*<<camlinternalFormat.ml:677:4>>*/ return [8, ty, symm(rest$7)];
+      case 9:
+       var rest$8 = param[3], ty2 = param[2], ty1 = param[1];
+        /*<<camlinternalFormat.ml:679:4>>*/ return [9, ty2, ty1, symm(rest$8)];
+      case 10:
+       var rest$9 = param[1];
+        /*<<camlinternalFormat.ml:672:21>>*/ return [10, symm(rest$9)];
+      case 11:
+       var rest$10 = param[1];
+        /*<<camlinternalFormat.ml:671:21>>*/ return [11, symm(rest$10)];
+      case 12:
+       var rest$11 = param[1];
+        /*<<camlinternalFormat.ml:673:19>>*/ return [12, symm(rest$11)];
+      case 13:
+       var rest$12 = param[1];
+        /*<<camlinternalFormat.ml:674:22>>*/ return [13, symm(rest$12)];
+      default:
+       var rest$13 = param[1];
+        /*<<camlinternalFormat.ml:675:30>>*/ return [14, symm(rest$13)];
+    }
+    /*<<camlinternalFormat.ml:680:32>>*/ }
+   function fmtty_rel_det(param){
+     /*<<camlinternalFormat.ml:682:8>>*/ if(typeof param !== "number")
+     switch(param[0]){
+       case 0:
+         /*<<camlinternalFormat.ml:696:25>>*/ var
+         rest = param[1],
+          /*<<camlinternalFormat.ml:696:25>>*/ match = fmtty_rel_det(rest),
+         de = match[4],
+         ed = match[3],
+         af = match[2],
+         fa = match[1],
+         _di_ =
+           function(param){
+             /*<<camlinternalFormat.ml:698:17>>*/ af(0);
+             /*<<camlinternalFormat.ml:698:39>>*/ return 0;
+            /*<<camlinternalFormat.ml:698:43>>*/ };
+         /*<<camlinternalFormat.ml:697:4>>*/ return [0,
+                function(param){
+                  /*<<camlinternalFormat.ml:697:17>>*/ fa(0);
+                  /*<<camlinternalFormat.ml:697:39>>*/ return 0;
+                 /*<<camlinternalFormat.ml:697:43>>*/ },
+                _di_,
+                ed,
+                de];
+       case 1:
+         /*<<camlinternalFormat.ml:701:25>>*/ var
+         rest$0 = param[1],
+          /*<<camlinternalFormat.ml:701:25>>*/ match$0 = fmtty_rel_det(rest$0),
+         de$0 = match$0[4],
+         ed$0 = match$0[3],
+         af$0 = match$0[2],
+         fa$0 = match$0[1],
+         _dj_ =
+           function(param){
+             /*<<camlinternalFormat.ml:703:17>>*/ af$0(0);
+             /*<<camlinternalFormat.ml:703:39>>*/ return 0;
+            /*<<camlinternalFormat.ml:703:43>>*/ };
+         /*<<camlinternalFormat.ml:702:4>>*/ return [0,
+                function(param){
+                  /*<<camlinternalFormat.ml:702:17>>*/ fa$0(0);
+                  /*<<camlinternalFormat.ml:702:39>>*/ return 0;
+                 /*<<camlinternalFormat.ml:702:43>>*/ },
+                _dj_,
+                ed$0,
+                de$0];
+       case 2:
+         /*<<camlinternalFormat.ml:706:25>>*/ var
+         rest$1 = param[1],
+          /*<<camlinternalFormat.ml:706:25>>*/ match$1 = fmtty_rel_det(rest$1),
+         de$1 = match$1[4],
+         ed$1 = match$1[3],
+         af$1 = match$1[2],
+         fa$1 = match$1[1],
+         _dk_ =
+           function(param){
+             /*<<camlinternalFormat.ml:708:17>>*/ af$1(0);
+             /*<<camlinternalFormat.ml:708:39>>*/ return 0;
+            /*<<camlinternalFormat.ml:708:43>>*/ };
+         /*<<camlinternalFormat.ml:707:4>>*/ return [0,
+                function(param){
+                  /*<<camlinternalFormat.ml:707:17>>*/ fa$1(0);
+                  /*<<camlinternalFormat.ml:707:39>>*/ return 0;
+                 /*<<camlinternalFormat.ml:707:43>>*/ },
+                _dk_,
+                ed$1,
+                de$1];
+       case 3:
+         /*<<camlinternalFormat.ml:711:25>>*/ var
+         rest$2 = param[1],
+          /*<<camlinternalFormat.ml:711:25>>*/ match$2 = fmtty_rel_det(rest$2),
+         de$2 = match$2[4],
+         ed$2 = match$2[3],
+         af$2 = match$2[2],
+         fa$2 = match$2[1],
+         _dl_ =
+           function(param){
+             /*<<camlinternalFormat.ml:713:17>>*/ af$2(0);
+             /*<<camlinternalFormat.ml:713:39>>*/ return 0;
+            /*<<camlinternalFormat.ml:713:43>>*/ };
+         /*<<camlinternalFormat.ml:712:4>>*/ return [0,
+                function(param){
+                  /*<<camlinternalFormat.ml:712:17>>*/ fa$2(0);
+                  /*<<camlinternalFormat.ml:712:39>>*/ return 0;
+                 /*<<camlinternalFormat.ml:712:43>>*/ },
+                _dl_,
+                ed$2,
+                de$2];
+       case 4:
+         /*<<camlinternalFormat.ml:721:25>>*/ var
+         rest$3 = param[1],
+          /*<<camlinternalFormat.ml:721:25>>*/ match$3 = fmtty_rel_det(rest$3),
+         de$3 = match$3[4],
+         ed$3 = match$3[3],
+         af$3 = match$3[2],
+         fa$3 = match$3[1],
+         _dm_ =
+           function(param){
+             /*<<camlinternalFormat.ml:723:17>>*/ af$3(0);
+             /*<<camlinternalFormat.ml:723:39>>*/ return 0;
+            /*<<camlinternalFormat.ml:723:43>>*/ };
+         /*<<camlinternalFormat.ml:722:4>>*/ return [0,
+                function(param){
+                  /*<<camlinternalFormat.ml:722:17>>*/ fa$3(0);
+                  /*<<camlinternalFormat.ml:722:39>>*/ return 0;
+                 /*<<camlinternalFormat.ml:722:43>>*/ },
+                _dm_,
+                ed$3,
+                de$3];
+       case 5:
+         /*<<camlinternalFormat.ml:716:25>>*/ var
+         rest$4 = param[1],
+          /*<<camlinternalFormat.ml:716:25>>*/ match$4 = fmtty_rel_det(rest$4),
+         de$4 = match$4[4],
+         ed$4 = match$4[3],
+         af$4 = match$4[2],
+         fa$4 = match$4[1],
+         _dn_ =
+           function(param){
+             /*<<camlinternalFormat.ml:718:17>>*/ af$4(0);
+             /*<<camlinternalFormat.ml:718:39>>*/ return 0;
+            /*<<camlinternalFormat.ml:718:43>>*/ };
+         /*<<camlinternalFormat.ml:717:4>>*/ return [0,
+                function(param){
+                  /*<<camlinternalFormat.ml:717:17>>*/ fa$4(0);
+                  /*<<camlinternalFormat.ml:717:39>>*/ return 0;
+                 /*<<camlinternalFormat.ml:717:43>>*/ },
+                _dn_,
+                ed$4,
+                de$4];
+       case 6:
+         /*<<camlinternalFormat.ml:726:25>>*/ var
+         rest$5 = param[1],
+          /*<<camlinternalFormat.ml:726:25>>*/ match$5 = fmtty_rel_det(rest$5),
+         de$5 = match$5[4],
+         ed$5 = match$5[3],
+         af$5 = match$5[2],
+         fa$5 = match$5[1],
+         _do_ =
+           function(param){
+             /*<<camlinternalFormat.ml:728:17>>*/ af$5(0);
+             /*<<camlinternalFormat.ml:728:39>>*/ return 0;
+            /*<<camlinternalFormat.ml:728:43>>*/ };
+         /*<<camlinternalFormat.ml:727:4>>*/ return [0,
+                function(param){
+                  /*<<camlinternalFormat.ml:727:17>>*/ fa$5(0);
+                  /*<<camlinternalFormat.ml:727:39>>*/ return 0;
+                 /*<<camlinternalFormat.ml:727:43>>*/ },
+                _do_,
+                ed$5,
+                de$5];
+       case 7:
+         /*<<camlinternalFormat.ml:731:25>>*/ var
+         rest$6 = param[1],
+          /*<<camlinternalFormat.ml:731:25>>*/ match$6 = fmtty_rel_det(rest$6),
+         de$6 = match$6[4],
+         ed$6 = match$6[3],
+         af$6 = match$6[2],
+         fa$6 = match$6[1],
+         _dp_ =
+           function(param){
+             /*<<camlinternalFormat.ml:733:17>>*/ af$6(0);
+             /*<<camlinternalFormat.ml:733:39>>*/ return 0;
+            /*<<camlinternalFormat.ml:733:43>>*/ };
+         /*<<camlinternalFormat.ml:732:4>>*/ return [0,
+                function(param){
+                  /*<<camlinternalFormat.ml:732:17>>*/ fa$6(0);
+                  /*<<camlinternalFormat.ml:732:39>>*/ return 0;
+                 /*<<camlinternalFormat.ml:732:43>>*/ },
+                _dp_,
+                ed$6,
+                de$6];
+       case 8:
+         /*<<camlinternalFormat.ml:764:25>>*/ var
+         rest$7 = param[2],
+          /*<<camlinternalFormat.ml:764:25>>*/ match$7 = fmtty_rel_det(rest$7),
+         de$7 = match$7[4],
+         ed$7 = match$7[3],
+         af$7 = match$7[2],
+         fa$7 = match$7[1],
+         _dq_ =
+           function(param){
+             /*<<camlinternalFormat.ml:766:17>>*/ af$7(0);
+             /*<<camlinternalFormat.ml:766:39>>*/ return 0;
+            /*<<camlinternalFormat.ml:766:43>>*/ };
+         /*<<camlinternalFormat.ml:765:4>>*/ return [0,
+                function(param){
+                  /*<<camlinternalFormat.ml:765:17>>*/ fa$7(0);
+                  /*<<camlinternalFormat.ml:765:39>>*/ return 0;
+                 /*<<camlinternalFormat.ml:765:43>>*/ },
+                _dq_,
+                ed$7,
+                de$7];
+       case 9:
+         /*<<camlinternalFormat.ml:769:25>>*/ var
+         rest$8 = param[3],
+         ty2 = param[2],
+         ty1 = param[1],
+          /*<<camlinternalFormat.ml:769:25>>*/ match$8 = fmtty_rel_det(rest$8),
+         de$8 = match$8[4],
+         ed$8 = match$8[3],
+         af$8 = match$8[2],
+         fa$8 = match$8[1],
+          /*<<camlinternalFormat.ml:770:13>>*/ ty = trans(symm(ty1), ty2),
+          /*<<camlinternalFormat.ml:771:25>>*/ match$9 = fmtty_rel_det(ty),
+         jd = match$9[4],
+         dj = match$9[3],
+         ga = match$9[2],
+         ag = match$9[1],
+         _dr_ =
+           function(param){
+             /*<<camlinternalFormat.ml:775:17>>*/ jd(0);
+             /*<<camlinternalFormat.ml:775:50>>*/ de$8(0);
+             /*<<camlinternalFormat.ml:775:61>>*/ return 0;
+            /*<<camlinternalFormat.ml:775:65>>*/ },
+         _ds_ =
+           function(param){
+             /*<<camlinternalFormat.ml:774:17>>*/ ed$8(0);
+             /*<<camlinternalFormat.ml:774:50>>*/ dj(0);
+             /*<<camlinternalFormat.ml:774:61>>*/ return 0;
+            /*<<camlinternalFormat.ml:774:65>>*/ },
+         _dt_ =
+           function(param){
+             /*<<camlinternalFormat.ml:773:17>>*/ ga(0);
+             /*<<camlinternalFormat.ml:773:50>>*/ af$8(0);
+             /*<<camlinternalFormat.ml:773:61>>*/ return 0;
+            /*<<camlinternalFormat.ml:773:65>>*/ };
+         /*<<camlinternalFormat.ml:772:4>>*/ return [0,
+                function(param){
+                  /*<<camlinternalFormat.ml:772:17>>*/ fa$8(0);
+                  /*<<camlinternalFormat.ml:772:50>>*/ ag(0);
+                  /*<<camlinternalFormat.ml:772:61>>*/ return 0;
+                 /*<<camlinternalFormat.ml:772:65>>*/ },
+                _dt_,
+                _ds_,
+                _dr_];
+       case 10:
+         /*<<camlinternalFormat.ml:742:25>>*/ var
+         rest$9 = param[1],
+          /*<<camlinternalFormat.ml:742:25>>*/ match$10 =
+           fmtty_rel_det(rest$9),
+         de$9 = match$10[4],
+         ed$9 = match$10[3],
+         af$9 = match$10[2],
+         fa$9 = match$10[1],
+         _du_ =
+           function(param){
+             /*<<camlinternalFormat.ml:744:17>>*/ af$9(0);
+             /*<<camlinternalFormat.ml:744:39>>*/ return 0;
+            /*<<camlinternalFormat.ml:744:43>>*/ };
+         /*<<camlinternalFormat.ml:743:4>>*/ return [0,
+                function(param){
+                  /*<<camlinternalFormat.ml:743:17>>*/ fa$9(0);
+                  /*<<camlinternalFormat.ml:743:39>>*/ return 0;
+                 /*<<camlinternalFormat.ml:743:43>>*/ },
+                _du_,
+                ed$9,
+                de$9];
+       case 11:
+         /*<<camlinternalFormat.ml:737:25>>*/ var
+         rest$10 = param[1],
+          /*<<camlinternalFormat.ml:737:25>>*/ match$11 =
+           fmtty_rel_det(rest$10),
+         de$10 = match$11[4],
+         ed$10 = match$11[3],
+         af$10 = match$11[2],
+         fa$10 = match$11[1],
+         _dv_ =
+           function(param){
+             /*<<camlinternalFormat.ml:739:17>>*/ af$10(0);
+             /*<<camlinternalFormat.ml:739:39>>*/ return 0;
+            /*<<camlinternalFormat.ml:739:43>>*/ };
+         /*<<camlinternalFormat.ml:738:4>>*/ return [0,
+                function(param){
+                  /*<<camlinternalFormat.ml:738:17>>*/ fa$10(0);
+                  /*<<camlinternalFormat.ml:738:39>>*/ return 0;
+                 /*<<camlinternalFormat.ml:738:43>>*/ },
+                _dv_,
+                ed$10,
+                de$10];
+       case 12:
+         /*<<camlinternalFormat.ml:747:25>>*/ var
+         rest$11 = param[1],
+          /*<<camlinternalFormat.ml:747:25>>*/ match$12 =
+           fmtty_rel_det(rest$11),
+         de$11 = match$12[4],
+         ed$11 = match$12[3],
+         af$11 = match$12[2],
+         fa$11 = match$12[1],
+         _dw_ =
+           function(param){
+             /*<<camlinternalFormat.ml:749:17>>*/ af$11(0);
+             /*<<camlinternalFormat.ml:749:39>>*/ return 0;
+            /*<<camlinternalFormat.ml:749:43>>*/ };
+         /*<<camlinternalFormat.ml:748:4>>*/ return [0,
+                function(param){
+                  /*<<camlinternalFormat.ml:748:17>>*/ fa$11(0);
+                  /*<<camlinternalFormat.ml:748:39>>*/ return 0;
+                 /*<<camlinternalFormat.ml:748:43>>*/ },
+                _dw_,
+                ed$11,
+                de$11];
+       case 13:
+         /*<<camlinternalFormat.ml:752:25>>*/ var
+         rest$12 = param[1],
+          /*<<camlinternalFormat.ml:752:25>>*/ match$13 =
+           fmtty_rel_det(rest$12),
+         de$12 = match$13[4],
+         ed$12 = match$13[3],
+         af$12 = match$13[2],
+         fa$12 = match$13[1],
+          /*<<camlinternalFormat.ml:753:4>>*/ _dx_ =
+           function(param){
+             /*<<camlinternalFormat.ml:756:17>>*/ de$12(0);
+             /*<<camlinternalFormat.ml:756:39>>*/ return 0;
+            /*<<camlinternalFormat.ml:756:43>>*/ },
+         _dy_ =
+           function(param){
+             /*<<camlinternalFormat.ml:755:17>>*/ ed$12(0);
+             /*<<camlinternalFormat.ml:755:39>>*/ return 0;
+            /*<<camlinternalFormat.ml:755:43>>*/ },
+         _dz_ =
+           function(param){
+             /*<<camlinternalFormat.ml:754:17>>*/ af$12(0);
+             /*<<camlinternalFormat.ml:754:39>>*/ return 0;
+            /*<<camlinternalFormat.ml:754:43>>*/ };
+         /*<<camlinternalFormat.ml:753:4>>*/ return [0,
+                function(param){
+                  /*<<camlinternalFormat.ml:753:17>>*/ fa$12(0);
+                  /*<<camlinternalFormat.ml:753:39>>*/ return 0;
+                 /*<<camlinternalFormat.ml:753:43>>*/ },
+                _dz_,
+                _dy_,
+                _dx_];
+       default:
+         /*<<camlinternalFormat.ml:758:25>>*/ var
+         rest$13 = param[1],
+          /*<<camlinternalFormat.ml:758:25>>*/ match$14 =
+           fmtty_rel_det(rest$13),
+         de$13 = match$14[4],
+         ed$13 = match$14[3],
+         af$13 = match$14[2],
+         fa$13 = match$14[1],
+          /*<<camlinternalFormat.ml:759:4>>*/ _dA_ =
+           function(param){
+             /*<<camlinternalFormat.ml:762:17>>*/ de$13(0);
+             /*<<camlinternalFormat.ml:762:39>>*/ return 0;
+            /*<<camlinternalFormat.ml:762:43>>*/ },
+         _dB_ =
+           function(param){
+             /*<<camlinternalFormat.ml:761:17>>*/ ed$13(0);
+             /*<<camlinternalFormat.ml:761:39>>*/ return 0;
+            /*<<camlinternalFormat.ml:761:43>>*/ },
+         _dC_ =
+           function(param){
+             /*<<camlinternalFormat.ml:760:17>>*/ af$13(0);
+             /*<<camlinternalFormat.ml:760:39>>*/ return 0;
+            /*<<camlinternalFormat.ml:760:43>>*/ };
+         /*<<camlinternalFormat.ml:759:4>>*/ return [0,
+                function(param){
+                  /*<<camlinternalFormat.ml:759:17>>*/ fa$13(0);
+                  /*<<camlinternalFormat.ml:759:39>>*/ return 0;
+                 /*<<camlinternalFormat.ml:759:43>>*/ },
+                _dC_,
+                _dB_,
+                _dA_];
+     }
+     /*<<camlinternalFormat.ml:691:4>>*/ function _df_(param){
+      /*<<camlinternalFormat.ml:694:17>>*/ return 0;
+     /*<<camlinternalFormat.ml:694:21>>*/ }
+    function _dg_(param){
+      /*<<camlinternalFormat.ml:693:17>>*/ return 0;
+     /*<<camlinternalFormat.ml:693:21>>*/ }
+    function _dh_(param){
+      /*<<camlinternalFormat.ml:692:17>>*/ return 0;
+     /*<<camlinternalFormat.ml:692:21>>*/ }
+     /*<<camlinternalFormat.ml:691:4>>*/ return [0,
+            function(param){
+              /*<<camlinternalFormat.ml:691:17>>*/ return 0;
+             /*<<camlinternalFormat.ml:691:21>>*/ },
+            _dh_,
+            _dg_,
+            _df_];
+    /*<<camlinternalFormat.ml:775:66>>*/ }
+   function trans(ty1, ty2){
+     /*<<camlinternalFormat.ml:803:17>>*/ a:
+    {
+     b:
+     {
+      c:
+      {
+       d:
+       {
+        e:
+        {
+         f:
+         {
+          g:
+          {
+           if(typeof ty1 !== "number"){
+            switch(ty1[0]){
+              case 0:
+               var rest1 = ty1[1];
+               if(typeof ty2 !== "number")
+                switch(ty2[0]){
+                  case 0:
+                   var rest2 = ty2[1];
+                    /*<<camlinternalFormat.ml:804:36>>*/ return [0,
+                           trans(rest1, rest2)];
+                  case 8:
+                   break f;
+                  case 9:
+                   break g;
+                  case 10:
+                   break a;
+                  case 11:
+                   break b;
+                  case 12:
+                   break c;
+                  case 13:
+                   break d;
+                  case 14:
+                   break e;
+                }
+               break;
+              case 1:
+               var rest1$0 = ty1[1];
+               if(typeof ty2 !== "number")
+                switch(ty2[0]){
+                  case 1:
+                   var rest2$0 = ty2[1];
+                    /*<<camlinternalFormat.ml:805:40>>*/ return [1,
+                           trans(rest1$0, rest2$0)];
+                  case 8:
+                   break f;
+                  case 9:
+                   break g;
+                  case 10:
+                   break a;
+                  case 11:
+                   break b;
+                  case 12:
+                   break c;
+                  case 13:
+                   break d;
+                  case 14:
+                   break e;
+                }
+               break;
+              case 2:
+               var rest1$1 = ty1[1];
+               if(typeof ty2 !== "number")
+                switch(ty2[0]){
+                  case 2:
+                   var rest2$1 = ty2[1];
+                    /*<<camlinternalFormat.ml:807:34>>*/ return [2,
+                           trans(rest1$1, rest2$1)];
+                  case 8:
+                   break f;
+                  case 9:
+                   break g;
+                  case 10:
+                   break a;
+                  case 11:
+                   break b;
+                  case 12:
+                   break c;
+                  case 13:
+                   break d;
+                  case 14:
+                   break e;
+                }
+               break;
+              case 3:
+               var rest1$2 = ty1[1];
+               if(typeof ty2 !== "number")
+                switch(ty2[0]){
+                  case 3:
+                   var rest2$2 = ty2[1];
+                    /*<<camlinternalFormat.ml:808:38>>*/ return [3,
+                           trans(rest1$2, rest2$2)];
+                  case 8:
+                   break f;
+                  case 9:
+                   break g;
+                  case 10:
+                   break a;
+                  case 11:
+                   break b;
+                  case 12:
+                   break c;
+                  case 13:
+                   break d;
+                  case 14:
+                   break e;
+                }
+               break;
+              case 4:
+               var rest1$3 = ty1[1];
+               if(typeof ty2 !== "number")
+                switch(ty2[0]){
+                  case 4:
+                   var rest2$3 = ty2[1];
+                    /*<<camlinternalFormat.ml:810:46>>*/ return [4,
+                           trans(rest1$3, rest2$3)];
+                  case 8:
+                   break f;
+                  case 9:
+                   break g;
+                  case 10:
+                   break a;
+                  case 11:
+                   break b;
+                  case 12:
+                   break c;
+                  case 13:
+                   break d;
+                  case 14:
+                   break e;
+                }
+               break;
+              case 5:
+               var rest1$4 = ty1[1];
+               if(typeof ty2 !== "number")
+                switch(ty2[0]){
+                  case 5:
+                   var rest2$4 = ty2[1];
+                    /*<<camlinternalFormat.ml:809:38>>*/ return [5,
+                           trans(rest1$4, rest2$4)];
+                  case 8:
+                   break f;
+                  case 9:
+                   break g;
+                  case 10:
+                   break a;
+                  case 11:
+                   break b;
+                  case 12:
+                   break c;
+                  case 13:
+                   break d;
+                  case 14:
+                   break e;
+                }
+               break;
+              case 6:
+               var rest1$5 = ty1[1];
+               if(typeof ty2 !== "number")
+                switch(ty2[0]){
+                  case 6:
+                   var rest2$5 = ty2[1];
+                    /*<<camlinternalFormat.ml:811:38>>*/ return [6,
+                           trans(rest1$5, rest2$5)];
+                  case 8:
+                   break f;
+                  case 9:
+                   break g;
+                  case 10:
+                   break a;
+                  case 11:
+                   break b;
+                  case 12:
+                   break c;
+                  case 13:
+                   break d;
+                  case 14:
+                   break e;
+                }
+               break;
+              case 7:
+               var rest1$6 = ty1[1];
+               if(typeof ty2 !== "number")
+                switch(ty2[0]){
+                  case 7:
+                   var rest2$6 = ty2[1];
+                    /*<<camlinternalFormat.ml:806:36>>*/ return [7,
+                           trans(rest1$6, rest2$6)];
+                  case 8:
+                   break f;
+                  case 9:
+                   break g;
+                  case 10:
+                   break a;
+                  case 11:
+                   break b;
+                  case 12:
+                   break c;
+                  case 13:
+                   break d;
+                  case 14:
+                   break e;
+                }
+               break;
+              case 8:
+               var rest1$7 = ty1[2], ty1$0 = ty1[1];
+               if(typeof ty2 !== "number")
+                switch(ty2[0]){
+                  case 8:
+                    /*<<camlinternalFormat.ml:835:34>>*/ var
+                    rest2$7 = ty2[2],
+                    ty2$0 = ty2[1],
+                     /*<<camlinternalFormat.ml:835:34>>*/ _de_ =
+                      trans(rest1$7, rest2$7);
+                    /*<<camlinternalFormat.ml:835:4>>*/ return [8,
+                           trans(ty1$0, ty2$0),
+                           _de_];
+                  case 10:
+                   break a;
+                  case 11:
+                   break b;
+                  case 12:
+                   break c;
+                  case 13:
+                   break d;
+                  case 14:
+                   break e;
+                }
+                /*<<camlinternalFormat.ml:836:26>>*/ throw  /*<<camlinternalFormat.ml:836:26>>*/ caml_maybe_attach_backtrace
+                      ([0, Assert_failure, _k_], 1);
+              case 9:
+               var rest1$8 = ty1[3], ty12 = ty1[2], ty11 = ty1[1];
+               if(typeof ty2 !== "number")
+                switch(ty2[0]){
+                  case 8:
+                   break f;
+                  case 9:
+                    /*<<camlinternalFormat.ml:841:13>>*/ var
+                    rest2$8 = ty2[3],
+                    ty22 = ty2[2],
+                    ty21 = ty2[1],
+                     /*<<camlinternalFormat.ml:841:13>>*/ ty =
+                      trans(symm(ty12), ty21),
+                     /*<<camlinternalFormat.ml:842:23>>*/ match =
+                      fmtty_rel_det(ty),
+                    f4 = match[4],
+                    f2 = match[2];
+                    /*<<camlinternalFormat.ml:843:15>>*/ f2(0);
+                    /*<<camlinternalFormat.ml:844:15>>*/ f4(0);
+                    /*<<camlinternalFormat.ml:845:4>>*/ return [9,
+                           ty11,
+                           ty22,
+                           trans(rest1$8, rest2$8)];
+                  case 10:
+                   break a;
+                  case 11:
+                   break b;
+                  case 12:
+                   break c;
+                  case 13:
+                   break d;
+                  case 14:
+                   break e;
+                }
+                /*<<camlinternalFormat.ml:846:28>>*/ throw  /*<<camlinternalFormat.ml:846:28>>*/ caml_maybe_attach_backtrace
+                      ([0, Assert_failure, _l_], 1);
+              case 10:
+               var rest1$9 = ty1[1];
+               if(typeof ty2 !== "number" && 10 === ty2[0]){
+                var rest2$9 = ty2[1];
+                 /*<<camlinternalFormat.ml:813:38>>*/ return [10,
+                        trans(rest1$9, rest2$9)];
+               }
+                /*<<camlinternalFormat.ml:814:21>>*/ throw  /*<<camlinternalFormat.ml:814:21>>*/ caml_maybe_attach_backtrace
+                      ([0, Assert_failure, _m_], 1);
+              case 11:
+               var rest1$10 = ty1[1];
+               if(typeof ty2 !== "number")
+                switch(ty2[0]){
+                  case 10:
+                   break a;
+                  case 11:
+                   var rest2$10 = ty2[1];
+                    /*<<camlinternalFormat.ml:817:38>>*/ return [11,
+                           trans(rest1$10, rest2$10)];
+                }
+                /*<<camlinternalFormat.ml:818:21>>*/ throw  /*<<camlinternalFormat.ml:818:21>>*/ caml_maybe_attach_backtrace
+                      ([0, Assert_failure, _n_], 1);
+              case 12:
+               var rest1$11 = ty1[1];
+               if(typeof ty2 !== "number")
+                switch(ty2[0]){
+                  case 10:
+                   break a;
+                  case 11:
+                   break b;
+                  case 12:
+                   var rest2$11 = ty2[1];
+                    /*<<camlinternalFormat.ml:821:34>>*/ return [12,
+                           trans(rest1$11, rest2$11)];
+                }
+                /*<<camlinternalFormat.ml:822:19>>*/ throw  /*<<camlinternalFormat.ml:822:19>>*/ caml_maybe_attach_backtrace
+                      ([0, Assert_failure, _o_], 1);
+              case 13:
+               var rest1$12 = ty1[1];
+               if(typeof ty2 !== "number")
+                switch(ty2[0]){
+                  case 10:
+                   break a;
+                  case 11:
+                   break b;
+                  case 12:
+                   break c;
+                  case 13:
+                   var rest2$12 = ty2[1];
+                    /*<<camlinternalFormat.ml:825:40>>*/ return [13,
+                           trans(rest1$12, rest2$12)];
+                }
+                /*<<camlinternalFormat.ml:826:22>>*/ throw  /*<<camlinternalFormat.ml:826:22>>*/ caml_maybe_attach_backtrace
+                      ([0, Assert_failure, _p_], 1);
+              default:
+               var rest1$13 = ty1[1];
+               if(typeof ty2 !== "number")
+                switch(ty2[0]){
+                  case 10:
+                   break a;
+                  case 11:
+                   break b;
+                  case 12:
+                   break c;
+                  case 13:
+                   break d;
+                  case 14:
+                   var rest2$13 = ty2[1];
+                    /*<<camlinternalFormat.ml:830:4>>*/ return [14,
+                           trans(rest1$13, rest2$13)];
+                }
+                /*<<camlinternalFormat.ml:831:30>>*/ throw  /*<<camlinternalFormat.ml:831:30>>*/ caml_maybe_attach_backtrace
+                      ([0, Assert_failure, _q_], 1);
+            }
+             /*<<camlinternalFormat.ml:851:23>>*/ throw  /*<<camlinternalFormat.ml:851:23>>*/ caml_maybe_attach_backtrace
+                   ([0, Assert_failure, _j_], 1);
+           }
+           if(typeof ty2 === "number")
+             /*<<camlinternalFormat.ml:849:34>>*/ return 0;
+           switch(ty2[0]){
+             case 10:
+              break a;
+             case 11:
+              break b;
+             case 12:
+              break c;
+             case 13:
+              break d;
+             case 14:
+              break e;
+             case 8:
+              break f;
+             case 9: break;
+             default:
+               /*<<camlinternalFormat.ml:850:23>>*/ throw  /*<<camlinternalFormat.ml:850:23>>*/ caml_maybe_attach_backtrace
+                     ([0, Assert_failure, _b_], 1);
+           }
+          }
+           /*<<camlinternalFormat.ml:847:28>>*/ throw  /*<<camlinternalFormat.ml:847:28>>*/ caml_maybe_attach_backtrace
+                 ([0, Assert_failure, _d_], 1);
+         }
+          /*<<camlinternalFormat.ml:837:26>>*/ throw  /*<<camlinternalFormat.ml:837:26>>*/ caml_maybe_attach_backtrace
+                ([0, Assert_failure, _c_], 1);
+        }
+         /*<<camlinternalFormat.ml:832:30>>*/ throw  /*<<camlinternalFormat.ml:832:30>>*/ caml_maybe_attach_backtrace
+               ([0, Assert_failure, _i_], 1);
+       }
+        /*<<camlinternalFormat.ml:827:22>>*/ throw  /*<<camlinternalFormat.ml:827:22>>*/ caml_maybe_attach_backtrace
+              ([0, Assert_failure, _h_], 1);
+      }
+       /*<<camlinternalFormat.ml:823:19>>*/ throw  /*<<camlinternalFormat.ml:823:19>>*/ caml_maybe_attach_backtrace
+             ([0, Assert_failure, _g_], 1);
+     }
+      /*<<camlinternalFormat.ml:819:21>>*/ throw  /*<<camlinternalFormat.ml:819:21>>*/ caml_maybe_attach_backtrace
+            ([0, Assert_failure, _f_], 1);
+    }
+     /*<<camlinternalFormat.ml:815:21>>*/ throw  /*<<camlinternalFormat.ml:815:21>>*/ caml_maybe_attach_backtrace
+           ([0, Assert_failure, _e_], 1);
+    /*<<camlinternalFormat.ml:851:35>>*/ }
+   function fmtty_of_padding_fmtty(pad, fmtty){
+     /*<<camlinternalFormat.ml:952:19>>*/ return typeof pad === "number"
+            ? fmtty
+            : 0 === pad[0] ? fmtty : [2, fmtty];
+    /*<<camlinternalFormat.ml:955:35>>*/ }
+   function fmtty_of_custom(arity, fmtty){
+     /*<<camlinternalFormat.ml:921:19>>*/ if(! arity)
+      /*<<camlinternalFormat.ml:922:19>>*/ return fmtty;
+    var arity$0 = arity[1];
+     /*<<camlinternalFormat.ml:923:25>>*/ return [12,
+            fmtty_of_custom(arity$0, fmtty)];
+    /*<<camlinternalFormat.ml:923:61>>*/ }
+   function fmtty_of_fmt(fmtty){
+     /*<<camlinternalFormat.ml:863:13>>*/ var fmtty$0 = fmtty;
+     /*<<camlinternalFormat.ml:863:13>>*/ for(;;){
+     if(typeof fmtty$0 === "number")
+       /*<<camlinternalFormat.ml:916:34>>*/ return 0;
+     switch(fmtty$0[0]){
+       case 0:
+        var rest = fmtty$0[1];
+         /*<<camlinternalFormat.ml:890:34>>*/ return [0, fmtty_of_fmt(rest)];
+       case 1:
+        var rest$0 = fmtty$0[1];
+         /*<<camlinternalFormat.ml:891:34>>*/ return [0, fmtty_of_fmt(rest$0)];
+       case 2:
+        var rest$1 = fmtty$0[2], pad = fmtty$0[1];
+         /*<<camlinternalFormat.ml:865:31>>*/ return fmtty_of_padding_fmtty
+                (pad, [1, fmtty_of_fmt(rest$1)]);
+       case 3:
+        var rest$2 = fmtty$0[2], pad$0 = fmtty$0[1];
+         /*<<camlinternalFormat.ml:867:31>>*/ return fmtty_of_padding_fmtty
+                (pad$0, [1, fmtty_of_fmt(rest$2)]);
+       case 4:
+         /*<<camlinternalFormat.ml:870:18>>*/ var
+         rest$3 = fmtty$0[4],
+         prec = fmtty$0[3],
+         pad$1 = fmtty$0[2],
+          /*<<camlinternalFormat.ml:870:18>>*/ ty_rest = fmtty_of_fmt(rest$3),
+          /*<<camlinternalFormat.ml:871:18>>*/ prec_ty =
+           fmtty_of_precision_fmtty(prec, [2, ty_rest]);
+         /*<<camlinternalFormat.ml:872:4>>*/ return fmtty_of_padding_fmtty
+                (pad$1, prec_ty);
+       case 5:
+         /*<<camlinternalFormat.ml:874:18>>*/ var
+         rest$4 = fmtty$0[4],
+         prec$0 = fmtty$0[3],
+         pad$2 = fmtty$0[2],
+          /*<<camlinternalFormat.ml:874:18>>*/ ty_rest$0 =
+           fmtty_of_fmt(rest$4),
+          /*<<camlinternalFormat.ml:875:18>>*/ prec_ty$0 =
+           fmtty_of_precision_fmtty(prec$0, [3, ty_rest$0]);
+         /*<<camlinternalFormat.ml:876:4>>*/ return fmtty_of_padding_fmtty
+                (pad$2, prec_ty$0);
+       case 6:
+         /*<<camlinternalFormat.ml:878:18>>*/ var
+         rest$5 = fmtty$0[4],
+         prec$1 = fmtty$0[3],
+         pad$3 = fmtty$0[2],
+          /*<<camlinternalFormat.ml:878:18>>*/ ty_rest$1 =
+           fmtty_of_fmt(rest$5),
+          /*<<camlinternalFormat.ml:879:18>>*/ prec_ty$1 =
+           fmtty_of_precision_fmtty(prec$1, [4, ty_rest$1]);
+         /*<<camlinternalFormat.ml:880:4>>*/ return fmtty_of_padding_fmtty
+                (pad$3, prec_ty$1);
+       case 7:
+         /*<<camlinternalFormat.ml:882:18>>*/ var
+         rest$6 = fmtty$0[4],
+         prec$2 = fmtty$0[3],
+         pad$4 = fmtty$0[2],
+          /*<<camlinternalFormat.ml:882:18>>*/ ty_rest$2 =
+           fmtty_of_fmt(rest$6),
+          /*<<camlinternalFormat.ml:883:18>>*/ prec_ty$2 =
+           fmtty_of_precision_fmtty(prec$2, [5, ty_rest$2]);
+         /*<<camlinternalFormat.ml:884:4>>*/ return fmtty_of_padding_fmtty
+                (pad$4, prec_ty$2);
+       case 8:
+         /*<<camlinternalFormat.ml:886:18>>*/ var
+         rest$7 = fmtty$0[4],
+         prec$3 = fmtty$0[3],
+         pad$5 = fmtty$0[2],
+          /*<<camlinternalFormat.ml:886:18>>*/ ty_rest$3 =
+           fmtty_of_fmt(rest$7),
+          /*<<camlinternalFormat.ml:887:18>>*/ prec_ty$3 =
+           fmtty_of_precision_fmtty(prec$3, [6, ty_rest$3]);
+         /*<<camlinternalFormat.ml:888:4>>*/ return fmtty_of_padding_fmtty
+                (pad$5, prec_ty$3);
+       case 9:
+        var rest$8 = fmtty$0[2], pad$6 = fmtty$0[1];
+         /*<<camlinternalFormat.ml:893:33>>*/ return fmtty_of_padding_fmtty
+                (pad$6, [7, fmtty_of_fmt(rest$8)]);
+       case 10:
+        var fmtty$1 = fmtty$0[1], fmtty$0 = fmtty$1; break;
+       case 11:
+        var fmtty$2 = fmtty$0[2], fmtty$0 = fmtty$2; break;
+       case 12:
+        var fmtty$3 = fmtty$0[2], fmtty$0 = fmtty$3; break;
+       case 13:
+        var rest$9 = fmtty$0[3], ty = fmtty$0[2];
+         /*<<camlinternalFormat.ml:900:4>>*/ return [8,
+                ty,
+                fmtty_of_fmt(rest$9)];
+       case 14:
+        var rest$10 = fmtty$0[3], ty$0 = fmtty$0[2];
+         /*<<camlinternalFormat.ml:902:4>>*/ return [9,
+                ty$0,
+                ty$0,
+                fmtty_of_fmt(rest$10)];
+       case 15:
+        var rest$11 = fmtty$0[1];
+         /*<<camlinternalFormat.ml:894:34>>*/ return [10,
+                fmtty_of_fmt(rest$11)];
+       case 16:
+        var rest$12 = fmtty$0[1];
+         /*<<camlinternalFormat.ml:895:34>>*/ return [11,
+                fmtty_of_fmt(rest$12)];
+       case 17:
+        var fmtty$4 = fmtty$0[2], fmtty$0 = fmtty$4; break;
+       case 18:
+         /*<<camlinternalFormat.ml:914:54>>*/ var
+         rest$13 = fmtty$0[2],
+         formatting_gen = fmtty$0[1],
+          /*<<camlinternalFormat.ml:914:54>>*/ _db_ = fmtty_of_fmt(rest$13);
+        if(0 === formatting_gen[0])
+         var fmt = formatting_gen[1][1], _dc_ = fmtty_of_fmt(fmt);
+        else
+         var fmt$0 = formatting_gen[1][1], _dc_ = fmtty_of_fmt(fmt$0);
+         /*<<camlinternalFormat.ml:914:54>>*/ return  /*<<camlinternalFormat.ml:914:54>>*/ caml_call2
+                (CamlinternalFormatBasics[1], _dc_, _db_);
+       case 19:
+        var rest$14 = fmtty$0[1];
+         /*<<camlinternalFormat.ml:897:34>>*/ return [13,
+                fmtty_of_fmt(rest$14)];
+       case 20:
+        var rest$15 = fmtty$0[3];
+         /*<<camlinternalFormat.ml:908:34>>*/ return [1,
+                fmtty_of_fmt(rest$15)];
+       case 21:
+        var rest$16 = fmtty$0[2];
+         /*<<camlinternalFormat.ml:909:34>>*/ return [2,
+                fmtty_of_fmt(rest$16)];
+       case 22:
+        var rest$17 = fmtty$0[1];
+         /*<<camlinternalFormat.ml:910:34>>*/ return [0,
+                fmtty_of_fmt(rest$17)];
+       case 23:
+        var fmtty$5 = fmtty$0[2], ign = fmtty$0[1];
+        if(typeof ign === "number")
+         switch(ign){
+           case 0:
+            var fmtty$0 = fmtty$5; break;
+           case 1:
+            var fmtty$0 = fmtty$5; break;
+           case 2:
+             /*<<camlinternalFormat.ml:944:39>>*/ return [14,
+                    fmtty_of_fmt(fmtty$5)];
+           default: var fmtty$0 = fmtty$5;
+         }
+        else
+         switch(ign[0]){
+           case 0:
+            var fmtty$0 = fmtty$5; break;
+           case 1:
+            var fmtty$0 = fmtty$5; break;
+           case 2:
+            var fmtty$0 = fmtty$5; break;
+           case 3:
+            var fmtty$0 = fmtty$5; break;
+           case 4:
+            var fmtty$0 = fmtty$5; break;
+           case 5:
+            var fmtty$0 = fmtty$5; break;
+           case 6:
+            var fmtty$0 = fmtty$5; break;
+           case 7:
+            var fmtty$0 = fmtty$5; break;
+           case 8:
+            var fmtty$0 = fmtty$5; break;
+           case 9:
+             /*<<camlinternalFormat.ml:943:58>>*/ var
+             fmtty$6 = ign[2],
+              /*<<camlinternalFormat.ml:943:58>>*/ _dd_ =
+               fmtty_of_fmt(fmtty$5);
+             /*<<camlinternalFormat.ml:943:58>>*/ return  /*<<camlinternalFormat.ml:943:58>>*/ caml_call2
+                    (CamlinternalFormatBasics[1], fmtty$6, _dd_);
+           case 10:
+            var fmtty$0 = fmtty$5; break;
+           default: var fmtty$0 = fmtty$5;
+         }
+        break;
+       default:
+        var rest$18 = fmtty$0[3], arity = fmtty$0[1];
+         /*<<camlinternalFormat.ml:896:56>>*/ return fmtty_of_custom
+                (arity, fmtty_of_fmt(rest$18));
+     }
+    }
+    /*<<camlinternalFormat.ml:916:46>>*/ }
+   function fmtty_of_precision_fmtty(prec, fmtty){
+     /*<<camlinternalFormat.ml:960:20>>*/ return typeof prec === "number"
+            ? prec ? [2, fmtty] : fmtty
+            : fmtty;
+    /*<<camlinternalFormat.ml:963:37>>*/ }
+    /*<<camlinternalFormat.ml:969:0>>*/  /*<<camlinternalFormat.ml:969:0>>*/ var
+    Type_mismatch =
+      [248, cst_CamlinternalFormat_Type_mi, runtime.caml_fresh_oo_id(0)];
+   function type_padding(pad, fmtty){
+     /*<<camlinternalFormat.ml:977:17>>*/ if(typeof pad === "number")
+      /*<<camlinternalFormat.ml:978:21>>*/ return [0, 0, fmtty];
+    if(0 === pad[0]){
+     var w = pad[2], padty = pad[1];
+      /*<<camlinternalFormat.ml:979:33>>*/ return [0, [0, padty, w], fmtty];
+    }
+    if(typeof fmtty !== "number" && 2 === fmtty[0]){
+     var rest = fmtty[1], padty$0 = pad[1];
+      /*<<camlinternalFormat.ml:980:38>>*/ return [0, [1, padty$0], rest];
+    }
+     /*<<camlinternalFormat.ml:981:9>>*/ throw  /*<<camlinternalFormat.ml:981:9>>*/ caml_maybe_attach_backtrace
+           (Type_mismatch, 1);
+    /*<<camlinternalFormat.ml:981:28>>*/ }
+   function type_padprec(pad, prec, fmtty){
+     /*<<camlinternalFormat.ml:989:22>>*/  /*<<camlinternalFormat.ml:989:34>>*/ var
+     match = type_padding(pad, fmtty);
+    if(typeof prec !== "number"){
+     var rest$1 = match[2], pad$2 = match[1], p = prec[1];
+      /*<<camlinternalFormat.ml:993:4>>*/ return [0, pad$2, [0, p], rest$1];
+    }
+    if(! prec){
+     var rest$0 = match[2], pad$1 = match[1];
+      /*<<camlinternalFormat.ml:991:4>>*/ return [0, pad$1, 0, rest$0];
+    }
+    var match$0 = match[2];
+    if(typeof match$0 !== "number" && 2 === match$0[0]){
+     var rest = match$0[1], pad$0 = match[1];
+      /*<<camlinternalFormat.ml:995:4>>*/ return [0, pad$0, 1, rest];
+    }
+     /*<<camlinternalFormat.ml:996:35>>*/ throw  /*<<camlinternalFormat.ml:996:35>>*/ caml_maybe_attach_backtrace
+           (Type_mismatch, 1);
+    /*<<camlinternalFormat.ml:996:54>>*/ }
+   function type_format(fmt, fmtty){
+     /*<<camlinternalFormat.ml:1008:19>>*/  /*<<camlinternalFormat.ml:1008:25>>*/ var
+     _da_ = type_format_gen(fmt, fmtty);
+    if(typeof _da_[2] !== "number")
+      /*<<camlinternalFormat.ml:1010:9>>*/ throw  /*<<camlinternalFormat.ml:1010:9>>*/ caml_maybe_attach_backtrace
+            (Type_mismatch, 1);
+    var fmt$0 = _da_[1];
+     /*<<camlinternalFormat.ml:1009:42>>*/ return fmt$0;
+    /*<<camlinternalFormat.ml:1010:28>>*/ }
+   function type_ignored_param_one(ign, fmt, fmtty){
+     /*<<camlinternalFormat.ml:1194:2>>*/ var
+      /*<<camlinternalFormat.ml:1194:37>>*/ match =
+       type_format_gen(fmt, fmtty),
+     fmtty$0 = match[2],
+     fmt$0 = match[1];
+     /*<<camlinternalFormat.ml:1195:2>>*/ return [0,
+            [23, ign, fmt$0],
+            fmtty$0];
+    /*<<camlinternalFormat.ml:1195:51>>*/ }
+   function type_format_gen(fmt, fmtty0){
+     /*<<camlinternalFormat.ml:1018:19>>*/ if(typeof fmt === "number")
+      /*<<camlinternalFormat.ml:1133:33>>*/ return [0, 0, fmtty0];
+    switch(fmt[0]){
+      case 0:
+       if(typeof fmtty0 !== "number" && 0 === fmtty0[0]){
+         /*<<camlinternalFormat.ml:1020:39>>*/ var
+         fmtty_rest = fmtty0[1],
+         fmt_rest = fmt[1],
+          /*<<camlinternalFormat.ml:1020:39>>*/ match =
+           type_format_gen(fmt_rest, fmtty_rest),
+         fmtty = match[2],
+         fmt$0 = match[1];
+         /*<<camlinternalFormat.ml:1021:4>>*/ return [0, [0, fmt$0], fmtty];
+       }
+       break;
+      case 1:
+       if(typeof fmtty0 !== "number" && 0 === fmtty0[0]){
+         /*<<camlinternalFormat.ml:1023:39>>*/ var
+         fmtty_rest$0 = fmtty0[1],
+         fmt_rest$0 = fmt[1],
+          /*<<camlinternalFormat.ml:1023:39>>*/ match$0 =
+           type_format_gen(fmt_rest$0, fmtty_rest$0),
+         fmtty$0 = match$0[2],
+         fmt$1 = match$0[1];
+         /*<<camlinternalFormat.ml:1024:4>>*/ return [0, [1, fmt$1], fmtty$0];
+       }
+       break;
+      case 2:
+        /*<<camlinternalFormat.ml:1026:10>>*/ var
+        fmt_rest$1 = fmt[2],
+        pad = fmt[1],
+         /*<<camlinternalFormat.ml:1026:10>>*/ match$1 =
+          type_padding(pad, fmtty0),
+        pad$0 = match$1[1],
+        match$2 = match$1[2];
+       if(typeof match$2 !== "number" && 1 === match$2[0]){
+         /*<<camlinternalFormat.ml:1028:41>>*/ var
+         fmtty_rest$1 = match$2[1],
+          /*<<camlinternalFormat.ml:1028:41>>*/ match$3 =
+           type_format_gen(fmt_rest$1, fmtty_rest$1),
+         fmtty$1 = match$3[2],
+         fmt$2 = match$3[1];
+         /*<<camlinternalFormat.ml:1029:6>>*/ return [0,
+                [2, pad$0, fmt$2],
+                fmtty$1];
+       }
+        /*<<camlinternalFormat.ml:1030:34>>*/ throw  /*<<camlinternalFormat.ml:1030:34>>*/ caml_maybe_attach_backtrace
+              (Type_mismatch, 1);
+      case 3:
+        /*<<camlinternalFormat.ml:1033:10>>*/ var
+        fmt_rest$2 = fmt[2],
+        pad$1 = fmt[1],
+         /*<<camlinternalFormat.ml:1033:10>>*/ match$4 =
+          type_padding(pad$1, fmtty0),
+        pad$2 = match$4[1],
+        match$5 = match$4[2];
+       if(typeof match$5 !== "number" && 1 === match$5[0]){
+         /*<<camlinternalFormat.ml:1035:41>>*/ var
+         fmtty_rest$2 = match$5[1],
+          /*<<camlinternalFormat.ml:1035:41>>*/ match$6 =
+           type_format_gen(fmt_rest$2, fmtty_rest$2),
+         fmtty$2 = match$6[2],
+         fmt$3 = match$6[1];
+         /*<<camlinternalFormat.ml:1036:6>>*/ return [0,
+                [3, pad$2, fmt$3],
+                fmtty$2];
+       }
+        /*<<camlinternalFormat.ml:1037:34>>*/ throw  /*<<camlinternalFormat.ml:1037:34>>*/ caml_maybe_attach_backtrace
+              (Type_mismatch, 1);
+      case 4:
+        /*<<camlinternalFormat.ml:1040:10>>*/ var
+        fmt_rest$3 = fmt[4],
+        prec = fmt[3],
+        pad$3 = fmt[2],
+        iconv = fmt[1],
+         /*<<camlinternalFormat.ml:1040:10>>*/ match$7 =
+          type_padprec(pad$3, prec, fmtty0),
+        pad$4 = match$7[1],
+        match$8 = match$7[3];
+       if(typeof match$8 !== "number" && 2 === match$8[0]){
+         /*<<camlinternalFormat.ml:1042:41>>*/ var
+         fmtty_rest$3 = match$8[1],
+         prec$0 = match$7[2],
+          /*<<camlinternalFormat.ml:1042:41>>*/ match$9 =
+           type_format_gen(fmt_rest$3, fmtty_rest$3),
+         fmtty$3 = match$9[2],
+         fmt$4 = match$9[1];
+         /*<<camlinternalFormat.ml:1043:6>>*/ return [0,
+                [4, iconv, pad$4, prec$0, fmt$4],
+                fmtty$3];
+       }
+        /*<<camlinternalFormat.ml:1044:37>>*/ throw  /*<<camlinternalFormat.ml:1044:37>>*/ caml_maybe_attach_backtrace
+              (Type_mismatch, 1);
+      case 5:
+        /*<<camlinternalFormat.ml:1047:10>>*/ var
+        fmt_rest$4 = fmt[4],
+        prec$1 = fmt[3],
+        pad$5 = fmt[2],
+        iconv$0 = fmt[1],
+         /*<<camlinternalFormat.ml:1047:10>>*/ match$10 =
+          type_padprec(pad$5, prec$1, fmtty0),
+        pad$6 = match$10[1],
+        match$11 = match$10[3];
+       if(typeof match$11 !== "number" && 3 === match$11[0]){
+         /*<<camlinternalFormat.ml:1049:41>>*/ var
+         fmtty_rest$4 = match$11[1],
+         prec$2 = match$10[2],
+          /*<<camlinternalFormat.ml:1049:41>>*/ match$12 =
+           type_format_gen(fmt_rest$4, fmtty_rest$4),
+         fmtty$4 = match$12[2],
+         fmt$5 = match$12[1];
+         /*<<camlinternalFormat.ml:1050:6>>*/ return [0,
+                [5, iconv$0, pad$6, prec$2, fmt$5],
+                fmtty$4];
+       }
+        /*<<camlinternalFormat.ml:1051:37>>*/ throw  /*<<camlinternalFormat.ml:1051:37>>*/ caml_maybe_attach_backtrace
+              (Type_mismatch, 1);
+      case 6:
+        /*<<camlinternalFormat.ml:1054:10>>*/ var
+        fmt_rest$5 = fmt[4],
+        prec$3 = fmt[3],
+        pad$7 = fmt[2],
+        iconv$1 = fmt[1],
+         /*<<camlinternalFormat.ml:1054:10>>*/ match$13 =
+          type_padprec(pad$7, prec$3, fmtty0),
+        pad$8 = match$13[1],
+        match$14 = match$13[3];
+       if(typeof match$14 !== "number" && 4 === match$14[0]){
+         /*<<camlinternalFormat.ml:1056:41>>*/ var
+         fmtty_rest$5 = match$14[1],
+         prec$4 = match$13[2],
+          /*<<camlinternalFormat.ml:1056:41>>*/ match$15 =
+           type_format_gen(fmt_rest$5, fmtty_rest$5),
+         fmtty$5 = match$15[2],
+         fmt$6 = match$15[1];
+         /*<<camlinternalFormat.ml:1057:6>>*/ return [0,
+                [6, iconv$1, pad$8, prec$4, fmt$6],
+                fmtty$5];
+       }
+        /*<<camlinternalFormat.ml:1058:37>>*/ throw  /*<<camlinternalFormat.ml:1058:37>>*/ caml_maybe_attach_backtrace
+              (Type_mismatch, 1);
+      case 7:
+        /*<<camlinternalFormat.ml:1061:10>>*/ var
+        fmt_rest$6 = fmt[4],
+        prec$5 = fmt[3],
+        pad$9 = fmt[2],
+        iconv$2 = fmt[1],
+         /*<<camlinternalFormat.ml:1061:10>>*/ match$16 =
+          type_padprec(pad$9, prec$5, fmtty0),
+        pad$10 = match$16[1],
+        match$17 = match$16[3];
+       if(typeof match$17 !== "number" && 5 === match$17[0]){
+         /*<<camlinternalFormat.ml:1063:41>>*/ var
+         fmtty_rest$6 = match$17[1],
+         prec$6 = match$16[2],
+          /*<<camlinternalFormat.ml:1063:41>>*/ match$18 =
+           type_format_gen(fmt_rest$6, fmtty_rest$6),
+         fmtty$6 = match$18[2],
+         fmt$7 = match$18[1];
+         /*<<camlinternalFormat.ml:1064:6>>*/ return [0,
+                [7, iconv$2, pad$10, prec$6, fmt$7],
+                fmtty$6];
+       }
+        /*<<camlinternalFormat.ml:1065:37>>*/ throw  /*<<camlinternalFormat.ml:1065:37>>*/ caml_maybe_attach_backtrace
+              (Type_mismatch, 1);
+      case 8:
+        /*<<camlinternalFormat.ml:1068:10>>*/ var
+        fmt_rest$7 = fmt[4],
+        prec$7 = fmt[3],
+        pad$11 = fmt[2],
+        fconv = fmt[1],
+         /*<<camlinternalFormat.ml:1068:10>>*/ match$19 =
+          type_padprec(pad$11, prec$7, fmtty0),
+        pad$12 = match$19[1],
+        match$20 = match$19[3];
+       if(typeof match$20 !== "number" && 6 === match$20[0]){
+         /*<<camlinternalFormat.ml:1070:41>>*/ var
+         fmtty_rest$7 = match$20[1],
+         prec$8 = match$19[2],
+          /*<<camlinternalFormat.ml:1070:41>>*/ match$21 =
+           type_format_gen(fmt_rest$7, fmtty_rest$7),
+         fmtty$7 = match$21[2],
+         fmt$8 = match$21[1];
+         /*<<camlinternalFormat.ml:1071:6>>*/ return [0,
+                [8, fconv, pad$12, prec$8, fmt$8],
+                fmtty$7];
+       }
+        /*<<camlinternalFormat.ml:1072:37>>*/ throw  /*<<camlinternalFormat.ml:1072:37>>*/ caml_maybe_attach_backtrace
+              (Type_mismatch, 1);
+      case 9:
+        /*<<camlinternalFormat.ml:1075:10>>*/ var
+        fmt_rest$8 = fmt[2],
+        pad$13 = fmt[1],
+         /*<<camlinternalFormat.ml:1075:10>>*/ match$22 =
+          type_padding(pad$13, fmtty0),
+        pad$14 = match$22[1],
+        match$23 = match$22[2];
+       if(typeof match$23 !== "number" && 7 === match$23[0]){
+         /*<<camlinternalFormat.ml:1077:41>>*/ var
+         fmtty_rest$8 = match$23[1],
+          /*<<camlinternalFormat.ml:1077:41>>*/ match$24 =
+           type_format_gen(fmt_rest$8, fmtty_rest$8),
+         fmtty$8 = match$24[2],
+         fmt$9 = match$24[1];
+         /*<<camlinternalFormat.ml:1078:6>>*/ return [0,
+                [9, pad$14, fmt$9],
+                fmtty$8];
+       }
+        /*<<camlinternalFormat.ml:1079:34>>*/ throw  /*<<camlinternalFormat.ml:1079:34>>*/ caml_maybe_attach_backtrace
+              (Type_mismatch, 1);
+      case 10:
+        /*<<camlinternalFormat.ml:1082:39>>*/ var
+        fmt_rest$9 = fmt[1],
+         /*<<camlinternalFormat.ml:1082:39>>*/ match$25 =
+          type_format_gen(fmt_rest$9, fmtty0),
+        fmtty$9 = match$25[2],
+        fmt$10 = match$25[1];
+        /*<<camlinternalFormat.ml:1083:4>>*/ return [0, [10, fmt$10], fmtty$9];
+      case 11:
+        /*<<camlinternalFormat.ml:1086:39>>*/ var
+        fmt_rest$10 = fmt[2],
+        str = fmt[1],
+         /*<<camlinternalFormat.ml:1086:39>>*/ match$26 =
+          type_format_gen(fmt_rest$10, fmtty0),
+        fmtty$10 = match$26[2],
+        fmt$11 = match$26[1];
+        /*<<camlinternalFormat.ml:1087:4>>*/ return [0,
+               [11, str, fmt$11],
+               fmtty$10];
+      case 12:
+        /*<<camlinternalFormat.ml:1089:39>>*/ var
+        fmt_rest$11 = fmt[2],
+        chr = fmt[1],
+         /*<<camlinternalFormat.ml:1089:39>>*/ match$27 =
+          type_format_gen(fmt_rest$11, fmtty0),
+        fmtty$11 = match$27[2],
+        fmt$12 = match$27[1];
+        /*<<camlinternalFormat.ml:1090:4>>*/ return [0,
+               [12, chr, fmt$12],
+               fmtty$11];
+      case 13:
+       if(typeof fmtty0 !== "number" && 8 === fmtty0[0]){
+        var
+         fmtty_rest$9 = fmtty0[2],
+         sub_fmtty = fmtty0[1],
+         fmt_rest$12 = fmt[3],
+         sub_fmtty$0 = fmt[2],
+         pad_opt = fmt[1];
+         /*<<camlinternalFormat.ml:1094:7>>*/ if
+         ( /*<<camlinternalFormat.ml:1094:7>>*/ caml_notequal
+           ([0, sub_fmtty$0], [0, sub_fmtty]))
+          /*<<camlinternalFormat.ml:1094:56>>*/ throw  /*<<camlinternalFormat.ml:1094:56>>*/ caml_maybe_attach_backtrace
+                (Type_mismatch, 1);
+         /*<<camlinternalFormat.ml:1095:39>>*/ var
+          /*<<camlinternalFormat.ml:1095:39>>*/ match$28 =
+           type_format_gen(fmt_rest$12, fmtty_rest$9),
+         fmtty$12 = match$28[2],
+         fmt$13 = match$28[1];
+         /*<<camlinternalFormat.ml:1096:4>>*/ return [0,
+                [13, pad_opt, sub_fmtty, fmt$13],
+                fmtty$12];
+       }
+       break;
+      case 14:
+       if(typeof fmtty0 !== "number" && 9 === fmtty0[0]){
+         /*<<camlinternalFormat.ml:1099:42>>*/ var
+         fmtty_rest$10 = fmtty0[3],
+         sub_fmtty1 = fmtty0[1],
+         fmt_rest$13 = fmt[3],
+         sub_fmtty$1 = fmt[2],
+         pad_opt$0 = fmt[1],
+          /*<<camlinternalFormat.ml:1099:42>>*/ _c__ =
+           [0,
+             /*<<camlinternalFormat.ml:1099:52>>*/ caml_call1
+             (CamlinternalFormatBasics[2], sub_fmtty1)];
+         /*<<camlinternalFormat.ml:1099:7>>*/ if
+         ( /*<<camlinternalFormat.ml:1099:7>>*/ caml_notequal
+           ([0,
+              /*<<camlinternalFormat.ml:1099:17>>*/ caml_call1
+              (CamlinternalFormatBasics[2], sub_fmtty$1)],
+            _c__))
+          /*<<camlinternalFormat.ml:1100:6>>*/ throw  /*<<camlinternalFormat.ml:1100:6>>*/ caml_maybe_attach_backtrace
+                (Type_mismatch, 1);
+         /*<<camlinternalFormat.ml:1102:6>>*/ var
+          /*<<camlinternalFormat.ml:1102:6>>*/ match$29 =
+           type_format_gen
+            (fmt_rest$13,
+              /*<<camlinternalFormat.ml:1102:31>>*/ caml_call1
+              (CamlinternalFormatBasics[2], fmtty_rest$10)),
+         fmtty$13 = match$29[2],
+         fmt$14 = match$29[1];
+         /*<<camlinternalFormat.ml:1104:4>>*/ return [0,
+                [14, pad_opt$0, sub_fmtty1, fmt$14],
+                fmtty$13];
+       }
+       break;
+      case 15:
+       if(typeof fmtty0 !== "number" && 10 === fmtty0[0]){
+         /*<<camlinternalFormat.ml:1107:39>>*/ var
+         fmtty_rest$11 = fmtty0[1],
+         fmt_rest$14 = fmt[1],
+          /*<<camlinternalFormat.ml:1107:39>>*/ match$30 =
+           type_format_gen(fmt_rest$14, fmtty_rest$11),
+         fmtty$14 = match$30[2],
+         fmt$15 = match$30[1];
+         /*<<camlinternalFormat.ml:1108:4>>*/ return [0,
+                [15, fmt$15],
+                fmtty$14];
+       }
+       break;
+      case 16:
+       if(typeof fmtty0 !== "number" && 11 === fmtty0[0]){
+         /*<<camlinternalFormat.ml:1110:39>>*/ var
+         fmtty_rest$12 = fmtty0[1],
+         fmt_rest$15 = fmt[1],
+          /*<<camlinternalFormat.ml:1110:39>>*/ match$31 =
+           type_format_gen(fmt_rest$15, fmtty_rest$12),
+         fmtty$15 = match$31[2],
+         fmt$16 = match$31[1];
+         /*<<camlinternalFormat.ml:1111:4>>*/ return [0,
+                [16, fmt$16],
+                fmtty$15];
+       }
+       break;
+      case 17:
+        /*<<camlinternalFormat.ml:1115:39>>*/ var
+        fmt_rest$16 = fmt[2],
+        formatting_lit = fmt[1],
+         /*<<camlinternalFormat.ml:1115:39>>*/ match$32 =
+          type_format_gen(fmt_rest$16, fmtty0),
+        fmtty$16 = match$32[2],
+        fmt$17 = match$32[1];
+        /*<<camlinternalFormat.ml:1116:4>>*/ return [0,
+               [17, formatting_lit, fmt$17],
+               fmtty$16];
+      case 18:
+       var fmt_rest$17 = fmt[2], formatting_gen = fmt[1];
+       if(0 === formatting_gen[0]){
+         /*<<camlinternalFormat.ml:1144:39>>*/ var
+         match$36 = formatting_gen[1],
+         str$0 = match$36[2],
+         fmt1 = match$36[1],
+          /*<<camlinternalFormat.ml:1144:39>>*/ match$37 =
+           type_format_gen(fmt1, fmtty0),
+         fmtty2 = match$37[2],
+         fmt2 = match$37[1],
+          /*<<camlinternalFormat.ml:1145:39>>*/ match$38 =
+           type_format_gen(fmt_rest$17, fmtty2),
+         fmtty3 = match$38[2],
+         fmt3 = match$38[1];
+         /*<<camlinternalFormat.ml:1146:4>>*/ return [0,
+                [18, [0, [0, fmt2, str$0]], fmt3],
+                fmtty3];
+       }
+        /*<<camlinternalFormat.ml:1148:39>>*/ var
+        match$39 = formatting_gen[1],
+        str$1 = match$39[2],
+        fmt1$0 = match$39[1],
+         /*<<camlinternalFormat.ml:1148:39>>*/ match$40 =
+          type_format_gen(fmt1$0, fmtty0),
+        fmtty2$0 = match$40[2],
+        fmt2$0 = match$40[1],
+         /*<<camlinternalFormat.ml:1149:39>>*/ match$41 =
+          type_format_gen(fmt_rest$17, fmtty2$0),
+        fmtty3$0 = match$41[2],
+        fmt3$0 = match$41[1];
+        /*<<camlinternalFormat.ml:1150:4>>*/ return [0,
+               [18, [1, [0, fmt2$0, str$1]], fmt3$0],
+               fmtty3$0];
+      case 19:
+       if(typeof fmtty0 !== "number" && 13 === fmtty0[0]){
+         /*<<camlinternalFormat.ml:1122:39>>*/ var
+         fmtty_rest$13 = fmtty0[1],
+         fmt_rest$18 = fmt[1],
+          /*<<camlinternalFormat.ml:1122:39>>*/ match$33 =
+           type_format_gen(fmt_rest$18, fmtty_rest$13),
+         fmtty$17 = match$33[2],
+         fmt$18 = match$33[1];
+         /*<<camlinternalFormat.ml:1123:4>>*/ return [0,
+                [19, fmt$18],
+                fmtty$17];
+       }
+       break;
+      case 20:
+       if(typeof fmtty0 !== "number" && 1 === fmtty0[0]){
+         /*<<camlinternalFormat.ml:1125:39>>*/ var
+         fmtty_rest$14 = fmtty0[1],
+         fmt_rest$19 = fmt[3],
+         char_set = fmt[2],
+         width_opt = fmt[1],
+          /*<<camlinternalFormat.ml:1125:39>>*/ match$34 =
+           type_format_gen(fmt_rest$19, fmtty_rest$14),
+         fmtty$18 = match$34[2],
+         fmt$19 = match$34[1];
+         /*<<camlinternalFormat.ml:1126:4>>*/ return [0,
+                [20, width_opt, char_set, fmt$19],
+                fmtty$18];
+       }
+       break;
+      case 21:
+       if(typeof fmtty0 !== "number" && 2 === fmtty0[0]){
+         /*<<camlinternalFormat.ml:1128:39>>*/ var
+         fmtty_rest$15 = fmtty0[1],
+         fmt_rest$20 = fmt[2],
+         counter = fmt[1],
+          /*<<camlinternalFormat.ml:1128:39>>*/ match$35 =
+           type_format_gen(fmt_rest$20, fmtty_rest$15),
+         fmtty$19 = match$35[2],
+         fmt$20 = match$35[1];
+         /*<<camlinternalFormat.ml:1129:4>>*/ return [0,
+                [21, counter, fmt$20],
+                fmtty$19];
+       }
+       break;
+      case 23:
+       var rest = fmt[2], ign = fmt[1];
+       if(typeof ign !== "number")
+        switch(ign[0]){
+          case 0:
+            /*<<camlinternalFormat.ml:1161:42>>*/ return type_ignored_param_one
+                   (ign, rest, fmtty0);
+          case 1:
+            /*<<camlinternalFormat.ml:1162:42>>*/ return type_ignored_param_one
+                   (ign, rest, fmtty0);
+          case 2:
+            /*<<camlinternalFormat.ml:1163:42>>*/ return type_ignored_param_one
+                   (ign, rest, fmtty0);
+          case 3:
+            /*<<camlinternalFormat.ml:1164:42>>*/ return type_ignored_param_one
+                   (ign, rest, fmtty0);
+          case 4:
+            /*<<camlinternalFormat.ml:1165:42>>*/ return type_ignored_param_one
+                   (ign, rest, fmtty0);
+          case 5:
+            /*<<camlinternalFormat.ml:1166:42>>*/ return type_ignored_param_one
+                   (ign, rest, fmtty0);
+          case 6:
+            /*<<camlinternalFormat.ml:1167:42>>*/ return type_ignored_param_one
+                   (ign, rest, fmtty0);
+          case 7:
+            /*<<camlinternalFormat.ml:1168:42>>*/ return type_ignored_param_one
+                   (ign, rest, fmtty0);
+          case 8:
+           var sub_fmtty$2 = ign[2], pad_opt$1 = ign[1];
+            /*<<camlinternalFormat.ml:1173:4>>*/ return type_ignored_param_one
+                   ([8, pad_opt$1, sub_fmtty$2], rest, fmtty0);
+          case 9:
+            /*<<camlinternalFormat.ml:1176:6>>*/ var
+            sub_fmtty$3 = ign[2],
+            pad_opt$2 = ign[1],
+             /*<<camlinternalFormat.ml:1176:6>>*/ _c$_ =
+              type_ignored_format_substituti(sub_fmtty$3, rest, fmtty0),
+            match$43 = _c$_[2],
+            fmtty$21 = match$43[2],
+            fmt$22 = match$43[1],
+            sub_fmtty$4 = _c$_[1];
+            /*<<camlinternalFormat.ml:1177:4>>*/ return [0,
+                   [23, [9, pad_opt$2, sub_fmtty$4], fmt$22],
+                   fmtty$21];
+          case 10:
+            /*<<camlinternalFormat.ml:1169:42>>*/ return type_ignored_param_one
+                   (ign, rest, fmtty0);
+          default:
+            /*<<camlinternalFormat.ml:1170:42>>*/ return type_ignored_param_one
+                   (ign, rest, fmtty0);
+        }
+       switch(ign){
+         case 0:
+           /*<<camlinternalFormat.ml:1159:42>>*/ return type_ignored_param_one
+                  (ign, rest, fmtty0);
+         case 1:
+           /*<<camlinternalFormat.ml:1160:42>>*/ return type_ignored_param_one
+                  (ign, rest, fmtty0);
+         case 2:
+          if(typeof fmtty0 !== "number" && 14 === fmtty0[0]){
+            /*<<camlinternalFormat.ml:1183:41>>*/ var
+            fmtty_rest$16 = fmtty0[1],
+             /*<<camlinternalFormat.ml:1183:41>>*/ match$42 =
+              type_format_gen(rest, fmtty_rest$16),
+            fmtty$20 = match$42[2],
+            fmt$21 = match$42[1];
+            /*<<camlinternalFormat.ml:1184:6>>*/ return [0,
+                   [23, 2, fmt$21],
+                   fmtty$20];
+          }
+           /*<<camlinternalFormat.ml:1185:11>>*/ throw  /*<<camlinternalFormat.ml:1185:11>>*/ caml_maybe_attach_backtrace
+                 (Type_mismatch, 1);
+         default:
+           /*<<camlinternalFormat.ml:1171:42>>*/ return type_ignored_param_one
+                  (ign, rest, fmtty0);
+       }
+    }
+     /*<<camlinternalFormat.ml:1135:9>>*/ throw  /*<<camlinternalFormat.ml:1135:9>>*/ caml_maybe_attach_backtrace
+           (Type_mismatch, 1);
+    /*<<camlinternalFormat.ml:1135:28>>*/ }
+   function type_ignored_format_substituti(sub_fmtty, fmt, fmtty){
+     /*<<camlinternalFormat.ml:1202:27>>*/ if(typeof sub_fmtty === "number")
+      /*<<camlinternalFormat.ml:1276:4>>*/ return [0,
+             0,
+             type_format_gen(fmt, fmtty)];
+    switch(sub_fmtty[0]){
+      case 0:
+       if(typeof fmtty !== "number" && 0 === fmtty[0]){
+         /*<<camlinternalFormat.ml:1205:6>>*/ var
+         fmtty_rest = fmtty[1],
+         sub_fmtty_rest = sub_fmtty[1],
+          /*<<camlinternalFormat.ml:1205:6>>*/ match =
+           type_ignored_format_substituti(sub_fmtty_rest, fmt, fmtty_rest),
+         fmt$0 = match[2],
+         sub_fmtty_rest$0 = match[1];
+         /*<<camlinternalFormat.ml:1206:4>>*/ return [0,
+                [0, sub_fmtty_rest$0],
+                fmt$0];
+       }
+       break;
+      case 1:
+       if(typeof fmtty !== "number" && 1 === fmtty[0]){
+         /*<<camlinternalFormat.ml:1209:6>>*/ var
+         fmtty_rest$0 = fmtty[1],
+         sub_fmtty_rest$1 = sub_fmtty[1],
+          /*<<camlinternalFormat.ml:1209:6>>*/ match$0 =
+           type_ignored_format_substituti(sub_fmtty_rest$1, fmt, fmtty_rest$0),
+         fmt$1 = match$0[2],
+         sub_fmtty_rest$2 = match$0[1];
+         /*<<camlinternalFormat.ml:1210:4>>*/ return [0,
+                [1, sub_fmtty_rest$2],
+                fmt$1];
+       }
+       break;
+      case 2:
+       if(typeof fmtty !== "number" && 2 === fmtty[0]){
+         /*<<camlinternalFormat.ml:1213:6>>*/ var
+         fmtty_rest$1 = fmtty[1],
+         sub_fmtty_rest$3 = sub_fmtty[1],
+          /*<<camlinternalFormat.ml:1213:6>>*/ match$1 =
+           type_ignored_format_substituti(sub_fmtty_rest$3, fmt, fmtty_rest$1),
+         fmt$2 = match$1[2],
+         sub_fmtty_rest$4 = match$1[1];
+         /*<<camlinternalFormat.ml:1214:4>>*/ return [0,
+                [2, sub_fmtty_rest$4],
+                fmt$2];
+       }
+       break;
+      case 3:
+       if(typeof fmtty !== "number" && 3 === fmtty[0]){
+         /*<<camlinternalFormat.ml:1217:6>>*/ var
+         fmtty_rest$2 = fmtty[1],
+         sub_fmtty_rest$5 = sub_fmtty[1],
+          /*<<camlinternalFormat.ml:1217:6>>*/ match$2 =
+           type_ignored_format_substituti(sub_fmtty_rest$5, fmt, fmtty_rest$2),
+         fmt$3 = match$2[2],
+         sub_fmtty_rest$6 = match$2[1];
+         /*<<camlinternalFormat.ml:1218:4>>*/ return [0,
+                [3, sub_fmtty_rest$6],
+                fmt$3];
+       }
+       break;
+      case 4:
+       if(typeof fmtty !== "number" && 4 === fmtty[0]){
+         /*<<camlinternalFormat.ml:1221:6>>*/ var
+         fmtty_rest$3 = fmtty[1],
+         sub_fmtty_rest$7 = sub_fmtty[1],
+          /*<<camlinternalFormat.ml:1221:6>>*/ match$3 =
+           type_ignored_format_substituti(sub_fmtty_rest$7, fmt, fmtty_rest$3),
+         fmt$4 = match$3[2],
+         sub_fmtty_rest$8 = match$3[1];
+         /*<<camlinternalFormat.ml:1222:4>>*/ return [0,
+                [4, sub_fmtty_rest$8],
+                fmt$4];
+       }
+       break;
+      case 5:
+       if(typeof fmtty !== "number" && 5 === fmtty[0]){
+         /*<<camlinternalFormat.ml:1225:6>>*/ var
+         fmtty_rest$4 = fmtty[1],
+         sub_fmtty_rest$9 = sub_fmtty[1],
+          /*<<camlinternalFormat.ml:1225:6>>*/ match$4 =
+           type_ignored_format_substituti(sub_fmtty_rest$9, fmt, fmtty_rest$4),
+         fmt$5 = match$4[2],
+         sub_fmtty_rest$10 = match$4[1];
+         /*<<camlinternalFormat.ml:1226:4>>*/ return [0,
+                [5, sub_fmtty_rest$10],
+                fmt$5];
+       }
+       break;
+      case 6:
+       if(typeof fmtty !== "number" && 6 === fmtty[0]){
+         /*<<camlinternalFormat.ml:1229:6>>*/ var
+         fmtty_rest$5 = fmtty[1],
+         sub_fmtty_rest$11 = sub_fmtty[1],
+          /*<<camlinternalFormat.ml:1229:6>>*/ match$5 =
+           type_ignored_format_substituti
+            (sub_fmtty_rest$11, fmt, fmtty_rest$5),
+         fmt$6 = match$5[2],
+         sub_fmtty_rest$12 = match$5[1];
+         /*<<camlinternalFormat.ml:1230:4>>*/ return [0,
+                [6, sub_fmtty_rest$12],
+                fmt$6];
+       }
+       break;
+      case 7:
+       if(typeof fmtty !== "number" && 7 === fmtty[0]){
+         /*<<camlinternalFormat.ml:1233:6>>*/ var
+         fmtty_rest$6 = fmtty[1],
+         sub_fmtty_rest$13 = sub_fmtty[1],
+          /*<<camlinternalFormat.ml:1233:6>>*/ match$6 =
+           type_ignored_format_substituti
+            (sub_fmtty_rest$13, fmt, fmtty_rest$6),
+         fmt$7 = match$6[2],
+         sub_fmtty_rest$14 = match$6[1];
+         /*<<camlinternalFormat.ml:1234:4>>*/ return [0,
+                [7, sub_fmtty_rest$14],
+                fmt$7];
+       }
+       break;
+      case 8:
+       if(typeof fmtty !== "number" && 8 === fmtty[0]){
+        var
+         fmtty_rest$7 = fmtty[2],
+         sub2_fmtty = fmtty[1],
+         sub_fmtty_rest$15 = sub_fmtty[2],
+         sub2_fmtty$0 = sub_fmtty[1];
+         /*<<camlinternalFormat.ml:1254:7>>*/ if
+         ( /*<<camlinternalFormat.ml:1254:7>>*/ caml_notequal
+           ([0, sub2_fmtty$0], [0, sub2_fmtty]))
+          /*<<camlinternalFormat.ml:1254:58>>*/ throw  /*<<camlinternalFormat.ml:1254:58>>*/ caml_maybe_attach_backtrace
+                (Type_mismatch, 1);
+         /*<<camlinternalFormat.ml:1256:6>>*/ var
+          /*<<camlinternalFormat.ml:1256:6>>*/ match$7 =
+           type_ignored_format_substituti
+            (sub_fmtty_rest$15, fmt, fmtty_rest$7),
+         fmt$8 = match$7[2],
+         sub_fmtty_rest$16 = match$7[1];
+         /*<<camlinternalFormat.ml:1257:4>>*/ return [0,
+                [8, sub2_fmtty, sub_fmtty_rest$16],
+                fmt$8];
+       }
+       break;
+      case 9:
+       if(typeof fmtty !== "number" && 9 === fmtty[0]){
+         /*<<camlinternalFormat.ml:1261:43>>*/ var
+         fmtty_rest$8 = fmtty[3],
+         sub2_fmtty$1 = fmtty[2],
+         sub1_fmtty = fmtty[1],
+         sub_fmtty_rest$17 = sub_fmtty[3],
+         sub2_fmtty$2 = sub_fmtty[2],
+         sub1_fmtty$0 = sub_fmtty[1],
+          /*<<camlinternalFormat.ml:1261:43>>*/ _c8_ =
+           [0,
+             /*<<camlinternalFormat.ml:1261:53>>*/ caml_call1
+             (CamlinternalFormatBasics[2], sub1_fmtty)];
+         /*<<camlinternalFormat.ml:1261:7>>*/ if
+         ( /*<<camlinternalFormat.ml:1261:7>>*/ caml_notequal
+           ([0,
+              /*<<camlinternalFormat.ml:1261:17>>*/ caml_call1
+              (CamlinternalFormatBasics[2], sub1_fmtty$0)],
+            _c8_))
+          /*<<camlinternalFormat.ml:1262:9>>*/ throw  /*<<camlinternalFormat.ml:1262:9>>*/ caml_maybe_attach_backtrace
+                (Type_mismatch, 1);
+         /*<<camlinternalFormat.ml:1263:43>>*/  /*<<camlinternalFormat.ml:1263:43>>*/ var
+         _c9_ =
+           [0,
+             /*<<camlinternalFormat.ml:1263:53>>*/ caml_call1
+             (CamlinternalFormatBasics[2], sub2_fmtty$1)];
+         /*<<camlinternalFormat.ml:1263:7>>*/ if
+         ( /*<<camlinternalFormat.ml:1263:7>>*/ caml_notequal
+           ([0,
+              /*<<camlinternalFormat.ml:1263:17>>*/ caml_call1
+              (CamlinternalFormatBasics[2], sub2_fmtty$2)],
+            _c9_))
+          /*<<camlinternalFormat.ml:1264:9>>*/ throw  /*<<camlinternalFormat.ml:1264:9>>*/ caml_maybe_attach_backtrace
+                (Type_mismatch, 1);
+         /*<<camlinternalFormat.ml:1265:21>>*/ var
+          /*<<camlinternalFormat.ml:1265:21>>*/ sub_fmtty$0 =
+           trans(symm(sub1_fmtty), sub2_fmtty$1),
+          /*<<camlinternalFormat.ml:1266:23>>*/ match$8 =
+           fmtty_rel_det(sub_fmtty$0),
+         f4 = match$8[4],
+         f2 = match$8[2];
+         /*<<camlinternalFormat.ml:1267:15>>*/ f2(0);
+         /*<<camlinternalFormat.ml:1268:15>>*/ f4(0);
+         /*<<camlinternalFormat.ml:1270:6>>*/ var
+          /*<<camlinternalFormat.ml:1270:6>>*/ match$9 =
+           type_ignored_format_substituti
+            ( /*<<camlinternalFormat.ml:1270:39>>*/ caml_call1
+              (CamlinternalFormatBasics[2], sub_fmtty_rest$17),
+             fmt,
+             fmtty_rest$8),
+         fmt$9 = match$9[2],
+         sub_fmtty_rest$18 = match$9[1];
+         /*<<camlinternalFormat.ml:1272:4>>*/ return [0,
+                [9, sub1_fmtty, sub2_fmtty$1, symm(sub_fmtty_rest$18)],
+                fmt$9];
+       }
+       break;
+      case 10:
+       if(typeof fmtty !== "number" && 10 === fmtty[0]){
+         /*<<camlinternalFormat.ml:1237:6>>*/ var
+         fmtty_rest$9 = fmtty[1],
+         sub_fmtty_rest$19 = sub_fmtty[1],
+          /*<<camlinternalFormat.ml:1237:6>>*/ match$10 =
+           type_ignored_format_substituti
+            (sub_fmtty_rest$19, fmt, fmtty_rest$9),
+         fmt$10 = match$10[2],
+         sub_fmtty_rest$20 = match$10[1];
+         /*<<camlinternalFormat.ml:1238:4>>*/ return [0,
+                [10, sub_fmtty_rest$20],
+                fmt$10];
+       }
+       break;
+      case 11:
+       if(typeof fmtty !== "number" && 11 === fmtty[0]){
+         /*<<camlinternalFormat.ml:1241:6>>*/ var
+         fmtty_rest$10 = fmtty[1],
+         sub_fmtty_rest$21 = sub_fmtty[1],
+          /*<<camlinternalFormat.ml:1241:6>>*/ match$11 =
+           type_ignored_format_substituti
+            (sub_fmtty_rest$21, fmt, fmtty_rest$10),
+         fmt$11 = match$11[2],
+         sub_fmtty_rest$22 = match$11[1];
+         /*<<camlinternalFormat.ml:1242:4>>*/ return [0,
+                [11, sub_fmtty_rest$22],
+                fmt$11];
+       }
+       break;
+      case 13:
+       if(typeof fmtty !== "number" && 13 === fmtty[0]){
+         /*<<camlinternalFormat.ml:1245:6>>*/ var
+         fmtty_rest$11 = fmtty[1],
+         sub_fmtty_rest$23 = sub_fmtty[1],
+          /*<<camlinternalFormat.ml:1245:6>>*/ match$12 =
+           type_ignored_format_substituti
+            (sub_fmtty_rest$23, fmt, fmtty_rest$11),
+         fmt$12 = match$12[2],
+         sub_fmtty_rest$24 = match$12[1];
+         /*<<camlinternalFormat.ml:1246:4>>*/ return [0,
+                [13, sub_fmtty_rest$24],
+                fmt$12];
+       }
+       break;
+      case 14:
+       if(typeof fmtty !== "number" && 14 === fmtty[0]){
+         /*<<camlinternalFormat.ml:1249:6>>*/ var
+         fmtty_rest$12 = fmtty[1],
+         sub_fmtty_rest$25 = sub_fmtty[1],
+          /*<<camlinternalFormat.ml:1249:6>>*/ match$13 =
+           type_ignored_format_substituti
+            (sub_fmtty_rest$25, fmt, fmtty_rest$12),
+         fmt$13 = match$13[2],
+         sub_fmtty_rest$26 = match$13[1];
+         /*<<camlinternalFormat.ml:1250:4>>*/ return [0,
+                [14, sub_fmtty_rest$26],
+                fmt$13];
+       }
+       break;
+    }
+     /*<<camlinternalFormat.ml:1277:9>>*/ throw  /*<<camlinternalFormat.ml:1277:9>>*/ caml_maybe_attach_backtrace
+           (Type_mismatch, 1);
+    /*<<camlinternalFormat.ml:1277:28>>*/ }
+   function recast(fmt, fmtty){
+     /*<<camlinternalFormat.ml:1312:2>>*/  /*<<camlinternalFormat.ml:1312:29>>*/ var
+     _c7_ = symm(fmtty);
+     /*<<camlinternalFormat.ml:1312:18>>*/ return type_format
+            (fmt,
+              /*<<camlinternalFormat.ml:1312:18>>*/ caml_call1
+              (CamlinternalFormatBasics[2], _c7_));
+    /*<<camlinternalFormat.ml:1312:42>>*/ }
+   function fix_padding(padty, width, str){
+     /*<<camlinternalFormat.ml:1319:2>>*/ var
+     len = caml_ml_string_length(str),
+      /*<<camlinternalFormat.ml:1320:2>>*/ padty$0 = 0 <= width ? padty : 0,
+      /*<<camlinternalFormat.ml:1321:4>>*/ width$0 =
+        /*<<camlinternalFormat.ml:1321:4>>*/ caml_call1(Stdlib[18], width);
+    if(width$0 <= len)  /*<<camlinternalFormat.ml:1332:23>>*/ return str;
+     /*<<camlinternalFormat.ml:1333:14>>*/ var
+     _c6_ = 2 === padty$0 ? 48 : 32,
+      /*<<camlinternalFormat.ml:1333:14>>*/ res =
+        /*<<camlinternalFormat.ml:1333:14>>*/ caml_call2
+        (Stdlib_Bytes[1], width$0, _c6_);
+     /*<<camlinternalFormat.ml:1334:4>>*/ switch(padty$0){
+      case 0:
+        /*<<camlinternalFormat.ml:1335:15>>*/  /*<<camlinternalFormat.ml:1335:15>>*/ caml_call5
+        (Stdlib_String[48], str, 0, res, 0, len);
+       break;
+      case 1:
+        /*<<camlinternalFormat.ml:1336:15>>*/  /*<<camlinternalFormat.ml:1336:15>>*/ caml_call5
+        (Stdlib_String[48], str, 0, res, width$0 - len | 0, len);
+       break;
+      default:
+       a:
+       if(0 < len){
+         /*<<camlinternalFormat.ml:1337:63>>*/ if
+         (43
+          !==  /*<<camlinternalFormat.ml:1337:29>>*/ caml_string_get(str, 0)
+          &&
+           45
+           !==  /*<<camlinternalFormat.ml:1337:46>>*/ caml_string_get(str, 0)
+           &&
+            32
+            !==  /*<<camlinternalFormat.ml:1337:63>>*/ caml_string_get(str, 0))
+         break a;
+         /*<<camlinternalFormat.ml:1338:6>>*/  /*<<camlinternalFormat.ml:1338:6>>*/ caml_bytes_set
+         (res,
+          0,
+           /*<<camlinternalFormat.ml:1338:22>>*/ caml_string_get(str, 0));
+         /*<<camlinternalFormat.ml:1339:6>>*/  /*<<camlinternalFormat.ml:1339:6>>*/ caml_call5
+         (Stdlib_String[48],
+          str,
+          1,
+          res,
+          (width$0 - len | 0) + 1 | 0,
+          len - 1 | 0);
+        break;
+       }
+       a:
+       if
+        (1 < len
+         &&
+          48
+          ===  /*<<camlinternalFormat.ml:1340:28>>*/ caml_string_get(str, 0)){
+         /*<<camlinternalFormat.ml:1340:63>>*/ if
+         (120
+          !==  /*<<camlinternalFormat.ml:1340:46>>*/ caml_string_get(str, 1)
+          &&
+           88
+           !==  /*<<camlinternalFormat.ml:1340:63>>*/ caml_string_get(str, 1))
+         break a;
+         /*<<camlinternalFormat.ml:1341:6>>*/  /*<<camlinternalFormat.ml:1341:6>>*/ caml_bytes_set
+         (res,
+          1,
+           /*<<camlinternalFormat.ml:1341:22>>*/ caml_string_get(str, 1));
+         /*<<camlinternalFormat.ml:1342:6>>*/  /*<<camlinternalFormat.ml:1342:6>>*/ caml_call5
+         (Stdlib_String[48],
+          str,
+          2,
+          res,
+          (width$0 - len | 0) + 2 | 0,
+          len - 2 | 0);
+        break;
+       }
+        /*<<camlinternalFormat.ml:1344:6>>*/  /*<<camlinternalFormat.ml:1344:6>>*/ caml_call5
+        (Stdlib_String[48], str, 0, res, width$0 - len | 0, len);
+    }
+     /*<<camlinternalFormat.ml:1346:4>>*/ return  /*<<camlinternalFormat.ml:1346:4>>*/ caml_call1
+            (Stdlib_Bytes[44], res);
+    /*<<camlinternalFormat.ml:1346:30>>*/ }
+   function fix_int_precision(prec, str){
+     /*<<camlinternalFormat.ml:1350:2>>*/ var
+      /*<<camlinternalFormat.ml:1350:13>>*/ prec$0 =
+        /*<<camlinternalFormat.ml:1350:13>>*/ caml_call1(Stdlib[18], prec),
+      /*<<camlinternalFormat.ml:1351:2>>*/ len =
+        /*<<camlinternalFormat.ml:1351:2>>*/ caml_ml_string_length(str),
+      /*<<camlinternalFormat.ml:1352:8>>*/ c =
+        /*<<camlinternalFormat.ml:1352:8>>*/ caml_string_get(str, 0);
+    a:
+    {
+     b:
+     {
+      if(58 > c){
+       if(32 !== c){
+        if(43 > c) break a;
+        switch(c - 43 | 0){
+          case 5:
+           c:
+           if(len < (prec$0 + 2 | 0) && 1 < len){
+             /*<<camlinternalFormat.ml:1358:60>>*/ if
+             (120
+              !==
+                /*<<camlinternalFormat.ml:1358:43>>*/ caml_string_get(str, 1)
+              &&
+               88
+               !==
+                 /*<<camlinternalFormat.ml:1358:60>>*/ caml_string_get(str, 1))
+             break c;
+             /*<<camlinternalFormat.ml:1359:14>>*/  /*<<camlinternalFormat.ml:1359:14>>*/ var
+             res$1 =
+                /*<<camlinternalFormat.ml:1359:14>>*/ caml_call2
+                (Stdlib_Bytes[1], prec$0 + 2 | 0, 48);
+             /*<<camlinternalFormat.ml:1360:4>>*/  /*<<camlinternalFormat.ml:1360:4>>*/ caml_bytes_set
+             (res$1,
+              1,
+               /*<<camlinternalFormat.ml:1360:20>>*/ caml_string_get(str, 1));
+             /*<<camlinternalFormat.ml:1361:4>>*/  /*<<camlinternalFormat.ml:1361:4>>*/ caml_call5
+             (Stdlib_String[48],
+              str,
+              2,
+              res$1,
+              (prec$0 - len | 0) + 4 | 0,
+              len - 2 | 0);
+             /*<<camlinternalFormat.ml:1361:4>>*/ return  /*<<camlinternalFormat.ml:1361:4>>*/ caml_call1
+                    (Stdlib_Bytes[44], res$1);
+           }
+           break b;
+          case 0:
+          case 2: break;
+          case 1:
+          case 3:
+          case 4:
+           break a;
+          default: break b;
+        }
+       }
+       if(len >= (prec$0 + 1 | 0)) break a;
+        /*<<camlinternalFormat.ml:1354:14>>*/  /*<<camlinternalFormat.ml:1354:14>>*/ var
+        res$0 =
+           /*<<camlinternalFormat.ml:1354:14>>*/ caml_call2
+           (Stdlib_Bytes[1], prec$0 + 1 | 0, 48);
+        /*<<camlinternalFormat.ml:1355:4>>*/  /*<<camlinternalFormat.ml:1355:4>>*/ caml_bytes_set
+        (res$0, 0, c);
+        /*<<camlinternalFormat.ml:1356:4>>*/  /*<<camlinternalFormat.ml:1356:4>>*/ caml_call5
+        (Stdlib_String[48],
+         str,
+         1,
+         res$0,
+         (prec$0 - len | 0) + 2 | 0,
+         len - 1 | 0);
+        /*<<camlinternalFormat.ml:1356:4>>*/ return  /*<<camlinternalFormat.ml:1356:4>>*/ caml_call1
+               (Stdlib_Bytes[44], res$0);
+      }
+      if(71 <= c){if(5 < c - 97 >>> 0) break a;} else if(65 > c) break a;
+     }
+     if(len < prec$0){
+       /*<<camlinternalFormat.ml:1364:14>>*/  /*<<camlinternalFormat.ml:1364:14>>*/ var
+       res =
+          /*<<camlinternalFormat.ml:1364:14>>*/ caml_call2
+          (Stdlib_Bytes[1], prec$0, 48);
+       /*<<camlinternalFormat.ml:1365:4>>*/  /*<<camlinternalFormat.ml:1365:4>>*/ caml_call5
+       (Stdlib_String[48], str, 0, res, prec$0 - len | 0, len);
+       /*<<camlinternalFormat.ml:1365:4>>*/ return  /*<<camlinternalFormat.ml:1365:4>>*/ caml_call1
+              (Stdlib_Bytes[44], res);
+     }
+    }
+     /*<<camlinternalFormat.ml:1368:4>>*/ return str;
+    /*<<camlinternalFormat.ml:1368:7>>*/ }
+   function string_to_caml_string(str){
+     /*<<camlinternalFormat.ml:1372:2>>*/ var
+      /*<<camlinternalFormat.ml:1372:12>>*/ str$0 =
+        /*<<camlinternalFormat.ml:1372:12>>*/ caml_call1
+        (Stdlib_String[24], str),
+      /*<<camlinternalFormat.ml:1373:2>>*/ l =
+        /*<<camlinternalFormat.ml:1373:2>>*/ caml_ml_string_length(str$0),
+      /*<<camlinternalFormat.ml:1374:12>>*/ res =
+        /*<<camlinternalFormat.ml:1374:12>>*/ caml_call2
+        (Stdlib_Bytes[1], l + 2 | 0, 34);
+     /*<<camlinternalFormat.ml:1375:2>>*/  /*<<camlinternalFormat.ml:1375:2>>*/ caml_blit_string
+     (str$0, 0, res, 1, l);
+     /*<<camlinternalFormat.ml:1375:2>>*/ return  /*<<camlinternalFormat.ml:1375:2>>*/ caml_call1
+            (Stdlib_Bytes[44], res);
+    /*<<camlinternalFormat.ml:1376:28>>*/ }
+   function format_of_fconv(fconv, prec){
+     /*<<camlinternalFormat.ml:1414:4>>*/ var
+      /*<<camlinternalFormat.ml:1414:15>>*/ prec$0 =
+        /*<<camlinternalFormat.ml:1414:15>>*/ caml_call1(Stdlib[18], prec),
+      /*<<camlinternalFormat.ml:1415:15>>*/ symb = char_of_fconv(_r_, fconv),
+      /*<<camlinternalFormat.ml:1416:14>>*/ buf = buffer_create(16);
+     /*<<camlinternalFormat.ml:1417:4>>*/ buffer_add_char(buf, 37);
+     /*<<camlinternalFormat.ml:1418:4>>*/ bprint_fconv_flag(buf, fconv);
+     /*<<camlinternalFormat.ml:1419:4>>*/ buffer_add_char(buf, 46);
+     /*<<camlinternalFormat.ml:1420:4>>*/ buffer_add_string
+     (buf,
+       /*<<camlinternalFormat.ml:1420:26>>*/ caml_call1
+       (Stdlib_Int[12], prec$0));
+     /*<<camlinternalFormat.ml:1421:4>>*/ buffer_add_char(buf, symb);
+     /*<<camlinternalFormat.ml:1421:4>>*/ return buffer_contents(buf);
+    /*<<camlinternalFormat.ml:1422:23>>*/ }
+   function transform_int_alt(iconv, s){
+     /*<<camlinternalFormat.ml:1425:2>>*/ if(13 > iconv)
+      /*<<camlinternalFormat.ml:1447:9>>*/ return s;
+     /*<<camlinternalFormat.ml:1428:14>>*/ var
+      /*<<camlinternalFormat.ml:1428:14>>*/ n = [0, 0],
+     _c1_ = caml_ml_string_length(s) - 1 | 0,
+      /*<<camlinternalFormat.ml:1428:14>>*/ _c0_ = 0;
+    if(_c1_ >= 0){
+     var i$0 = _c0_;
+     for(;;){
+      if(9 >= caml_string_unsafe_get(s, i$0) - 48 >>> 0) n[1]++;
+       /*<<camlinternalFormat.ml:1429:6>>*/  /*<<camlinternalFormat.ml:1429:6>>*/ var
+       _c5_ = i$0 + 1 | 0;
+      if(_c1_ === i$0) break;
+      var i$0 = _c5_;
+     }
+    }
+     /*<<camlinternalFormat.ml:1436:14>>*/ var
+     digits = n[1],
+      /*<<camlinternalFormat.ml:1436:14>>*/ buf =
+        /*<<camlinternalFormat.ml:1436:14>>*/ caml_create_bytes
+        (caml_ml_string_length(s) + ((digits - 1 | 0) / 3 | 0) | 0),
+      /*<<camlinternalFormat.ml:1437:14>>*/ pos = [0, 0];
+    function put(c){
+      /*<<camlinternalFormat.ml:1438:16>>*/  /*<<camlinternalFormat.ml:1438:16>>*/ caml_bytes_set
+      (buf, pos[1], c);
+     pos[1]++;
+     return 0;
+     /*<<camlinternalFormat.ml:1438:46>>*/ }
+     /*<<camlinternalFormat.ml:1439:15>>*/ var
+      /*<<camlinternalFormat.ml:1439:15>>*/ left =
+       [0, ((digits - 1 | 0) % 3 | 0) + 1 | 0],
+     _c3_ = caml_ml_string_length(s) - 1 | 0,
+      /*<<camlinternalFormat.ml:1439:15>>*/ _c2_ = 0;
+    if(_c3_ >= 0){
+     var i = _c2_;
+     for(;;){
+      var c = caml_string_unsafe_get(s, i);
+      if(9 < c - 48 >>> 0)
+        /*<<camlinternalFormat.ml:1444:13>>*/ put(c);
+      else{
+       if(0 === left[1]){
+         /*<<camlinternalFormat.ml:1443:29>>*/ put(95);
+        left[1] = 3;
+       }
+       left[1] += -1;
+        /*<<camlinternalFormat.ml:1443:61>>*/ put(c);
+      }
+       /*<<camlinternalFormat.ml:1440:4>>*/  /*<<camlinternalFormat.ml:1440:4>>*/ var
+       _c4_ = i + 1 | 0;
+      if(_c3_ === i) break;
+      var i = _c4_;
+     }
+    }
+     /*<<camlinternalFormat.ml:1446:4>>*/ return  /*<<camlinternalFormat.ml:1446:4>>*/ caml_call1
+            (Stdlib_Bytes[44], buf);
+    /*<<camlinternalFormat.ml:1447:10>>*/ }
+   function convert_int(iconv, n){
+     /*<<camlinternalFormat.ml:1451:2>>*/ switch(iconv){
+      case 1:
+       var _cZ_ = cst_d$0; break;
+      case 2:
+       var _cZ_ = cst_d$1; break;
+      case 4:
+       var _cZ_ = cst_i$1; break;
+      case 5:
+       var _cZ_ = cst_i$2; break;
+      case 6:
+       var _cZ_ = cst_x; break;
+      case 7:
+       var _cZ_ = cst_x$0; break;
+      case 8:
+       var _cZ_ = cst_X; break;
+      case 9:
+       var _cZ_ = cst_X$0; break;
+      case 10:
+       var _cZ_ = cst_o; break;
+      case 11:
+       var _cZ_ = cst_o$0; break;
+      case 0:
+      case 13:
+       var _cZ_ = cst_d; break;
+      case 3:
+      case 14:
+       var _cZ_ = cst_i$0; break;
+      default: var _cZ_ = cst_u;
+    }
+     /*<<camlinternalFormat.ml:1451:26>>*/ return transform_int_alt
+            (iconv,
+              /*<<camlinternalFormat.ml:1451:26>>*/ caml_format_int(_cZ_, n));
+    /*<<camlinternalFormat.ml:1451:64>>*/ }
+   function convert_int32(iconv, n){
+     /*<<camlinternalFormat.ml:1453:2>>*/ switch(iconv){
+      case 1:
+       var _cY_ = cst_ld$0; break;
+      case 2:
+       var _cY_ = cst_ld$1; break;
+      case 4:
+       var _cY_ = cst_li$1; break;
+      case 5:
+       var _cY_ = cst_li$2; break;
+      case 6:
+       var _cY_ = cst_lx; break;
+      case 7:
+       var _cY_ = cst_lx$0; break;
+      case 8:
+       var _cY_ = cst_lX; break;
+      case 9:
+       var _cY_ = cst_lX$0; break;
+      case 10:
+       var _cY_ = cst_lo; break;
+      case 11:
+       var _cY_ = cst_lo$0; break;
+      case 0:
+      case 13:
+       var _cY_ = cst_ld; break;
+      case 3:
+      case 14:
+       var _cY_ = cst_li$0; break;
+      default: var _cY_ = cst_lu;
+    }
+     /*<<camlinternalFormat.ml:1453:26>>*/ return transform_int_alt
+            (iconv,
+              /*<<camlinternalFormat.ml:1453:26>>*/ caml_format_int(_cY_, n));
+    /*<<camlinternalFormat.ml:1453:67>>*/ }
+   function convert_nativeint(iconv, n){
+     /*<<camlinternalFormat.ml:1455:2>>*/ switch(iconv){
+      case 1:
+       var _cX_ = cst_nd$0; break;
+      case 2:
+       var _cX_ = cst_nd$1; break;
+      case 4:
+       var _cX_ = cst_ni$1; break;
+      case 5:
+       var _cX_ = cst_ni$2; break;
+      case 6:
+       var _cX_ = cst_nx; break;
+      case 7:
+       var _cX_ = cst_nx$0; break;
+      case 8:
+       var _cX_ = cst_nX; break;
+      case 9:
+       var _cX_ = cst_nX$0; break;
+      case 10:
+       var _cX_ = cst_no; break;
+      case 11:
+       var _cX_ = cst_no$0; break;
+      case 0:
+      case 13:
+       var _cX_ = cst_nd; break;
+      case 3:
+      case 14:
+       var _cX_ = cst_ni$0; break;
+      default: var _cX_ = cst_nu;
+    }
+     /*<<camlinternalFormat.ml:1455:26>>*/ return transform_int_alt
+            (iconv,
+              /*<<camlinternalFormat.ml:1455:26>>*/ caml_format_int(_cX_, n));
+    /*<<camlinternalFormat.ml:1455:71>>*/ }
+   function convert_int64(iconv, n){
+     /*<<camlinternalFormat.ml:1457:2>>*/ switch(iconv){
+      case 1:
+       var _cW_ = cst_Ld$0; break;
+      case 2:
+       var _cW_ = cst_Ld$1; break;
+      case 4:
+       var _cW_ = cst_Li$1; break;
+      case 5:
+       var _cW_ = cst_Li$2; break;
+      case 6:
+       var _cW_ = cst_Lx; break;
+      case 7:
+       var _cW_ = cst_Lx$0; break;
+      case 8:
+       var _cW_ = cst_LX; break;
+      case 9:
+       var _cW_ = cst_LX$0; break;
+      case 10:
+       var _cW_ = cst_Lo; break;
+      case 11:
+       var _cW_ = cst_Lo$0; break;
+      case 0:
+      case 13:
+       var _cW_ = cst_Ld; break;
+      case 3:
+      case 14:
+       var _cW_ = cst_Li$0; break;
+      default: var _cW_ = cst_Lu;
+    }
+     /*<<camlinternalFormat.ml:1457:26>>*/ return transform_int_alt
+            (iconv,
+              /*<<camlinternalFormat.ml:1457:26>>*/ runtime.caml_int64_format
+              (_cW_, n));
+    /*<<camlinternalFormat.ml:1457:67>>*/ }
+   function convert_float(fconv, prec, x){
+    function hex(param){
+      /*<<camlinternalFormat.ml:1463:4>>*/ switch(fconv[1]){
+       case 0:
+        var sign = 45; break;
+       case 1:
+        var sign = 43; break;
+       default: var sign = 32;
+     }
+      /*<<camlinternalFormat.ml:1468:4>>*/ return  /*<<camlinternalFormat.ml:1468:4>>*/ runtime.caml_hexstring_of_float
+             (x, prec, sign);
+     /*<<camlinternalFormat.ml:1468:34>>*/ }
+     /*<<camlinternalFormat.ml:1477:2>>*/ function caml_special_val(str){
+      /*<<camlinternalFormat.ml:1477:29>>*/  /*<<camlinternalFormat.ml:1477:35>>*/ var
+      match =
+         /*<<camlinternalFormat.ml:1477:35>>*/ runtime.caml_classify_float(x);
+     return 3 === match
+             ? x < 0. ? cst_neg_infinity : cst_infinity
+             : 4 <= match ? cst_nan : str;
+     /*<<camlinternalFormat.ml:1480:21>>*/ }
+    switch(fconv[2]){
+      case 5:
+        /*<<camlinternalFormat.ml:1486:14>>*/ var
+         /*<<camlinternalFormat.ml:1486:14>>*/ str =
+           /*<<camlinternalFormat.ml:1486:14>>*/ caml_format_float
+           (format_of_fconv(fconv, prec), x),
+        len = caml_ml_string_length(str),
+        i = 0;
+        /*<<camlinternalFormat.ml:1472:6>>*/ for(;;){
+        if(i === len)
+         var _cT_ = 0;
+        else{
+          /*<<camlinternalFormat.ml:1473:14>>*/  /*<<camlinternalFormat.ml:1473:14>>*/ var
+          _cS_ =
+             /*<<camlinternalFormat.ml:1473:14>>*/ caml_string_get(str, i)
+            - 46
+            | 0;
+         a:
+         {
+          if(23 < _cS_ >>> 0){
+           if(55 === _cS_) break a;
+          }
+          else if(21 < _cS_ - 1 >>> 0) break a;
+           /*<<camlinternalFormat.ml:1475:15>>*/ var
+            /*<<camlinternalFormat.ml:1475:15>>*/ i$0 = i + 1 | 0,
+           i = i$0;
+          continue;
+         }
+         var _cT_ = 1;
+        }
+         /*<<camlinternalFormat.ml:1476:7>>*/  /*<<camlinternalFormat.ml:1476:7>>*/ var
+         _cU_ =
+           _cT_
+            ? str
+            :  /*<<camlinternalFormat.ml:1476:32>>*/ caml_call2
+              (Stdlib[28], str, cst$17);
+         /*<<camlinternalFormat.ml:1487:21>>*/ return caml_special_val(_cU_);
+       }
+      case 6:
+        /*<<camlinternalFormat.ml:1482:15>>*/ return hex(0);
+      case 7:
+        /*<<camlinternalFormat.ml:1483:38>>*/  /*<<camlinternalFormat.ml:1483:38>>*/ var
+        _cV_ = hex(0);
+        /*<<camlinternalFormat.ml:1483:38>>*/ return  /*<<camlinternalFormat.ml:1483:38>>*/ caml_call1
+               (Stdlib_String[25], _cV_);
+      case 8:
+        /*<<camlinternalFormat.ml:1484:33>>*/ return caml_special_val(hex(0));
+      default:
+        /*<<camlinternalFormat.ml:1489:4>>*/ return  /*<<camlinternalFormat.ml:1489:4>>*/ caml_format_float
+               (format_of_fconv(fconv, prec), x);
+    }
+    /*<<camlinternalFormat.ml:1489:47>>*/ }
+   function string_of_fmtty(fmtty){
+     /*<<camlinternalFormat.ml:1501:2>>*/  /*<<camlinternalFormat.ml:1501:12>>*/ var
+     buf = buffer_create(16);
+     /*<<camlinternalFormat.ml:1502:2>>*/ bprint_fmtty(buf, fmtty);
+     /*<<camlinternalFormat.ml:1502:2>>*/ return buffer_contents(buf);
+    /*<<camlinternalFormat.ml:1503:21>>*/ }
+   function make_int_padding_precision(k, acc, fmt, pad, prec, trans, iconv){
+     /*<<camlinternalFormat.ml:1691:40>>*/ if(typeof pad === "number"){
+     if(typeof prec === "number")
+      return prec
+              ? function
+               (p, x){
+                 /*<<camlinternalFormat.ml:1702:6>>*/  /*<<camlinternalFormat.ml:1702:16>>*/ var
+                 str =
+                   fix_int_precision
+                    (p,
+                      /*<<camlinternalFormat.ml:1702:36>>*/ caml_call2
+                      (trans, iconv, x));
+                 /*<<camlinternalFormat.ml:1703:6>>*/ return make_printf
+                        (k, [4, acc, str], fmt);
+                /*<<camlinternalFormat.ml:1703:52>>*/ }
+              : function
+               (x){
+                 /*<<camlinternalFormat.ml:1694:6>>*/  /*<<camlinternalFormat.ml:1694:16>>*/ var
+                 str =
+                    /*<<camlinternalFormat.ml:1694:16>>*/ caml_call2
+                    (trans, iconv, x);
+                 /*<<camlinternalFormat.ml:1695:6>>*/ return make_printf
+                        (k, [4, acc, str], fmt);
+                /*<<camlinternalFormat.ml:1695:52>>*/ };
+     var p = prec[1];
+      /*<<camlinternalFormat.ml:1697:4>>*/ return function(x){
+       /*<<camlinternalFormat.ml:1698:6>>*/  /*<<camlinternalFormat.ml:1698:16>>*/ var
+       str =
+         fix_int_precision
+          (p,
+            /*<<camlinternalFormat.ml:1698:36>>*/ caml_call2(trans, iconv, x));
+       /*<<camlinternalFormat.ml:1699:6>>*/ return make_printf
+              (k, [4, acc, str], fmt); /*<<camlinternalFormat.ml:1699:52>>*/ };
+    }
+    if(0 === pad[0]){
+     var w = pad[2], padty = pad[1];
+     if(typeof prec === "number")
+      return prec
+              ? function
+               (p, x){
+                 /*<<camlinternalFormat.ml:1714:6>>*/  /*<<camlinternalFormat.ml:1714:16>>*/ var
+                 str =
+                   fix_padding
+                    (padty,
+                     w,
+                     fix_int_precision
+                      (p,
+                        /*<<camlinternalFormat.ml:1714:57>>*/ caml_call2
+                        (trans, iconv, x)));
+                 /*<<camlinternalFormat.ml:1715:6>>*/ return make_printf
+                        (k, [4, acc, str], fmt);
+                /*<<camlinternalFormat.ml:1715:52>>*/ }
+              : function
+               (x){
+                 /*<<camlinternalFormat.ml:1706:6>>*/  /*<<camlinternalFormat.ml:1706:16>>*/ var
+                 str =
+                   fix_padding
+                    (padty,
+                     w,
+                      /*<<camlinternalFormat.ml:1706:36>>*/ caml_call2
+                      (trans, iconv, x));
+                 /*<<camlinternalFormat.ml:1707:6>>*/ return make_printf
+                        (k, [4, acc, str], fmt);
+                /*<<camlinternalFormat.ml:1707:52>>*/ };
+     var p$0 = prec[1];
+      /*<<camlinternalFormat.ml:1709:4>>*/ return function(x){
+       /*<<camlinternalFormat.ml:1710:6>>*/  /*<<camlinternalFormat.ml:1710:16>>*/ var
+       str =
+         fix_padding
+          (padty,
+           w,
+           fix_int_precision
+            (p$0,
+              /*<<camlinternalFormat.ml:1710:57>>*/ caml_call2
+              (trans, iconv, x)));
+       /*<<camlinternalFormat.ml:1711:6>>*/ return make_printf
+              (k, [4, acc, str], fmt); /*<<camlinternalFormat.ml:1711:52>>*/ };
+    }
+    var padty$0 = pad[1];
+    if(typeof prec === "number")
+     return prec
+             ? function
+              (w, p, x){
+                /*<<camlinternalFormat.ml:1726:6>>*/  /*<<camlinternalFormat.ml:1726:16>>*/ var
+                str =
+                  fix_padding
+                   (padty$0,
+                    w,
+                    fix_int_precision
+                     (p,
+                       /*<<camlinternalFormat.ml:1726:57>>*/ caml_call2
+                       (trans, iconv, x)));
+                /*<<camlinternalFormat.ml:1727:6>>*/ return make_printf
+                       (k, [4, acc, str], fmt);
+               /*<<camlinternalFormat.ml:1727:52>>*/ }
+             : function
+              (w, x){
+                /*<<camlinternalFormat.ml:1718:6>>*/  /*<<camlinternalFormat.ml:1718:16>>*/ var
+                str =
+                  fix_padding
+                   (padty$0,
+                    w,
+                     /*<<camlinternalFormat.ml:1718:36>>*/ caml_call2
+                     (trans, iconv, x));
+                /*<<camlinternalFormat.ml:1719:6>>*/ return make_printf
+                       (k, [4, acc, str], fmt);
+               /*<<camlinternalFormat.ml:1719:52>>*/ };
+    var p$1 = prec[1];
+     /*<<camlinternalFormat.ml:1721:4>>*/ return function(w, x){
+      /*<<camlinternalFormat.ml:1722:6>>*/  /*<<camlinternalFormat.ml:1722:16>>*/ var
+      str =
+        fix_padding
+         (padty$0,
+          w,
+          fix_int_precision
+           (p$1,
+             /*<<camlinternalFormat.ml:1722:57>>*/ caml_call2(trans, iconv, x)));
+      /*<<camlinternalFormat.ml:1723:6>>*/ return make_printf
+             (k, [4, acc, str], fmt); /*<<camlinternalFormat.ml:1723:52>>*/ };
+    /*<<camlinternalFormat.ml:1727:52>>*/ }
+   function make_padding(k, acc, fmt, pad, trans){
+     /*<<camlinternalFormat.ml:1670:29>>*/ if(typeof pad === "number")
+      /*<<camlinternalFormat.ml:1672:4>>*/ return function(x){
+       /*<<camlinternalFormat.ml:1673:6>>*/  /*<<camlinternalFormat.ml:1673:20>>*/ var
+       new_acc =
+         [4, acc,  /*<<camlinternalFormat.ml:1673:42>>*/ caml_call1(trans, x)];
+       /*<<camlinternalFormat.ml:1674:6>>*/ return make_printf
+              (k, new_acc, fmt); /*<<camlinternalFormat.ml:1674:31>>*/ };
+    if(0 === pad[0]){
+     var width = pad[2], padty = pad[1];
+      /*<<camlinternalFormat.ml:1676:4>>*/ return function(x){
+       /*<<camlinternalFormat.ml:1677:6>>*/  /*<<camlinternalFormat.ml:1677:20>>*/ var
+       new_acc =
+         [4,
+          acc,
+          fix_padding
+           (padty,
+            width,
+             /*<<camlinternalFormat.ml:1677:66>>*/ caml_call1(trans, x))];
+       /*<<camlinternalFormat.ml:1678:6>>*/ return make_printf
+              (k, new_acc, fmt); /*<<camlinternalFormat.ml:1678:31>>*/ };
+    }
+    var padty$0 = pad[1];
+     /*<<camlinternalFormat.ml:1680:4>>*/ return function(w, x){
+      /*<<camlinternalFormat.ml:1681:6>>*/  /*<<camlinternalFormat.ml:1681:20>>*/ var
+      new_acc =
+        [4,
+         acc,
+         fix_padding
+          (padty$0,
+           w,
+            /*<<camlinternalFormat.ml:1681:62>>*/ caml_call1(trans, x))];
+      /*<<camlinternalFormat.ml:1682:6>>*/ return make_printf(k, new_acc, fmt); /*<<camlinternalFormat.ml:1682:31>>*/ };
+    /*<<camlinternalFormat.ml:1682:31>>*/ }
+   function make_printf$0(counter, k, acc, fmt){
+     /*<<camlinternalFormat.ml:1518:17>>*/ var
+     k$0 = k,
+     acc$0 = acc,
+     fmt$0 = fmt;
+     /*<<camlinternalFormat.ml:1518:17>>*/ for(;;){
+     if(typeof fmt$0 === "number")
+       /*<<camlinternalFormat.ml:1605:4>>*/ return  /*<<camlinternalFormat.ml:1605:4>>*/ caml_call1
+              (k$0, acc$0);
+     switch(fmt$0[0]){
+       case 0:
+        var rest = fmt$0[1];
+         /*<<camlinternalFormat.ml:1520:4>>*/ return function(c){
+          /*<<camlinternalFormat.ml:1521:6>>*/  /*<<camlinternalFormat.ml:1521:20>>*/ var
+          new_acc = [5, acc$0, c];
+          /*<<camlinternalFormat.ml:1522:6>>*/ return make_printf
+                 (k$0, new_acc, rest); /*<<camlinternalFormat.ml:1522:32>>*/ };
+       case 1:
+        var rest$0 = fmt$0[1];
+         /*<<camlinternalFormat.ml:1524:4>>*/ return function(c){
+          /*<<camlinternalFormat.ml:1525:6>>*/ var
+           /*<<camlinternalFormat.ml:1493:12>>*/ str =
+             /*<<camlinternalFormat.ml:1493:12>>*/ caml_call1
+             (Stdlib_Char[2], c),
+           /*<<camlinternalFormat.ml:1494:2>>*/ l =
+             /*<<camlinternalFormat.ml:1494:2>>*/ caml_ml_string_length(str),
+           /*<<camlinternalFormat.ml:1495:12>>*/ res =
+             /*<<camlinternalFormat.ml:1495:12>>*/ caml_call2
+             (Stdlib_Bytes[1], l + 2 | 0, 39);
+          /*<<camlinternalFormat.ml:1496:2>>*/  /*<<camlinternalFormat.ml:1496:2>>*/ caml_blit_string
+          (str, 0, res, 1, l);
+          /*<<camlinternalFormat.ml:1525:20>>*/  /*<<camlinternalFormat.ml:1525:20>>*/ var
+          new_acc =
+            [4,
+             acc$0,
+              /*<<camlinternalFormat.ml:1496:2>>*/ caml_call1
+              (Stdlib_Bytes[44], res)];
+          /*<<camlinternalFormat.ml:1526:6>>*/ return make_printf
+                 (k$0, new_acc, rest$0); /*<<camlinternalFormat.ml:1526:32>>*/ };
+       case 2:
+        var rest$1 = fmt$0[2], pad = fmt$0[1];
+         /*<<camlinternalFormat.ml:1528:32>>*/ return make_padding
+                (k$0,
+                 acc$0,
+                 rest$1,
+                 pad,
+                 function(str){
+                   /*<<camlinternalFormat.ml:1528:44>>*/ return str;
+                  /*<<camlinternalFormat.ml:1528:47>>*/ });
+       case 3:
+        var rest$2 = fmt$0[2], pad$0 = fmt$0[1];
+         /*<<camlinternalFormat.ml:1530:4>>*/ return make_padding
+                (k$0, acc$0, rest$2, pad$0, string_to_caml_string);
+       case 4:
+        var
+         rest$3 = fmt$0[4],
+         prec = fmt$0[3],
+         pad$1 = fmt$0[2],
+         iconv = fmt$0[1];
+         /*<<camlinternalFormat.ml:1532:4>>*/ return make_int_padding_precision
+                (k$0, acc$0, rest$3, pad$1, prec, convert_int, iconv);
+       case 5:
+        var
+         rest$4 = fmt$0[4],
+         prec$0 = fmt$0[3],
+         pad$2 = fmt$0[2],
+         iconv$0 = fmt$0[1];
+         /*<<camlinternalFormat.ml:1534:4>>*/ return make_int_padding_precision
+                (k$0, acc$0, rest$4, pad$2, prec$0, convert_int32, iconv$0);
+       case 6:
+        var
+         rest$5 = fmt$0[4],
+         prec$1 = fmt$0[3],
+         pad$3 = fmt$0[2],
+         iconv$1 = fmt$0[1];
+         /*<<camlinternalFormat.ml:1536:4>>*/ return make_int_padding_precision
+                (k$0,
+                 acc$0,
+                 rest$5,
+                 pad$3,
+                 prec$1,
+                 convert_nativeint,
+                 iconv$1);
+       case 7:
+        var
+         rest$6 = fmt$0[4],
+         prec$2 = fmt$0[3],
+         pad$4 = fmt$0[2],
+         iconv$2 = fmt$0[1];
+         /*<<camlinternalFormat.ml:1538:4>>*/ return make_int_padding_precision
+                (k$0, acc$0, rest$6, pad$4, prec$2, convert_int64, iconv$2);
+       case 8:
+        var
+         rest$7 = fmt$0[4],
+         prec$3 = fmt$0[3],
+         pad$5 = fmt$0[2],
+         fconv = fmt$0[1];
+        if(typeof pad$5 === "number"){
+         if(typeof prec$3 === "number")
+          return prec$3
+                  ? function
+                   (p, x){
+                     /*<<camlinternalFormat.ml:1746:6>>*/  /*<<camlinternalFormat.ml:1746:16>>*/ var
+                     str = convert_float(fconv, p, x);
+                     /*<<camlinternalFormat.ml:1747:6>>*/ return make_printf
+                            (k$0, [4, acc$0, str], rest$7);
+                    /*<<camlinternalFormat.ml:1747:52>>*/ }
+                  : function
+                   (x){
+                     /*<<camlinternalFormat.ml:1738:6>>*/  /*<<camlinternalFormat.ml:1738:16>>*/ var
+                     str =
+                       convert_float(fconv, default_float_precision(fconv), x);
+                     /*<<camlinternalFormat.ml:1739:6>>*/ return make_printf
+                            (k$0, [4, acc$0, str], rest$7);
+                    /*<<camlinternalFormat.ml:1739:52>>*/ };
+         var p = prec$3[1];
+          /*<<camlinternalFormat.ml:1741:4>>*/ return function(x){
+           /*<<camlinternalFormat.ml:1742:6>>*/  /*<<camlinternalFormat.ml:1742:16>>*/ var
+           str = convert_float(fconv, p, x);
+           /*<<camlinternalFormat.ml:1743:6>>*/ return make_printf
+                  (k$0, [4, acc$0, str], rest$7); /*<<camlinternalFormat.ml:1743:52>>*/ };
+        }
+        if(0 === pad$5[0]){
+         var w = pad$5[2], padty = pad$5[1];
+         if(typeof prec$3 === "number")
+          return prec$3
+                  ? function
+                   (p, x){
+                     /*<<camlinternalFormat.ml:1759:6>>*/  /*<<camlinternalFormat.ml:1759:16>>*/ var
+                     str = fix_padding(padty, w, convert_float(fconv, p, x));
+                     /*<<camlinternalFormat.ml:1760:6>>*/ return make_printf
+                            (k$0, [4, acc$0, str], rest$7);
+                    /*<<camlinternalFormat.ml:1760:52>>*/ }
+                  : function
+                   (x){
+                     /*<<camlinternalFormat.ml:1750:6>>*/ var
+                      /*<<camlinternalFormat.ml:1750:16>>*/ str =
+                       convert_float(fconv, default_float_precision(fconv), x),
+                      /*<<camlinternalFormat.ml:1751:17>>*/ str$0 =
+                       fix_padding(padty, w, str);
+                     /*<<camlinternalFormat.ml:1752:6>>*/ return make_printf
+                            (k$0, [4, acc$0, str$0], rest$7);
+                    /*<<camlinternalFormat.ml:1752:53>>*/ };
+         var p$0 = prec$3[1];
+          /*<<camlinternalFormat.ml:1754:4>>*/ return function(x){
+           /*<<camlinternalFormat.ml:1755:6>>*/  /*<<camlinternalFormat.ml:1755:16>>*/ var
+           str = fix_padding(padty, w, convert_float(fconv, p$0, x));
+           /*<<camlinternalFormat.ml:1756:6>>*/ return make_printf
+                  (k$0, [4, acc$0, str], rest$7); /*<<camlinternalFormat.ml:1756:52>>*/ };
+        }
+        var padty$0 = pad$5[1];
+        if(typeof prec$3 === "number")
+         return prec$3
+                 ? function
+                  (w, p, x){
+                    /*<<camlinternalFormat.ml:1772:6>>*/  /*<<camlinternalFormat.ml:1772:16>>*/ var
+                    str = fix_padding(padty$0, w, convert_float(fconv, p, x));
+                    /*<<camlinternalFormat.ml:1773:6>>*/ return make_printf
+                           (k$0, [4, acc$0, str], rest$7);
+                   /*<<camlinternalFormat.ml:1773:52>>*/ }
+                 : function
+                  (w, x){
+                    /*<<camlinternalFormat.ml:1763:6>>*/ var
+                     /*<<camlinternalFormat.ml:1763:16>>*/ str =
+                      convert_float(fconv, default_float_precision(fconv), x),
+                     /*<<camlinternalFormat.ml:1764:17>>*/ str$0 =
+                      fix_padding(padty$0, w, str);
+                    /*<<camlinternalFormat.ml:1765:6>>*/ return make_printf
+                           (k$0, [4, acc$0, str$0], rest$7);
+                   /*<<camlinternalFormat.ml:1765:53>>*/ };
+        var p$1 = prec$3[1];
+         /*<<camlinternalFormat.ml:1767:4>>*/ return function(w, x){
+          /*<<camlinternalFormat.ml:1768:6>>*/  /*<<camlinternalFormat.ml:1768:16>>*/ var
+          str = fix_padding(padty$0, w, convert_float(fconv, p$1, x));
+          /*<<camlinternalFormat.ml:1769:6>>*/ return make_printf
+                 (k$0, [4, acc$0, str], rest$7); /*<<camlinternalFormat.ml:1769:52>>*/ };
+       case 9:
+        var rest$8 = fmt$0[2], pad$6 = fmt$0[1];
+         /*<<camlinternalFormat.ml:1542:4>>*/ return make_padding
+                (k$0, acc$0, rest$8, pad$6, Stdlib[30]);
+       case 10:
+         /*<<camlinternalFormat.ml:1560:18>>*/ var
+         rest$9 = fmt$0[1],
+          /*<<camlinternalFormat.ml:1560:18>>*/ acc$1 = [7, acc$0],
+         acc$0 = acc$1,
+         fmt$0 = rest$9;
+        break;
+       case 11:
+         /*<<camlinternalFormat.ml:1563:18>>*/ var
+         rest$10 = fmt$0[2],
+         str = fmt$0[1],
+          /*<<camlinternalFormat.ml:1563:18>>*/ acc$2 = [2, acc$0, str],
+         acc$0 = acc$2,
+         fmt$0 = rest$10;
+        break;
+       case 12:
+         /*<<camlinternalFormat.ml:1565:18>>*/ var
+         rest$11 = fmt$0[2],
+         chr = fmt$0[1],
+          /*<<camlinternalFormat.ml:1565:18>>*/ acc$3 = [3, acc$0, chr],
+         acc$0 = acc$3,
+         fmt$0 = rest$11;
+        break;
+       case 13:
+         /*<<camlinternalFormat.ml:1568:13>>*/ var
+         rest$12 = fmt$0[3],
+         sub_fmtty = fmt$0[2],
+          /*<<camlinternalFormat.ml:1568:13>>*/ ty =
+           string_of_fmtty(sub_fmtty);
+         /*<<camlinternalFormat.ml:1569:4>>*/ return function(str){
+          /*<<camlinternalFormat.ml:1570:6>>*/ return make_printf
+                 (k$0, [4, acc$0, ty], rest$12); /*<<camlinternalFormat.ml:1571:52>>*/ };
+       case 14:
+        var rest$13 = fmt$0[3], fmtty = fmt$0[2];
+         /*<<camlinternalFormat.ml:1573:4>>*/ return function(param){
+          /*<<camlinternalFormat.ml:1573:4>>*/ var
+          fmt = param[1],
+           /*<<camlinternalFormat.ml:1574:18>>*/ _cR_ = recast(fmt, fmtty);
+          /*<<camlinternalFormat.ml:1574:6>>*/ return make_printf
+                 (k$0,
+                  acc$0,
+                   /*<<camlinternalFormat.ml:1574:6>>*/ caml_call2
+                   (CamlinternalFormatBasics[3], _cR_, rest$13)); /*<<camlinternalFormat.ml:1574:42>>*/ };
+       case 15:
+        var rest$14 = fmt$0[1];
+         /*<<camlinternalFormat.ml:1544:4>>*/ return function(f, x){
+          /*<<camlinternalFormat.ml:1544:15>>*/ return make_printf
+                 (k$0,
+                  [6,
+                   acc$0,
+                   function(o){
+                     /*<<camlinternalFormat.ml:1544:55>>*/ return caml_call2
+                            (f, o, x);
+                    /*<<camlinternalFormat.ml:1544:60>>*/ }],
+                  rest$14); /*<<camlinternalFormat.ml:1544:67>>*/ };
+       case 16:
+        var rest$15 = fmt$0[1];
+         /*<<camlinternalFormat.ml:1546:4>>*/ return function(f){
+          /*<<camlinternalFormat.ml:1546:13>>*/ return make_printf
+                 (k$0, [6, acc$0, f], rest$15); /*<<camlinternalFormat.ml:1546:52>>*/ };
+       case 17:
+         /*<<camlinternalFormat.ml:1594:18>>*/ var
+         rest$16 = fmt$0[2],
+         fmting_lit = fmt$0[1],
+          /*<<camlinternalFormat.ml:1594:18>>*/ acc$4 = [0, acc$0, fmting_lit],
+         acc$0 = acc$4,
+         fmt$0 = rest$16;
+        break;
+       case 18:
+        var _cP_ = fmt$0[1];
+        if(0 === _cP_[0])
+         var
+          rest$17 = fmt$0[2],
+          fmt$1 = _cP_[1][1],
+          k$3 =
+            function(acc, k, rest){
+             function k$0(kacc){
+               /*<<camlinternalFormat.ml:1597:6>>*/ return make_printf
+                      (k, [1, acc, [0, kacc]], rest);
+              /*<<camlinternalFormat.ml:1597:70>>*/ }
+             return k$0;
+            },
+          k$1 = k$3(acc$0, k$0, rest$17),
+          k$0 = k$1,
+          acc$0 = 0,
+          fmt$0 = fmt$1;
+        else
+         var
+          rest$18 = fmt$0[2],
+          fmt$2 = _cP_[1][1],
+          k$4 =
+            function(acc, k, rest){
+             function k$0(kacc){
+               /*<<camlinternalFormat.ml:1601:6>>*/ return make_printf
+                      (k, [1, acc, [1, kacc]], rest);
+              /*<<camlinternalFormat.ml:1601:70>>*/ }
+             return k$0;
+            },
+          k$2 = k$4(acc$0, k$0, rest$18),
+          k$0 = k$2,
+          acc$0 = 0,
+          fmt$0 = fmt$2;
+        break;
+       case 19:
+         /*<<camlinternalFormat.ml:1558:4>>*/ throw  /*<<camlinternalFormat.ml:1558:4>>*/ caml_maybe_attach_backtrace
+               ([0, Assert_failure, _s_], 1);
+       case 20:
+         /*<<camlinternalFormat.ml:1577:18>>*/ var
+         rest$19 = fmt$0[3],
+          /*<<camlinternalFormat.ml:1577:18>>*/ new_acc =
+           [8, acc$0, cst_Printf_bad_conversion];
+         /*<<camlinternalFormat.ml:1578:4>>*/ return function(param){
+          /*<<camlinternalFormat.ml:1578:13>>*/ return make_printf
+                 (k$0, new_acc, rest$19); /*<<camlinternalFormat.ml:1578:39>>*/ };
+       case 21:
+        var rest$20 = fmt$0[2];
+         /*<<camlinternalFormat.ml:1583:4>>*/ return function(n){
+          /*<<camlinternalFormat.ml:1584:6>>*/  /*<<camlinternalFormat.ml:1584:20>>*/ var
+          new_acc =
+            [4,
+             acc$0,
+              /*<<camlinternalFormat.ml:1584:42>>*/ caml_format_int
+              (cst_u$0, n)];
+          /*<<camlinternalFormat.ml:1585:6>>*/ return make_printf
+                 (k$0, new_acc, rest$20); /*<<camlinternalFormat.ml:1585:32>>*/ };
+       case 22:
+        var rest$21 = fmt$0[1];
+         /*<<camlinternalFormat.ml:1587:4>>*/ return function(c){
+          /*<<camlinternalFormat.ml:1588:6>>*/  /*<<camlinternalFormat.ml:1588:20>>*/ var
+          new_acc = [5, acc$0, c];
+          /*<<camlinternalFormat.ml:1589:6>>*/ return make_printf
+                 (k$0, new_acc, rest$21); /*<<camlinternalFormat.ml:1589:32>>*/ };
+       case 23:
+        var rest$22 = fmt$0[2], ign = fmt$0[1];
+         /*<<camlinternalFormat.ml:1591:4>>*/ if(counter >= 50)
+          /*<<camlinternalFormat.ml:1591:4>>*/ return  /*<<camlinternalFormat.ml:1591:4>>*/ caml_trampoline_return
+                 (make_ignored_param$0, [0, k$0, acc$0, ign, rest$22]);
+        var counter$1 = counter + 1 | 0;
+         /*<<camlinternalFormat.ml:1591:4>>*/ return make_ignored_param$0
+                (counter$1, k$0, acc$0, ign, rest$22);
+       default:
+         /*<<camlinternalFormat.ml:1548:33>>*/ var
+         rest$23 = fmt$0[3],
+         f = fmt$0[2],
+         arity = fmt$0[1],
+          /*<<camlinternalFormat.ml:1548:33>>*/ _cQ_ =
+            /*<<camlinternalFormat.ml:1548:33>>*/ caml_call1(f, 0);
+         /*<<camlinternalFormat.ml:1548:33>>*/ if(counter >= 50)
+          /*<<camlinternalFormat.ml:1548:33>>*/ return  /*<<camlinternalFormat.ml:1548:33>>*/ caml_trampoline_return
+                 (make_custom$0, [0, k$0, acc$0, rest$23, arity, _cQ_]);
+        var counter$0 = counter + 1 | 0;
+         /*<<camlinternalFormat.ml:1548:33>>*/ return make_custom$0
+                (counter$0, k$0, acc$0, rest$23, arity, _cQ_);
+     }
+    }
+    /*<<camlinternalFormat.ml:1605:9>>*/ }
+   function make_ignored_param$0(counter, k, acc, ign, fmt){
+     /*<<camlinternalFormat.ml:1613:21>>*/ if(typeof ign === "number")
+     switch(ign){
+       case 0:
+         /*<<camlinternalFormat.ml:1614:39>>*/ if(counter >= 50)
+          /*<<camlinternalFormat.ml:1614:39>>*/ return  /*<<camlinternalFormat.ml:1614:39>>*/ caml_trampoline_return
+                 (make_invalid_arg, [0, k, acc, fmt]);
+        var counter$0 = counter + 1 | 0;
+         /*<<camlinternalFormat.ml:1614:39>>*/ return make_invalid_arg
+                (counter$0, k, acc, fmt);
+       case 1:
+         /*<<camlinternalFormat.ml:1615:39>>*/ if(counter >= 50)
+          /*<<camlinternalFormat.ml:1615:39>>*/ return  /*<<camlinternalFormat.ml:1615:39>>*/ caml_trampoline_return
+                 (make_invalid_arg, [0, k, acc, fmt]);
+        var counter$1 = counter + 1 | 0;
+         /*<<camlinternalFormat.ml:1615:39>>*/ return make_invalid_arg
+                (counter$1, k, acc, fmt);
+       case 2:
+         /*<<camlinternalFormat.ml:1626:39>>*/ throw  /*<<camlinternalFormat.ml:1626:39>>*/ caml_maybe_attach_backtrace
+               ([0, Assert_failure, _t_], 1);
+       default:
+         /*<<camlinternalFormat.ml:1629:39>>*/ if(counter >= 50)
+          /*<<camlinternalFormat.ml:1629:39>>*/ return  /*<<camlinternalFormat.ml:1629:39>>*/ caml_trampoline_return
+                 (make_invalid_arg, [0, k, acc, fmt]);
+        var counter$2 = counter + 1 | 0;
+         /*<<camlinternalFormat.ml:1629:39>>*/ return make_invalid_arg
+                (counter$2, k, acc, fmt);
+     }
+    switch(ign[0]){
+      case 0:
+        /*<<camlinternalFormat.ml:1616:39>>*/ if(counter >= 50)
+         /*<<camlinternalFormat.ml:1616:39>>*/ return  /*<<camlinternalFormat.ml:1616:39>>*/ caml_trampoline_return
+                (make_invalid_arg, [0, k, acc, fmt]);
+       var counter$3 = counter + 1 | 0;
+        /*<<camlinternalFormat.ml:1616:39>>*/ return make_invalid_arg
+               (counter$3, k, acc, fmt);
+      case 1:
+        /*<<camlinternalFormat.ml:1617:39>>*/ if(counter >= 50)
+         /*<<camlinternalFormat.ml:1617:39>>*/ return  /*<<camlinternalFormat.ml:1617:39>>*/ caml_trampoline_return
+                (make_invalid_arg, [0, k, acc, fmt]);
+       var counter$4 = counter + 1 | 0;
+        /*<<camlinternalFormat.ml:1617:39>>*/ return make_invalid_arg
+               (counter$4, k, acc, fmt);
+      case 2:
+        /*<<camlinternalFormat.ml:1618:39>>*/ if(counter >= 50)
+         /*<<camlinternalFormat.ml:1618:39>>*/ return  /*<<camlinternalFormat.ml:1618:39>>*/ caml_trampoline_return
+                (make_invalid_arg, [0, k, acc, fmt]);
+       var counter$5 = counter + 1 | 0;
+        /*<<camlinternalFormat.ml:1618:39>>*/ return make_invalid_arg
+               (counter$5, k, acc, fmt);
+      case 3:
+        /*<<camlinternalFormat.ml:1619:39>>*/ if(counter >= 50)
+         /*<<camlinternalFormat.ml:1619:39>>*/ return  /*<<camlinternalFormat.ml:1619:39>>*/ caml_trampoline_return
+                (make_invalid_arg, [0, k, acc, fmt]);
+       var counter$6 = counter + 1 | 0;
+        /*<<camlinternalFormat.ml:1619:39>>*/ return make_invalid_arg
+               (counter$6, k, acc, fmt);
+      case 4:
+        /*<<camlinternalFormat.ml:1620:39>>*/ if(counter >= 50)
+         /*<<camlinternalFormat.ml:1620:39>>*/ return  /*<<camlinternalFormat.ml:1620:39>>*/ caml_trampoline_return
+                (make_invalid_arg, [0, k, acc, fmt]);
+       var counter$7 = counter + 1 | 0;
+        /*<<camlinternalFormat.ml:1620:39>>*/ return make_invalid_arg
+               (counter$7, k, acc, fmt);
+      case 5:
+        /*<<camlinternalFormat.ml:1621:39>>*/ if(counter >= 50)
+         /*<<camlinternalFormat.ml:1621:39>>*/ return  /*<<camlinternalFormat.ml:1621:39>>*/ caml_trampoline_return
+                (make_invalid_arg, [0, k, acc, fmt]);
+       var counter$8 = counter + 1 | 0;
+        /*<<camlinternalFormat.ml:1621:39>>*/ return make_invalid_arg
+               (counter$8, k, acc, fmt);
+      case 6:
+        /*<<camlinternalFormat.ml:1622:39>>*/ if(counter >= 50)
+         /*<<camlinternalFormat.ml:1622:39>>*/ return  /*<<camlinternalFormat.ml:1622:39>>*/ caml_trampoline_return
+                (make_invalid_arg, [0, k, acc, fmt]);
+       var counter$9 = counter + 1 | 0;
+        /*<<camlinternalFormat.ml:1622:39>>*/ return make_invalid_arg
+               (counter$9, k, acc, fmt);
+      case 7:
+        /*<<camlinternalFormat.ml:1623:39>>*/ if(counter >= 50)
+         /*<<camlinternalFormat.ml:1623:39>>*/ return  /*<<camlinternalFormat.ml:1623:39>>*/ caml_trampoline_return
+                (make_invalid_arg, [0, k, acc, fmt]);
+       var counter$10 = counter + 1 | 0;
+        /*<<camlinternalFormat.ml:1623:39>>*/ return make_invalid_arg
+               (counter$10, k, acc, fmt);
+      case 8:
+        /*<<camlinternalFormat.ml:1624:39>>*/ if(counter >= 50)
+         /*<<camlinternalFormat.ml:1624:39>>*/ return  /*<<camlinternalFormat.ml:1624:39>>*/ caml_trampoline_return
+                (make_invalid_arg, [0, k, acc, fmt]);
+       var counter$11 = counter + 1 | 0;
+        /*<<camlinternalFormat.ml:1624:39>>*/ return make_invalid_arg
+               (counter$11, k, acc, fmt);
+      case 9:
+       var fmtty = ign[2];
+        /*<<camlinternalFormat.ml:1625:39>>*/ if(counter >= 50)
+         /*<<camlinternalFormat.ml:1625:39>>*/ return  /*<<camlinternalFormat.ml:1625:39>>*/ caml_trampoline_return
+                (make_from_fmtty$0, [0, k, acc, fmtty, fmt]);
+       var counter$14 = counter + 1 | 0;
+        /*<<camlinternalFormat.ml:1625:39>>*/ return make_from_fmtty$0
+               (counter$14, k, acc, fmtty, fmt);
+      case 10:
+        /*<<camlinternalFormat.ml:1627:39>>*/ if(counter >= 50)
+         /*<<camlinternalFormat.ml:1627:39>>*/ return  /*<<camlinternalFormat.ml:1627:39>>*/ caml_trampoline_return
+                (make_invalid_arg, [0, k, acc, fmt]);
+       var counter$12 = counter + 1 | 0;
+        /*<<camlinternalFormat.ml:1627:39>>*/ return make_invalid_arg
+               (counter$12, k, acc, fmt);
+      default:
+        /*<<camlinternalFormat.ml:1628:39>>*/ if(counter >= 50)
+         /*<<camlinternalFormat.ml:1628:39>>*/ return  /*<<camlinternalFormat.ml:1628:39>>*/ caml_trampoline_return
+                (make_invalid_arg, [0, k, acc, fmt]);
+       var counter$13 = counter + 1 | 0;
+        /*<<camlinternalFormat.ml:1628:39>>*/ return make_invalid_arg
+               (counter$13, k, acc, fmt);
+    }
+    /*<<camlinternalFormat.ml:1629:65>>*/ }
+   function make_from_fmtty$0(counter, k, acc, fmtty, fmt){
+     /*<<camlinternalFormat.ml:1637:23>>*/ if(typeof fmtty !== "number")
+     switch(fmtty[0]){
+       case 0:
+        var rest = fmtty[1];
+         /*<<camlinternalFormat.ml:1638:31>>*/ return function(param){
+          /*<<camlinternalFormat.ml:1638:40>>*/ return make_from_fmtty
+                 (k, acc, rest, fmt); /*<<camlinternalFormat.ml:1638:70>>*/ };
+       case 1:
+        var rest$0 = fmtty[1];
+         /*<<camlinternalFormat.ml:1639:31>>*/ return function(param){
+          /*<<camlinternalFormat.ml:1639:40>>*/ return make_from_fmtty
+                 (k, acc, rest$0, fmt); /*<<camlinternalFormat.ml:1639:70>>*/ };
+       case 2:
+        var rest$1 = fmtty[1];
+         /*<<camlinternalFormat.ml:1640:31>>*/ return function(param){
+          /*<<camlinternalFormat.ml:1640:40>>*/ return make_from_fmtty
+                 (k, acc, rest$1, fmt); /*<<camlinternalFormat.ml:1640:70>>*/ };
+       case 3:
+        var rest$2 = fmtty[1];
+         /*<<camlinternalFormat.ml:1641:31>>*/ return function(param){
+          /*<<camlinternalFormat.ml:1641:40>>*/ return make_from_fmtty
+                 (k, acc, rest$2, fmt); /*<<camlinternalFormat.ml:1641:70>>*/ };
+       case 4:
+        var rest$3 = fmtty[1];
+         /*<<camlinternalFormat.ml:1642:31>>*/ return function(param){
+          /*<<camlinternalFormat.ml:1642:40>>*/ return make_from_fmtty
+                 (k, acc, rest$3, fmt); /*<<camlinternalFormat.ml:1642:70>>*/ };
+       case 5:
+        var rest$4 = fmtty[1];
+         /*<<camlinternalFormat.ml:1643:31>>*/ return function(param){
+          /*<<camlinternalFormat.ml:1643:40>>*/ return make_from_fmtty
+                 (k, acc, rest$4, fmt); /*<<camlinternalFormat.ml:1643:70>>*/ };
+       case 6:
+        var rest$5 = fmtty[1];
+         /*<<camlinternalFormat.ml:1644:31>>*/ return function(param){
+          /*<<camlinternalFormat.ml:1644:40>>*/ return make_from_fmtty
+                 (k, acc, rest$5, fmt); /*<<camlinternalFormat.ml:1644:70>>*/ };
+       case 7:
+        var rest$6 = fmtty[1];
+         /*<<camlinternalFormat.ml:1645:31>>*/ return function(param){
+          /*<<camlinternalFormat.ml:1645:40>>*/ return make_from_fmtty
+                 (k, acc, rest$6, fmt); /*<<camlinternalFormat.ml:1645:70>>*/ };
+       case 8:
+        var rest$7 = fmtty[2];
+         /*<<camlinternalFormat.ml:1651:31>>*/ return function(param){
+          /*<<camlinternalFormat.ml:1651:40>>*/ return make_from_fmtty
+                 (k, acc, rest$7, fmt); /*<<camlinternalFormat.ml:1651:70>>*/ };
+       case 9:
+         /*<<camlinternalFormat.ml:1654:13>>*/ var
+         rest$8 = fmtty[3],
+         ty2 = fmtty[2],
+         ty1 = fmtty[1],
+          /*<<camlinternalFormat.ml:1654:13>>*/ ty = trans(symm(ty1), ty2);
+         /*<<camlinternalFormat.ml:1655:4>>*/ return function(param){
+          /*<<camlinternalFormat.ml:1655:13>>*/ return make_from_fmtty
+                 (k,
+                  acc,
+                   /*<<camlinternalFormat.ml:1655:35>>*/ caml_call2
+                   (CamlinternalFormatBasics[1], ty, rest$8),
+                  fmt); /*<<camlinternalFormat.ml:1655:61>>*/ };
+       case 10:
+        var rest$9 = fmtty[1];
+         /*<<camlinternalFormat.ml:1646:31>>*/ return function(param, _cO_){
+          /*<<camlinternalFormat.ml:1646:42>>*/ return make_from_fmtty
+                 (k, acc, rest$9, fmt); /*<<camlinternalFormat.ml:1646:72>>*/ };
+       case 11:
+        var rest$10 = fmtty[1];
+         /*<<camlinternalFormat.ml:1647:31>>*/ return function(param){
+          /*<<camlinternalFormat.ml:1647:40>>*/ return make_from_fmtty
+                 (k, acc, rest$10, fmt); /*<<camlinternalFormat.ml:1647:70>>*/ };
+       case 12:
+        var rest$11 = fmtty[1];
+         /*<<camlinternalFormat.ml:1648:31>>*/ return function(param){
+          /*<<camlinternalFormat.ml:1648:40>>*/ return make_from_fmtty
+                 (k, acc, rest$11, fmt); /*<<camlinternalFormat.ml:1648:70>>*/ };
+       case 13:
+         /*<<camlinternalFormat.ml:1649:31>>*/ throw  /*<<camlinternalFormat.ml:1649:31>>*/ caml_maybe_attach_backtrace
+               ([0, Assert_failure, _u_], 1);
+       default:
+         /*<<camlinternalFormat.ml:1650:31>>*/ throw  /*<<camlinternalFormat.ml:1650:31>>*/ caml_maybe_attach_backtrace
+               ([0, Assert_failure, _v_], 1);
+     }
+     /*<<camlinternalFormat.ml:1652:31>>*/ if(counter >= 50)
+      /*<<camlinternalFormat.ml:1652:31>>*/ return  /*<<camlinternalFormat.ml:1652:31>>*/ caml_trampoline_return
+             (make_invalid_arg, [0, k, acc, fmt]);
+    var counter$0 = counter + 1 | 0;
+     /*<<camlinternalFormat.ml:1652:31>>*/ return make_invalid_arg
+            (counter$0, k, acc, fmt);
+    /*<<camlinternalFormat.ml:1655:61>>*/ }
+   function make_invalid_arg(counter, k, acc, fmt){
+     /*<<camlinternalFormat.ml:1663:2>>*/  /*<<camlinternalFormat.ml:1663:16>>*/ var
+     _cN_ = [8, acc, cst_Printf_bad_conversion$0];
+     /*<<camlinternalFormat.ml:1663:2>>*/ if(counter >= 50)
+      /*<<camlinternalFormat.ml:1663:2>>*/ return  /*<<camlinternalFormat.ml:1663:2>>*/ caml_trampoline_return
+             (make_printf$0, [0, k, _cN_, fmt]);
+    var counter$0 = counter + 1 | 0;
+     /*<<camlinternalFormat.ml:1663:2>>*/ return make_printf$0
+            (counter$0, k, _cN_, fmt);
+    /*<<camlinternalFormat.ml:1663:72>>*/ }
+   function make_custom$0(counter, k, acc, rest, arity, f){
+     /*<<camlinternalFormat.ml:1778:28>>*/ if(arity){
+     var arity$0 = arity[1];
+      /*<<camlinternalFormat.ml:1781:4>>*/ return function(x){
+       /*<<camlinternalFormat.ml:1782:6>>*/ return make_custom
+              (k,
+               acc,
+               rest,
+               arity$0,
+                /*<<camlinternalFormat.ml:1782:35>>*/ caml_call1(f, x)); /*<<camlinternalFormat.ml:1782:40>>*/ };
+    }
+     /*<<camlinternalFormat.ml:1779:33>>*/  /*<<camlinternalFormat.ml:1779:33>>*/ var
+     _cM_ = [4, acc, f];
+     /*<<camlinternalFormat.ml:1779:19>>*/ if(counter >= 50)
+      /*<<camlinternalFormat.ml:1779:19>>*/ return  /*<<camlinternalFormat.ml:1779:19>>*/ caml_trampoline_return
+             (make_printf$0, [0, k, _cM_, rest]);
+    var counter$0 = counter + 1 | 0;
+     /*<<camlinternalFormat.ml:1779:19>>*/ return make_printf$0
+            (counter$0, k, _cM_, rest);
+    /*<<camlinternalFormat.ml:1782:40>>*/ }
+   function make_printf(k, acc, fmt){
+     /*<<?>>*/ return caml_trampoline(make_printf$0(0, k, acc, fmt));
+   }
+   function make_ignored_param(k, acc, ign, fmt){
+     /*<<?>>*/ return caml_trampoline
+            (make_ignored_param$0(0, k, acc, ign, fmt));
+   }
+   function make_from_fmtty(k, acc, fmtty, fmt){
+     /*<<?>>*/ return caml_trampoline
+            (make_from_fmtty$0(0, k, acc, fmtty, fmt));
+   }
+   function make_custom(k, acc, rest, arity, f){
+     /*<<?>>*/ return caml_trampoline
+            (make_custom$0(0, k, acc, rest, arity, f));
+   }
+   function fn_of_padding_precision(k, o, fmt, pad, prec){
+     /*<<camlinternalFormat.ml:1863:26>>*/ if(typeof pad === "number"){
+     if(typeof prec !== "number"){
+       /*<<camlinternalFormat.ml:1867:14>>*/  /*<<camlinternalFormat.ml:1867:14>>*/ var
+       _cl_ = make_iprintf(k, o, fmt);
+       /*<<camlinternalFormat.ml:1867:14>>*/ return function(_cL_){
+        /*<<?>>*/ return _cl_;};
+     }
+     if(prec){
+       /*<<camlinternalFormat.ml:1869:21>>*/ var
+        /*<<camlinternalFormat.ml:1869:21>>*/ _ci_ = make_iprintf(k, o, fmt),
+        /*<<camlinternalFormat.ml:1869:14>>*/ _cj_ =
+         function(_cK_){ /*<<?>>*/ return _ci_;};
+       /*<<camlinternalFormat.ml:1869:14>>*/ return function(_cJ_){
+        /*<<?>>*/ return _cj_;};
+     }
+      /*<<camlinternalFormat.ml:1865:14>>*/  /*<<camlinternalFormat.ml:1865:14>>*/ var
+      _ck_ = make_iprintf(k, o, fmt);
+      /*<<camlinternalFormat.ml:1865:14>>*/ return function(_cI_){
+       /*<<?>>*/ return _ck_;};
+    }
+    if(0 === pad[0]){
+     if(typeof prec !== "number"){
+       /*<<camlinternalFormat.ml:1873:14>>*/  /*<<camlinternalFormat.ml:1873:14>>*/ var
+       _cp_ = make_iprintf(k, o, fmt);
+       /*<<camlinternalFormat.ml:1873:14>>*/ return function(_cH_){
+        /*<<?>>*/ return _cp_;};
+     }
+     if(prec){
+       /*<<camlinternalFormat.ml:1875:21>>*/ var
+        /*<<camlinternalFormat.ml:1875:21>>*/ _cm_ = make_iprintf(k, o, fmt),
+        /*<<camlinternalFormat.ml:1875:14>>*/ _cn_ =
+         function(_cG_){ /*<<?>>*/ return _cm_;};
+       /*<<camlinternalFormat.ml:1875:14>>*/ return function(_cF_){
+        /*<<?>>*/ return _cn_;};
+     }
+      /*<<camlinternalFormat.ml:1871:14>>*/  /*<<camlinternalFormat.ml:1871:14>>*/ var
+      _co_ = make_iprintf(k, o, fmt);
+      /*<<camlinternalFormat.ml:1871:14>>*/ return function(_cE_){
+       /*<<?>>*/ return _co_;};
+    }
+    if(typeof prec !== "number"){
+      /*<<camlinternalFormat.ml:1879:21>>*/ var
+       /*<<camlinternalFormat.ml:1879:21>>*/ _cv_ = make_iprintf(k, o, fmt),
+       /*<<camlinternalFormat.ml:1879:14>>*/ _cw_ =
+        function(_cD_){ /*<<?>>*/ return _cv_;};
+      /*<<camlinternalFormat.ml:1879:14>>*/ return function(_cC_){
+       /*<<?>>*/ return _cw_;};
+    }
+    if(prec){
+      /*<<camlinternalFormat.ml:1881:28>>*/ var
+       /*<<camlinternalFormat.ml:1881:28>>*/ _cq_ = make_iprintf(k, o, fmt),
+       /*<<camlinternalFormat.ml:1881:21>>*/ _cr_ =
+        function(_cB_){ /*<<?>>*/ return _cq_;},
+       /*<<camlinternalFormat.ml:1881:14>>*/ _cs_ =
+        function(_cA_){ /*<<?>>*/ return _cr_;};
+      /*<<camlinternalFormat.ml:1881:14>>*/ return function(_cz_){
+       /*<<?>>*/ return _cs_;};
+    }
+     /*<<camlinternalFormat.ml:1877:21>>*/  /*<<camlinternalFormat.ml:1877:21>>*/ var
+     _ct_ = make_iprintf(k, o, fmt);
+     /*<<camlinternalFormat.ml:1877:14>>*/ function _cu_(_cy_){
+      /*<<?>>*/ return _ct_;
+    }
+     /*<<camlinternalFormat.ml:1877:14>>*/ return function(_cx_){
+      /*<<?>>*/ return _cu_;};
+    /*<<camlinternalFormat.ml:1881:52>>*/ }
+   function make_iprintf$0(counter, k, o, fmt){
+     /*<<camlinternalFormat.ml:1788:17>>*/ var k$0 = k, fmt$0 = fmt;
+     /*<<camlinternalFormat.ml:1788:17>>*/ for(;;){
+     if(typeof fmt$0 === "number")
+       /*<<camlinternalFormat.ml:1858:8>>*/ return  /*<<camlinternalFormat.ml:1858:8>>*/ caml_call1
+              (k$0, o);
+     switch(fmt$0[0]){
+       case 0:
+         /*<<camlinternalFormat.ml:1790:14>>*/ var
+         rest = fmt$0[1],
+          /*<<camlinternalFormat.ml:1790:14>>*/ _by_ =
+           make_iprintf(k$0, o, rest);
+         /*<<camlinternalFormat.ml:1790:14>>*/ return function(_ch_){
+          /*<<?>>*/ return _by_;};
+       case 1:
+         /*<<camlinternalFormat.ml:1792:14>>*/ var
+         rest$0 = fmt$0[1],
+          /*<<camlinternalFormat.ml:1792:14>>*/ _bz_ =
+           make_iprintf(k$0, o, rest$0);
+         /*<<camlinternalFormat.ml:1792:14>>*/ return function(_cg_){
+          /*<<?>>*/ return _bz_;};
+       case 2:
+        var _bA_ = fmt$0[1];
+        if(typeof _bA_ === "number"){
+          /*<<camlinternalFormat.ml:1794:14>>*/ var
+          rest$1 = fmt$0[2],
+           /*<<camlinternalFormat.ml:1794:14>>*/ _bB_ =
+            make_iprintf(k$0, o, rest$1);
+          /*<<camlinternalFormat.ml:1794:14>>*/ return function(_cf_){
+           /*<<?>>*/ return _bB_;};
+        }
+        if(0 === _bA_[0]){
+          /*<<camlinternalFormat.ml:1796:14>>*/ var
+          rest$2 = fmt$0[2],
+           /*<<camlinternalFormat.ml:1796:14>>*/ _bC_ =
+            make_iprintf(k$0, o, rest$2);
+          /*<<camlinternalFormat.ml:1796:14>>*/ return function(_ce_){
+           /*<<?>>*/ return _bC_;};
+        }
+         /*<<camlinternalFormat.ml:1798:21>>*/ var
+         rest$3 = fmt$0[2],
+          /*<<camlinternalFormat.ml:1798:21>>*/ _bD_ =
+           make_iprintf(k$0, o, rest$3),
+          /*<<camlinternalFormat.ml:1798:14>>*/ _bE_ =
+           function(_cd_){ /*<<?>>*/ return _bD_;};
+         /*<<camlinternalFormat.ml:1798:14>>*/ return function(_cc_){
+          /*<<?>>*/ return _bE_;};
+       case 3:
+        var _bF_ = fmt$0[1];
+        if(typeof _bF_ === "number"){
+          /*<<camlinternalFormat.ml:1800:14>>*/ var
+          rest$4 = fmt$0[2],
+           /*<<camlinternalFormat.ml:1800:14>>*/ _bG_ =
+            make_iprintf(k$0, o, rest$4);
+          /*<<camlinternalFormat.ml:1800:14>>*/ return function(_cb_){
+           /*<<?>>*/ return _bG_;};
+        }
+        if(0 === _bF_[0]){
+          /*<<camlinternalFormat.ml:1802:14>>*/ var
+          rest$5 = fmt$0[2],
+           /*<<camlinternalFormat.ml:1802:14>>*/ _bH_ =
+            make_iprintf(k$0, o, rest$5);
+          /*<<camlinternalFormat.ml:1802:14>>*/ return function(_ca_){
+           /*<<?>>*/ return _bH_;};
+        }
+         /*<<camlinternalFormat.ml:1804:21>>*/ var
+         rest$6 = fmt$0[2],
+          /*<<camlinternalFormat.ml:1804:21>>*/ _bI_ =
+           make_iprintf(k$0, o, rest$6),
+          /*<<camlinternalFormat.ml:1804:14>>*/ _bJ_ =
+           function(_b$_){ /*<<?>>*/ return _bI_;};
+         /*<<camlinternalFormat.ml:1804:14>>*/ return function(_b__){
+          /*<<?>>*/ return _bJ_;};
+       case 4:
+        var rest$7 = fmt$0[4], prec = fmt$0[3], pad = fmt$0[2];
+         /*<<camlinternalFormat.ml:1806:8>>*/ return fn_of_padding_precision
+                (k$0, o, rest$7, pad, prec);
+       case 5:
+        var rest$8 = fmt$0[4], prec$0 = fmt$0[3], pad$0 = fmt$0[2];
+         /*<<camlinternalFormat.ml:1808:8>>*/ return fn_of_padding_precision
+                (k$0, o, rest$8, pad$0, prec$0);
+       case 6:
+        var rest$9 = fmt$0[4], prec$1 = fmt$0[3], pad$1 = fmt$0[2];
+         /*<<camlinternalFormat.ml:1810:8>>*/ return fn_of_padding_precision
+                (k$0, o, rest$9, pad$1, prec$1);
+       case 7:
+        var rest$10 = fmt$0[4], prec$2 = fmt$0[3], pad$2 = fmt$0[2];
+         /*<<camlinternalFormat.ml:1812:8>>*/ return fn_of_padding_precision
+                (k$0, o, rest$10, pad$2, prec$2);
+       case 8:
+        var rest$11 = fmt$0[4], prec$3 = fmt$0[3], pad$3 = fmt$0[2];
+         /*<<camlinternalFormat.ml:1814:8>>*/ return fn_of_padding_precision
+                (k$0, o, rest$11, pad$3, prec$3);
+       case 9:
+        var _bK_ = fmt$0[1];
+        if(typeof _bK_ === "number"){
+          /*<<camlinternalFormat.ml:1816:14>>*/ var
+          rest$12 = fmt$0[2],
+           /*<<camlinternalFormat.ml:1816:14>>*/ _bL_ =
+            make_iprintf(k$0, o, rest$12);
+          /*<<camlinternalFormat.ml:1816:14>>*/ return function(_b9_){
+           /*<<?>>*/ return _bL_;};
+        }
+        if(0 === _bK_[0]){
+          /*<<camlinternalFormat.ml:1818:14>>*/ var
+          rest$13 = fmt$0[2],
+           /*<<camlinternalFormat.ml:1818:14>>*/ _bM_ =
+            make_iprintf(k$0, o, rest$13);
+          /*<<camlinternalFormat.ml:1818:14>>*/ return function(_b8_){
+           /*<<?>>*/ return _bM_;};
+        }
+         /*<<camlinternalFormat.ml:1820:21>>*/ var
+         rest$14 = fmt$0[2],
+          /*<<camlinternalFormat.ml:1820:21>>*/ _bN_ =
+           make_iprintf(k$0, o, rest$14),
+          /*<<camlinternalFormat.ml:1820:14>>*/ _bO_ =
+           function(_b7_){ /*<<?>>*/ return _bN_;};
+         /*<<camlinternalFormat.ml:1820:14>>*/ return function(_b6_){
+          /*<<?>>*/ return _bO_;};
+       case 10:
+        var rest$15 = fmt$0[1], fmt$0 = rest$15; break;
+       case 11:
+        var rest$16 = fmt$0[2], fmt$0 = rest$16; break;
+       case 12:
+        var rest$17 = fmt$0[2], fmt$0 = rest$17; break;
+       case 13:
+         /*<<camlinternalFormat.ml:1838:14>>*/ var
+         rest$18 = fmt$0[3],
+          /*<<camlinternalFormat.ml:1838:14>>*/ _bP_ =
+           make_iprintf(k$0, o, rest$18);
+         /*<<camlinternalFormat.ml:1838:14>>*/ return function(_b5_){
+          /*<<?>>*/ return _bP_;};
+       case 14:
+        var rest$19 = fmt$0[3], fmtty = fmt$0[2];
+         /*<<camlinternalFormat.ml:1840:8>>*/ return function(param){
+          /*<<camlinternalFormat.ml:1840:8>>*/ var
+          fmt = param[1],
+           /*<<camlinternalFormat.ml:1842:24>>*/ _b4_ = recast(fmt, fmtty);
+          /*<<camlinternalFormat.ml:1842:12>>*/ return make_iprintf
+                 (k$0,
+                  o,
+                   /*<<camlinternalFormat.ml:1842:12>>*/ caml_call2
+                   (CamlinternalFormatBasics[3], _b4_, rest$19)); /*<<camlinternalFormat.ml:1842:48>>*/ };
+       case 15:
+         /*<<camlinternalFormat.ml:1822:21>>*/ var
+         rest$20 = fmt$0[1],
+          /*<<camlinternalFormat.ml:1822:21>>*/ _bQ_ =
+           make_iprintf(k$0, o, rest$20),
+          /*<<camlinternalFormat.ml:1822:14>>*/ _bR_ =
+           function(_b3_){ /*<<?>>*/ return _bQ_;};
+         /*<<camlinternalFormat.ml:1822:14>>*/ return function(_b2_){
+          /*<<?>>*/ return _bR_;};
+       case 16:
+         /*<<camlinternalFormat.ml:1824:14>>*/ var
+         rest$21 = fmt$0[1],
+          /*<<camlinternalFormat.ml:1824:14>>*/ _bS_ =
+           make_iprintf(k$0, o, rest$21);
+         /*<<camlinternalFormat.ml:1824:14>>*/ return function(_b1_){
+          /*<<?>>*/ return _bS_;};
+       case 17:
+        var rest$22 = fmt$0[2], fmt$0 = rest$22; break;
+       case 18:
+        var _bT_ = fmt$0[1];
+        if(0 === _bT_[0])
+         var
+          rest$23 = fmt$0[2],
+          fmt$1 = _bT_[1][1],
+          k$3 =
+            function(k, rest){
+             function k$0(koc){
+               /*<<camlinternalFormat.ml:1854:33>>*/ return make_iprintf
+                      (k, koc, rest);
+              /*<<camlinternalFormat.ml:1854:56>>*/ }
+             return k$0;
+            },
+          k$1 = k$3(k$0, rest$23),
+          k$0 = k$1,
+          fmt$0 = fmt$1;
+        else
+         var
+          rest$24 = fmt$0[2],
+          fmt$2 = _bT_[1][1],
+          k$4 =
+            function(k, rest){
+             function k$0(koc){
+               /*<<camlinternalFormat.ml:1856:33>>*/ return make_iprintf
+                      (k, koc, rest);
+              /*<<camlinternalFormat.ml:1856:56>>*/ }
+             return k$0;
+            },
+          k$2 = k$4(k$0, rest$24),
+          k$0 = k$2,
+          fmt$0 = fmt$2;
+        break;
+       case 19:
+         /*<<camlinternalFormat.ml:1830:8>>*/ throw  /*<<camlinternalFormat.ml:1830:8>>*/ caml_maybe_attach_backtrace
+               ([0, Assert_failure, _w_], 1);
+       case 20:
+         /*<<camlinternalFormat.ml:1844:14>>*/ var
+         rest$25 = fmt$0[3],
+          /*<<camlinternalFormat.ml:1844:14>>*/ _bU_ =
+           make_iprintf(k$0, o, rest$25);
+         /*<<camlinternalFormat.ml:1844:14>>*/ return function(_b0_){
+          /*<<?>>*/ return _bU_;};
+       case 21:
+         /*<<camlinternalFormat.ml:1846:14>>*/ var
+         rest$26 = fmt$0[2],
+          /*<<camlinternalFormat.ml:1846:14>>*/ _bV_ =
+           make_iprintf(k$0, o, rest$26);
+         /*<<camlinternalFormat.ml:1846:14>>*/ return function(_bZ_){
+          /*<<?>>*/ return _bV_;};
+       case 22:
+         /*<<camlinternalFormat.ml:1848:14>>*/ var
+         rest$27 = fmt$0[1],
+          /*<<camlinternalFormat.ml:1848:14>>*/ _bW_ =
+           make_iprintf(k$0, o, rest$27);
+         /*<<camlinternalFormat.ml:1848:14>>*/ return function(_bY_){
+          /*<<?>>*/ return _bW_;};
+       case 23:
+        var rest$28 = fmt$0[2], ign = fmt$0[1], _bX_ = 0;
+         /*<<camlinternalFormat.ml:1850:8>>*/ return make_ignored_param
+                (function(param){
+                   /*<<camlinternalFormat.ml:1850:37>>*/ return caml_call1
+                          (k$0, o);
+                  /*<<camlinternalFormat.ml:1850:40>>*/ },
+                 _bX_,
+                 ign,
+                 rest$28);
+       default:
+        var rest$29 = fmt$0[3], arity = fmt$0[1];
+         /*<<camlinternalFormat.ml:1826:8>>*/ if(counter >= 50)
+          /*<<camlinternalFormat.ml:1826:8>>*/ return  /*<<camlinternalFormat.ml:1826:8>>*/ caml_trampoline_return
+                 (fn_of_custom_arity$0, [0, k$0, o, rest$29, arity]);
+        var counter$0 = counter + 1 | 0;
+         /*<<camlinternalFormat.ml:1826:8>>*/ return fn_of_custom_arity$0
+                (counter$0, k$0, o, rest$29, arity);
+     }
+    }
+    /*<<camlinternalFormat.ml:1858:11>>*/ }
+   function fn_of_custom_arity$0(counter, k, o, fmt, param){
+     /*<<camlinternalFormat.ml:1882:4>>*/ if(param){
+      /*<<camlinternalFormat.ml:1889:14>>*/ var
+      arity = param[1],
+       /*<<camlinternalFormat.ml:1889:14>>*/ _bw_ =
+        fn_of_custom_arity(k, o, fmt, arity);
+      /*<<camlinternalFormat.ml:1889:14>>*/ return function(_bx_){
+       /*<<?>>*/ return _bw_;};
+    }
+     /*<<camlinternalFormat.ml:1887:8>>*/ if(counter >= 50)
+      /*<<camlinternalFormat.ml:1887:8>>*/ return  /*<<camlinternalFormat.ml:1887:8>>*/ caml_trampoline_return
+             (make_iprintf$0, [0, k, o, fmt]);
+    var counter$0 = counter + 1 | 0;
+     /*<<camlinternalFormat.ml:1887:8>>*/ return make_iprintf$0
+            (counter$0, k, o, fmt);
+    /*<<camlinternalFormat.ml:1889:48>>*/ }
+   function make_iprintf(k, o, fmt){
+     /*<<?>>*/ return caml_trampoline(make_iprintf$0(0, k, o, fmt));
+   }
+   function fn_of_custom_arity(k, o, fmt, param){
+     /*<<?>>*/ return caml_trampoline
+            (fn_of_custom_arity$0(0, k, o, fmt, param));
+   }
+   function output_acc(o, acc){
+     /*<<camlinternalFormat.ml:1897:27>>*/ var acc$0 = acc;
+     /*<<camlinternalFormat.ml:1897:27>>*/ for(;;){
+     if(typeof acc$0 === "number")
+       /*<<camlinternalFormat.ml:1912:32>>*/ return 0;
+     switch(acc$0[0]){
+       case 0:
+         /*<<camlinternalFormat.ml:1899:12>>*/ var
+         fmting_lit = acc$0[2],
+         p = acc$0[1],
+          /*<<camlinternalFormat.ml:1899:12>>*/ s =
+           string_of_formatting_lit(fmting_lit);
+         /*<<camlinternalFormat.ml:1900:4>>*/ output_acc(o, p);
+         /*<<camlinternalFormat.ml:1900:4>>*/ return  /*<<camlinternalFormat.ml:1900:4>>*/ caml_call2
+                (Stdlib[66], o, s);
+       case 1:
+        var match = acc$0[2], p$0 = acc$0[1];
+        if(0 === match[0]){
+         var acc$1 = match[1];
+          /*<<camlinternalFormat.ml:1902:4>>*/ output_acc(o, p$0);
+          /*<<camlinternalFormat.ml:1902:20>>*/  /*<<camlinternalFormat.ml:1902:20>>*/ caml_call2
+          (Stdlib[66], o, cst$18);
+         var acc$0 = acc$1;
+        }
+        else{
+         var acc$2 = match[1];
+          /*<<camlinternalFormat.ml:1904:4>>*/ output_acc(o, p$0);
+          /*<<camlinternalFormat.ml:1904:20>>*/  /*<<camlinternalFormat.ml:1904:20>>*/ caml_call2
+          (Stdlib[66], o, cst$19);
+         var acc$0 = acc$2;
+        }
+        break;
+       case 6:
+        var f = acc$0[2], p$3 = acc$0[1];
+         /*<<camlinternalFormat.ml:1909:32>>*/ output_acc(o, p$3);
+         /*<<camlinternalFormat.ml:1909:32>>*/ return  /*<<camlinternalFormat.ml:1909:32>>*/ caml_call1
+                (f, o);
+       case 7:
+        var p$4 = acc$0[1];
+         /*<<camlinternalFormat.ml:1910:32>>*/ output_acc(o, p$4);
+         /*<<camlinternalFormat.ml:1910:32>>*/ return  /*<<camlinternalFormat.ml:1910:32>>*/ caml_call1
+                (Stdlib[63], o);
+       case 8:
+        var msg = acc$0[2], p$5 = acc$0[1];
+         /*<<camlinternalFormat.ml:1911:32>>*/ output_acc(o, p$5);
+         /*<<camlinternalFormat.ml:1911:32>>*/ return  /*<<camlinternalFormat.ml:1911:32>>*/ caml_call1
+                (Stdlib[1], msg);
+       case 2:
+       case 4:
+        var s$0 = acc$0[2], p$1 = acc$0[1];
+         /*<<camlinternalFormat.ml:1906:32>>*/ output_acc(o, p$1);
+         /*<<camlinternalFormat.ml:1906:32>>*/ return  /*<<camlinternalFormat.ml:1906:32>>*/ caml_call2
+                (Stdlib[66], o, s$0);
+       default:
+        var c = acc$0[2], p$2 = acc$0[1];
+         /*<<camlinternalFormat.ml:1908:32>>*/ output_acc(o, p$2);
+         /*<<camlinternalFormat.ml:1908:32>>*/ return  /*<<camlinternalFormat.ml:1908:32>>*/ caml_call2
+                (Stdlib[65], o, c);
+     }
+    }
+    /*<<camlinternalFormat.ml:1912:34>>*/ }
+   function bufput_acc(b, acc){
+     /*<<camlinternalFormat.ml:1917:27>>*/ var acc$0 = acc;
+     /*<<camlinternalFormat.ml:1917:27>>*/ for(;;){
+     if(typeof acc$0 === "number")
+       /*<<camlinternalFormat.ml:1932:32>>*/ return 0;
+     switch(acc$0[0]){
+       case 0:
+         /*<<camlinternalFormat.ml:1919:12>>*/ var
+         fmting_lit = acc$0[2],
+         p = acc$0[1],
+          /*<<camlinternalFormat.ml:1919:12>>*/ s =
+           string_of_formatting_lit(fmting_lit);
+         /*<<camlinternalFormat.ml:1920:4>>*/ bufput_acc(b, p);
+         /*<<camlinternalFormat.ml:1920:4>>*/ return  /*<<camlinternalFormat.ml:1920:4>>*/ caml_call2
+                (Stdlib_Buffer[16], b, s);
+       case 1:
+        var match = acc$0[2], p$0 = acc$0[1];
+        if(0 === match[0]){
+         var acc$1 = match[1];
+          /*<<camlinternalFormat.ml:1922:4>>*/ bufput_acc(b, p$0);
+          /*<<camlinternalFormat.ml:1922:20>>*/  /*<<camlinternalFormat.ml:1922:20>>*/ caml_call2
+          (Stdlib_Buffer[16], b, cst$20);
+         var acc$0 = acc$1;
+        }
+        else{
+         var acc$2 = match[1];
+          /*<<camlinternalFormat.ml:1924:4>>*/ bufput_acc(b, p$0);
+          /*<<camlinternalFormat.ml:1924:20>>*/  /*<<camlinternalFormat.ml:1924:20>>*/ caml_call2
+          (Stdlib_Buffer[16], b, cst$21);
+         var acc$0 = acc$2;
+        }
+        break;
+       case 6:
+        var f = acc$0[2], p$3 = acc$0[1];
+         /*<<camlinternalFormat.ml:1929:32>>*/ bufput_acc(b, p$3);
+         /*<<camlinternalFormat.ml:1929:32>>*/ return  /*<<camlinternalFormat.ml:1929:32>>*/ caml_call1
+                (f, b);
+       case 7:
+        var acc$3 = acc$0[1], acc$0 = acc$3; break;
+       case 8:
+        var msg = acc$0[2], p$4 = acc$0[1];
+         /*<<camlinternalFormat.ml:1931:32>>*/ bufput_acc(b, p$4);
+         /*<<camlinternalFormat.ml:1931:32>>*/ return  /*<<camlinternalFormat.ml:1931:32>>*/ caml_call1
+                (Stdlib[1], msg);
+       case 2:
+       case 4:
+        var s$0 = acc$0[2], p$1 = acc$0[1];
+         /*<<camlinternalFormat.ml:1926:32>>*/ bufput_acc(b, p$1);
+         /*<<camlinternalFormat.ml:1926:32>>*/ return  /*<<camlinternalFormat.ml:1926:32>>*/ caml_call2
+                (Stdlib_Buffer[16], b, s$0);
+       default:
+        var c = acc$0[2], p$2 = acc$0[1];
+         /*<<camlinternalFormat.ml:1928:32>>*/ bufput_acc(b, p$2);
+         /*<<camlinternalFormat.ml:1928:32>>*/ return  /*<<camlinternalFormat.ml:1928:32>>*/ caml_call2
+                (Stdlib_Buffer[12], b, c);
+     }
+    }
+    /*<<camlinternalFormat.ml:1932:34>>*/ }
+   function strput_acc(b, acc){
+     /*<<camlinternalFormat.ml:1938:27>>*/ var acc$0 = acc;
+     /*<<camlinternalFormat.ml:1938:27>>*/ for(;;){
+     if(typeof acc$0 === "number")
+       /*<<camlinternalFormat.ml:1953:32>>*/ return 0;
+     switch(acc$0[0]){
+       case 0:
+         /*<<camlinternalFormat.ml:1940:12>>*/ var
+         fmting_lit = acc$0[2],
+         p = acc$0[1],
+          /*<<camlinternalFormat.ml:1940:12>>*/ s =
+           string_of_formatting_lit(fmting_lit);
+         /*<<camlinternalFormat.ml:1941:4>>*/ strput_acc(b, p);
+         /*<<camlinternalFormat.ml:1941:4>>*/ return  /*<<camlinternalFormat.ml:1941:4>>*/ caml_call2
+                (Stdlib_Buffer[16], b, s);
+       case 1:
+        var match = acc$0[2], p$0 = acc$0[1];
+        if(0 === match[0]){
+         var acc$1 = match[1];
+          /*<<camlinternalFormat.ml:1943:4>>*/ strput_acc(b, p$0);
+          /*<<camlinternalFormat.ml:1943:20>>*/  /*<<camlinternalFormat.ml:1943:20>>*/ caml_call2
+          (Stdlib_Buffer[16], b, cst$22);
+         var acc$0 = acc$1;
+        }
+        else{
+         var acc$2 = match[1];
+          /*<<camlinternalFormat.ml:1945:4>>*/ strput_acc(b, p$0);
+          /*<<camlinternalFormat.ml:1945:20>>*/  /*<<camlinternalFormat.ml:1945:20>>*/ caml_call2
+          (Stdlib_Buffer[16], b, cst$23);
+         var acc$0 = acc$2;
+        }
+        break;
+       case 6:
+        var f = acc$0[2], p$3 = acc$0[1];
+         /*<<camlinternalFormat.ml:1950:32>>*/ strput_acc(b, p$3);
+         /*<<camlinternalFormat.ml:1950:68>>*/  /*<<camlinternalFormat.ml:1950:68>>*/ var
+         _bv_ =  /*<<camlinternalFormat.ml:1950:68>>*/ caml_call1(f, 0);
+         /*<<camlinternalFormat.ml:1950:68>>*/ return  /*<<camlinternalFormat.ml:1950:68>>*/ caml_call2
+                (Stdlib_Buffer[16], b, _bv_);
+       case 7:
+        var acc$3 = acc$0[1], acc$0 = acc$3; break;
+       case 8:
+        var msg = acc$0[2], p$4 = acc$0[1];
+         /*<<camlinternalFormat.ml:1952:32>>*/ strput_acc(b, p$4);
+         /*<<camlinternalFormat.ml:1952:32>>*/ return  /*<<camlinternalFormat.ml:1952:32>>*/ caml_call1
+                (Stdlib[1], msg);
+       case 2:
+       case 4:
+        var s$0 = acc$0[2], p$1 = acc$0[1];
+         /*<<camlinternalFormat.ml:1947:32>>*/ strput_acc(b, p$1);
+         /*<<camlinternalFormat.ml:1947:32>>*/ return  /*<<camlinternalFormat.ml:1947:32>>*/ caml_call2
+                (Stdlib_Buffer[16], b, s$0);
+       default:
+        var c = acc$0[2], p$2 = acc$0[1];
+         /*<<camlinternalFormat.ml:1949:32>>*/ strput_acc(b, p$2);
+         /*<<camlinternalFormat.ml:1949:32>>*/ return  /*<<camlinternalFormat.ml:1949:32>>*/ caml_call2
+                (Stdlib_Buffer[12], b, c);
+     }
+    }
+    /*<<camlinternalFormat.ml:1953:34>>*/ }
+   function failwith_message(param){
+     /*<<camlinternalFormat.ml:1960:12>>*/ var
+     fmt = param[1],
+      /*<<camlinternalFormat.ml:1960:12>>*/ buf =
+        /*<<camlinternalFormat.ml:1960:12>>*/ caml_call1
+        (Stdlib_Buffer[1], 256);
+    function k(acc){
+      /*<<camlinternalFormat.ml:1961:14>>*/ strput_acc(buf, acc);
+      /*<<camlinternalFormat.ml:1961:43>>*/  /*<<camlinternalFormat.ml:1961:43>>*/ var
+      _bu_ =
+         /*<<camlinternalFormat.ml:1961:43>>*/ caml_call1
+         (Stdlib_Buffer[2], buf);
+      /*<<camlinternalFormat.ml:1961:43>>*/ return  /*<<camlinternalFormat.ml:1961:43>>*/ caml_call1
+             (Stdlib[2], _bu_);
+     /*<<camlinternalFormat.ml:1961:64>>*/ }
+     /*<<camlinternalFormat.ml:1962:2>>*/ return make_printf(k, 0, fmt);
+   }
+   function open_box_of_string(str){
+     /*<<camlinternalFormat.ml:1969:2>>*/ if
+     ( /*<<camlinternalFormat.ml:1969:5>>*/ runtime.caml_string_equal
+       (str, cst$43))
+      /*<<camlinternalFormat.ml:1969:19>>*/ return _x_;
+    var len = caml_ml_string_length(str);
+    function invalid_box(param){
+      /*<<camlinternalFormat.ml:1971:25>>*/ return  /*<<camlinternalFormat.ml:1971:4>>*/ caml_call1
+             (failwith_message(_y_), str);
+     /*<<camlinternalFormat.ml:1971:74>>*/ }
+    function parse_spaces(i){
+      /*<<camlinternalFormat.ml:1973:6>>*/ var i$0 = i;
+      /*<<camlinternalFormat.ml:1973:6>>*/ for(;;){
+      if(i$0 === len)  /*<<camlinternalFormat.ml:1973:22>>*/ return i$0;
+       /*<<camlinternalFormat.ml:1974:14>>*/  /*<<camlinternalFormat.ml:1974:14>>*/ var
+       match =
+          /*<<camlinternalFormat.ml:1974:14>>*/ caml_string_get(str, i$0);
+      if(9 !== match && 32 !== match)
+        /*<<camlinternalFormat.ml:1976:15>>*/ return i$0;
+       /*<<camlinternalFormat.ml:1975:24>>*/ var
+        /*<<camlinternalFormat.ml:1975:24>>*/ i$1 = i$0 + 1 | 0,
+       i$0 = i$1;
+     }
+     /*<<camlinternalFormat.ml:1976:16>>*/ }
+     /*<<camlinternalFormat.ml:1987:17>>*/ var
+      /*<<camlinternalFormat.ml:1987:17>>*/ wstart = parse_spaces(0),
+     wend = wstart;
+     /*<<camlinternalFormat.ml:1978:6>>*/ for(;;){
+     if
+      (wend !== len
+       &&
+        25
+        >=
+          /*<<camlinternalFormat.ml:1979:14>>*/ caml_string_get(str, wend)
+         - 97
+         >>> 0){
+       /*<<camlinternalFormat.ml:1980:24>>*/ var
+        /*<<camlinternalFormat.ml:1980:24>>*/ j = wend + 1 | 0,
+       wend = j;
+      continue;
+     }
+      /*<<camlinternalFormat.ml:1989:19>>*/ var
+       /*<<camlinternalFormat.ml:1989:19>>*/ box_name =
+         /*<<camlinternalFormat.ml:1989:19>>*/ caml_call3
+         (Stdlib_String[15], str, wstart, wend - wstart | 0),
+       /*<<camlinternalFormat.ml:1990:17>>*/ nstart = parse_spaces(wend),
+      nend = nstart;
+      /*<<camlinternalFormat.ml:1983:6>>*/ for(;;){
+      a:
+      if(nend !== len){
+        /*<<camlinternalFormat.ml:1984:14>>*/  /*<<camlinternalFormat.ml:1984:14>>*/ var
+        match =
+           /*<<camlinternalFormat.ml:1984:14>>*/ caml_string_get(str, nend);
+       b:
+       {
+        if(48 <= match){
+         if(58 > match) break b;
+        }
+        else if(45 === match) break b;
+        break a;
+       }
+        /*<<camlinternalFormat.ml:1985:30>>*/ var
+         /*<<camlinternalFormat.ml:1985:30>>*/ j$0 = nend + 1 | 0,
+        nend = j$0;
+       continue;
+      }
+      if(nstart === nend)
+       var indent = 0;
+      else
+        /*<<camlinternalFormat.ml:1994:8>>*/ try{
+         /*<<camlinternalFormat.ml:1994:12>>*/ var
+          /*<<camlinternalFormat.ml:1994:12>>*/ _bs_ =
+            /*<<camlinternalFormat.ml:1994:12>>*/ runtime.caml_int_of_string
+            ( /*<<camlinternalFormat.ml:1994:26>>*/ caml_call3
+              (Stdlib_String[15], str, nstart, nend - nstart | 0)),
+         indent = _bs_;
+       }
+       catch(_bt_){
+        var _br_ = caml_wrap_exception(_bt_);
+        if(_br_[1] !== Stdlib[7]) throw caml_maybe_attach_backtrace(_br_, 0);
+        var indent = invalid_box(0);
+       }
+       /*<<camlinternalFormat.ml:1996:18>>*/  /*<<camlinternalFormat.ml:1996:18>>*/ var
+       exp_end = parse_spaces(nend);
+      if(exp_end !== len)
+        /*<<camlinternalFormat.ml:1997:27>>*/ invalid_box(0);
+      a:
+      {
+       if
+        (caml_string_notequal(box_name, cst$43)
+         && caml_string_notequal(box_name, "b")){
+        if(! caml_string_notequal(box_name, "h")){var box_type = 0; break a;}
+        if(! caml_string_notequal(box_name, "hov")){var box_type = 3; break a;}
+        if(! caml_string_notequal(box_name, "hv")){var box_type = 2; break a;}
+        if(caml_string_notequal(box_name, "v")){
+         var box_type = invalid_box(0);
+         break a;
+        }
+        var box_type = 1;
+        break a;
+       }
+       var box_type = 4;
+      }
+       /*<<camlinternalFormat.ml:2005:4>>*/ return [0, indent, box_type];
+     }
+    }
+    /*<<camlinternalFormat.ml:2005:22>>*/ }
+   function make_padding_fmt_ebb(pad, fmt){
+     /*<<camlinternalFormat.ml:2015:15>>*/ if(typeof pad === "number")
+      /*<<camlinternalFormat.ml:2016:26>>*/ return [0, 0, fmt];
+    if(0 === pad[0]){
+     var w = pad[2], s = pad[1];
+      /*<<camlinternalFormat.ml:2017:26>>*/ return [0, [0, s, w], fmt];
+    }
+    var s$0 = pad[1];
+     /*<<camlinternalFormat.ml:2018:26>>*/ return [0, [1, s$0], fmt];
+    /*<<camlinternalFormat.ml:2018:62>>*/ }
+   function make_padprec_fmt_ebb(pad, prec, fmt){
+     /*<<camlinternalFormat.ml:2038:2>>*/ if(typeof prec === "number")
+     var match = prec ? [0, 1, fmt] : [0, 0, fmt];
+    else
+     var p = prec[1], match = [0, [0, p], fmt];
+    var prec$0 = match[1];
+     /*<<camlinternalFormat.ml:2039:2>>*/ if(typeof pad === "number")
+      /*<<camlinternalFormat.ml:2040:26>>*/ return [0, 0, prec$0, fmt];
+     /*<<camlinternalFormat.ml:2039:2>>*/ if(0 === pad[0]){
+     var w = pad[2], s = pad[1];
+      /*<<camlinternalFormat.ml:2041:26>>*/ return [0, [0, s, w], prec$0, fmt];
+    }
+    var s$0 = pad[1];
+     /*<<camlinternalFormat.ml:2042:26>>*/ return [0, [1, s$0], prec$0, fmt];
+    /*<<camlinternalFormat.ml:2042:69>>*/ }
+   function fmt_ebb_of_string(legacy_behavior, str){
+     /*<<?>>*/ if(legacy_behavior)
+     var flag = legacy_behavior[1], legacy_behavior$0 = flag;
+    else
+     var legacy_behavior$0 = 1;
+    function invalid_format_message(str_ind, msg){
+      /*<<camlinternalFormat.ml:2084:4>>*/ return  /*<<camlinternalFormat.ml:2084:4>>*/ caml_call3
+             (failwith_message(_z_), str, str_ind, msg);
+     /*<<camlinternalFormat.ml:2086:21>>*/ }
+     /*<<camlinternalFormat.ml:2091:2>>*/ function unexpected_end_of_format
+    (end_ind){
+      /*<<camlinternalFormat.ml:2092:4>>*/ return invalid_format_message
+             (end_ind, cst_unexpected_end_of_format);
+     /*<<camlinternalFormat.ml:2093:32>>*/ }
+    function invalid_format_without(str_ind, c, s){
+      /*<<camlinternalFormat.ml:2104:4>>*/ return  /*<<camlinternalFormat.ml:2104:4>>*/ caml_call4
+             (failwith_message(_A_), str, str_ind, c, s);
+     /*<<camlinternalFormat.ml:2106:21>>*/ }
+    function expected_character(str_ind, expected, read){
+      /*<<camlinternalFormat.ml:2112:4>>*/ return  /*<<camlinternalFormat.ml:2112:4>>*/ caml_call4
+             (failwith_message(_B_), str, str_ind, expected, read);
+     /*<<camlinternalFormat.ml:2114:31>>*/ }
+    function add_literal(lit_start, str_ind, fmt){
+      /*<<camlinternalFormat.ml:2843:31>>*/ var
+      size = str_ind - lit_start | 0;
+     return 0 === size
+             ? [0, fmt]
+             : 1
+               === size
+               ? [0,
+                 [12,
+                   /*<<camlinternalFormat.ml:2845:37>>*/ caml_string_get
+                   (str, lit_start),
+                  fmt]]
+               : [0,
+                 [11,
+                   /*<<camlinternalFormat.ml:2846:39>>*/ caml_call3
+                   (Stdlib_String[15], str, lit_start, size),
+                  fmt]];
+     /*<<camlinternalFormat.ml:2846:75>>*/ }
+    function parse(lit_start, end_ind){
+      /*<<camlinternalFormat.ml:2119:25>>*/ var str_ind = lit_start;
+      /*<<camlinternalFormat.ml:2124:4>>*/ for(;;){
+      if(str_ind === end_ind)
+        /*<<camlinternalFormat.ml:2124:30>>*/ return add_literal
+               (lit_start, str_ind, 0);
+       /*<<camlinternalFormat.ml:2125:12>>*/  /*<<camlinternalFormat.ml:2125:12>>*/ var
+       match =
+          /*<<camlinternalFormat.ml:2125:12>>*/ caml_string_get(str, str_ind);
+      if(37 === match){
+       var str_ind$2 = str_ind + 1 | 0;
+       if(str_ind$2 === end_ind)
+         /*<<camlinternalFormat.ml:2141:30>>*/ unexpected_end_of_format
+         (end_ind);
+       var
+        match$1 =
+          95
+           ===
+             /*<<camlinternalFormat.ml:2142:10>>*/ caml_string_get
+             (str, str_ind$2)
+           ? parse_flags(str_ind, str_ind$2 + 1 | 0, end_ind, 1)
+           : parse_flags(str_ind, str_ind$2, end_ind, 0),
+        fmt_rest = match$1[1];
+        /*<<camlinternalFormat.ml:2128:8>>*/ return add_literal
+               (lit_start, str_ind, fmt_rest);
+      }
+      if(64 === match){
+       var str_ind$0 = str_ind + 1 | 0;
+       a:
+       if(str_ind$0 === end_ind)
+        var match$0 = _N_;
+       else{
+         /*<<camlinternalFormat.ml:2593:12>>*/  /*<<camlinternalFormat.ml:2593:12>>*/ var
+         c =
+            /*<<camlinternalFormat.ml:2593:12>>*/ caml_string_get
+            (str, str_ind$0);
+        if(65 <= c){
+         if(94 <= c){
+           /*<<camlinternalFormat.ml:2593:12>>*/  /*<<camlinternalFormat.ml:2593:12>>*/ var
+           switcher = c - 123 | 0;
+          if(2 >= switcher >>> 0)
+           switch(switcher){
+             case 0:
+              var match$0 = parse_tag(1, str_ind$0 + 1 | 0, end_ind); break a;
+             case 1: break;
+             default:
+              var
+               fmt_rest$2 = parse(str_ind$0 + 1 | 0, end_ind)[1],
+               match$0 = [0, [17, 1, fmt_rest$2]];
+              break a;
+           }
+         }
+         else if(91 <= c)
+          switch(c - 91 | 0){
+            case 0:
+             var match$0 = parse_tag(0, str_ind$0 + 1 | 0, end_ind); break a;
+            case 1: break;
+            default:
+             var
+              fmt_rest$3 = parse(str_ind$0 + 1 | 0, end_ind)[1],
+              match$0 = [0, [17, 0, fmt_rest$3]];
+             break a;
+          }
+        }
+        else{
+         if(10 === c){
+          var
+           fmt_rest$4 = parse(str_ind$0 + 1 | 0, end_ind)[1],
+           match$0 = [0, [17, 3, fmt_rest$4]];
+          break a;
+         }
+         if(32 <= c)
+          switch(c - 32 | 0){
+            case 0:
+             var
+              fmt_rest$5 = parse(str_ind$0 + 1 | 0, end_ind)[1],
+              match$0 = [0, [17, _O_, fmt_rest$5]];
+             break a;
+            case 5:
+              /*<<camlinternalFormat.ml:2626:42>>*/ if
+              ((str_ind$0 + 1 | 0) < end_ind
+               &&
+                37
+                ===
+                  /*<<camlinternalFormat.ml:2626:42>>*/ caml_string_get
+                  (str, str_ind$0 + 1 | 0)){
+              var
+               fmt_rest$6 = parse(str_ind$0 + 2 | 0, end_ind)[1],
+               match$0 = [0, [17, 6, fmt_rest$6]];
+              break a;
+             }
+             var
+              fmt_rest$7 = parse(str_ind$0, end_ind)[1],
+              match$0 = [0, [12, 64, fmt_rest$7]];
+             break a;
+            case 12:
+             var
+              fmt_rest$8 = parse(str_ind$0 + 1 | 0, end_ind)[1],
+              match$0 = [0, [17, _P_, fmt_rest$8]];
+             break a;
+            case 14:
+             var
+              fmt_rest$9 = parse(str_ind$0 + 1 | 0, end_ind)[1],
+              match$0 = [0, [17, 4, fmt_rest$9]];
+             break a;
+            case 27:
+             var str_ind$3 = str_ind$0 + 1 | 0;
+             b:
+             try{
+              var
+               _bg_ = str_ind$3 === end_ind ? 1 : 0,
+               _bh_ =
+                 _bg_
+                 ||
+                  (60
+                    !==
+                      /*<<camlinternalFormat.ml:2666:32>>*/ caml_string_get
+                      (str, str_ind$3)
+                    ? 1
+                    : 0);
+              if(_bh_)
+                /*<<camlinternalFormat.ml:2666:58>>*/ throw  /*<<camlinternalFormat.ml:2666:58>>*/ caml_maybe_attach_backtrace
+                      (Stdlib[8], 1);
+               /*<<camlinternalFormat.ml:2667:24>>*/ var
+                /*<<camlinternalFormat.ml:2667:24>>*/ str_ind_1 =
+                 parse_spaces(str_ind$3 + 1 | 0, end_ind),
+                /*<<camlinternalFormat.ml:2668:14>>*/ match$2 =
+                  /*<<camlinternalFormat.ml:2668:14>>*/ caml_string_get
+                  (str, str_ind_1);
+              c:
+              {
+               if(48 <= match$2){
+                if(58 > match$2) break c;
+               }
+               else if(45 === match$2) break c;
+                /*<<camlinternalFormat.ml:2684:15>>*/ throw  /*<<camlinternalFormat.ml:2684:15>>*/ caml_maybe_attach_backtrace
+                      (Stdlib[8], 1);
+              }
+               /*<<camlinternalFormat.ml:2670:33>>*/ var
+                /*<<camlinternalFormat.ml:2670:33>>*/ match$3 =
+                 parse_integer(str_ind_1, end_ind),
+               width = match$3[2],
+               str_ind_2 = match$3[1],
+                /*<<camlinternalFormat.ml:2671:28>>*/ str_ind_3 =
+                 parse_spaces(str_ind_2, end_ind),
+                /*<<camlinternalFormat.ml:2672:18>>*/ switcher$0 =
+                  /*<<camlinternalFormat.ml:2672:18>>*/ caml_string_get
+                  (str, str_ind_3)
+                 - 45
+                 | 0;
+              if(12 < switcher$0 >>> 0){
+               if(17 === switcher$0){
+                 /*<<camlinternalFormat.ml:2674:24>>*/ var
+                  /*<<camlinternalFormat.ml:2674:24>>*/ s =
+                    /*<<camlinternalFormat.ml:2674:24>>*/ caml_call3
+                    (Stdlib_String[15],
+                     str,
+                     str_ind$3 - 2 | 0,
+                     (str_ind_3 - str_ind$3 | 0) + 3 | 0),
+                  /*<<camlinternalFormat.ml:2675:31>>*/ _bi_ =
+                   [0, s, width, 0],
+                  /*<<camlinternalFormat.ml:2675:31>>*/ _bj_ =
+                   str_ind_3 + 1 | 0,
+                 formatting_lit$0 = _bi_,
+                 next_ind = _bj_;
+                break b;
+               }
+              }
+              else if(1 < switcher$0 - 1 >>> 0){
+                /*<<camlinternalFormat.ml:2677:40>>*/ var
+                 /*<<camlinternalFormat.ml:2677:40>>*/ match$4 =
+                  parse_integer(str_ind_3, end_ind),
+                offset = match$4[2],
+                str_ind_4 = match$4[1],
+                 /*<<camlinternalFormat.ml:2678:32>>*/ str_ind_5 =
+                  parse_spaces(str_ind_4, end_ind);
+               if
+                (62
+                 !==
+                   /*<<camlinternalFormat.ml:2679:19>>*/ caml_string_get
+                   (str, str_ind_5))
+                 /*<<camlinternalFormat.ml:2679:47>>*/ throw  /*<<camlinternalFormat.ml:2679:47>>*/ caml_maybe_attach_backtrace
+                       (Stdlib[8], 1);
+                /*<<camlinternalFormat.ml:2680:24>>*/ var
+                 /*<<camlinternalFormat.ml:2680:24>>*/ s$0 =
+                   /*<<camlinternalFormat.ml:2680:24>>*/ caml_call3
+                   (Stdlib_String[15],
+                    str,
+                    str_ind$3 - 2 | 0,
+                    (str_ind_5 - str_ind$3 | 0) + 3 | 0),
+                 /*<<camlinternalFormat.ml:2681:31>>*/ _bk_ =
+                  [0, s$0, width, offset],
+                 /*<<camlinternalFormat.ml:2681:31>>*/ _bl_ =
+                  str_ind_5 + 1 | 0,
+                formatting_lit$0 = _bk_,
+                next_ind = _bl_;
+               break b;
+              }
+               /*<<camlinternalFormat.ml:2682:21>>*/ throw  /*<<camlinternalFormat.ml:2682:21>>*/ caml_maybe_attach_backtrace
+                     (Stdlib[8], 1);
+             }
+             catch(_bq_){
+              var _bf_ = caml_wrap_exception(_bq_);
+              if(_bf_ !== Stdlib[8] && _bf_[1] !== Stdlib[7])
+               throw caml_maybe_attach_backtrace(_bf_, 0);
+              var formatting_lit$0 = formatting_lit, next_ind = str_ind$3;
+             }
+             var
+              fmt_rest$12 = parse(next_ind, end_ind)[1],
+              match$0 = [0, [17, formatting_lit$0, fmt_rest$12]];
+             break a;
+            case 28:
+             var str_ind$4 = str_ind$0 + 1 | 0;
+              /*<<camlinternalFormat.ml:2694:4>>*/ try{
+               /*<<camlinternalFormat.ml:2696:24>>*/ var
+                /*<<camlinternalFormat.ml:2696:24>>*/ str_ind_1$0 =
+                 parse_spaces(str_ind$4, end_ind),
+                /*<<camlinternalFormat.ml:2697:14>>*/ match$6 =
+                  /*<<camlinternalFormat.ml:2697:14>>*/ caml_string_get
+                  (str, str_ind_1$0);
+              b:
+              {
+               c:
+               {
+                if(48 <= match$6){
+                 if(58 > match$6) break c;
+                }
+                else if(45 === match$6) break c;
+                var _bo_ = 0;
+                break b;
+               }
+                /*<<camlinternalFormat.ml:2699:32>>*/ var
+                 /*<<camlinternalFormat.ml:2699:32>>*/ match$7 =
+                  parse_integer(str_ind_1$0, end_ind),
+                size = match$7[2],
+                str_ind_2$0 = match$7[1],
+                 /*<<camlinternalFormat.ml:2700:26>>*/ str_ind_3$0 =
+                  parse_spaces(str_ind_2$0, end_ind);
+               if
+                (62
+                 !==
+                   /*<<camlinternalFormat.ml:2701:13>>*/ caml_string_get
+                   (str, str_ind_3$0))
+                 /*<<camlinternalFormat.ml:2701:41>>*/ throw  /*<<camlinternalFormat.ml:2701:41>>*/ caml_maybe_attach_backtrace
+                       (Stdlib[8], 1);
+                /*<<camlinternalFormat.ml:2702:18>>*/ var
+                 /*<<camlinternalFormat.ml:2702:18>>*/ s$1 =
+                   /*<<camlinternalFormat.ml:2702:18>>*/ caml_call3
+                   (Stdlib_String[15],
+                    str,
+                    str_ind$4 - 2 | 0,
+                    (str_ind_3$0 - str_ind$4 | 0) + 3 | 0),
+                _bo_ = [0, [0, str_ind_3$0 + 1 | 0, [1, s$1, size]]];
+              }
+              var _bn_ = _bo_;
+             }
+             catch(_bp_){
+              var _bm_ = caml_wrap_exception(_bp_);
+              if(_bm_ !== Stdlib[8] && _bm_[1] !== Stdlib[7])
+               throw caml_maybe_attach_backtrace(_bm_, 0);
+              var _bn_ = 0;
+             }
+             if(_bn_)
+              var
+               match$5 = _bn_[1],
+               formatting_lit$1 = match$5[2],
+               next_ind$0 = match$5[1],
+               fmt_rest$13 = parse(next_ind$0, end_ind)[1],
+               _be_ = [0, [17, formatting_lit$1, fmt_rest$13]];
+             else
+              var
+               fmt_rest$14 = parse(str_ind$4, end_ind)[1],
+               _be_ = [0, [17, _Q_, fmt_rest$14]];
+             var match$0 = _be_;
+             break a;
+            case 31:
+             var
+              fmt_rest$10 = parse(str_ind$0 + 1 | 0, end_ind)[1],
+              match$0 = [0, [17, 2, fmt_rest$10]];
+             break a;
+            case 32:
+             var
+              fmt_rest$11 = parse(str_ind$0 + 1 | 0, end_ind)[1],
+              match$0 = [0, [17, 5, fmt_rest$11]];
+             break a;
+          }
+        }
+        var
+         fmt_rest$1 = parse(str_ind$0 + 1 | 0, end_ind)[1],
+         match$0 = [0, [17, [2, c], fmt_rest$1]];
+       }
+       var fmt_rest$0 = match$0[1];
+        /*<<camlinternalFormat.ml:2131:8>>*/ return add_literal
+               (lit_start, str_ind, fmt_rest$0);
+      }
+      var str_ind$1 = str_ind + 1 | 0, str_ind = str_ind$1;
+     }
+     /*<<camlinternalFormat.ml:2119:62>>*/ }
+    function parse_conversion
+    (pct_ind,
+     str_ind,
+     end_ind,
+     plus,
+     hash,
+     space,
+     ign,
+     pad,
+     prec,
+     padprec,
+     symb){
+      /*<<camlinternalFormat.ml:2295:21>>*/ var
+       /*<<camlinternalFormat.ml:2295:21>>*/ plus_used = [0, 0],
+       /*<<camlinternalFormat.ml:2295:47>>*/ hash_used = [0, 0],
+       /*<<camlinternalFormat.ml:2296:21>>*/ space_used = [0, 0],
+       /*<<camlinternalFormat.ml:2296:48>>*/ ign_used = [0, 0],
+       /*<<camlinternalFormat.ml:2297:21>>*/ pad_used = [0, 0],
+       /*<<camlinternalFormat.ml:2297:48>>*/ prec_used = [0, 0];
+     function get_plus(param){
+       /*<<camlinternalFormat.ml:2300:25>>*/ plus_used[1] = 1;
+       /*<<camlinternalFormat.ml:2300:4>>*/ return plus;
+      /*<<camlinternalFormat.ml:2300:49>>*/ }
+     function get_hash(param){
+       /*<<camlinternalFormat.ml:2301:24>>*/ hash_used[1] = 1;
+      return hash;
+      /*<<camlinternalFormat.ml:2301:47>>*/ }
+     function get_space(param){
+       /*<<camlinternalFormat.ml:2302:25>>*/ space_used[1] = 1;
+      return space;
+      /*<<camlinternalFormat.ml:2302:50>>*/ }
+     function get_ign(param){
+       /*<<camlinternalFormat.ml:2303:25>>*/ ign_used[1] = 1;
+      return ign;
+      /*<<camlinternalFormat.ml:2303:48>>*/ }
+     function get_pad(param){
+       /*<<camlinternalFormat.ml:2304:25>>*/ pad_used[1] = 1;
+      return pad;
+      /*<<camlinternalFormat.ml:2304:48>>*/ }
+     function get_prec(param){
+       /*<<camlinternalFormat.ml:2305:25>>*/ prec_used[1] = 1;
+      return prec;
+      /*<<camlinternalFormat.ml:2305:49>>*/ }
+     function get_padprec(param){
+       /*<<camlinternalFormat.ml:2306:25>>*/ pad_used[1] = 1;
+      return padprec;
+      /*<<camlinternalFormat.ml:2306:52>>*/ }
+     function get_int_pad(param){
+       /*<<camlinternalFormat.ml:2320:7>>*/ var
+        /*<<camlinternalFormat.ml:2320:13>>*/ pad = get_pad(0),
+        /*<<camlinternalFormat.ml:2320:25>>*/ match = get_prec(0);
+       /*<<camlinternalFormat.ml:2320:25>>*/ if
+       (typeof match === "number" && ! match)
+        /*<<camlinternalFormat.ml:2321:32>>*/ return pad;
+      if(typeof pad === "number")
+        /*<<camlinternalFormat.ml:2322:32>>*/ return 0;
+      if(0 !== pad[0])
+       return 2 <= pad[1]
+               ? legacy_behavior$0
+                 ? _H_
+                 : incompatible_flag(pct_ind, str_ind, 48, cst_precision$1)
+               : pad;
+      if(2 > pad[1])  /*<<camlinternalFormat.ml:2329:38>>*/ return pad;
+      var n = pad[2];
+       /*<<camlinternalFormat.ml:2324:11>>*/ return legacy_behavior$0
+              ? [0, 1, n]
+              : incompatible_flag(pct_ind, str_ind, 48, cst_precision$0);
+      /*<<camlinternalFormat.ml:2330:41>>*/ }
+     function check_no_0(symb, pad){
+       /*<<camlinternalFormat.ml:2334:6>>*/ if(typeof pad === "number")
+        /*<<camlinternalFormat.ml:2335:22>>*/ return pad;
+      if(0 !== pad[0])
+       return 2 <= pad[1]
+               ? legacy_behavior$0
+                 ? _I_
+                 : incompatible_flag(pct_ind, str_ind, symb, cst_0$1)
+               : pad;
+      if(2 > pad[1])  /*<<camlinternalFormat.ml:2336:43>>*/ return pad;
+      var width = pad[2];
+       /*<<camlinternalFormat.ml:2339:8>>*/ return legacy_behavior$0
+              ? [0, 1, width]
+              : incompatible_flag(pct_ind, str_ind, symb, cst_0$0);
+      /*<<camlinternalFormat.ml:2343:55>>*/ }
+     function opt_of_pad(c, pad){
+       /*<<camlinternalFormat.ml:2349:64>>*/ if(typeof pad === "number")
+        /*<<camlinternalFormat.ml:2350:22>>*/ return 0;
+      if(0 === pad[0])
+       switch(pad[1]){
+         case 0:
+          var width = pad[2];
+           /*<<camlinternalFormat.ml:2356:8>>*/ return legacy_behavior$0
+                  ? [0, width]
+                  : incompatible_flag(pct_ind, str_ind, c, cst$24);
+         case 1:
+          var width$0 = pad[2];
+           /*<<camlinternalFormat.ml:2351:38>>*/ return [0, width$0];
+         default:
+          var width$1 = pad[2];
+           /*<<camlinternalFormat.ml:2353:8>>*/ return legacy_behavior$0
+                  ? [0, width$1]
+                  : incompatible_flag(pct_ind, str_ind, c, cst_0$2);
+       }
+       /*<<camlinternalFormat.ml:2358:25>>*/ return incompatible_flag
+              (pct_ind, str_ind, c, cst$25);
+      /*<<camlinternalFormat.ml:2358:66>>*/ }
+     function get_pad_opt(c){
+       /*<<camlinternalFormat.ml:2360:24>>*/ return opt_of_pad(c, get_pad(0));
+      /*<<camlinternalFormat.ml:2360:49>>*/ }
+     function get_padprec_opt(c){
+       /*<<camlinternalFormat.ml:2361:28>>*/ return opt_of_pad
+              (c, get_padprec(0));
+      /*<<camlinternalFormat.ml:2361:57>>*/ }
+     a:
+     {
+       /*<<camlinternalFormat.ml:2372:4>>*/ if(124 > symb)
+       switch(symb){
+         case 33:
+          var
+           fmt_rest$5 = parse(str_ind, end_ind)[1],
+           fmt_result = [0, [10, fmt_rest$5]];
+          break a;
+         case 40:
+           /*<<camlinternalFormat.ml:2531:20>>*/ var
+            /*<<camlinternalFormat.ml:2531:20>>*/ sub_end =
+             search_subformat_end(str_ind, end_ind, 41),
+           fmt_rest$7 = parse(sub_end + 2 | 0, end_ind)[1],
+           sub_fmt = parse(str_ind, sub_end)[1],
+            /*<<camlinternalFormat.ml:2534:22>>*/ sub_fmtty =
+             fmtty_of_fmt(sub_fmt);
+           /*<<camlinternalFormat.ml:2535:9>>*/ if(get_ign(0))
+            /*<<camlinternalFormat.ml:2536:22>>*/ var
+             /*<<camlinternalFormat.ml:2536:22>>*/ ignored$2 =
+              [9, get_pad_opt(95), sub_fmtty],
+            _aN_ = [0, [23, ignored$2, fmt_rest$7]];
+          else
+           var _aN_ = [0, [14, get_pad_opt(40), sub_fmtty, fmt_rest$7]];
+          var fmt_result = _aN_;
+          break a;
+         case 44:
+          var fmt_result = parse(str_ind, end_ind); break a;
+         case 67:
+           /*<<camlinternalFormat.ml:2397:9>>*/ var
+           fmt_rest$10 = parse(str_ind, end_ind)[1],
+            /*<<camlinternalFormat.ml:2397:9>>*/ _aP_ =
+             get_ign(0) ? [0, [23, 1, fmt_rest$10]] : [0, [1, fmt_rest$10]],
+           fmt_result = _aP_;
+          break a;
+         case 78:
+          var fmt_rest$14 = parse(str_ind, end_ind)[1], counter$0 = 2;
+           /*<<camlinternalFormat.ml:2433:9>>*/ if(get_ign(0))
+            /*<<camlinternalFormat.ml:2434:22>>*/ var
+             /*<<camlinternalFormat.ml:2434:22>>*/ ignored$6 = [11, counter$0],
+            _aV_ = [0, [23, ignored$6, fmt_rest$14]];
+          else
+           var _aV_ = [0, [21, counter$0, fmt_rest$14]];
+          var fmt_result = _aV_;
+          break a;
+         case 83:
+           /*<<camlinternalFormat.ml:2410:16>>*/ var
+            /*<<camlinternalFormat.ml:2410:16>>*/ pad$6 =
+             check_no_0(symb, get_padprec(0)),
+           fmt_rest$15 = parse(str_ind, end_ind)[1];
+           /*<<camlinternalFormat.ml:2412:9>>*/ if(get_ign(0))
+            /*<<camlinternalFormat.ml:2413:22>>*/ var
+             /*<<camlinternalFormat.ml:2413:22>>*/ ignored$7 =
+              [1, get_padprec_opt(95)],
+            _aW_ = [0, [23, ignored$7, fmt_rest$15]];
+          else
+            /*<<camlinternalFormat.ml:2417:10>>*/ var
+             /*<<camlinternalFormat.ml:2417:10>>*/ match$5 =
+              make_padding_fmt_ebb(pad$6, fmt_rest$15),
+            fmt_rest$16 = match$5[2],
+            pad$7 = match$5[1],
+            _aW_ = [0, [3, pad$7, fmt_rest$16]];
+          var fmt_result = _aW_;
+          break a;
+         case 91:
+          if(str_ind === end_ind)
+            /*<<camlinternalFormat.ml:2717:30>>*/ unexpected_end_of_format
+            (end_ind);
+           /*<<camlinternalFormat.ml:2719:19>>*/ var
+            /*<<camlinternalFormat.ml:2719:19>>*/ char_set =
+             create_char_set(0),
+           add_char =
+             function(c){
+               /*<<camlinternalFormat.ml:2721:6>>*/ return add_in_char_set
+                      (char_set, c);
+              /*<<camlinternalFormat.ml:2721:32>>*/ },
+           add_range =
+             function(c$0, c){
+               /*<<camlinternalFormat.ml:2724:6>>*/ if(c >= c$0){
+               var i = c$0;
+               for(;;){
+                 /*<<camlinternalFormat.ml:2725:8>>*/ add_in_char_set
+                 (char_set,
+                   /*<<camlinternalFormat.ml:2725:33>>*/ caml_call1
+                   (Stdlib[29], i));
+                 /*<<camlinternalFormat.ml:2725:8>>*/  /*<<camlinternalFormat.ml:2725:8>>*/ var
+                 _bd_ = i + 1 | 0;
+                if(c === i) break;
+                var i = _bd_;
+               }
+              }
+              return 0;
+              /*<<camlinternalFormat.ml:2726:10>>*/ },
+           fail_single_percent =
+             function(str_ind){
+               /*<<camlinternalFormat.ml:2730:6>>*/ return  /*<<camlinternalFormat.ml:2730:6>>*/ caml_call2
+                      (failwith_message(_R_), str, str_ind);
+              /*<<camlinternalFormat.ml:2732:54>>*/ },
+           parse_char_set_content =
+             function(counter, str_ind, end_ind){
+               /*<<camlinternalFormat.ml:2743:6>>*/ var str_ind$0 = str_ind;
+               /*<<camlinternalFormat.ml:2743:6>>*/ for(;;){
+               if(str_ind$0 === end_ind)
+                 /*<<camlinternalFormat.ml:2743:32>>*/ unexpected_end_of_format
+                 (end_ind);
+                /*<<camlinternalFormat.ml:2744:12>>*/  /*<<camlinternalFormat.ml:2744:12>>*/ var
+                c =
+                   /*<<camlinternalFormat.ml:2744:12>>*/ caml_string_get
+                   (str, str_ind$0);
+               if(45 !== c){
+                if(93 === c)
+                  /*<<camlinternalFormat.ml:2746:8>>*/ return str_ind$0 + 1
+                        | 0;
+                var _bc_ = str_ind$0 + 1 | 0;
+                 /*<<camlinternalFormat.ml:2751:8>>*/ if(counter >= 50)
+                  /*<<camlinternalFormat.ml:2751:8>>*/ return  /*<<camlinternalFormat.ml:2751:8>>*/ caml_trampoline_return
+                         (parse_char_set_after_char$0, [0, _bc_, end_ind, c]);
+                var counter$0 = counter + 1 | 0;
+                 /*<<camlinternalFormat.ml:2751:8>>*/ return parse_char_set_after_char$0
+                        (counter$0, _bc_, end_ind, c);
+               }
+                /*<<camlinternalFormat.ml:2748:8>>*/ add_char(45);
+               var str_ind$1 = str_ind$0 + 1 | 0, str_ind$0 = str_ind$1;
+              }
+              /*<<camlinternalFormat.ml:2751:57>>*/ },
+           parse_char_set_after_char$0 =
+             function(counter, str_ind, end_ind, c){
+               /*<<camlinternalFormat.ml:2755:6>>*/ var
+               str_ind$0 = str_ind,
+               c$0 = c;
+               /*<<camlinternalFormat.ml:2755:6>>*/ for(;;){
+               if(str_ind$0 === end_ind)
+                 /*<<camlinternalFormat.ml:2755:32>>*/ unexpected_end_of_format
+                 (end_ind);
+                /*<<camlinternalFormat.ml:2756:12>>*/  /*<<camlinternalFormat.ml:2756:12>>*/ var
+                c$1 =
+                   /*<<camlinternalFormat.ml:2756:12>>*/ caml_string_get
+                   (str, str_ind$0);
+               a:
+               {
+                if(46 <= c$1){
+                 if(64 !== c$1){
+                  if(93 !== c$1) break a;
+                   /*<<camlinternalFormat.ml:2758:8>>*/ add_char(c$0);
+                   /*<<camlinternalFormat.ml:2758:8>>*/ return str_ind$0 + 1
+                         | 0;
+                 }
+                }
+                else if(37 !== c$1){
+                 if(45 > c$1) break a;
+                 var str_ind$2 = str_ind$0 + 1 | 0;
+                 if(str_ind$2 === end_ind)
+                   /*<<camlinternalFormat.ml:2775:32>>*/ unexpected_end_of_format
+                   (end_ind);
+                  /*<<camlinternalFormat.ml:2776:12>>*/  /*<<camlinternalFormat.ml:2776:12>>*/ var
+                  c$2 =
+                     /*<<camlinternalFormat.ml:2776:12>>*/ caml_string_get
+                     (str, str_ind$2);
+                 if(37 === c$2){
+                  if((str_ind$2 + 1 | 0) === end_ind)
+                    /*<<camlinternalFormat.ml:2782:38>>*/ unexpected_end_of_format
+                    (end_ind);
+                   /*<<camlinternalFormat.ml:2783:20>>*/  /*<<camlinternalFormat.ml:2783:20>>*/ var
+                   c$3 =
+                      /*<<camlinternalFormat.ml:2783:20>>*/ caml_string_get
+                      (str, str_ind$2 + 1 | 0);
+                  if(37 !== c$3 && 64 !== c$3)
+                    /*<<camlinternalFormat.ml:2787:17>>*/ return fail_single_percent
+                           (str_ind$2);
+                   /*<<camlinternalFormat.ml:2785:12>>*/ add_range(c$0, c$3);
+                  var _ba_ = str_ind$2 + 2 | 0;
+                   /*<<camlinternalFormat.ml:2785:12>>*/ if(counter >= 50)
+                    /*<<camlinternalFormat.ml:2785:12>>*/ return  /*<<camlinternalFormat.ml:2785:12>>*/ caml_trampoline_return
+                           (parse_char_set_content, [0, _ba_, end_ind]);
+                  var counter$2 = counter + 1 | 0;
+                   /*<<camlinternalFormat.ml:2785:12>>*/ return parse_char_set_content
+                          (counter$2, _ba_, end_ind);
+                 }
+                 if(93 === c$2){
+                   /*<<camlinternalFormat.ml:2778:8>>*/ add_char(c$0);
+                   /*<<camlinternalFormat.ml:2779:8>>*/ add_char(45);
+                   /*<<camlinternalFormat.ml:2779:8>>*/ return str_ind$2 + 1
+                         | 0;
+                 }
+                  /*<<camlinternalFormat.ml:2790:8>>*/ add_range(c$0, c$2);
+                 var _bb_ = str_ind$2 + 1 | 0;
+                  /*<<camlinternalFormat.ml:2790:8>>*/ if(counter >= 50)
+                   /*<<camlinternalFormat.ml:2790:8>>*/ return  /*<<camlinternalFormat.ml:2790:8>>*/ caml_trampoline_return
+                          (parse_char_set_content, [0, _bb_, end_ind]);
+                 var counter$1 = counter + 1 | 0;
+                  /*<<camlinternalFormat.ml:2790:8>>*/ return parse_char_set_content
+                         (counter$1, _bb_, end_ind);
+                }
+                if(37 === c$0){
+                  /*<<camlinternalFormat.ml:2763:8>>*/ add_char(c$1);
+                 var _a$_ = str_ind$0 + 1 | 0;
+                  /*<<camlinternalFormat.ml:2763:8>>*/ if(counter >= 50)
+                   /*<<camlinternalFormat.ml:2763:8>>*/ return  /*<<camlinternalFormat.ml:2763:8>>*/ caml_trampoline_return
+                          (parse_char_set_content, [0, _a$_, end_ind]);
+                 var counter$0 = counter + 1 | 0;
+                  /*<<camlinternalFormat.ml:2763:8>>*/ return parse_char_set_content
+                         (counter$0, _a$_, end_ind);
+                }
+               }
+               if(37 === c$0)
+                 /*<<camlinternalFormat.ml:2766:24>>*/ fail_single_percent
+                 (str_ind$0);
+                /*<<camlinternalFormat.ml:2770:8>>*/ add_char(c$0);
+               var
+                str_ind$1 = str_ind$0 + 1 | 0,
+                str_ind$0 = str_ind$1,
+                c$0 = c$1;
+              }
+              /*<<camlinternalFormat.ml:2771:58>>*/ },
+           parse_char_set_after_char =
+             function(str_ind, end_ind, c){
+               /*<<?>>*/ return caml_trampoline
+                      (parse_char_set_after_char$0(0, str_ind, end_ind, c));
+             };
+          if(str_ind === end_ind)
+            /*<<camlinternalFormat.ml:2794:32>>*/ unexpected_end_of_format
+            (end_ind);
+          if
+           (94
+            ===
+              /*<<camlinternalFormat.ml:2795:12>>*/ caml_string_get
+              (str, str_ind))
+           var
+            str_ind$0 = str_ind + 1 | 0,
+            reverse = 1,
+            str_ind$1 = str_ind$0;
+          else
+           var reverse = 0, str_ind$1 = str_ind;
+          if(str_ind$1 === end_ind)
+            /*<<camlinternalFormat.ml:2737:32>>*/ unexpected_end_of_format
+            (end_ind);
+           /*<<camlinternalFormat.ml:2738:14>>*/ var
+            /*<<camlinternalFormat.ml:2738:14>>*/ c =
+              /*<<camlinternalFormat.ml:2738:14>>*/ caml_string_get
+              (str, str_ind$1),
+            /*<<camlinternalFormat.ml:2739:6>>*/ next_ind =
+             parse_char_set_after_char(str_ind$1 + 1 | 0, end_ind, c),
+            /*<<camlinternalFormat.ml:2799:19>>*/ char_set$0 =
+             freeze_char_set(char_set),
+            /*<<camlinternalFormat.ml:2800:4>>*/ char_set$1 =
+             reverse ? rev_char_set(char_set$0) : char_set$0,
+           fmt_rest$19 = parse(next_ind, end_ind)[1];
+           /*<<camlinternalFormat.ml:2543:9>>*/ if(get_ign(0))
+            /*<<camlinternalFormat.ml:2544:22>>*/ var
+             /*<<camlinternalFormat.ml:2544:22>>*/ ignored$9 =
+              [10, get_pad_opt(95), char_set$1],
+            _a1_ = [0, [23, ignored$9, fmt_rest$19]];
+          else
+           var _a1_ = [0, [20, get_pad_opt(91), char_set$1, fmt_rest$19]];
+          var fmt_result = _a1_;
+          break a;
+         case 97:
+          var
+           fmt_rest$20 = parse(str_ind, end_ind)[1],
+           fmt_result = [0, [15, fmt_rest$20]];
+          break a;
+         case 99:
+           /*<<camlinternalFormat.ml:2387:18>>*/ var
+           char_format =
+             function(fmt_rest){
+               /*<<camlinternalFormat.ml:2377:8>>*/ return get_ign(0)
+                      ? [0, [23, 0, fmt_rest]]
+                      : [0, [0, fmt_rest]];
+              /*<<camlinternalFormat.ml:2379:36>>*/ },
+           fmt_rest$21 = parse(str_ind, end_ind)[1],
+            /*<<camlinternalFormat.ml:2387:18>>*/ match$7 = get_pad_opt(99);
+          if(match$7){
+           if(0 === match$7[1])
+             /*<<camlinternalFormat.ml:2382:11>>*/ var
+              /*<<camlinternalFormat.ml:2382:11>>*/ _a2_ =
+               get_ign(0) ? [0, [23, 3, fmt_rest$21]] : [0, [22, fmt_rest$21]],
+             _a3_ = _a2_;
+           else
+            var
+             _a3_ =
+               legacy_behavior$0
+                ? char_format(fmt_rest$21)
+                : invalid_format_message
+                  (str_ind, cst_non_zero_widths_are_unsupp);
+           var _a4_ = _a3_;
+          }
+          else
+           var _a4_ = char_format(fmt_rest$21);
+          var fmt_result = _a4_;
+          break a;
+         case 114:
+           /*<<camlinternalFormat.ml:2512:9>>*/ var
+           fmt_rest$22 = parse(str_ind, end_ind)[1],
+            /*<<camlinternalFormat.ml:2512:9>>*/ _a5_ =
+             get_ign(0) ? [0, [23, 2, fmt_rest$22]] : [0, [19, fmt_rest$22]],
+           fmt_result = _a5_;
+          break a;
+         case 115:
+           /*<<camlinternalFormat.ml:2400:16>>*/ var
+            /*<<camlinternalFormat.ml:2400:16>>*/ pad$9 =
+             check_no_0(symb, get_padprec(0)),
+           fmt_rest$23 = parse(str_ind, end_ind)[1];
+           /*<<camlinternalFormat.ml:2402:9>>*/ if(get_ign(0))
+            /*<<camlinternalFormat.ml:2403:22>>*/ var
+             /*<<camlinternalFormat.ml:2403:22>>*/ ignored$10 =
+              [0, get_padprec_opt(95)],
+            _a6_ = [0, [23, ignored$10, fmt_rest$23]];
+          else
+            /*<<camlinternalFormat.ml:2407:10>>*/ var
+             /*<<camlinternalFormat.ml:2407:10>>*/ match$8 =
+              make_padding_fmt_ebb(pad$9, fmt_rest$23),
+            fmt_rest$24 = match$8[2],
+            pad$10 = match$8[1],
+            _a6_ = [0, [2, pad$10, fmt_rest$24]];
+          var fmt_result = _a6_;
+          break a;
+         case 116:
+          var
+           fmt_rest$25 = parse(str_ind, end_ind)[1],
+           fmt_result = [0, [16, fmt_rest$25]];
+          break a;
+         case 123:
+           /*<<camlinternalFormat.ml:2521:20>>*/ var
+            /*<<camlinternalFormat.ml:2521:20>>*/ sub_end$0 =
+             search_subformat_end(str_ind, end_ind, 125),
+           sub_fmt$0 = parse(str_ind, sub_end$0)[1],
+           fmt_rest$26 = parse(sub_end$0 + 2 | 0, end_ind)[1],
+            /*<<camlinternalFormat.ml:2524:22>>*/ sub_fmtty$0 =
+             fmtty_of_fmt(sub_fmt$0);
+           /*<<camlinternalFormat.ml:2525:9>>*/ if(get_ign(0))
+            /*<<camlinternalFormat.ml:2526:22>>*/ var
+             /*<<camlinternalFormat.ml:2526:22>>*/ ignored$11 =
+              [8, get_pad_opt(95), sub_fmtty$0],
+            _a7_ = [0, [23, ignored$11, fmt_rest$26]];
+          else
+           var _a7_ = [0, [13, get_pad_opt(123), sub_fmtty$0, fmt_rest$26]];
+          var fmt_result = _a7_;
+          break a;
+         case 66:
+         case 98:
+           /*<<camlinternalFormat.ml:2495:16>>*/ var
+            /*<<camlinternalFormat.ml:2495:16>>*/ pad$3 =
+             check_no_0(symb, get_padprec(0)),
+           fmt_rest$8 = parse(str_ind, end_ind)[1];
+           /*<<camlinternalFormat.ml:2497:9>>*/ if(get_ign(0))
+            /*<<camlinternalFormat.ml:2498:22>>*/ var
+             /*<<camlinternalFormat.ml:2498:22>>*/ ignored$3 =
+              [7, get_padprec_opt(95)],
+            _aO_ = [0, [23, ignored$3, fmt_rest$8]];
+          else
+            /*<<camlinternalFormat.ml:2502:10>>*/ var
+             /*<<camlinternalFormat.ml:2502:10>>*/ match$3 =
+              make_padding_fmt_ebb(pad$3, fmt_rest$8),
+            fmt_rest$9 = match$3[2],
+            pad$4 = match$3[1],
+            _aO_ = [0, [9, pad$4, fmt_rest$9]];
+          var fmt_result = _aO_;
+          break a;
+         case 37:
+         case 64:
+          var
+           fmt_rest$6 = parse(str_ind, end_ind)[1],
+           fmt_result = [0, [12, symb, fmt_rest$6]];
+          break a;
+         case 76:
+         case 108:
+         case 110:
+          if(str_ind !== end_ind){
+            /*<<camlinternalFormat.ml:2438:63>>*/ var
+             /*<<camlinternalFormat.ml:2438:63>>*/ symb$0 =
+               /*<<camlinternalFormat.ml:2438:63>>*/ caml_string_get
+               (str, str_ind),
+             /*<<camlinternalFormat.ml:2892:25>>*/ _a8_ = symb$0 - 88 | 0;
+           b:
+           {
+            if(32 >= _a8_ >>> 0)
+             switch(_a8_){
+               case 0:
+               case 12:
+               case 17:
+               case 23:
+               case 29:
+               case 32:
+                var _aU_ = 1; break b;
+             }
+            var _aU_ = 0;
+           }
+            /*<<camlinternalFormat.ml:2438:50>>*/ if(_aU_) break;
+          }
+          var fmt_rest$13 = parse(str_ind, end_ind)[1];
+          b:
+          {
+           if(108 <= symb){
+            if(111 > symb)
+             switch(symb - 108 | 0){
+               case 0:
+                var counter = 0; break b;
+               case 1: break;
+               default: var counter = 1; break b;
+             }
+           }
+           else if(76 === symb){var counter = 2; break b;}
+            /*<<camlinternalFormat.ml:2899:34>>*/ throw  /*<<camlinternalFormat.ml:2899:34>>*/ caml_maybe_attach_backtrace
+                  ([0, Assert_failure, _V_], 1);
+          }
+           /*<<camlinternalFormat.ml:2441:9>>*/ if(get_ign(0))
+            /*<<camlinternalFormat.ml:2442:22>>*/ var
+             /*<<camlinternalFormat.ml:2442:22>>*/ ignored$5 = [11, counter],
+            _aT_ = [0, [23, ignored$5, fmt_rest$13]];
+          else
+           var _aT_ = [0, [21, counter, fmt_rest$13]];
+          var fmt_result = _aT_;
+          break a;
+         case 32:
+         case 35:
+         case 43:
+         case 45:
+         case 95:
+          var
+           fmt_result =
+              /*<<camlinternalFormat.ml:2549:6>>*/ caml_call3
+              (failwith_message(_M_), str, pct_ind, symb);
+          break a;
+         case 88:
+         case 100:
+         case 105:
+         case 111:
+         case 117:
+         case 120:
+           /*<<camlinternalFormat.ml:2421:8>>*/ var
+            /*<<camlinternalFormat.ml:2421:8>>*/ _aX_ = get_space(0),
+            /*<<camlinternalFormat.ml:2420:65>>*/ _aY_ = get_hash(0),
+            /*<<camlinternalFormat.ml:2420:18>>*/ iconv$2 =
+             compute_int_conv(pct_ind, str_ind, get_plus(0), _aY_, _aX_, symb),
+           fmt_rest$17 = parse(str_ind, end_ind)[1];
+           /*<<camlinternalFormat.ml:2423:9>>*/ if(get_ign(0))
+            /*<<camlinternalFormat.ml:2424:22>>*/ var
+             /*<<camlinternalFormat.ml:2424:22>>*/ ignored$8 =
+              [2, iconv$2, get_pad_opt(95)],
+            _aZ_ = [0, [23, ignored$8, fmt_rest$17]];
+          else
+            /*<<camlinternalFormat.ml:2428:48>>*/ var
+             /*<<camlinternalFormat.ml:2428:48>>*/ _a0_ = get_prec(0),
+             /*<<camlinternalFormat.ml:2428:10>>*/ match$6 =
+              make_padprec_fmt_ebb(get_int_pad(0), _a0_, fmt_rest$17),
+            fmt_rest$18 = match$6[3],
+            prec$4 = match$6[2],
+            pad$8 = match$6[1],
+            _aZ_ = [0, [4, iconv$2, pad$8, prec$4, fmt_rest$18]];
+          var fmt_result = _aZ_;
+          break a;
+         case 69:
+         case 70:
+         case 71:
+         case 72:
+         case 101:
+         case 102:
+         case 103:
+         case 104:
+           /*<<camlinternalFormat.ml:2485:38>>*/ var
+            /*<<camlinternalFormat.ml:2485:38>>*/ space$1 = get_space(0),
+            /*<<camlinternalFormat.ml:2485:24>>*/ hash$1 = get_hash(0),
+            /*<<camlinternalFormat.ml:2485:10>>*/ plus$2 = get_plus(0),
+           flag =
+             plus$2
+              ? space$1
+                ? legacy_behavior$0
+                  ? 1
+                  : incompatible_flag(pct_ind, str_ind, 32, cst$36)
+                : 1
+              : space$1 ? 2 : 0;
+          b:
+          {
+           c:
+           if(73 <= symb){
+            var switcher = symb - 101 | 0;
+            if(3 >= switcher >>> 0){
+             switch(switcher){
+               case 0:
+                var _a9_ = 1; break;
+               case 1:
+                var _a9_ = 0; break;
+               case 2:
+                var _a9_ = 3; break;
+               default: var _a9_ = 6;
+             }
+             var kind = _a9_;
+             break b;
+            }
+           }
+           else if(69 <= symb){
+            switch(symb - 69 | 0){
+              case 0:
+               var _a__ = 2; break;
+              case 1:
+               break c;
+              case 2:
+               var _a__ = 4; break;
+              default: var _a__ = 7;
+            }
+            var kind = _a__;
+            break b;
+           }
+           if(hash$1){
+            if(70 === symb){var kind = 8; break b;}
+           }
+           else if(70 === symb){var kind = 5; break b;}
+            /*<<camlinternalFormat.ml:2957:11>>*/ throw  /*<<camlinternalFormat.ml:2957:11>>*/ caml_maybe_attach_backtrace
+                  ([0, Assert_failure, _X_], 1);
+          }
+           /*<<camlinternalFormat.ml:2958:4>>*/ var
+            /*<<camlinternalFormat.ml:2958:4>>*/ fconv = [0, flag, kind],
+           fmt_rest$11 = parse(str_ind, end_ind)[1];
+           /*<<camlinternalFormat.ml:2487:9>>*/ if(get_ign(0)){
+            /*<<camlinternalFormat.ml:2366:32>>*/  /*<<camlinternalFormat.ml:2366:32>>*/ var
+            match = get_prec(0);
+           if(typeof match === "number")
+            var
+             _aQ_ =
+               match ? incompatible_flag(pct_ind, str_ind, 95, cst$26) : 0;
+           else
+            var ndec = match[1], _aQ_ = [0, ndec];
+            /*<<camlinternalFormat.ml:2488:22>>*/ var
+             /*<<camlinternalFormat.ml:2488:22>>*/ ignored$4 =
+              [6, get_pad_opt(95), _aQ_],
+            _aR_ = [0, [23, ignored$4, fmt_rest$11]];
+          }
+          else
+            /*<<camlinternalFormat.ml:2492:44>>*/ var
+             /*<<camlinternalFormat.ml:2492:44>>*/ _aS_ = get_prec(0),
+             /*<<camlinternalFormat.ml:2492:10>>*/ match$4 =
+              make_padprec_fmt_ebb(get_pad(0), _aS_, fmt_rest$11),
+            fmt_rest$12 = match$4[3],
+            prec$3 = match$4[2],
+            pad$5 = match$4[1],
+            _aR_ = [0, [8, fconv, pad$5, prec$3, fmt_rest$12]];
+          var fmt_result = _aR_;
+          break a;
+       }
+      b:
+      if(108 <= symb){
+       if(111 > symb){
+        switch(symb - 108 | 0){
+          case 0:
+            /*<<camlinternalFormat.ml:2449:25>>*/ var
+             /*<<camlinternalFormat.ml:2449:25>>*/ _ax_ =
+               /*<<camlinternalFormat.ml:2449:25>>*/ caml_string_get
+               (str, str_ind),
+             /*<<camlinternalFormat.ml:2449:10>>*/ _ay_ = get_space(0),
+             /*<<camlinternalFormat.ml:2448:61>>*/ _az_ = get_hash(0),
+             /*<<camlinternalFormat.ml:2448:8>>*/ iconv =
+              compute_int_conv
+               (pct_ind, str_ind + 1 | 0, get_plus(0), _az_, _ay_, _ax_),
+            fmt_rest = parse(str_ind + 1 | 0, end_ind)[1];
+            /*<<camlinternalFormat.ml:2451:9>>*/ if(get_ign(0))
+             /*<<camlinternalFormat.ml:2452:22>>*/ var
+              /*<<camlinternalFormat.ml:2452:22>>*/ ignored =
+               [3, iconv, get_pad_opt(95)],
+             _aA_ = [0, [23, ignored, fmt_rest]];
+           else
+             /*<<camlinternalFormat.ml:2456:48>>*/ var
+              /*<<camlinternalFormat.ml:2456:48>>*/ _aC_ = get_prec(0),
+              /*<<camlinternalFormat.ml:2456:10>>*/ match$0 =
+               make_padprec_fmt_ebb(get_int_pad(0), _aC_, fmt_rest),
+             fmt_rest$0 = match$0[3],
+             prec$0 = match$0[2],
+             pad$0 = match$0[1],
+             _aA_ = [0, [5, iconv, pad$0, prec$0, fmt_rest$0]];
+           var _aB_ = _aA_;
+           break;
+          case 1:
+           break b;
+          default:
+            /*<<camlinternalFormat.ml:2461:39>>*/ var
+             /*<<camlinternalFormat.ml:2461:39>>*/ _aD_ =
+               /*<<camlinternalFormat.ml:2461:39>>*/ caml_string_get
+               (str, str_ind),
+             /*<<camlinternalFormat.ml:2461:24>>*/ _aE_ = get_space(0),
+             /*<<camlinternalFormat.ml:2461:10>>*/ _aF_ = get_hash(0),
+             /*<<camlinternalFormat.ml:2460:8>>*/ iconv$0 =
+              compute_int_conv
+               (pct_ind, str_ind + 1 | 0, get_plus(0), _aF_, _aE_, _aD_),
+            fmt_rest$1 = parse(str_ind + 1 | 0, end_ind)[1];
+            /*<<camlinternalFormat.ml:2463:9>>*/ if(get_ign(0))
+             /*<<camlinternalFormat.ml:2464:22>>*/ var
+              /*<<camlinternalFormat.ml:2464:22>>*/ ignored$0 =
+               [4, iconv$0, get_pad_opt(95)],
+             _aG_ = [0, [23, ignored$0, fmt_rest$1]];
+           else
+             /*<<camlinternalFormat.ml:2468:48>>*/ var
+              /*<<camlinternalFormat.ml:2468:48>>*/ _aH_ = get_prec(0),
+              /*<<camlinternalFormat.ml:2468:10>>*/ match$1 =
+               make_padprec_fmt_ebb(get_int_pad(0), _aH_, fmt_rest$1),
+             fmt_rest$2 = match$1[3],
+             prec$1 = match$1[2],
+             pad$1 = match$1[1],
+             _aG_ = [0, [6, iconv$0, pad$1, prec$1, fmt_rest$2]];
+           var _aB_ = _aG_;
+        }
+        var fmt_result = _aB_;
+        break a;
+       }
+      }
+      else if(76 === symb){
+        /*<<camlinternalFormat.ml:2473:25>>*/ var
+         /*<<camlinternalFormat.ml:2473:25>>*/ _aI_ =
+           /*<<camlinternalFormat.ml:2473:25>>*/ caml_string_get(str, str_ind),
+         /*<<camlinternalFormat.ml:2473:10>>*/ _aJ_ = get_space(0),
+         /*<<camlinternalFormat.ml:2472:61>>*/ _aK_ = get_hash(0),
+         /*<<camlinternalFormat.ml:2472:8>>*/ iconv$1 =
+          compute_int_conv
+           (pct_ind, str_ind + 1 | 0, get_plus(0), _aK_, _aJ_, _aI_),
+        fmt_rest$3 = parse(str_ind + 1 | 0, end_ind)[1];
+        /*<<camlinternalFormat.ml:2475:9>>*/ if(get_ign(0))
+         /*<<camlinternalFormat.ml:2476:22>>*/ var
+          /*<<camlinternalFormat.ml:2476:22>>*/ ignored$1 =
+           [5, iconv$1, get_pad_opt(95)],
+         _aL_ = [0, [23, ignored$1, fmt_rest$3]];
+       else
+         /*<<camlinternalFormat.ml:2480:48>>*/ var
+          /*<<camlinternalFormat.ml:2480:48>>*/ _aM_ = get_prec(0),
+          /*<<camlinternalFormat.ml:2480:10>>*/ match$2 =
+           make_padprec_fmt_ebb(get_int_pad(0), _aM_, fmt_rest$3),
+         fmt_rest$4 = match$2[3],
+         prec$2 = match$2[2],
+         pad$2 = match$2[1],
+         _aL_ = [0, [7, iconv$1, pad$2, prec$2, fmt_rest$4]];
+       var fmt_result = _aL_;
+       break a;
+      }
+      var
+       fmt_result =
+          /*<<camlinternalFormat.ml:2554:6>>*/ caml_call3
+          (failwith_message(_J_), str, str_ind - 1 | 0, symb);
+     }
+     if(1 - legacy_behavior$0){
+      var _ao_ = 1 - plus_used[1], plus$0 = _ao_ ? plus : _ao_;
+      if(plus$0)
+        /*<<camlinternalFormat.ml:2564:6>>*/ incompatible_flag
+        (pct_ind, str_ind, symb, cst$27);
+      var _ap_ = 1 - hash_used[1], hash$0 = _ap_ ? hash : _ap_;
+      if(hash$0)
+        /*<<camlinternalFormat.ml:2566:6>>*/ incompatible_flag
+        (pct_ind, str_ind, symb, cst$28);
+      var _aq_ = 1 - space_used[1], space$0 = _aq_ ? space : _aq_;
+      if(space$0)
+        /*<<camlinternalFormat.ml:2568:6>>*/ incompatible_flag
+        (pct_ind, str_ind, symb, cst$29);
+      var
+       _ar_ = 1 - pad_used[1],
+       _as_ =
+         _ar_
+          ?  /*<<camlinternalFormat.ml:2569:25>>*/ caml_notequal
+            ([0, pad], _K_)
+          : _ar_;
+       /*<<camlinternalFormat.ml:2569:25>>*/ if(_as_)
+        /*<<camlinternalFormat.ml:2570:6>>*/ incompatible_flag
+        (pct_ind, str_ind, symb, cst_padding$0);
+      var
+       _at_ = 1 - prec_used[1],
+       _au_ =
+         _at_
+          ?  /*<<camlinternalFormat.ml:2571:25>>*/ caml_notequal
+            ([0, prec], _L_)
+          : _at_;
+       /*<<camlinternalFormat.ml:2571:25>>*/ if(_au_){
+       var _av_ = ign ? 95 : symb;
+        /*<<camlinternalFormat.ml:2572:6>>*/ incompatible_flag
+        (pct_ind, str_ind, _av_, cst_precision$2);
+      }
+      var plus$1 = ign ? plus : ign;
+      if(plus$1)
+        /*<<camlinternalFormat.ml:2574:24>>*/ incompatible_flag
+        (pct_ind, str_ind, 95, cst$30);
+     }
+     var _aw_ = 1 - ign_used[1], ign$0 = _aw_ ? ign : _aw_;
+     a:
+     if(ign$0){
+      b:
+      {
+       if(38 <= symb){
+        if(44 !== symb && 64 !== symb) break b;
+       }
+       else if(33 !== symb && 37 > symb) break b;
+       if(legacy_behavior$0) break a;
+      }
+       /*<<camlinternalFormat.ml:2584:10>>*/ incompatible_flag
+       (pct_ind, str_ind, symb, cst$31);
+     }
+      /*<<camlinternalFormat.ml:2584:10>>*/ return fmt_result;
+    }
+    function parse_after_precision
+    (pct_ind, str_ind, end_ind, minus, plus, hash, space, ign, pad, prec){
+      /*<<camlinternalFormat.ml:2268:4>>*/ if(str_ind === end_ind)
+       /*<<camlinternalFormat.ml:2268:30>>*/ unexpected_end_of_format(end_ind);
+     function parse_conv(padprec){
+       /*<<camlinternalFormat.ml:2270:6>>*/ return parse_conversion
+              (pct_ind,
+               str_ind + 1 | 0,
+               end_ind,
+               plus,
+               hash,
+               space,
+               ign,
+               pad,
+               prec,
+               padprec,
+                /*<<camlinternalFormat.ml:2271:21>>*/ caml_string_get
+                (str, str_ind));
+      /*<<camlinternalFormat.ml:2271:34>>*/ }
+     if(typeof pad !== "number")
+       /*<<camlinternalFormat.ml:2287:13>>*/ return parse_conv(pad);
+     if(typeof prec === "number" && ! prec)
+       /*<<camlinternalFormat.ml:2281:29>>*/ return parse_conv(0);
+     if(minus){
+      if(typeof prec === "number")
+        /*<<camlinternalFormat.ml:2285:33>>*/ return parse_conv(_F_);
+      var n = prec[1];
+       /*<<camlinternalFormat.ml:2283:46>>*/ return parse_conv([0, 0, n]);
+     }
+     if(typeof prec === "number")
+       /*<<camlinternalFormat.ml:2284:34>>*/ return parse_conv(_G_);
+     var n$0 = prec[1];
+      /*<<camlinternalFormat.ml:2282:47>>*/ return parse_conv([0, 1, n$0]);
+     /*<<camlinternalFormat.ml:2287:27>>*/ }
+    function parse_after_padding
+    (pct_ind, str_ind, end_ind, minus, plus, hash, space, ign, pad){
+      /*<<camlinternalFormat.ml:2219:4>>*/ if(str_ind === end_ind)
+       /*<<camlinternalFormat.ml:2219:30>>*/ unexpected_end_of_format(end_ind);
+      /*<<camlinternalFormat.ml:2220:10>>*/  /*<<camlinternalFormat.ml:2220:10>>*/ var
+      symb =
+         /*<<camlinternalFormat.ml:2220:10>>*/ caml_string_get(str, str_ind);
+     if(46 !== symb)
+       /*<<camlinternalFormat.ml:2225:6>>*/ return parse_conversion
+              (pct_ind,
+               str_ind + 1 | 0,
+               end_ind,
+               plus,
+               hash,
+               space,
+               ign,
+               pad,
+               0,
+               pad,
+               symb);
+     var str_ind$0 = str_ind + 1 | 0;
+     if(str_ind$0 === end_ind)
+       /*<<camlinternalFormat.ml:2233:30>>*/ unexpected_end_of_format(end_ind);
+     function parse_literal(minus, str_ind){
+       /*<<camlinternalFormat.ml:2235:6>>*/ var
+        /*<<camlinternalFormat.ml:2235:26>>*/ match =
+         parse_positive(str_ind, end_ind, 0),
+       prec = match[2],
+       new_ind = match[1];
+       /*<<camlinternalFormat.ml:2237:12>>*/ return parse_after_precision
+              (pct_ind,
+               new_ind,
+               end_ind,
+               minus,
+               plus,
+               hash,
+               space,
+               ign,
+               pad,
+               [0, prec]);
+      /*<<camlinternalFormat.ml:2237:32>>*/ }
+      /*<<camlinternalFormat.ml:2238:10>>*/  /*<<camlinternalFormat.ml:2238:10>>*/ var
+      symb$0 =
+         /*<<camlinternalFormat.ml:2238:10>>*/ caml_string_get(str, str_ind$0);
+     if(48 <= symb$0){
+      if(58 > symb$0)
+        /*<<camlinternalFormat.ml:2239:20>>*/ return parse_literal
+               (minus, str_ind$0);
+     }
+     else if(42 <= symb$0)
+      switch(symb$0 - 42 | 0){
+        case 0:
+          /*<<camlinternalFormat.ml:2251:6>>*/ return parse_after_precision
+                 (pct_ind,
+                  str_ind$0 + 1 | 0,
+                  end_ind,
+                  minus,
+                  plus,
+                  hash,
+                  space,
+                  ign,
+                  pad,
+                  1);
+        case 1:
+        case 3:
+         if(legacy_behavior$0){
+           /*<<camlinternalFormat.ml:2249:6>>*/ var
+            /*<<camlinternalFormat.ml:2249:6>>*/ _an_ = str_ind$0 + 1 | 0,
+           minus$0 = minus || (45 === symb$0 ? 1 : 0);
+           /*<<camlinternalFormat.ml:2249:6>>*/ return parse_literal
+                  (minus$0, _an_);
+         }
+         break;
+      }
+     return legacy_behavior$0
+             ? parse_after_precision
+               (pct_ind,
+                str_ind$0,
+                end_ind,
+                minus,
+                plus,
+                hash,
+                space,
+                ign,
+                pad,
+                _E_)
+             : invalid_format_without(str_ind$0 - 1 | 0, 46, cst_precision);
+     /*<<camlinternalFormat.ml:2226:29>>*/ }
+    function parse_flags(pct_ind, str_ind, end_ind, ign){
+      /*<<camlinternalFormat.ml:2149:4>>*/ var
+       /*<<camlinternalFormat.ml:2149:15>>*/ zero = [0, 0],
+       /*<<camlinternalFormat.ml:2149:37>>*/ minus = [0, 0],
+       /*<<camlinternalFormat.ml:2150:15>>*/ plus = [0, 0],
+       /*<<camlinternalFormat.ml:2150:37>>*/ space = [0, 0],
+       /*<<camlinternalFormat.ml:2151:15>>*/ hash = [0, 0];
+     function set_flag(str_ind, flag){
+       /*<<camlinternalFormat.ml:2154:6>>*/ var
+       _ak_ = flag[1],
+       _al_ = _ak_ ? 1 - legacy_behavior$0 : _ak_;
+      if(_al_){
+        /*<<camlinternalFormat.ml:2157:22>>*/  /*<<camlinternalFormat.ml:2157:22>>*/ var
+        _am_ =
+           /*<<camlinternalFormat.ml:2157:22>>*/ caml_string_get(str, str_ind);
+        /*<<camlinternalFormat.ml:2155:8>>*/  /*<<camlinternalFormat.ml:2155:8>>*/ caml_call3
+        (failwith_message(_C_), str, str_ind, _am_);
+      }
+      flag[1] = 1;
+      return 0;
+      /*<<camlinternalFormat.ml:2158:19>>*/ }
+     var str_ind$0 = str_ind;
+      /*<<camlinternalFormat.ml:2161:6>>*/ for(;;){
+      if(str_ind$0 === end_ind)
+        /*<<camlinternalFormat.ml:2161:32>>*/ unexpected_end_of_format
+        (end_ind);
+       /*<<camlinternalFormat.ml:2162:18>>*/  /*<<camlinternalFormat.ml:2162:18>>*/ var
+       switcher =
+          /*<<camlinternalFormat.ml:2162:18>>*/ caml_string_get
+          (str, str_ind$0)
+         - 32
+         | 0;
+      if(16 >= switcher >>> 0)
+       switch(switcher){
+         case 0:
+           /*<<camlinternalFormat.ml:2167:15>>*/ set_flag(str_ind$0, space);
+           /*<<camlinternalFormat.ml:2167:15>>*/ var
+            /*<<camlinternalFormat.ml:2167:15>>*/ str_ind$1 =
+             str_ind$0 + 1 | 0,
+           str_ind$0 = str_ind$1;
+          continue;
+         case 3:
+           /*<<camlinternalFormat.ml:2166:15>>*/ set_flag(str_ind$0, hash);
+           /*<<camlinternalFormat.ml:2166:15>>*/ var
+            /*<<camlinternalFormat.ml:2166:15>>*/ str_ind$2 =
+             str_ind$0 + 1 | 0,
+           str_ind$0 = str_ind$2;
+          continue;
+         case 11:
+           /*<<camlinternalFormat.ml:2165:15>>*/ set_flag(str_ind$0, plus);
+           /*<<camlinternalFormat.ml:2165:15>>*/ var
+            /*<<camlinternalFormat.ml:2165:15>>*/ str_ind$3 =
+             str_ind$0 + 1 | 0,
+           str_ind$0 = str_ind$3;
+          continue;
+         case 13:
+           /*<<camlinternalFormat.ml:2164:15>>*/ set_flag(str_ind$0, minus);
+           /*<<camlinternalFormat.ml:2164:15>>*/ var
+            /*<<camlinternalFormat.ml:2164:15>>*/ str_ind$4 =
+             str_ind$0 + 1 | 0,
+           str_ind$0 = str_ind$4;
+          continue;
+         case 16:
+           /*<<camlinternalFormat.ml:2163:15>>*/ set_flag(str_ind$0, zero);
+           /*<<camlinternalFormat.ml:2163:15>>*/ var
+            /*<<camlinternalFormat.ml:2163:15>>*/ str_ind$5 =
+             str_ind$0 + 1 | 0,
+           str_ind$0 = str_ind$5;
+          continue;
+       }
+      var
+       space$0 = space[1],
+       hash$0 = hash[1],
+       plus$0 = plus[1],
+       minus$0 = minus[1],
+       zero$0 = zero[1];
+      if(str_ind$0 === end_ind)
+        /*<<camlinternalFormat.ml:2180:30>>*/ unexpected_end_of_format
+        (end_ind);
+       /*<<camlinternalFormat.ml:2188:10>>*/ var
+       padty =
+         zero$0
+          ? minus$0
+            ? legacy_behavior$0
+              ? 0
+              : incompatible_flag(pct_ind, str_ind$0, 45, cst_0)
+            : 2
+          : minus$0 ? 0 : 1,
+        /*<<camlinternalFormat.ml:2188:10>>*/ match =
+          /*<<camlinternalFormat.ml:2188:10>>*/ caml_string_get
+          (str, str_ind$0);
+      if(48 <= match){
+       if(58 > match){
+         /*<<camlinternalFormat.ml:2190:27>>*/ var
+          /*<<camlinternalFormat.ml:2190:27>>*/ match$0 =
+           parse_positive(str_ind$0, end_ind, 0),
+         width = match$0[2],
+         new_ind = match$0[1];
+         /*<<camlinternalFormat.ml:2192:8>>*/ return parse_after_padding
+                (pct_ind,
+                 new_ind,
+                 end_ind,
+                 minus$0,
+                 plus$0,
+                 hash$0,
+                 space$0,
+                 ign,
+                 [0, padty, width]);
+       }
+      }
+      else if(42 === match)
+        /*<<camlinternalFormat.ml:2195:12>>*/ return parse_after_padding
+               (pct_ind,
+                str_ind$0 + 1 | 0,
+                end_ind,
+                minus$0,
+                plus$0,
+                hash$0,
+                space$0,
+                ign,
+                [1, padty]);
+      switch(padty){
+        case 0:
+         if(1 - legacy_behavior$0)
+           /*<<camlinternalFormat.ml:2200:10>>*/ invalid_format_without
+           (str_ind$0 - 1 | 0, 45, cst_padding);
+          /*<<camlinternalFormat.ml:2200:10>>*/ return parse_after_padding
+                 (pct_ind,
+                  str_ind$0,
+                  end_ind,
+                  minus$0,
+                  plus$0,
+                  hash$0,
+                  space$0,
+                  ign,
+                  0);
+        case 1:
+          /*<<camlinternalFormat.ml:2210:8>>*/ return parse_after_padding
+                 (pct_ind,
+                  str_ind$0,
+                  end_ind,
+                  minus$0,
+                  plus$0,
+                  hash$0,
+                  space$0,
+                  ign,
+                  0);
+        default:
+          /*<<camlinternalFormat.ml:2207:8>>*/ return parse_after_padding
+                 (pct_ind,
+                  str_ind$0,
+                  end_ind,
+                  minus$0,
+                  plus$0,
+                  hash$0,
+                  space$0,
+                  ign,
+                  _D_);
+      }
+     }
+     /*<<camlinternalFormat.ml:2173:22>>*/ }
+    function parse_tag(is_open_tag, str_ind, end_ind){
+      /*<<camlinternalFormat.ml:2639:4>>*/ try{
+      if(str_ind === end_ind)
+        /*<<camlinternalFormat.ml:2640:32>>*/ throw  /*<<camlinternalFormat.ml:2640:32>>*/ caml_maybe_attach_backtrace
+              (Stdlib[8], 1);
+      if
+       (60
+        !==
+          /*<<camlinternalFormat.ml:2641:12>>*/ caml_string_get(str, str_ind))
+        /*<<camlinternalFormat.ml:2653:8>>*/ throw  /*<<camlinternalFormat.ml:2653:8>>*/ caml_maybe_attach_backtrace
+              (Stdlib[8], 1);
+       /*<<camlinternalFormat.ml:2643:18>>*/  /*<<camlinternalFormat.ml:2643:18>>*/ var
+       ind =
+          /*<<camlinternalFormat.ml:2643:18>>*/ caml_call3
+          (Stdlib_String[31], str, str_ind + 1 | 0, 62);
+      if(end_ind <= ind)
+        /*<<camlinternalFormat.ml:2644:31>>*/ throw  /*<<camlinternalFormat.ml:2644:31>>*/ caml_maybe_attach_backtrace
+              (Stdlib[8], 1);
+       /*<<camlinternalFormat.ml:2645:22>>*/ var
+        /*<<camlinternalFormat.ml:2645:22>>*/ sub_str =
+          /*<<camlinternalFormat.ml:2645:22>>*/ caml_call3
+          (Stdlib_String[15], str, str_ind, (ind - str_ind | 0) + 1 | 0),
+       fmt_rest$0 = parse(ind + 1 | 0, end_ind)[1],
+       sub_fmt = parse(str_ind, ind + 1 | 0)[1],
+        /*<<camlinternalFormat.ml:2648:25>>*/ sub_format$0 =
+         [0, sub_fmt, sub_str],
+        /*<<camlinternalFormat.ml:2649:8>>*/ formatting$0 =
+         is_open_tag ? [0, sub_format$0] : [1, sub_format$0],
+        /*<<camlinternalFormat.ml:2651:8>>*/ _ai_ =
+         [0, [18, formatting$0, fmt_rest$0]];
+       /*<<camlinternalFormat.ml:2651:8>>*/ return _ai_;
+     }
+     catch(_aj_){
+      var _ah_ = caml_wrap_exception(_aj_);
+      if(_ah_ !== Stdlib[8]) throw caml_maybe_attach_backtrace(_ah_, 0);
+       /*<<camlinternalFormat.ml:2657:6>>*/ var
+       fmt_rest = parse(str_ind, end_ind)[1],
+        /*<<camlinternalFormat.ml:2657:6>>*/ formatting =
+         is_open_tag ? [0, sub_format] : [1, sub_format];
+       /*<<camlinternalFormat.ml:2659:6>>*/ return [0,
+              [18, formatting, fmt_rest]];
+     }
+     /*<<camlinternalFormat.ml:2659:53>>*/ }
+    function parse_spaces(str_ind, end_ind){
+      /*<<camlinternalFormat.ml:2804:4>>*/ var str_ind$0 = str_ind;
+      /*<<camlinternalFormat.ml:2804:4>>*/ for(;;){
+      if(str_ind$0 === end_ind)
+        /*<<camlinternalFormat.ml:2804:30>>*/ unexpected_end_of_format
+        (end_ind);
+       /*<<camlinternalFormat.ml:2805:7>>*/ if
+       (32
+        !==
+          /*<<camlinternalFormat.ml:2805:7>>*/ caml_string_get(str, str_ind$0))
+        /*<<camlinternalFormat.ml:2805:72>>*/ return str_ind$0;
+      var str_ind$1 = str_ind$0 + 1 | 0, str_ind$0 = str_ind$1;
+     }
+     /*<<camlinternalFormat.ml:2805:79>>*/ }
+    function parse_positive(str_ind, end_ind, acc){
+      /*<<camlinternalFormat.ml:2810:4>>*/ var
+      str_ind$0 = str_ind,
+      acc$0 = acc;
+      /*<<camlinternalFormat.ml:2810:4>>*/ for(;;){
+      if(str_ind$0 === end_ind)
+        /*<<camlinternalFormat.ml:2810:30>>*/ unexpected_end_of_format
+        (end_ind);
+       /*<<camlinternalFormat.ml:2811:10>>*/  /*<<camlinternalFormat.ml:2811:10>>*/ var
+       c =
+          /*<<camlinternalFormat.ml:2811:10>>*/ caml_string_get
+          (str, str_ind$0);
+      if(9 < c - 48 >>> 0)
+        /*<<camlinternalFormat.ml:2820:11>>*/ return [0, str_ind$0, acc$0];
+      var new_acc = (acc$0 * 10 | 0) + (c - 48 | 0) | 0;
+      if(Stdlib_Sys[12] < new_acc){
+        /*<<camlinternalFormat.ml:2815:8>>*/  /*<<camlinternalFormat.ml:2815:8>>*/ var
+        _ag_ = Stdlib_Sys[12];
+        /*<<camlinternalFormat.ml:2815:8>>*/ return  /*<<camlinternalFormat.ml:2815:8>>*/ caml_call3
+               (failwith_message(_S_), str, new_acc, _ag_);
+      }
+      var
+       str_ind$1 = str_ind$0 + 1 | 0,
+       str_ind$0 = str_ind$1,
+       acc$0 = new_acc;
+     }
+     /*<<camlinternalFormat.ml:2820:23>>*/ }
+    function parse_integer(str_ind, end_ind){
+      /*<<camlinternalFormat.ml:2825:4>>*/ if(str_ind === end_ind)
+       /*<<camlinternalFormat.ml:2825:30>>*/ unexpected_end_of_format(end_ind);
+      /*<<camlinternalFormat.ml:2826:10>>*/  /*<<camlinternalFormat.ml:2826:10>>*/ var
+      match =
+         /*<<camlinternalFormat.ml:2826:10>>*/ caml_string_get(str, str_ind);
+     if(48 <= match){
+      if(58 > match)
+        /*<<camlinternalFormat.ml:2827:20>>*/ return parse_positive
+               (str_ind, end_ind, 0);
+     }
+     else if(45 === match){
+      if((str_ind + 1 | 0) === end_ind)
+        /*<<camlinternalFormat.ml:2829:36>>*/ unexpected_end_of_format
+        (end_ind);
+       /*<<camlinternalFormat.ml:2830:12>>*/  /*<<camlinternalFormat.ml:2830:12>>*/ var
+       c =
+          /*<<camlinternalFormat.ml:2830:12>>*/ caml_string_get
+          (str, str_ind + 1 | 0);
+      if(9 < c - 48 >>> 0)
+        /*<<camlinternalFormat.ml:2835:8>>*/ return expected_character
+               (str_ind + 1 | 0, cst_digit, c);
+       /*<<camlinternalFormat.ml:2832:26>>*/ var
+        /*<<camlinternalFormat.ml:2832:26>>*/ match$0 =
+         parse_positive(str_ind + 1 | 0, end_ind, 0),
+       n = match$0[2],
+       next_ind = match$0[1];
+       /*<<camlinternalFormat.ml:2833:8>>*/ return [0, next_ind, - n | 0];
+     }
+      /*<<camlinternalFormat.ml:2837:11>>*/ throw  /*<<camlinternalFormat.ml:2837:11>>*/ caml_maybe_attach_backtrace
+            ([0, Assert_failure, _T_], 1);
+     /*<<camlinternalFormat.ml:2837:23>>*/ }
+    function search_subformat_end(str_ind, end_ind, c){
+      /*<<camlinternalFormat.ml:2851:4>>*/ var str_ind$0 = str_ind;
+      /*<<camlinternalFormat.ml:2851:4>>*/ for(;;){
+      if(str_ind$0 === end_ind)
+        /*<<camlinternalFormat.ml:2852:6>>*/  /*<<camlinternalFormat.ml:2852:6>>*/ caml_call3
+        (failwith_message(_U_), str, c, end_ind);
+      if
+       (37
+        ===
+          /*<<camlinternalFormat.ml:2855:10>>*/ caml_string_get
+          (str, str_ind$0)){
+       if((str_ind$0 + 1 | 0) === end_ind)
+         /*<<camlinternalFormat.ml:2857:36>>*/ unexpected_end_of_format
+         (end_ind);
+       if
+        ( /*<<camlinternalFormat.ml:2858:9>>*/ caml_string_get
+          (str, str_ind$0 + 1 | 0)
+         === c)
+         /*<<camlinternalFormat.ml:2858:62>>*/ return str_ind$0;
+        /*<<camlinternalFormat.ml:2859:20>>*/  /*<<camlinternalFormat.ml:2859:20>>*/ var
+        match =
+           /*<<camlinternalFormat.ml:2859:20>>*/ caml_string_get
+           (str, str_ind$0 + 1 | 0);
+       if(95 <= match){
+        if(123 <= match){
+         if(126 > match)
+          switch(match - 123 | 0){
+            case 0:
+              /*<<camlinternalFormat.ml:2874:24>>*/ var
+               /*<<camlinternalFormat.ml:2874:24>>*/ sub_end =
+                search_subformat_end(str_ind$0 + 2 | 0, end_ind, 125),
+               /*<<camlinternalFormat.ml:2874:24>>*/ str_ind$2 =
+                sub_end + 2 | 0,
+              str_ind$0 = str_ind$2;
+             continue;
+            case 1: break;
+            default:
+              /*<<camlinternalFormat.ml:2882:10>>*/ return expected_character
+                     (str_ind$0 + 1 | 0, cst_character, 125);
+          }
+        }
+        else if(96 > match){
+         if((str_ind$0 + 2 | 0) === end_ind)
+           /*<<camlinternalFormat.ml:2862:40>>*/ unexpected_end_of_format
+           (end_ind);
+          /*<<camlinternalFormat.ml:2863:22>>*/  /*<<camlinternalFormat.ml:2863:22>>*/ var
+          match$0 =
+             /*<<camlinternalFormat.ml:2863:22>>*/ caml_string_get
+             (str, str_ind$0 + 2 | 0);
+         if(40 === match$0){
+           /*<<camlinternalFormat.ml:2868:26>>*/ var
+            /*<<camlinternalFormat.ml:2868:26>>*/ sub_end$0 =
+             search_subformat_end(str_ind$0 + 3 | 0, end_ind, 41),
+            /*<<camlinternalFormat.ml:2868:26>>*/ str_ind$3 =
+             sub_end$0 + 2 | 0,
+           str_ind$0 = str_ind$3;
+          continue;
+         }
+         if(123 === match$0){
+           /*<<camlinternalFormat.ml:2865:26>>*/ var
+            /*<<camlinternalFormat.ml:2865:26>>*/ sub_end$1 =
+             search_subformat_end(str_ind$0 + 3 | 0, end_ind, 125),
+            /*<<camlinternalFormat.ml:2865:26>>*/ str_ind$4 =
+             sub_end$1 + 2 | 0,
+           str_ind$0 = str_ind$4;
+          continue;
+         }
+         var str_ind$5 = str_ind$0 + 3 | 0, str_ind$0 = str_ind$5;
+         continue;
+        }
+       }
+       else{
+        if(40 === match){
+          /*<<camlinternalFormat.ml:2878:24>>*/ var
+           /*<<camlinternalFormat.ml:2878:24>>*/ sub_end$2 =
+            search_subformat_end(str_ind$0 + 2 | 0, end_ind, 41),
+           /*<<camlinternalFormat.ml:2878:24>>*/ str_ind$6 = sub_end$2 + 2 | 0,
+          str_ind$0 = str_ind$6;
+         continue;
+        }
+        if(41 === match)
+          /*<<camlinternalFormat.ml:2885:10>>*/ return expected_character
+                 (str_ind$0 + 1 | 0, cst_character$0, 41);
+       }
+       var str_ind$1 = str_ind$0 + 2 | 0, str_ind$0 = str_ind$1;
+      }
+      else
+       var str_ind$7 = str_ind$0 + 1 | 0, str_ind$0 = str_ind$7;
+     }
+     /*<<camlinternalFormat.ml:2889:55>>*/ }
+    function incompatible_flag(pct_ind, str_ind, symb, option){
+      /*<<camlinternalFormat.ml:2963:6>>*/  /*<<camlinternalFormat.ml:2963:19>>*/ var
+      subfmt =
+         /*<<camlinternalFormat.ml:2963:19>>*/ caml_call3
+         (Stdlib_String[15], str, pct_ind, str_ind - pct_ind | 0);
+      /*<<camlinternalFormat.ml:2964:6>>*/ return  /*<<camlinternalFormat.ml:2964:6>>*/ caml_call5
+             (failwith_message(_Y_), str, pct_ind, option, symb, subfmt);
+     /*<<camlinternalFormat.ml:2967:38>>*/ }
+    function compute_int_conv(pct_ind, str_ind, plus, hash, space, symb){
+      /*<<camlinternalFormat.ml:2903:4>>*/ var
+      plus$0 = plus,
+      hash$0 = hash,
+      space$0 = space;
+      /*<<camlinternalFormat.ml:2903:4>>*/ for(;;){
+      a:
+      {
+       if(plus$0){
+        if(! hash$0){
+         if(space$0) break a;
+         if(100 === symb)  /*<<camlinternalFormat.ml:2906:34>>*/ return 1;
+         if(105 === symb)  /*<<camlinternalFormat.ml:2906:71>>*/ return 4;
+         break a;
+        }
+       }
+       else{
+        if(! hash$0){
+         if(space$0){
+          if(100 === symb)  /*<<camlinternalFormat.ml:2905:34>>*/ return 2;
+          if(105 === symb)  /*<<camlinternalFormat.ml:2905:71>>*/ return 5;
+          break a;
+         }
+         var switcher$1 = symb - 88 | 0;
+         if(32 < switcher$1 >>> 0) break a;
+         switch(switcher$1){
+           case 0:
+             /*<<camlinternalFormat.ml:2907:71>>*/ return 8;
+           case 12:
+             /*<<camlinternalFormat.ml:2904:34>>*/ return 0;
+           case 17:
+             /*<<camlinternalFormat.ml:2904:71>>*/ return 3;
+           case 23:
+             /*<<camlinternalFormat.ml:2909:34>>*/ return 10;
+           case 29:
+             /*<<camlinternalFormat.ml:2911:34>>*/ return 12;
+           case 32:
+             /*<<camlinternalFormat.ml:2907:34>>*/ return 6;
+           default: break a;
+         }
+        }
+        if(! space$0){
+         var switcher$0 = symb - 88 | 0;
+         if(32 >= switcher$0 >>> 0)
+          switch(switcher$0){
+            case 0:
+              /*<<camlinternalFormat.ml:2908:71>>*/ return 9;
+            case 12:
+              /*<<camlinternalFormat.ml:2912:34>>*/ return 13;
+            case 17:
+              /*<<camlinternalFormat.ml:2913:34>>*/ return 14;
+            case 23:
+              /*<<camlinternalFormat.ml:2910:34>>*/ return 11;
+            case 29:
+              /*<<camlinternalFormat.ml:2914:34>>*/ return 15;
+            case 32:
+              /*<<camlinternalFormat.ml:2908:34>>*/ return 7;
+          }
+        }
+       }
+       var switcher = symb - 88 | 0;
+       if(32 >= switcher >>> 0)
+        switch(switcher){
+          case 0:
+           if(legacy_behavior$0)
+             /*<<camlinternalFormat.ml:2916:46>>*/ return 9;
+           break;
+          case 23:
+           if(legacy_behavior$0)
+             /*<<camlinternalFormat.ml:2917:46>>*/ return 11;
+           break;
+          case 32:
+           if(legacy_behavior$0)
+             /*<<camlinternalFormat.ml:2915:46>>*/ return 7;
+           break;
+          case 12:
+          case 17:
+          case 29:
+           if(! legacy_behavior$0)
+             /*<<camlinternalFormat.ml:2921:11>>*/ return incompatible_flag
+                    (pct_ind, str_ind, symb, cst$35);
+           var hash$0 = 0;
+           continue;
+        }
+      }
+      if(plus$0)
+       if(space$0){
+        if(! legacy_behavior$0)
+          /*<<camlinternalFormat.ml:2926:11>>*/ return incompatible_flag
+                 (pct_ind, str_ind, 32, cst$32);
+        var space$0 = 0;
+       }
+       else{
+        if(! legacy_behavior$0)
+          /*<<camlinternalFormat.ml:2934:11>>*/ return incompatible_flag
+                 (pct_ind, str_ind, symb, cst$33);
+        var plus$0 = 0;
+       }
+      else{
+       if(! space$0)
+         /*<<camlinternalFormat.ml:2935:28>>*/ throw  /*<<camlinternalFormat.ml:2935:28>>*/ caml_maybe_attach_backtrace
+               ([0, Assert_failure, _W_], 1);
+       if(! legacy_behavior$0)
+         /*<<camlinternalFormat.ml:2930:11>>*/ return incompatible_flag
+                (pct_ind, str_ind, symb, cst$34);
+       var space$0 = 0;
+      }
+     }
+     /*<<camlinternalFormat.ml:2935:40>>*/ }
+    return parse(0, caml_ml_string_length(str));
+   }
+   function format_of_string_fmtty(str, fmtty){
+     /*<<camlinternalFormat.ml:2977:2>>*/ var
+     fmt = fmt_ebb_of_string(0, str)[1];
+     /*<<camlinternalFormat.ml:2978:2>>*/ try{
+      /*<<camlinternalFormat.ml:2978:6>>*/  /*<<camlinternalFormat.ml:2978:6>>*/ var
+      _ae_ = [0, type_format(fmt, fmtty), str];
+      /*<<camlinternalFormat.ml:2978:6>>*/ return _ae_;
+    }
+    catch(_af_){
+     var _ac_ = caml_wrap_exception(_af_);
+     if(_ac_ !== Type_mismatch) throw caml_maybe_attach_backtrace(_ac_, 0);
+      /*<<camlinternalFormat.ml:2982:10>>*/  /*<<camlinternalFormat.ml:2982:10>>*/ var
+      _ad_ = string_of_fmtty(fmtty);
+      /*<<camlinternalFormat.ml:2982:10>>*/ return  /*<<camlinternalFormat.ml:2982:10>>*/ caml_call2
+             (failwith_message(_Z_), str, _ad_);
+    }
+    /*<<camlinternalFormat.ml:2982:33>>*/ }
+   function format_of_string_format(str, param){
+    var
+     str$0 = param[2],
+     fmt = param[1],
+     fmt$0 = fmt_ebb_of_string(0, str)[1];
+     /*<<camlinternalFormat.ml:2988:2>>*/ try{
+      /*<<camlinternalFormat.ml:2988:6>>*/  /*<<camlinternalFormat.ml:2988:6>>*/ var
+      _aa_ = [0, type_format(fmt$0, fmtty_of_fmt(fmt)), str];
+      /*<<camlinternalFormat.ml:2988:6>>*/ return _aa_;
+    }
+    catch(_ab_){
+     var _$_ = caml_wrap_exception(_ab_);
+     if(_$_ === Type_mismatch)
+       /*<<camlinternalFormat.ml:2990:4>>*/ return  /*<<camlinternalFormat.ml:2990:4>>*/ caml_call2
+              (failwith_message(___), str, str$0);
+     throw caml_maybe_attach_backtrace(_$_, 0);
+    }
+   }
+   var
+    CamlinternalFormat =
+      [0,
+       is_in_char_set,
+       rev_char_set,
+       create_char_set,
+       add_in_char_set,
+       freeze_char_set,
+       param_format_of_ignored_format,
+       make_printf,
+       make_iprintf,
+       output_acc,
+       bufput_acc,
+       strput_acc,
+       type_format,
+       fmt_ebb_of_string,
+       format_of_string_fmtty,
+       format_of_string_format,
+       char_of_iconv,
+       string_of_formatting_lit,
+       string_of_fmtty,
+       string_of_fmt,
+       open_box_of_string,
+       symm,
+       trans,
+       recast];
+   runtime.caml_register_global(197, CamlinternalFormat, "CamlinternalFormat");
+   return;
+   /*<<?>>*/ }
+  (globalThis));
+
+//# unitInfo: Provides: Stdlib__Printf
+//# unitInfo: Requires: CamlinternalFormat, Stdlib, Stdlib__Buffer
+(function
+  (globalThis){
+   "use strict";
+   var runtime = globalThis.jsoo_runtime;
+    /*<<?>>*/ function caml_call1(f, a0){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 1
+            ? f(a0)
+            : runtime.caml_call_gen(f, [a0]);
+   }
+    /*<<?>>*/ function caml_call2(f, a0, a1){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 2
+            ? f(a0, a1)
+            : runtime.caml_call_gen(f, [a0, a1]);
+   }
+    /*<<?>>*/ function caml_call3(f, a0, a1, a2){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 3
+            ? f(a0, a1, a2)
+            : runtime.caml_call_gen(f, [a0, a1, a2]);
+   }
+   var
+    global_data = runtime.caml_get_global_data(),
+    Stdlib_Buffer = global_data.Stdlib__Buffer,
+    CamlinternalFormat = global_data.CamlinternalFormat,
+    Stdlib = global_data.Stdlib;
+   function kfprintf(k, o, param){
+     /*<<printf.ml:20:2>>*/ var
+     fmt = param[1],
+      /*<<printf.ml:20:2>>*/ _g_ = 0;
+    function _h_(acc){
+      /*<<printf.ml:20:26>>*/  /*<<printf.ml:20:26>>*/ caml_call2
+      (CamlinternalFormat[9], o, acc);
+     return caml_call1(k, o);
+     /*<<printf.ml:20:47>>*/ }
+     /*<<printf.ml:20:2>>*/ return  /*<<printf.ml:20:2>>*/ caml_call3
+            (CamlinternalFormat[7], _h_, _g_, fmt);
+   }
+   function kbprintf(k, b, param){
+     /*<<printf.ml:22:2>>*/ var
+     fmt = param[1],
+      /*<<printf.ml:22:2>>*/ _e_ = 0;
+    function _f_(acc){
+      /*<<printf.ml:22:26>>*/  /*<<printf.ml:22:26>>*/ caml_call2
+      (CamlinternalFormat[10], b, acc);
+     return caml_call1(k, b);
+     /*<<printf.ml:22:47>>*/ }
+     /*<<printf.ml:22:2>>*/ return  /*<<printf.ml:22:2>>*/ caml_call3
+            (CamlinternalFormat[7], _f_, _e_, fmt);
+   }
+   function ikfprintf(k, oc, param){
+    var fmt = param[1];
+     /*<<printf.ml:24:2>>*/ return  /*<<printf.ml:24:2>>*/ caml_call3
+            (CamlinternalFormat[8], k, oc, fmt);
+   }
+   function fprintf(oc, fmt){
+     /*<<printf.ml:27:21>>*/ return kfprintf
+            (function(_d_){ /*<<?>>*/ return 0;}, oc, fmt);
+    /*<<printf.ml:27:43>>*/ }
+   function bprintf(b, fmt){
+     /*<<printf.ml:28:20>>*/ return kbprintf
+            (function(_c_){ /*<<?>>*/ return 0;}, b, fmt);
+    /*<<printf.ml:28:41>>*/ }
+   function ifprintf(oc, fmt){
+     /*<<printf.ml:29:22>>*/ return ikfprintf
+            (function(_b_){ /*<<?>>*/ return 0;}, oc, fmt);
+    /*<<printf.ml:29:45>>*/ }
+   function ibprintf(b, fmt){
+     /*<<printf.ml:30:21>>*/ return ikfprintf
+            (function(_a_){ /*<<?>>*/ return 0;}, b, fmt);
+    /*<<printf.ml:30:43>>*/ }
+   function printf(fmt){
+     /*<<printf.ml:31:17>>*/ return fprintf(Stdlib[39], fmt);
+    /*<<printf.ml:31:35>>*/ }
+   function eprintf(fmt){
+     /*<<printf.ml:32:18>>*/ return fprintf(Stdlib[40], fmt);
+    /*<<printf.ml:32:36>>*/ }
+   function ksprintf(k, param){
+    var fmt = param[1];
+     /*<<printf.ml:35:2>>*/ function k$0(acc){
+      /*<<printf.ml:36:4>>*/  /*<<printf.ml:36:14>>*/ var
+      buf =  /*<<printf.ml:36:14>>*/ caml_call1(Stdlib_Buffer[1], 64);
+      /*<<printf.ml:37:4>>*/  /*<<printf.ml:37:4>>*/ caml_call2
+      (CamlinternalFormat[11], buf, acc);
+      /*<<printf.ml:38:6>>*/ return  /*<<printf.ml:38:6>>*/ caml_call1
+             (k,  /*<<printf.ml:38:6>>*/ caml_call1(Stdlib_Buffer[2], buf));
+     /*<<printf.ml:38:27>>*/ }
+     /*<<printf.ml:39:2>>*/ return  /*<<printf.ml:39:2>>*/ caml_call3
+            (CamlinternalFormat[7], k$0, 0, fmt);
+   }
+   function sprintf(fmt){
+     /*<<printf.ml:41:18>>*/ return ksprintf
+            (function(s){
+               /*<<printf.ml:41:37>>*/ return s;
+              /*<<printf.ml:41:38>>*/ },
+             fmt);
+    /*<<printf.ml:41:43>>*/ }
+   var
+    Stdlib_Printf =
+      [0,
+       fprintf,
+       printf,
+       eprintf,
+       sprintf,
+       bprintf,
+       ifprintf,
+       ibprintf,
+       kfprintf,
+       ikfprintf,
+       ksprintf,
+       kbprintf,
+       ikfprintf,
+       ksprintf];
+   runtime.caml_register_global(3, Stdlib_Printf, "Stdlib__Printf");
+   return;
+   /*<<?>>*/ }
+  (globalThis));
+
+//# unitInfo: Provides: Stdlib__Arg
+//# unitInfo: Requires: Stdlib, Stdlib__Array, Stdlib__Buffer, Stdlib__Int, Stdlib__List, Stdlib__Printf, Stdlib__String, Stdlib__Sys
+(function
+  (globalThis){
+   "use strict";
+   var
+    runtime = globalThis.jsoo_runtime,
+    cst$7 = "",
+    cst$9 = "  ",
+    cst_Display_this_list_of_optio$1 = " Display this list of options",
+    cst_s = "%s",
+    cst_help$4 = "--help",
+    cst_help$3 = "-help",
+    cst$8 = ".\n",
+    cst_a_float$1 = "a float",
+    cst_an_integer$1 = "an integer",
+    caml_check_bound = runtime.caml_check_bound,
+    caml_equal = runtime.caml_equal,
+    caml_fresh_oo_id = runtime.caml_fresh_oo_id,
+    caml_maybe_attach_backtrace = runtime.caml_maybe_attach_backtrace,
+    caml_ml_string_length = runtime.caml_ml_string_length,
+    caml_string_get = runtime.caml_string_get,
+    caml_string_notequal = runtime.caml_string_notequal,
+    caml_sys_argv = runtime.caml_sys_argv,
+    caml_wrap_exception = runtime.caml_wrap_exception;
+    /*<<?>>*/ function caml_call1(f, a0){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 1
+            ? f(a0)
+            : runtime.caml_call_gen(f, [a0]);
+   }
+    /*<<?>>*/ function caml_call2(f, a0, a1){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 2
+            ? f(a0, a1)
+            : runtime.caml_call_gen(f, [a0, a1]);
+   }
+    /*<<?>>*/ function caml_call3(f, a0, a1, a2){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 3
+            ? f(a0, a1, a2)
+            : runtime.caml_call_gen(f, [a0, a1, a2]);
+   }
+    /*<<?>>*/ function caml_call4(f, a0, a1, a2, a3){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 4
+            ? f(a0, a1, a2, a3)
+            : runtime.caml_call_gen(f, [a0, a1, a2, a3]);
+   }
+    /*<<?>>*/ function caml_call5(f, a0, a1, a2, a3, a4){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 5
+            ? f(a0, a1, a2, a3, a4)
+            : runtime.caml_call_gen(f, [a0, a1, a2, a3, a4]);
+   }
+    /*<<?>>*/ function caml_call6(f, a0, a1, a2, a3, a4, a5){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 6
+            ? f(a0, a1, a2, a3, a4, a5)
+            : runtime.caml_call_gen(f, [a0, a1, a2, a3, a4, a5]);
+   }
+    /*<<arg.ml:50:0>>*/ var
+    global_data = runtime.caml_get_global_data(),
+    cst$6 = "\n",
+    cst$3 = cst$7,
+    cst$4 = " ",
+    cst$5 = cst$7,
+    cst$2 = "(?)",
+    cst = "}",
+    cst$0 = "|",
+    cst$1 = "{",
+    Stdlib = global_data.Stdlib,
+    Stdlib_Printf = global_data.Stdlib__Printf,
+    Stdlib_Array = global_data.Stdlib__Array,
+    Stdlib_Buffer = global_data.Stdlib__Buffer,
+    Stdlib_List = global_data.Stdlib__List,
+    Stdlib_String = global_data.Stdlib__String,
+    Stdlib_Int = global_data.Stdlib__Int,
+     /*<<arg.ml:50:0>>*/ Bad = [248, "Stdlib.Arg.Bad", caml_fresh_oo_id(0)],
+     /*<<arg.ml:51:0>>*/ Help = [248, "Stdlib.Arg.Help", caml_fresh_oo_id(0)],
+     /*<<arg.ml:59:0>>*/ Stop = [248, "Stdlib.Arg.Stop", caml_fresh_oo_id(0)],
+    _v_ = [0, [2, 0, [0, 0]], "%s%c"],
+    _p_ = [0, [2, 0, 0], cst_s],
+    _q_ = [0, [2, 0, 0], cst_s],
+    _n_ = [0, [2, 0, 0], cst_s],
+    _o_ = [0, [2, 0, 0], cst_s],
+    _l_ = [0, [2, 0, 0], cst_s],
+    _m_ = [0, [2, 0, 0], cst_s],
+    cst_a_boolean = "a boolean",
+    cst_an_integer = cst_an_integer$1,
+    cst_an_integer$0 = cst_an_integer$1,
+    cst_a_float = cst_a_float$1,
+    cst_a_float$0 = cst_a_float$1,
+    cst_one_of = "one of: ",
+    cst_Arg_Expand_is_is_only_allo =
+      "Arg.Expand is is only allowed with Arg.parse_and_expand_argv_dynamic",
+    cst_no_argument = "no argument",
+    _f_ =
+      [0,
+       [2, 0, [11, ": unknown option '", [2, 0, [11, "'.\n", 0]]]],
+       "%s: unknown option '%s'.\n"],
+    _i_ =
+      [0,
+       [2,
+        0,
+        [11,
+         ": wrong argument '",
+         [2,
+          0,
+          [11,
+           "'; option '",
+           [2, 0, [11, "' expects ", [2, 0, [11, cst$8, 0]]]]]]]],
+       "%s: wrong argument '%s'; option '%s' expects %s.\n"],
+    _j_ =
+      [0,
+       [2, 0, [11, ": option '", [2, 0, [11, "' needs an argument.\n", 0]]]],
+       "%s: option '%s' needs an argument.\n"],
+    _k_ = [0, [2, 0, [11, ": ", [2, 0, [11, cst$8, 0]]]], "%s: %s.\n"],
+    _g_ = [0, cst_help$3],
+    _h_ = [0, cst_help$4],
+    _e_ = [0, [2, 0, 0], cst_s],
+    _d_ = [0, [2, 0, [12, 10, 0]], "%s\n"],
+    cst_help$2 = cst_help$3,
+    cst_Display_this_list_of_optio = cst_Display_this_list_of_optio$1,
+    cst_help = cst_help$3,
+    cst_help$1 = cst_help$4,
+    cst_Display_this_list_of_optio$0 = cst_Display_this_list_of_optio$1,
+    cst_help$0 = cst_help$4,
+    _c_ = [0, cst_help$3],
+    _a_ = [0, [11, cst$9, [2, 0, [12, 32, [2, 0, [12, 10, 0]]]]], "  %s %s\n"],
+    _b_ =
+      [0,
+       [11, cst$9, [2, 0, [12, 32, [2, 0, [2, 0, [12, 10, 0]]]]]],
+       "  %s %s%s\n"],
+    cst_none = "<none>";
+   function assoc3(x, l){
+     /*<<arg.ml:64:2>>*/ var l$0 = l;
+     /*<<arg.ml:64:2>>*/ for(;;){
+     if(! l$0)
+       /*<<arg.ml:65:10>>*/ throw  /*<<arg.ml:65:10>>*/ caml_maybe_attach_backtrace
+             (Stdlib[8], 1);
+     var match = l$0[1], y2 = match[2], y1 = match[1];
+      /*<<arg.ml:66:26>>*/ if( /*<<arg.ml:66:26>>*/ caml_equal(y1, x))
+       /*<<arg.ml:66:36>>*/ return y2;
+     var t = l$0[2], l$0 = t;
+    }
+    /*<<arg.ml:67:24>>*/ }
+   function make_symlist(prefix, sep, suffix, l){
+     /*<<arg.ml:77:2>>*/ if(! l)  /*<<arg.ml:78:10>>*/ return cst_none;
+     /*<<arg.ml:79:53>>*/ var
+     t = l[2],
+     h = l[1],
+      /*<<arg.ml:79:53>>*/ _aD_ =
+        /*<<arg.ml:79:53>>*/ caml_call2(Stdlib[28], prefix, h);
+    function _aE_(x, y){
+      /*<<arg.ml:79:40>>*/  /*<<arg.ml:79:44>>*/ var
+      _aG_ =  /*<<arg.ml:79:44>>*/ caml_call2(Stdlib[28], sep, y);
+      /*<<arg.ml:79:44>>*/ return  /*<<arg.ml:79:44>>*/ caml_call2
+             (Stdlib[28], x, _aG_);
+     /*<<arg.ml:79:51>>*/ }
+     /*<<arg.ml:79:12>>*/  /*<<arg.ml:79:12>>*/ var
+     _aF_ =  /*<<arg.ml:79:12>>*/ caml_call3(Stdlib_List[25], _aE_, _aD_, t);
+     /*<<arg.ml:79:12>>*/ return  /*<<arg.ml:79:12>>*/ caml_call2
+            (Stdlib[28], _aF_, suffix);
+    /*<<arg.ml:79:77>>*/ }
+   function help_action(param){
+     /*<<arg.ml:91:21>>*/ throw  /*<<arg.ml:91:21>>*/ caml_maybe_attach_backtrace
+           ([0, Stop, _c_], 1);
+    /*<<arg.ml:91:51>>*/ }
+   function add_help(speclist){
+     /*<<arg.ml:94:2>>*/ try{
+      /*<<arg.ml:95:15>>*/ assoc3(cst_help$2, speclist);
+      /*<<arg.ml:95:42>>*/ var  /*<<arg.ml:95:42>>*/ _aA_ = 0, add1 = _aA_;
+    }
+    catch(_aC_){
+     var _aw_ = caml_wrap_exception(_aC_);
+     if(_aw_ !== Stdlib[8]) throw caml_maybe_attach_backtrace(_aw_, 0);
+     var
+      add1 =
+        [0,
+         [0, cst_help, [0, help_action], cst_Display_this_list_of_optio],
+         0];
+    }
+    try{
+      /*<<arg.ml:99:15>>*/ assoc3(cst_help$1, speclist);
+      /*<<arg.ml:99:43>>*/ var  /*<<arg.ml:99:43>>*/ _az_ = 0, add2 = _az_;
+    }
+    catch(_aB_){
+     var _ax_ = caml_wrap_exception(_aB_);
+     if(_ax_ !== Stdlib[8]) throw caml_maybe_attach_backtrace(_ax_, 0);
+     var
+      add2 =
+        [0,
+         [0, cst_help$0, [0, help_action], cst_Display_this_list_of_optio$0],
+         0];
+    }
+     /*<<arg.ml:103:13>>*/  /*<<arg.ml:103:13>>*/ var
+     _ay_ =  /*<<arg.ml:103:13>>*/ caml_call2(Stdlib[37], add1, add2);
+     /*<<arg.ml:103:13>>*/ return  /*<<arg.ml:103:13>>*/ caml_call2
+            (Stdlib[37], speclist, _ay_);
+    /*<<arg.ml:103:26>>*/ }
+   function usage_b(buf, speclist, errmsg){
+     /*<<arg.ml:107:2>>*/  /*<<arg.ml:107:2>>*/ caml_call3
+     (Stdlib_Printf[5], buf, _d_, errmsg);
+     /*<<arg.ml:108:29>>*/  /*<<arg.ml:108:29>>*/ var
+     _as_ = add_help(speclist);
+     /*<<arg.ml:108:12>>*/ function _at_(param){
+     var
+      doc = param[3],
+      spec = param[2],
+      key = param[1],
+      _au_ = 0 <  /*<<arg.ml:83:2>>*/ caml_ml_string_length(doc) ? 1 : 0;
+     if(! _au_) return _au_;
+     if(11 !== spec[0])
+       /*<<arg.ml:88:8>>*/ return  /*<<arg.ml:88:8>>*/ caml_call4
+              (Stdlib_Printf[5], buf, _a_, key, doc);
+      /*<<arg.ml:86:38>>*/ var
+      l = spec[1],
+       /*<<arg.ml:86:38>>*/ _av_ = make_symlist(cst$1, cst$0, cst, l);
+      /*<<arg.ml:86:8>>*/ return  /*<<arg.ml:86:8>>*/ caml_call5
+             (Stdlib_Printf[5], buf, _b_, key, _av_, doc);
+    }
+     /*<<arg.ml:108:29>>*/ return  /*<<arg.ml:108:29>>*/ caml_call2
+            (Stdlib_List[17], _at_, _as_);
+    /*<<arg.ml:108:48>>*/ }
+   function usage_string(speclist, errmsg){
+     /*<<arg.ml:112:2>>*/  /*<<arg.ml:112:10>>*/ var
+     b =  /*<<arg.ml:112:10>>*/ caml_call1(Stdlib_Buffer[1], 200);
+     /*<<arg.ml:113:2>>*/ usage_b(b, speclist, errmsg);
+     /*<<arg.ml:113:2>>*/ return  /*<<arg.ml:113:2>>*/ caml_call1
+            (Stdlib_Buffer[2], b);
+    /*<<arg.ml:114:19>>*/ }
+   function usage(speclist, errmsg){
+     /*<<arg.ml:118:2>>*/  /*<<arg.ml:118:15>>*/ var
+     _ar_ = usage_string(speclist, errmsg);
+     /*<<arg.ml:118:15>>*/ return  /*<<arg.ml:118:15>>*/ caml_call2
+            (Stdlib_Printf[3], _e_, _ar_);
+    /*<<arg.ml:118:45>>*/ }
+    /*<<arg.ml:121:14>>*/  /*<<arg.ml:121:14>>*/ var current = [0, 0];
+   function int_of_string_opt(x){
+     /*<<arg.ml:128:2>>*/ try{
+      /*<<arg.ml:128:6>>*/  /*<<arg.ml:128:6>>*/ var
+      _ap_ = [0,  /*<<arg.ml:128:11>>*/ runtime.caml_int_of_string(x)];
+      /*<<arg.ml:128:6>>*/ return _ap_;
+    }
+    catch(_aq_){
+     var _ao_ = caml_wrap_exception(_aq_);
+     if(_ao_[1] === Stdlib[7])  /*<<arg.ml:129:20>>*/ return 0;
+     throw caml_maybe_attach_backtrace(_ao_, 0);
+    }
+    /*<<arg.ml:129:24>>*/ }
+   function float_of_string_opt(x){
+     /*<<arg.ml:132:2>>*/ try{
+      /*<<arg.ml:132:6>>*/  /*<<arg.ml:132:6>>*/ var
+      _am_ = [0,  /*<<arg.ml:132:11>>*/ runtime.caml_float_of_string(x)];
+      /*<<arg.ml:132:6>>*/ return _am_;
+    }
+    catch(_an_){
+     var _al_ = caml_wrap_exception(_an_);
+     if(_al_[1] === Stdlib[7])  /*<<arg.ml:133:20>>*/ return 0;
+     throw caml_maybe_attach_backtrace(_al_, 0);
+    }
+    /*<<arg.ml:133:24>>*/ }
+   function parse_and_expand_argv_dynamic_
+   (allow_expand, current, argv, speclist, anonfun, errmsg){
+    var initpos = current[1];
+    function convert_error(error){
+      /*<<arg.ml:143:4>>*/ var
+       /*<<arg.ml:143:12>>*/ b =
+         /*<<arg.ml:143:12>>*/ caml_call1(Stdlib_Buffer[1], 200),
+      progname =
+        initpos < argv[1].length - 1
+         ? caml_check_bound(argv[1], initpos)[1 + initpos]
+         : cst$2;
+      /*<<arg.ml:146:4>>*/ switch(error[0]){
+       case 0:
+        var s = error[1];
+        if
+         (caml_string_notequal(s, cst_help$4)
+          && caml_string_notequal(s, cst_help$3))
+          /*<<arg.ml:150:10>>*/  /*<<arg.ml:150:10>>*/ caml_call4
+          (Stdlib_Printf[5], b, _f_, progname, s);
+        break;
+       case 1:
+        var expected = error[3], arg = error[2], opt = error[1];
+         /*<<arg.ml:154:10>>*/  /*<<arg.ml:154:10>>*/ caml_call6
+         (Stdlib_Printf[5], b, _i_, progname, arg, opt, expected);
+        break;
+       case 2:
+        var s$0 = error[1];
+         /*<<arg.ml:152:10>>*/  /*<<arg.ml:152:10>>*/ caml_call4
+         (Stdlib_Printf[5], b, _j_, progname, s$0);
+        break;
+       default:
+        var s$1 = error[1];
+         /*<<arg.ml:157:10>>*/  /*<<arg.ml:157:10>>*/ caml_call4
+         (Stdlib_Printf[5], b, _k_, progname, s$1);
+     }
+      /*<<arg.ml:159:4>>*/ usage_b(b, speclist[1], errmsg);
+      /*<<arg.ml:160:34>>*/ if
+      (!
+        /*<<arg.ml:160:7>>*/ caml_equal(error, _g_)
+       && !  /*<<arg.ml:160:34>>*/ caml_equal(error, _h_))
+       /*<<arg.ml:162:9>>*/ return [0,
+              Bad,
+               /*<<arg.ml:162:13>>*/ caml_call1(Stdlib_Buffer[2], b)];
+      /*<<arg.ml:161:9>>*/ return [0,
+             Help,
+              /*<<arg.ml:161:14>>*/ caml_call1(Stdlib_Buffer[2], b)];
+     /*<<arg.ml:162:32>>*/ }
+     /*<<arg.ml:164:2>>*/ current[1]++;
+    for(;;){
+     if(current[1] >= argv[1].length - 1) return 0;
+      /*<<arg.ml:166:4>>*/ try{
+       /*<<arg.ml:167:14>>*/ var
+       _Y_ = current[1],
+        /*<<arg.ml:167:14>>*/ s = caml_check_bound(argv[1], _Y_)[1 + _Y_];
+      a:
+      {
+        /*<<arg.ml:168:33>>*/ if
+        (1 <=  /*<<arg.ml:168:6>>*/ caml_ml_string_length(s)
+         && 45 ===  /*<<arg.ml:168:33>>*/ caml_string_get(s, 0)){
+        try{
+          /*<<arg.ml:170:14>>*/ var
+          follow$1 = 0,
+           /*<<arg.ml:170:14>>*/ _aa_ = assoc3(s, speclist[1]),
+          follow$0 = follow$1,
+          action = _aa_;
+        }
+        catch(_aj_){
+         var _Z_ = caml_wrap_exception(_aj_);
+         if(_Z_ !== Stdlib[8]) throw caml_maybe_attach_backtrace(_Z_, 0);
+          /*<<arg.ml:172:10>>*/ try{
+           /*<<arg.ml:71:10>>*/ var
+            /*<<arg.ml:71:10>>*/ i =
+              /*<<arg.ml:71:10>>*/ caml_call2(Stdlib_String[35], s, 61),
+            /*<<arg.ml:72:2>>*/ len =
+              /*<<arg.ml:72:2>>*/ caml_ml_string_length(s),
+            /*<<arg.ml:73:20>>*/ arg =
+              /*<<arg.ml:73:20>>*/ caml_call3
+              (Stdlib_String[15], s, i + 1 | 0, len - (i + 1 | 0) | 0),
+            /*<<arg.ml:73:2>>*/ keyword =
+              /*<<arg.ml:73:2>>*/ caml_call3(Stdlib_String[15], s, 0, i),
+            /*<<arg.ml:174:38>>*/ follow = [0, arg],
+            /*<<arg.ml:174:12>>*/ _$_ = assoc3(keyword, speclist[1]),
+           follow$0 = follow,
+           action = _$_;
+         }
+         catch(_ak_){
+          var ___ = caml_wrap_exception(_ak_);
+          if(___ === Stdlib[8])
+            /*<<arg.ml:175:28>>*/ throw  /*<<arg.ml:175:28>>*/ caml_maybe_attach_backtrace
+                  ([0, Stop, [0, s]], 1);
+          throw caml_maybe_attach_backtrace(___, 0);
+         }
+        }
+        var
+         no_arg$0 =
+           function(s, follow){
+            function no_arg(param){
+              /*<<arg.ml:178:10>>*/ if(! follow)
+               /*<<arg.ml:179:20>>*/ return 0;
+             var arg = follow[1];
+              /*<<arg.ml:180:24>>*/ throw  /*<<arg.ml:180:24>>*/ caml_maybe_attach_backtrace
+                    ([0, Stop, [1, s, arg, cst_no_argument]], 1);
+             /*<<arg.ml:180:68>>*/ }
+            return no_arg;
+           },
+         no_arg = no_arg$0(s, follow$0),
+         get_arg$0 =
+           function(s, follow){
+            function get_arg(param){
+              /*<<arg.ml:182:10>>*/ if(follow){
+              var arg = follow[1];
+               /*<<arg.ml:186:24>>*/ return arg;
+             }
+             if((current[1] + 1 | 0) >= argv[1].length - 1)
+               /*<<arg.ml:185:19>>*/ throw  /*<<arg.ml:185:19>>*/ caml_maybe_attach_backtrace
+                     ([0, Stop, [2, s]], 1);
+             var _ai_ = current[1] + 1 | 0;
+              /*<<arg.ml:184:58>>*/ return caml_check_bound(argv[1], _ai_)
+                     [1 + _ai_];
+             /*<<arg.ml:186:27>>*/ }
+            return get_arg;
+           },
+         get_arg = get_arg$0(s, follow$0),
+         consume_arg$0 =
+           function(follow){
+            function consume_arg(param){
+              /*<<arg.ml:189:10>>*/ return follow ? 0 : (current[1]++, 0);
+             /*<<arg.ml:191:24>>*/ }
+            return consume_arg;
+           },
+         consume_arg = consume_arg$0(follow$0),
+         treat_action$0 =
+           function(s, no_arg, get_arg, consume_arg){
+            function treat_action(param){
+              /*<<arg.ml:193:31>>*/ switch(param[0]){
+               case 0:
+                var f = param[1];
+                 /*<<arg.ml:194:20>>*/ no_arg(0);
+                 /*<<arg.ml:194:20>>*/ return  /*<<arg.ml:194:20>>*/ caml_call1
+                        (f, 0);
+               case 1:
+                 /*<<arg.ml:196:22>>*/ var
+                 f$0 = param[1],
+                  /*<<arg.ml:196:22>>*/ arg = get_arg(0);
+                 /*<<arg.ml:124:2>>*/ try{
+                  /*<<arg.ml:124:6>>*/ var
+                   /*<<arg.ml:124:6>>*/ _ac_ =
+                    [0,  /*<<arg.ml:124:11>>*/ caml_call1(Stdlib[32], arg)],
+                  match = _ac_;
+                }
+                catch(_ah_){
+                 var _ab_ = caml_wrap_exception(_ah_);
+                 if(_ab_[1] !== Stdlib[6])
+                  throw caml_maybe_attach_backtrace(_ab_, 0);
+                 var match = 0;
+                }
+                if(! match)
+                  /*<<arg.ml:198:22>>*/ throw  /*<<arg.ml:198:22>>*/ caml_maybe_attach_backtrace
+                        ([0, Stop, [1, s, arg, cst_a_boolean]], 1);
+                var s$0 = match[1];
+                 /*<<arg.ml:199:24>>*/  /*<<arg.ml:199:24>>*/ caml_call1
+                 (f$0, s$0);
+                 /*<<arg.ml:201:12>>*/ return consume_arg(0);
+               case 2:
+                var r = param[1];
+                 /*<<arg.ml:202:19>>*/ no_arg(0);
+                r[1] = 1;
+                return 0;
+               case 3:
+                var r$0 = param[1];
+                 /*<<arg.ml:203:21>>*/ no_arg(0);
+                r$0[1] = 0;
+                return 0;
+               case 4:
+                 /*<<arg.ml:205:22>>*/ var
+                 f$1 = param[1],
+                  /*<<arg.ml:205:22>>*/ arg$0 = get_arg(0);
+                 /*<<arg.ml:206:12>>*/  /*<<arg.ml:206:12>>*/ caml_call1
+                 (f$1, arg$0);
+                 /*<<arg.ml:206:12>>*/ return consume_arg(0);
+               case 5:
+                var r$1 = param[1];
+                r$1[1] = get_arg(0);
+                 /*<<arg.ml:219:12>>*/ return consume_arg(0);
+               case 6:
+                 /*<<arg.ml:221:22>>*/ var
+                 f$2 = param[1],
+                  /*<<arg.ml:221:22>>*/ arg$1 = get_arg(0),
+                  /*<<arg.ml:222:24>>*/ match$0 = int_of_string_opt(arg$1);
+                if(! match$0)
+                  /*<<arg.ml:223:22>>*/ throw  /*<<arg.ml:223:22>>*/ caml_maybe_attach_backtrace
+                        ([0, Stop, [1, s, arg$1, cst_an_integer]], 1);
+                var x = match$0[1];
+                 /*<<arg.ml:224:24>>*/  /*<<arg.ml:224:24>>*/ caml_call1
+                 (f$2, x);
+                 /*<<arg.ml:226:12>>*/ return consume_arg(0);
+               case 7:
+                 /*<<arg.ml:228:22>>*/ var
+                 r$2 = param[1],
+                  /*<<arg.ml:228:22>>*/ arg$2 = get_arg(0),
+                  /*<<arg.ml:229:24>>*/ match$1 = int_of_string_opt(arg$2);
+                if(! match$1)
+                  /*<<arg.ml:230:22>>*/ throw  /*<<arg.ml:230:22>>*/ caml_maybe_attach_backtrace
+                        ([0, Stop, [1, s, arg$2, cst_an_integer$0]], 1);
+                var x$0 = match$1[1];
+                r$2[1] = x$0;
+                 /*<<arg.ml:233:12>>*/ return consume_arg(0);
+               case 8:
+                 /*<<arg.ml:235:22>>*/ var
+                 f$3 = param[1],
+                  /*<<arg.ml:235:22>>*/ arg$3 = get_arg(0),
+                  /*<<arg.ml:236:24>>*/ match$2 = float_of_string_opt(arg$3);
+                if(! match$2)
+                  /*<<arg.ml:237:22>>*/ throw  /*<<arg.ml:237:22>>*/ caml_maybe_attach_backtrace
+                        ([0, Stop, [1, s, arg$3, cst_a_float]], 1);
+                var x$1 = match$2[1];
+                 /*<<arg.ml:238:24>>*/  /*<<arg.ml:238:24>>*/ caml_call1
+                 (f$3, x$1);
+                 /*<<arg.ml:240:12>>*/ return consume_arg(0);
+               case 9:
+                 /*<<arg.ml:242:22>>*/ var
+                 r$3 = param[1],
+                  /*<<arg.ml:242:22>>*/ arg$4 = get_arg(0),
+                  /*<<arg.ml:243:24>>*/ match$3 = float_of_string_opt(arg$4);
+                if(! match$3)
+                  /*<<arg.ml:244:22>>*/ throw  /*<<arg.ml:244:22>>*/ caml_maybe_attach_backtrace
+                        ([0, Stop, [1, s, arg$4, cst_a_float$0]], 1);
+                var x$2 = match$3[1];
+                r$3[1] = x$2;
+                 /*<<arg.ml:247:12>>*/ return consume_arg(0);
+               case 10:
+                var specs = param[1];
+                 /*<<arg.ml:249:12>>*/ no_arg(0);
+                 /*<<arg.ml:249:12>>*/ return  /*<<arg.ml:249:12>>*/ caml_call2
+                        (Stdlib_List[17], treat_action, specs);
+               case 11:
+                 /*<<arg.ml:209:22>>*/ var
+                 f$4 = param[2],
+                 symb = param[1],
+                  /*<<arg.ml:209:22>>*/ arg$5 = get_arg(0);
+                 /*<<arg.ml:210:15>>*/ if
+                 ( /*<<arg.ml:210:15>>*/ caml_call2
+                   (Stdlib_List[36], arg$5, symb)){
+                  /*<<arg.ml:211:14>>*/  /*<<arg.ml:211:14>>*/ caml_call1
+                  (f$4, arg$5);
+                  /*<<arg.ml:211:14>>*/ return consume_arg(0);
+                }
+                 /*<<arg.ml:215:44>>*/  /*<<arg.ml:215:44>>*/ var
+                 _ad_ = make_symlist(cst$5, cst$4, cst$3, symb);
+                 /*<<arg.ml:213:21>>*/ throw  /*<<arg.ml:213:21>>*/ caml_maybe_attach_backtrace
+                       ([0,
+                         Stop,
+                         [1,
+                          s,
+                          arg$5,
+                           /*<<arg.ml:214:42>>*/ caml_call2
+                           (Stdlib[28], cst_one_of, _ad_)]],
+                        1);
+               case 12:
+                var f$5 = param[1];
+                 /*<<arg.ml:252:12>>*/ no_arg(0);
+                 /*<<arg.ml:255:14>>*/ for(;;){
+                 if(current[1] >= (argv[1].length - 1 - 1 | 0)) return 0;
+                 var _ae_ = current[1] + 1 | 0;
+                  /*<<arg.ml:254:14>>*/  /*<<arg.ml:254:14>>*/ caml_call1
+                  (f$5, caml_check_bound(argv[1], _ae_)[1 + _ae_]);
+                  /*<<arg.ml:255:14>>*/ consume_arg(0);
+                }
+                break;
+               case 13:
+                var f$6 = param[1];
+                 /*<<arg.ml:258:12>>*/ no_arg(0);
+                 /*<<arg.ml:259:22>>*/  /*<<arg.ml:259:22>>*/ var
+                 acc = [0, 0];
+                 /*<<arg.ml:262:14>>*/ for(;;){
+                 if(current[1] >= (argv[1].length - 1 - 1 | 0))
+                   /*<<arg.ml:264:14>>*/ return  /*<<arg.ml:264:14>>*/ caml_call1
+                          (f$6,
+                            /*<<arg.ml:264:14>>*/ caml_call1(Stdlib_List[9], acc[1]));
+                 var _ag_ = current[1] + 1 | 0, _af_ = acc[1];
+                 acc[1] = [0, caml_check_bound(argv[1], _ag_)[1 + _ag_], _af_];
+                  /*<<arg.ml:262:14>>*/ consume_arg(0);
+                }
+                break;
+               default:
+                var f$7 = param[1];
+                if(1 - allow_expand)
+                  /*<<arg.ml:267:14>>*/ throw  /*<<arg.ml:267:14>>*/ caml_maybe_attach_backtrace
+                        ([0, Stdlib[6], cst_Arg_Expand_is_is_only_allo], 1);
+                 /*<<arg.ml:269:22>>*/ var
+                  /*<<arg.ml:269:22>>*/ arg$6 = get_arg(0),
+                  /*<<arg.ml:270:25>>*/ newarg =
+                    /*<<arg.ml:270:25>>*/ caml_call1(f$7, arg$6);
+                 /*<<arg.ml:271:12>>*/ consume_arg(0);
+                 /*<<arg.ml:272:25>>*/ var
+                  /*<<arg.ml:272:25>>*/ before =
+                    /*<<arg.ml:272:25>>*/ caml_call3
+                    (Stdlib_Array[5], argv[1], 0, current[1] + 1 | 0),
+                  /*<<arg.ml:274:14>>*/ after =
+                    /*<<arg.ml:274:14>>*/ caml_call3
+                    (Stdlib_Array[5],
+                     argv[1],
+                     current[1] + 1 | 0,
+                     (argv[1].length - 1 - current[1] | 0) - 1 | 0);
+                argv[1] =
+                  /*<<arg.ml:276:19>>*/ caml_call1
+                  (Stdlib_Array[4], [0, before, [0, newarg, [0, after, 0]]]);
+                return 0;
+             }
+             /*<<arg.ml:276:54>>*/ }
+            return treat_action;
+           },
+         treat_action = treat_action$0(s, no_arg, get_arg, consume_arg);
+         /*<<arg.ml:278:8>>*/ treat_action(action);
+        break a;
+       }
+        /*<<arg.ml:279:11>>*/  /*<<arg.ml:279:11>>*/ caml_call1(anonfun, s);
+      }
+     }
+     catch(exn$0){
+      var exn = caml_wrap_exception(exn$0);
+      if(exn[1] === Bad){
+       var m = exn[2];
+        /*<<arg.ml:280:26>>*/ throw  /*<<arg.ml:280:26>>*/ caml_maybe_attach_backtrace
+              (convert_error([3, m]), 1);
+      }
+      if(exn[1] !== Stop) throw caml_maybe_attach_backtrace(exn, 0);
+      var e = exn[2];
+       /*<<arg.ml:281:27>>*/ throw  /*<<arg.ml:281:27>>*/ caml_maybe_attach_backtrace
+             (convert_error(e), 1);
+     }
+     current[1]++;
+    }
+   }
+   function parse_and_expand_argv_dynamic
+   (current, argv, speclist, anonfun, errmsg){
+     /*<<arg.ml:287:2>>*/ return parse_and_expand_argv_dynamic_
+            (1, current, argv, speclist, anonfun, errmsg);
+    /*<<arg.ml:287:77>>*/ }
+   function parse_argv_dynamic(opt, argv, speclist, anonfun, errmsg){
+     /*<<arg.ml:290:2>>*/ if(opt)
+     var sth = opt[1], current$0 = sth;
+    else
+     var current$0 = current;
+     /*<<arg.ml:290:2>>*/ return parse_and_expand_argv_dynamic_
+            (0, current$0, [0, argv], speclist, anonfun, errmsg);
+    /*<<arg.ml:291:10>>*/ }
+   function parse_argv(opt, argv, speclist, anonfun, errmsg){
+     /*<<arg.ml:295:2>>*/ if(opt)
+     var sth = opt[1], current$0 = sth;
+    else
+     var current$0 = current;
+     /*<<arg.ml:295:2>>*/ return parse_argv_dynamic
+            ([0, current$0], argv, [0, speclist], anonfun, errmsg);
+    /*<<arg.ml:295:72>>*/ }
+   function parse(l, f, msg){
+     /*<<arg.ml:299:2>>*/ try{
+      /*<<arg.ml:300:4>>*/  /*<<arg.ml:300:4>>*/ var
+      _X_ = parse_argv(0, caml_sys_argv(0), l, f, msg);
+      /*<<arg.ml:300:4>>*/ return _X_;
+    }
+    catch(exn$0){
+     var exn = caml_wrap_exception(exn$0);
+     if(exn[1] === Bad){
+      var msg$0 = exn[2];
+       /*<<arg.ml:302:15>>*/  /*<<arg.ml:302:15>>*/ caml_call2
+       (Stdlib_Printf[3], _l_, msg$0);
+       /*<<arg.ml:302:15>>*/ return  /*<<arg.ml:302:15>>*/ caml_call1
+              (Stdlib[99], 2);
+     }
+     if(exn[1] !== Help) throw caml_maybe_attach_backtrace(exn, 0);
+     var msg$1 = exn[2];
+      /*<<arg.ml:303:16>>*/  /*<<arg.ml:303:16>>*/ caml_call2
+      (Stdlib_Printf[2], _m_, msg$1);
+      /*<<arg.ml:303:16>>*/ return  /*<<arg.ml:303:16>>*/ caml_call1
+             (Stdlib[99], 0);
+    }
+    /*<<arg.ml:303:39>>*/ }
+   function parse_dynamic(l, f, msg){
+     /*<<arg.ml:307:2>>*/ try{
+      /*<<arg.ml:308:4>>*/  /*<<arg.ml:308:4>>*/ var
+      _W_ = parse_argv_dynamic(0, caml_sys_argv(0), l, f, msg);
+      /*<<arg.ml:308:4>>*/ return _W_;
+    }
+    catch(exn$0){
+     var exn = caml_wrap_exception(exn$0);
+     if(exn[1] === Bad){
+      var msg$0 = exn[2];
+       /*<<arg.ml:310:15>>*/  /*<<arg.ml:310:15>>*/ caml_call2
+       (Stdlib_Printf[3], _n_, msg$0);
+       /*<<arg.ml:310:15>>*/ return  /*<<arg.ml:310:15>>*/ caml_call1
+              (Stdlib[99], 2);
+     }
+     if(exn[1] !== Help) throw caml_maybe_attach_backtrace(exn, 0);
+     var msg$1 = exn[2];
+      /*<<arg.ml:311:16>>*/  /*<<arg.ml:311:16>>*/ caml_call2
+      (Stdlib_Printf[2], _o_, msg$1);
+      /*<<arg.ml:311:16>>*/ return  /*<<arg.ml:311:16>>*/ caml_call1
+             (Stdlib[99], 0);
+    }
+    /*<<arg.ml:311:39>>*/ }
+   function parse_expand(l, f, msg){
+     /*<<arg.ml:314:2>>*/ try{
+      /*<<arg.ml:315:15>>*/ var
+       /*<<arg.ml:315:15>>*/ argv = [0, caml_sys_argv(0)],
+       /*<<arg.ml:316:15>>*/ spec = [0, l],
+       /*<<arg.ml:317:18>>*/ current$0 = [0, current[1]],
+       /*<<arg.ml:318:4>>*/ _V_ =
+        parse_and_expand_argv_dynamic(current$0, argv, spec, f, msg);
+      /*<<arg.ml:318:4>>*/ return _V_;
+    }
+    catch(exn$0){
+     var exn = caml_wrap_exception(exn$0);
+     if(exn[1] === Bad){
+      var msg$0 = exn[2];
+       /*<<arg.ml:320:15>>*/  /*<<arg.ml:320:15>>*/ caml_call2
+       (Stdlib_Printf[3], _p_, msg$0);
+       /*<<arg.ml:320:15>>*/ return  /*<<arg.ml:320:15>>*/ caml_call1
+              (Stdlib[99], 2);
+     }
+     if(exn[1] !== Help) throw caml_maybe_attach_backtrace(exn, 0);
+     var msg$1 = exn[2];
+      /*<<arg.ml:321:16>>*/  /*<<arg.ml:321:16>>*/ caml_call2
+      (Stdlib_Printf[2], _q_, msg$1);
+      /*<<arg.ml:321:16>>*/ return  /*<<arg.ml:321:16>>*/ caml_call1
+             (Stdlib[99], 0);
+    }
+    /*<<arg.ml:321:39>>*/ }
+   function second_word(s){
+     /*<<arg.ml:325:2>>*/ var len = caml_ml_string_length(s);
+    function loop(n){
+      /*<<arg.ml:327:4>>*/ var n$0 = n;
+      /*<<arg.ml:327:4>>*/ for(;;){
+      if(len <= n$0)  /*<<arg.ml:326:2>>*/ return len;
+       /*<<arg.ml:328:12>>*/ if
+       (32 !==  /*<<arg.ml:328:12>>*/ caml_string_get(s, n$0))
+        /*<<arg.ml:329:9>>*/ return n$0;
+       /*<<arg.ml:328:29>>*/ var
+        /*<<arg.ml:328:29>>*/ n$1 = n$0 + 1 | 0,
+       n$0 = n$1;
+     }
+     /*<<arg.ml:329:10>>*/ }
+     /*<<arg.ml:331:2>>*/ try{
+      /*<<arg.ml:331:8>>*/  /*<<arg.ml:331:8>>*/ var
+      n$0 =  /*<<arg.ml:331:8>>*/ caml_call2(Stdlib_String[35], s, 9);
+    }
+    catch(_T_){
+     var _R_ = caml_wrap_exception(_T_);
+     if(_R_ !== Stdlib[8]) throw caml_maybe_attach_backtrace(_R_, 0);
+      /*<<arg.ml:334:6>>*/ try{
+       /*<<arg.ml:334:18>>*/  /*<<arg.ml:334:18>>*/ var
+       n =  /*<<arg.ml:334:18>>*/ caml_call2(Stdlib_String[35], s, 32);
+     }
+     catch(_U_){
+      var _S_ = caml_wrap_exception(_U_);
+      if(_S_ === Stdlib[8])  /*<<arg.ml:336:31>>*/ return len;
+      throw caml_maybe_attach_backtrace(_S_, 0);
+     }
+      /*<<arg.ml:334:18>>*/ return loop(n + 1 | 0);
+    }
+     /*<<arg.ml:331:8>>*/ return loop(n$0 + 1 | 0);
+    /*<<arg.ml:337:9>>*/ }
+   function max_arg_len(cur, param){
+    var doc = param[3], spec = param[2], kwd = param[1];
+     /*<<arg.ml:341:2>>*/ if(11 === spec[0])
+     return caml_call2(Stdlib_Int[11], cur, caml_ml_string_length(kwd));
+    var _Q_ = caml_ml_string_length(kwd) + second_word(doc) | 0;
+    return caml_call2(Stdlib_Int[11], cur, _Q_);
+   }
+   function replace_leading_tab(s){
+     /*<<arg.ml:347:2>>*/  /*<<arg.ml:347:13>>*/ var seen = [0, 0];
+    function _P_(c){
+      /*<<arg.ml:348:13>>*/ if(9 === c && ! seen[1]){
+      seen[1] = 1;
+       /*<<arg.ml:348:60>>*/ return 32;
+     }
+      /*<<arg.ml:348:71>>*/ return c;
+     /*<<arg.ml:348:73>>*/ }
+     /*<<arg.ml:348:2>>*/ return  /*<<arg.ml:348:2>>*/ caml_call2
+            (Stdlib_String[17], _P_, s);
+    /*<<arg.ml:348:75>>*/ }
+   function align(opt, speclist){
+     /*<<arg.ml:374:2>>*/ if(opt)
+     var sth = opt[1], limit = sth;
+    else
+     var limit = Stdlib[19];
+     /*<<arg.ml:374:18>>*/ var
+      /*<<arg.ml:374:18>>*/ completed = add_help(speclist),
+      /*<<arg.ml:375:12>>*/ len =
+        /*<<arg.ml:375:12>>*/ caml_call3
+        (Stdlib_List[25], max_arg_len, 0, completed),
+      /*<<arg.ml:376:12>>*/ len$0 =
+        /*<<arg.ml:376:12>>*/ caml_call2(Stdlib_Int[10], len, limit);
+     /*<<arg.ml:377:11>>*/ function _J_(ksd){
+     var kwd = ksd[1], spec = ksd[2];
+     if(! caml_string_notequal(ksd[3], cst$7))
+       /*<<arg.ml:355:6>>*/ return ksd;
+     if(11 === spec[0]){
+       /*<<arg.ml:357:19>>*/ var
+       msg$0 = ksd[3],
+        /*<<arg.ml:357:19>>*/ cutcol$0 = second_word(msg$0),
+        /*<<arg.ml:358:32>>*/ _M_ =
+          /*<<arg.ml:358:32>>*/ caml_call2
+          (Stdlib_Int[11], 0, len$0 - cutcol$0 | 0)
+         + 3
+         | 0,
+        /*<<arg.ml:358:19>>*/ spaces$0 =
+          /*<<arg.ml:358:19>>*/ caml_call2(Stdlib_String[1], _M_, 32),
+        /*<<arg.ml:359:34>>*/ _N_ = replace_leading_tab(msg$0),
+        /*<<arg.ml:359:25>>*/ _O_ =
+          /*<<arg.ml:359:25>>*/ caml_call2(Stdlib[28], spaces$0, _N_);
+       /*<<arg.ml:359:6>>*/ return [0,
+              kwd,
+              spec,
+               /*<<arg.ml:359:18>>*/ caml_call2(Stdlib[28], cst$6, _O_)];
+     }
+      /*<<arg.ml:361:19>>*/ var
+      msg = ksd[3],
+      spec$0 = ksd[2],
+       /*<<arg.ml:361:19>>*/ cutcol = second_word(msg),
+       /*<<arg.ml:362:6>>*/ kwd_len =
+         /*<<arg.ml:362:6>>*/ caml_ml_string_length(kwd),
+      diff = (len$0 - kwd_len | 0) - cutcol | 0;
+      /*<<arg.ml:364:6>>*/ if(0 >= diff)
+       /*<<arg.ml:365:8>>*/ return [0, kwd, spec$0, replace_leading_tab(msg)];
+      /*<<arg.ml:367:21>>*/ var
+       /*<<arg.ml:367:21>>*/ spaces =
+         /*<<arg.ml:367:21>>*/ caml_call2(Stdlib_String[1], diff, 32),
+       /*<<arg.ml:368:32>>*/ _K_ = replace_leading_tab(msg),
+       /*<<arg.ml:368:21>>*/ prefix =
+         /*<<arg.ml:368:21>>*/ caml_call3(Stdlib_String[15], _K_, 0, cutcol),
+       /*<<arg.ml:369:21>>*/ suffix =
+         /*<<arg.ml:369:21>>*/ caml_call3
+         (Stdlib_String[15],
+          msg,
+          cutcol,
+          caml_ml_string_length(msg) - cutcol | 0),
+       /*<<arg.ml:370:29>>*/ _L_ =
+         /*<<arg.ml:370:29>>*/ caml_call2(Stdlib[28], spaces, suffix);
+      /*<<arg.ml:370:8>>*/ return [0,
+             kwd,
+             spec$0,
+              /*<<arg.ml:370:20>>*/ caml_call2(Stdlib[28], prefix, _L_)];
+    }
+     /*<<arg.ml:377:2>>*/ return  /*<<arg.ml:377:2>>*/ caml_call2
+            (Stdlib_List[19], _J_, completed);
+    /*<<arg.ml:377:38>>*/ }
+   function read_aux(trim, sep, file){
+     /*<<arg.ml:387:2>>*/ var
+      /*<<arg.ml:387:11>>*/ ic =
+        /*<<arg.ml:387:11>>*/ caml_call1(Stdlib[80], file),
+      /*<<arg.ml:388:12>>*/ buf =
+        /*<<arg.ml:388:12>>*/ caml_call1(Stdlib_Buffer[1], 200),
+      /*<<arg.ml:389:14>>*/ words = [0, 0];
+    function stash(param){
+      /*<<arg.ml:391:4>>*/  /*<<arg.ml:391:15>>*/ var
+      word =  /*<<arg.ml:391:15>>*/ caml_call1(Stdlib_Buffer[2], buf);
+      /*<<arg.ml:392:4>>*/ if(trim){
+      var len = caml_ml_string_length(word);
+      a:
+      {
+        /*<<arg.ml:381:16>>*/ if
+        (0 < len
+         && 13 ===  /*<<arg.ml:381:16>>*/ caml_string_get(word, len - 1 | 0)){
+        var
+         _I_ =
+            /*<<arg.ml:382:4>>*/ caml_call3
+            (Stdlib_String[15], word, 0, len - 1 | 0);
+        break a;
+       }
+       var _I_ = word;
+      }
+      var word$0 = _I_;
+     }
+     else
+      var word$0 = word;
+     words[1] = [0, word$0, words[1]];
+      /*<<arg.ml:390:2>>*/ return  /*<<arg.ml:390:2>>*/ caml_call1
+             (Stdlib_Buffer[8], buf);
+     /*<<arg.ml:394:20>>*/ }
+     /*<<arg.ml:396:2>>*/ try{
+     for(;;){
+       /*<<arg.ml:398:16>>*/  /*<<arg.ml:398:16>>*/ var
+       c =  /*<<arg.ml:398:16>>*/ caml_call1(Stdlib[82], ic);
+      if(c === sep)
+        /*<<arg.ml:399:24>>*/ stash(0);
+      else
+        /*<<arg.ml:399:38>>*/  /*<<arg.ml:399:38>>*/ caml_call2
+        (Stdlib_Buffer[12], buf, c);
+     }
+    }
+    catch(_H_){
+     var _F_ = caml_wrap_exception(_H_);
+     if(_F_ !== Stdlib[12]) throw caml_maybe_attach_backtrace(_F_, 0);
+     if(0 <  /*<<arg.ml:403:5>>*/ caml_call1(Stdlib_Buffer[7], buf))
+       /*<<arg.ml:403:32>>*/ stash(0);
+      /*<<arg.ml:404:2>>*/  /*<<arg.ml:404:2>>*/ caml_call1(Stdlib[93], ic);
+      /*<<arg.ml:405:16>>*/  /*<<arg.ml:405:16>>*/ var
+      _G_ =  /*<<arg.ml:405:16>>*/ caml_call1(Stdlib_List[9], words[1]);
+      /*<<arg.ml:405:16>>*/ return  /*<<arg.ml:405:16>>*/ caml_call1
+             (Stdlib_Array[10], _G_);
+    }
+    /*<<arg.ml:405:33>>*/ }
+   var _r_ = 10, _s_ = 1;
+    /*<<arg.ml:407:15>>*/ function read_arg(_E_){
+     /*<<?>>*/ return read_aux(_s_, _r_, _E_);
+   }
+    /*<<arg.ml:407:15>>*/ var  /*<<arg.ml:407:15>>*/ _t_ = 0, _u_ = 0;
+    /*<<arg.ml:409:16>>*/ function read_arg0(_D_){
+     /*<<?>>*/ return read_aux(_u_, _t_, _D_);
+   }
+   function write_aux(sep, file, args){
+     /*<<arg.ml:412:2>>*/  /*<<arg.ml:412:11>>*/ var
+     oc =  /*<<arg.ml:412:11>>*/ caml_call1(Stdlib[61], file);
+    function _C_(s){
+      /*<<arg.ml:413:23>>*/ return caml_call4
+             (Stdlib_Printf[1], oc, _v_, s, sep);
+     /*<<arg.ml:413:46>>*/ }
+     /*<<arg.ml:413:2>>*/  /*<<arg.ml:413:2>>*/ caml_call2
+     (Stdlib_Array[11], _C_, args);
+     /*<<arg.ml:413:2>>*/ return  /*<<arg.ml:413:2>>*/ caml_call1
+            (Stdlib[76], oc);
+    /*<<arg.ml:414:14>>*/ }
+   var _w_ = 10;
+    /*<<arg.ml:416:16>>*/ function write_arg(_A_, _B_){
+     /*<<?>>*/ return write_aux(_w_, _A_, _B_);
+   }
+    /*<<arg.ml:416:16>>*/  /*<<arg.ml:416:16>>*/ var _x_ = 0;
+    /*<<arg.ml:418:17>>*/ function write_arg0(_y_, _z_){
+     /*<<?>>*/ return write_aux(_x_, _y_, _z_);
+   }
+   var
+    Stdlib_Arg =
+      [0,
+       parse,
+       parse_dynamic,
+       parse_argv,
+       parse_argv_dynamic,
+       parse_and_expand_argv_dynamic,
+       parse_expand,
+       Help,
+       Bad,
+       usage,
+       usage_string,
+       align,
+       current,
+       read_arg,
+       read_arg0,
+       write_arg,
+       write_arg0];
+   runtime.caml_register_global(54, Stdlib_Arg, "Stdlib__Arg");
+   return;
+   /*<<?>>*/ }
+  (globalThis));
+
+//# unitInfo: Provides: Stdlib__Printexc
+//# unitInfo: Requires: Stdlib, Stdlib__Atomic, Stdlib__Buffer, Stdlib__Obj, Stdlib__Printf
+(function
+  (globalThis){
+   "use strict";
+   var
+    runtime = globalThis.jsoo_runtime,
+    cst$4 = "",
+    cst_s = "%s\n",
+    cst_Program_not_linked_with_g_$0 =
+      "(Program not linked with -g, cannot print stack backtrace)\n",
+    cst_characters = ", characters ",
+    cst_Fatal_error_exception = "Fatal error: exception ",
+    cst_Fatal_error_exception_s = "Fatal error: exception %s\n",
+    cst_Uncaught_exception = "Uncaught exception: ",
+    cst_Uncaught_exception_s = "Uncaught exception: %s\n",
+    caml_check_bound = runtime.caml_check_bound,
+    caml_get_exception_raw_backtra = runtime.caml_get_exception_raw_backtrace,
+    caml_maybe_attach_backtrace = runtime.caml_maybe_attach_backtrace,
+    caml_obj_tag = runtime.caml_obj_tag,
+    caml_wrap_exception = runtime.caml_wrap_exception;
+    /*<<?>>*/ function caml_call1(f, a0){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 1
+            ? f(a0)
+            : runtime.caml_call_gen(f, [a0]);
+   }
+    /*<<?>>*/ function caml_call2(f, a0, a1){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 2
+            ? f(a0, a1)
+            : runtime.caml_call_gen(f, [a0, a1]);
+   }
+    /*<<?>>*/ function caml_call3(f, a0, a1, a2){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 3
+            ? f(a0, a1, a2)
+            : runtime.caml_call_gen(f, [a0, a1, a2]);
+   }
+    /*<<?>>*/ function caml_call6(f, a0, a1, a2, a3, a4, a5){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 6
+            ? f(a0, a1, a2, a3, a4, a5)
+            : runtime.caml_call_gen(f, [a0, a1, a2, a3, a4, a5]);
+   }
+    /*<<?>>*/ function caml_call8(f, a0, a1, a2, a3, a4, a5, a6, a7){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 8
+            ? f(a0, a1, a2, a3, a4, a5, a6, a7)
+            : runtime.caml_call_gen(f, [a0, a1, a2, a3, a4, a5, a6, a7]);
+   }
+    /*<<printexc.ml:20:15>>*/ var
+    global_data = runtime.caml_get_global_data(),
+    cst$0 = cst$4,
+    cst$3 = cst$4,
+    partial = [4, 0, 0, 0, [12, 45, [4, 0, 0, 0, 0]]],
+    cst$1 = cst$4,
+    cst$2 = cst$4,
+    cst = "_",
+    locfmt =
+      [0,
+       [11,
+        'File "',
+        [2,
+         0,
+         [11,
+          '", line ',
+          [4,
+           0,
+           0,
+           0,
+           [11,
+            cst_characters,
+            [4, 0, 0, 0, [12, 45, [4, 0, 0, 0, [11, ": ", [2, 0, 0]]]]]]]]]],
+       'File "%s", line %d, characters %d-%d: %s'],
+    Stdlib_Printf = global_data.Stdlib__Printf,
+    Stdlib_Atomic = global_data.Stdlib__Atomic,
+    Stdlib = global_data.Stdlib,
+    Stdlib_Buffer = global_data.Stdlib__Buffer,
+    Stdlib_Obj = global_data.Stdlib__Obj,
+     /*<<printexc.ml:20:15>>*/ printers =
+       /*<<printexc.ml:20:15>>*/ caml_call1(Stdlib_Atomic[1], 0),
+    _c_ = [0, [11, ", ", [2, 0, [2, 0, 0]]], ", %s%s"],
+    _o_ =
+      [0,
+       [11, cst_Fatal_error_exception, [2, 0, [12, 10, 0]]],
+       cst_Fatal_error_exception_s],
+    _p_ =
+      [0,
+       [11,
+        "Fatal error in uncaught exception handler: exception ",
+        [2, 0, [12, 10, 0]]],
+       "Fatal error in uncaught exception handler: exception %s\n"],
+    cst_Fatal_error_out_of_memory_ =
+      "Fatal error: out of memory in uncaught exception handler",
+    _n_ =
+      [0,
+       [11, cst_Fatal_error_exception, [2, 0, [12, 10, 0]]],
+       cst_Fatal_error_exception_s],
+    _l_ = [0, [2, 0, [12, 10, 0]], cst_s],
+    cst_Program_not_linked_with_g_ = cst_Program_not_linked_with_g_$0,
+    _j_ = [0, [2, 0, [12, 10, 0]], cst_s],
+    _k_ =
+      [0,
+       [11, cst_Program_not_linked_with_g_$0, 0],
+       cst_Program_not_linked_with_g_$0],
+    cst_Raised_at = "Raised at",
+    cst_Re_raised_at = "Re-raised at",
+    cst_Raised_by_primitive_operat = "Raised by primitive operation at",
+    cst_Called_from = "Called from",
+    cst_inlined = " (inlined)",
+    _h_ =
+      [0,
+       [2,
+        0,
+        [12,
+         32,
+         [2,
+          0,
+          [11,
+           ' in file "',
+           [2,
+            0,
+            [12,
+             34,
+             [2,
+              0,
+              [11, ", line ", [4, 0, 0, 0, [11, cst_characters, partial]]]]]]]]]],
+       '%s %s in file "%s"%s, line %d, characters %d-%d'],
+    _i_ = [0, [2, 0, [11, " unknown location", 0]], "%s unknown location"],
+    _g_ =
+      [0,
+       [11, cst_Uncaught_exception, [2, 0, [12, 10, 0]]],
+       cst_Uncaught_exception_s],
+    _f_ =
+      [0,
+       [11, cst_Uncaught_exception, [2, 0, [12, 10, 0]]],
+       cst_Uncaught_exception_s],
+    cst_Out_of_memory = "Out of memory",
+    cst_Stack_overflow = "Stack overflow",
+    cst_Pattern_matching_failed = "Pattern matching failed",
+    cst_Assertion_failed = "Assertion failed",
+    cst_Undefined_recursive_module = "Undefined recursive module",
+    _d_ = [0, [12, 40, [2, 0, [2, 0, [12, 41, 0]]]], "(%s%s)"],
+    _e_ = [0, [12, 40, [2, 0, [12, 41, 0]]], "(%s)"],
+    _b_ = [0, [4, 0, 0, 0, 0], "%d"],
+    _a_ = [0, [3, 0, 0], "%S"],
+    _m_ =
+      [0,
+       cst$4,
+       "(Cannot print locations:\n bytecode executable program file not found)",
+       "(Cannot print locations:\n bytecode executable program file appears to be corrupt)",
+       "(Cannot print locations:\n bytecode executable program file has wrong magic number)",
+       "(Cannot print locations:\n bytecode executable program file cannot be opened;\n -- too many open files. Try running with OCAMLRUNPARAM=b=2)"];
+   function field(x, i){
+     /*<<printexc.ml:25:2>>*/  /*<<printexc.ml:25:10>>*/ var f = x[1 + i];
+     /*<<printexc.ml:26:9>>*/ if
+     (!  /*<<printexc.ml:26:9>>*/ caml_call1(Stdlib_Obj[1], f))
+      /*<<printexc.ml:27:4>>*/ return  /*<<printexc.ml:27:4>>*/ caml_call2
+             (Stdlib_Printf[4], _b_, f);
+     /*<<printexc.ml:28:7>>*/  /*<<printexc.ml:28:7>>*/ var
+     _al_ = Stdlib_Obj[15];
+    if( /*<<printexc.ml:28:10>>*/ caml_obj_tag(f) === _al_)
+      /*<<printexc.ml:29:4>>*/ return  /*<<printexc.ml:29:4>>*/ caml_call2
+             (Stdlib_Printf[4], _a_, f);
+     /*<<printexc.ml:30:7>>*/  /*<<printexc.ml:30:7>>*/ var
+     _am_ = Stdlib_Obj[16];
+    return  /*<<printexc.ml:30:10>>*/ caml_obj_tag(f) === _am_
+            ?  /*<<printexc.ml:31:4>>*/ caml_call1(Stdlib[35], f)
+            : cst;
+    /*<<printexc.ml:33:7>>*/ }
+   function other_fields(x, i){
+     /*<<printexc.ml:36:2>>*/ if(x.length - 1 <= i)
+      /*<<printexc.ml:36:26>>*/ return cst$0;
+     /*<<printexc.ml:37:36>>*/ var
+      /*<<printexc.ml:37:36>>*/ _aj_ = other_fields(x, i + 1 | 0),
+      /*<<printexc.ml:37:24>>*/ _ak_ = field(x, i);
+     /*<<printexc.ml:37:36>>*/ return  /*<<printexc.ml:37:36>>*/ caml_call3
+            (Stdlib_Printf[4], _c_, _ak_, _aj_);
+    /*<<printexc.ml:37:58>>*/ }
+   function use_printers(x){
+     /*<<printexc.ml:47:2>>*/ var
+     param =  /*<<printexc.ml:53:7>>*/ caml_call1(Stdlib_Atomic[2], printers);
+     /*<<printexc.ml:47:17>>*/ for(;;){
+     if(! param)  /*<<printexc.ml:52:12>>*/ return 0;
+     var tl = param[2], hd = param[1];
+     a:
+     {
+       /*<<printexc.ml:49:8>>*/ try{
+        /*<<printexc.ml:49:15>>*/  /*<<printexc.ml:49:15>>*/ var
+        val =  /*<<printexc.ml:49:15>>*/ caml_call1(hd, x);
+      }
+      catch(_ai_){break a;}
+      if(val){var s = val[1];  /*<<printexc.ml:51:21>>*/ return [0, s];}
+     }
+     var param = tl;
+    }
+    /*<<printexc.ml:53:28>>*/ }
+   function string_of_extension_constructo(t){
+     /*<<printexc.ml:64:2>>*/ if
+     (0 ===  /*<<printexc.ml:56:5>>*/ caml_obj_tag(t)){
+      /*<<printexc.ml:60:17>>*/ var
+       /*<<printexc.ml:60:17>>*/ constructor = t[1][1],
+      match = t.length - 1;
+     if(2 < match >>> 0)
+       /*<<printexc.ml:44:38>>*/ var
+        /*<<printexc.ml:44:38>>*/ _ae_ = other_fields(t, 2),
+        /*<<printexc.ml:44:26>>*/ _af_ = field(t, 1),
+       _ah_ =
+          /*<<printexc.ml:44:38>>*/ caml_call3
+          (Stdlib_Printf[4], _d_, _af_, _ae_);
+     else
+      switch(match){
+        case 0:
+         var _ah_ = cst$1; break;
+        case 1:
+         var _ah_ = cst$2; break;
+        default:
+          /*<<printexc.ml:43:24>>*/ var
+           /*<<printexc.ml:43:24>>*/ _ag_ = field(t, 1),
+          _ah_ =
+             /*<<printexc.ml:43:24>>*/ caml_call2(Stdlib_Printf[4], _e_, _ag_);
+      }
+     var match$0 = [0, constructor, [0, _ah_]];
+    }
+    else
+     var match$0 = [0, t[1], 0];
+    var fields_opt = match$0[2], constructor$0 = match$0[1];
+     /*<<printexc.ml:65:2>>*/ if(! fields_opt)
+      /*<<printexc.ml:66:12>>*/ return constructor$0;
+    var f = fields_opt[1];
+     /*<<printexc.ml:67:14>>*/ return  /*<<printexc.ml:67:14>>*/ caml_call2
+            (Stdlib[28], constructor$0, f);
+    /*<<printexc.ml:67:29>>*/ }
+   function to_string_default(x){
+     /*<<printexc.ml:69:24>>*/ if(x === Stdlib[9])
+      /*<<printexc.ml:70:21>>*/ return cst_Out_of_memory;
+    if(x === Stdlib[10])  /*<<printexc.ml:71:22>>*/ return cst_Stack_overflow;
+    if(x[1] === Stdlib[4]){
+     var match = x[2], char$0 = match[3], line = match[2], file = match[1];
+      /*<<printexc.ml:73:6>>*/ return  /*<<printexc.ml:73:6>>*/ caml_call6
+             (Stdlib_Printf[4],
+              locfmt,
+              file,
+              line,
+              char$0,
+              char$0 + 5 | 0,
+              cst_Pattern_matching_failed);
+    }
+    if(x[1] === Stdlib[5]){
+     var
+      match$0 = x[2],
+      char$1 = match$0[3],
+      line$0 = match$0[2],
+      file$0 = match$0[1];
+      /*<<printexc.ml:75:6>>*/ return  /*<<printexc.ml:75:6>>*/ caml_call6
+             (Stdlib_Printf[4],
+              locfmt,
+              file$0,
+              line$0,
+              char$1,
+              char$1 + 6 | 0,
+              cst_Assertion_failed);
+    }
+    if(x[1] !== Stdlib[15])
+      /*<<printexc.ml:79:6>>*/ return string_of_extension_constructo(x);
+    var
+     match$1 = x[2],
+     char$2 = match$1[3],
+     line$1 = match$1[2],
+     file$1 = match$1[1];
+     /*<<printexc.ml:77:6>>*/ return  /*<<printexc.ml:77:6>>*/ caml_call6
+            (Stdlib_Printf[4],
+             locfmt,
+             file$1,
+             line$1,
+             char$2,
+             char$2 + 6 | 0,
+             cst_Undefined_recursive_module);
+    /*<<printexc.ml:79:50>>*/ }
+   function to_string(e){
+     /*<<printexc.ml:82:2>>*/  /*<<printexc.ml:82:8>>*/ var
+     match = use_printers(e);
+    if(! match)  /*<<printexc.ml:84:12>>*/ return to_string_default(e);
+    var s = match[1];
+     /*<<printexc.ml:83:14>>*/ return s;
+    /*<<printexc.ml:84:31>>*/ }
+   function print(fct, arg){
+     /*<<printexc.ml:87:2>>*/ try{
+      /*<<printexc.ml:88:4>>*/  /*<<printexc.ml:88:4>>*/ var
+      _ad_ =  /*<<printexc.ml:88:4>>*/ caml_call1(fct, arg);
+      /*<<printexc.ml:88:4>>*/ return _ad_;
+    }
+    catch(x$0){
+      /*<<printexc.ml:90:39>>*/ var
+      x = caml_wrap_exception(x$0),
+       /*<<printexc.ml:90:39>>*/ _ac_ = to_string(x);
+      /*<<printexc.ml:90:4>>*/  /*<<printexc.ml:90:4>>*/ caml_call2
+      (Stdlib_Printf[3], _f_, _ac_);
+      /*<<printexc.ml:91:4>>*/  /*<<printexc.ml:91:4>>*/ caml_call1
+      (Stdlib[63], Stdlib[40]);
+      /*<<printexc.ml:92:4>>*/ throw  /*<<printexc.ml:92:4>>*/ caml_maybe_attach_backtrace
+            (x, 0);
+    }
+    /*<<printexc.ml:92:11>>*/ }
+   function catch$0(fct, arg){
+     /*<<printexc.ml:95:2>>*/ try{
+      /*<<printexc.ml:96:4>>*/  /*<<printexc.ml:96:4>>*/ var
+      _ab_ =  /*<<printexc.ml:96:4>>*/ caml_call1(fct, arg);
+      /*<<printexc.ml:96:4>>*/ return _ab_;
+    }
+    catch(x$0){
+     var x = caml_wrap_exception(x$0);
+      /*<<printexc.ml:98:4>>*/  /*<<printexc.ml:98:4>>*/ caml_call1
+      (Stdlib[63], Stdlib[39]);
+      /*<<printexc.ml:99:39>>*/  /*<<printexc.ml:99:39>>*/ var
+      _aa_ = to_string(x);
+      /*<<printexc.ml:99:4>>*/  /*<<printexc.ml:99:4>>*/ caml_call2
+      (Stdlib_Printf[3], _g_, _aa_);
+      /*<<printexc.ml:99:4>>*/ return  /*<<printexc.ml:99:4>>*/ caml_call1
+             (Stdlib[99], 2);
+    }
+    /*<<printexc.ml:100:10>>*/ }
+   function raw_backtrace_entries(bt){
+     /*<<printexc.ml:106:31>>*/ return bt;
+    /*<<printexc.ml:106:33>>*/ }
+   function convert_raw_backtrace(bt){
+     /*<<printexc.ml:141:2>>*/ return [0,
+             /*<<printexc.ml:141:11>>*/ runtime.caml_convert_raw_backtrace(bt)];
+    /*<<printexc.ml:142:24>>*/ }
+   function format_backtrace_slot(pos, slot){
+    function info(is_raise){
+      /*<<printexc.ml:146:4>>*/ return is_raise
+             ? 0 === pos ? cst_Raised_at : cst_Re_raised_at
+             : 0 === pos ? cst_Raised_by_primitive_operat : cst_Called_from;
+     /*<<printexc.ml:149:75>>*/ }
+     /*<<printexc.ml:151:2>>*/ if(0 === slot[0]){
+      /*<<printexc.ml:159:14>>*/ var
+      _U_ = slot[5],
+      _V_ = slot[4],
+      _W_ = slot[3],
+      _X_ = slot[6] ? cst_inlined : cst$3,
+      _Y_ = slot[2],
+      _Z_ = slot[7],
+       /*<<printexc.ml:159:14>>*/ ___ = info(slot[1]);
+      /*<<printexc.ml:158:6>>*/ return [0,
+              /*<<printexc.ml:158:11>>*/ caml_call8
+              (Stdlib_Printf[4], _h_, ___, _Z_, _Y_, _X_, _W_, _V_, _U_)];
+    }
+    if(slot[1])  /*<<printexc.ml:154:50>>*/ return 0;
+     /*<<printexc.ml:156:44>>*/  /*<<printexc.ml:156:44>>*/ var _$_ = info(0);
+     /*<<printexc.ml:156:8>>*/ return [0,
+             /*<<printexc.ml:156:13>>*/ caml_call2(Stdlib_Printf[4], _i_, _$_)];
+    /*<<printexc.ml:161:52>>*/ }
+   function print_raw_backtrace(outchan, raw_backtrace){
+     /*<<printexc.ml:176:2>>*/  /*<<printexc.ml:176:36>>*/ var
+     backtrace = convert_raw_backtrace(raw_backtrace);
+    if(! backtrace)
+      /*<<printexc.ml:166:6>>*/ return  /*<<printexc.ml:166:6>>*/ caml_call2
+             (Stdlib_Printf[1], outchan, _k_);
+    var a = backtrace[1], _S_ = a.length - 1 - 1 | 0, _R_ = 0;
+    if(_S_ >= 0){
+     var i = _R_;
+     for(;;){
+       /*<<printexc.ml:170:14>>*/  /*<<printexc.ml:170:14>>*/ var
+       match = format_backtrace_slot(i, caml_check_bound(a, i)[1 + i]);
+      if(match){
+       var str = match[1];
+        /*<<printexc.ml:172:24>>*/  /*<<printexc.ml:172:24>>*/ caml_call3
+        (Stdlib_Printf[1], outchan, _j_, str);
+      }
+       /*<<printexc.ml:169:6>>*/  /*<<printexc.ml:169:6>>*/ var
+       _T_ = i + 1 | 0;
+      if(_S_ === i) break;
+      var i = _T_;
+     }
+    }
+    return 0;
+    /*<<printexc.ml:176:73>>*/ }
+   function print_backtrace(outchan){
+     /*<<printexc.ml:180:2>>*/ return print_raw_backtrace
+            (outchan,
+              /*<<printexc.ml:180:30>>*/ caml_get_exception_raw_backtra(0));
+    /*<<printexc.ml:180:52>>*/ }
+   function raw_backtrace_to_string(raw_backtrace){
+     /*<<printexc.ml:196:2>>*/  /*<<printexc.ml:196:22>>*/ var
+     backtrace = convert_raw_backtrace(raw_backtrace);
+    if(! backtrace)
+      /*<<printexc.ml:185:5>>*/ return cst_Program_not_linked_with_g_;
+     /*<<printexc.ml:187:14>>*/ var
+     a = backtrace[1],
+      /*<<printexc.ml:187:14>>*/ b =
+        /*<<printexc.ml:187:14>>*/ caml_call1(Stdlib_Buffer[1], 1024),
+     _P_ = a.length - 1 - 1 | 0,
+      /*<<printexc.ml:187:14>>*/ _O_ = 0;
+    if(_P_ >= 0){
+     var i = _O_;
+     for(;;){
+       /*<<printexc.ml:189:14>>*/  /*<<printexc.ml:189:14>>*/ var
+       match = format_backtrace_slot(i, caml_check_bound(a, i)[1 + i]);
+      if(match){
+       var str = match[1];
+        /*<<printexc.ml:191:24>>*/  /*<<printexc.ml:191:24>>*/ caml_call3
+        (Stdlib_Printf[5], b, _l_, str);
+      }
+       /*<<printexc.ml:188:6>>*/  /*<<printexc.ml:188:6>>*/ var
+       _Q_ = i + 1 | 0;
+      if(_P_ === i) break;
+      var i = _Q_;
+     }
+    }
+     /*<<printexc.ml:193:6>>*/ return  /*<<printexc.ml:193:6>>*/ caml_call1
+            (Stdlib_Buffer[2], b);
+    /*<<printexc.ml:196:59>>*/ }
+   function backtrace_slot_is_raise(param){
+     /*<<printexc.ml:198:30>>*/ return 0 === param[0] ? param[1] : param[1];
+    /*<<printexc.ml:200:36>>*/ }
+   function backtrace_slot_is_inline(param){
+     /*<<printexc.ml:202:31>>*/ return 0 === param[0] ? param[6] : 0;
+    /*<<printexc.ml:204:31>>*/ }
+   function backtrace_slot_location(param){
+     /*<<printexc.ml:213:30>>*/ return 0 === param[0]
+            ? [0, [0, param[2], param[3], param[4], param[5]]]
+            : 0;
+    /*<<printexc.ml:221:5>>*/ }
+   function backtrace_slot_defname(param){
+     /*<<printexc.ml:223:29>>*/ if
+     (0 === param[0] && runtime.caml_string_notequal(param[7], cst$4))
+      /*<<printexc.ml:226:24>>*/ return [0, param[7]];
+     /*<<printexc.ml:225:39>>*/ return 0;
+    /*<<printexc.ml:226:38>>*/ }
+   function backtrace_slots(raw_backtrace){
+     /*<<printexc.ml:235:2>>*/  /*<<printexc.ml:235:8>>*/ var
+     match = convert_raw_backtrace(raw_backtrace);
+    if(! match)  /*<<printexc.ml:236:14>>*/ return 0;
+    var backtrace = match[1], i$1 = backtrace.length - 1 - 1 | 0, i = i$1;
+     /*<<printexc.ml:241:30>>*/ for(;;){
+     if(-1 === i)
+      var _N_ = 0;
+     else{
+      var _M_ = 0 === caml_check_bound(backtrace, i)[1 + i][0] ? 1 : 0;
+       /*<<printexc.ml:243:15>>*/ if(! _M_){
+       var i$0 = i - 1 | 0, i = i$0;
+       continue;
+      }
+      var _N_ = _M_;
+     }
+      /*<<printexc.ml:244:9>>*/ return _N_ ? [0, backtrace] : 0;
+    }
+    /*<<printexc.ml:246:15>>*/ }
+   function backtrace_slots_of_raw_entry(entry){
+     /*<<printexc.ml:249:2>>*/ return backtrace_slots([0, entry]);
+    /*<<printexc.ml:249:29>>*/ }
+   function raw_backtrace_length(bt){
+     /*<<printexc.ml:260:30>>*/ return bt.length - 1;
+    /*<<printexc.ml:260:45>>*/ }
+   function get_backtrace(param){
+     /*<<printexc.ml:271:23>>*/ return raw_backtrace_to_string
+            ( /*<<printexc.ml:271:47>>*/ caml_get_exception_raw_backtra(0));
+    /*<<printexc.ml:271:69>>*/ }
+   function register_printer(fn){
+     /*<<printexc.ml:277:2>>*/ for(;;){
+      /*<<printexc.ml:277:21>>*/ var
+       /*<<printexc.ml:277:21>>*/ old_printers =
+         /*<<printexc.ml:277:21>>*/ caml_call1(Stdlib_Atomic[2], printers),
+       /*<<printexc.ml:278:21>>*/ new_printers = [0, fn, old_printers],
+       /*<<printexc.ml:279:16>>*/ success =
+         /*<<printexc.ml:279:16>>*/ caml_call3
+         (Stdlib_Atomic[5], printers, old_printers, new_printers),
+       /*<<printexc.ml:280:2>>*/ _L_ = 1 - success;
+     if(! _L_)  /*<<printexc.ml:280:2>>*/ return _L_;
+    }
+    /*<<printexc.ml:280:41>>*/ }
+   function exn_slot(x){
+     /*<<printexc.ml:285:2>>*/ return 0
+            ===  /*<<printexc.ml:286:5>>*/ caml_obj_tag(x)
+            ? x[1]
+            : x;
+    /*<<printexc.ml:286:44>>*/ }
+   function exn_slot_id(x){
+     /*<<printexc.ml:289:2>>*/  /*<<printexc.ml:289:13>>*/ var
+     slot = exn_slot(x);
+     /*<<printexc.ml:290:11>>*/ return slot[2];
+    /*<<printexc.ml:290:36>>*/ }
+   function exn_slot_name(x){
+     /*<<printexc.ml:293:2>>*/  /*<<printexc.ml:293:13>>*/ var
+     slot = exn_slot(x);
+     /*<<printexc.ml:294:11>>*/ return slot[1];
+    /*<<printexc.ml:294:39>>*/ }
+   var errors = _m_.slice();
+   function default_uncaught_exception_han(exn, raw_backtrace){
+     /*<<printexc.ml:316:2>>*/  /*<<printexc.ml:316:40>>*/ var
+     _I_ = to_string(exn);
+     /*<<printexc.ml:316:2>>*/  /*<<printexc.ml:316:2>>*/ caml_call2
+     (Stdlib_Printf[3], _n_, _I_);
+     /*<<printexc.ml:317:2>>*/ print_raw_backtrace(Stdlib[40], raw_backtrace);
+     /*<<printexc.ml:318:15>>*/  /*<<printexc.ml:318:15>>*/ var
+     status =  /*<<printexc.ml:318:15>>*/ runtime.caml_ml_debug_info_status(0);
+    if(status < 0){
+      /*<<printexc.ml:320:26>>*/ var
+       /*<<printexc.ml:320:26>>*/ _J_ =
+         /*<<printexc.ml:320:26>>*/ caml_call1(Stdlib[18], status),
+       /*<<printexc.ml:320:18>>*/ _K_ = caml_check_bound(errors, _J_)[1 + _J_];
+      /*<<printexc.ml:320:4>>*/  /*<<printexc.ml:320:4>>*/ caml_call1
+      (Stdlib[53], _K_);
+    }
+     /*<<printexc.ml:320:4>>*/ return  /*<<printexc.ml:320:4>>*/ caml_call1
+            (Stdlib[63], Stdlib[40]);
+    /*<<printexc.ml:321:14>>*/ }
+    /*<<printexc.ml:323:33>>*/  /*<<printexc.ml:323:33>>*/ var
+    uncaught_exception_handler = [0, default_uncaught_exception_han];
+   function set_uncaught_exception_handler(fn){
+     /*<<printexc.ml:325:40>>*/ uncaught_exception_handler[1] = fn;
+    return 0;
+    /*<<printexc.ml:325:72>>*/ }
+   var empty_backtrace = [0];
+   function handle_uncaught_exception(exn$0, debugger_in_use){
+     /*<<printexc.ml:364:2>>*/ try{
+      /*<<printexc.ml:336:2>>*/ try{
+      var
+       raw_backtrace =
+         debugger_in_use
+          ? empty_backtrace
+          :  /*<<printexc.ml:343:8>>*/ caml_get_exception_raw_backtra(0);
+       /*<<printexc.ml:345:4>>*/ try{
+        /*<<printexc.ml:345:9>>*/  /*<<printexc.ml:345:9>>*/ caml_call1
+        (Stdlib[103], 0);
+      }
+      catch(_H_){}
+       /*<<printexc.ml:346:4>>*/ try{
+        /*<<printexc.ml:347:6>>*/ var
+         /*<<printexc.ml:347:6>>*/ _D_ =
+           /*<<printexc.ml:347:6>>*/ caml_call2
+           (uncaught_exception_handler[1], exn$0, raw_backtrace),
+        _C_ = _D_;
+      }
+      catch(exn$1){
+        /*<<printexc.ml:349:27>>*/ var
+        exn = caml_wrap_exception(exn$1),
+         /*<<printexc.ml:349:27>>*/ raw_backtrace$0 =
+           /*<<printexc.ml:349:27>>*/ caml_get_exception_raw_backtra(0),
+         /*<<printexc.ml:350:44>>*/ _A_ = to_string(exn$0);
+        /*<<printexc.ml:350:6>>*/  /*<<printexc.ml:350:6>>*/ caml_call2
+        (Stdlib_Printf[3], _o_, _A_);
+        /*<<printexc.ml:351:6>>*/ print_raw_backtrace
+        (Stdlib[40], raw_backtrace);
+        /*<<printexc.ml:353:8>>*/  /*<<printexc.ml:353:8>>*/ var
+        _B_ = to_string(exn);
+        /*<<printexc.ml:352:6>>*/  /*<<printexc.ml:352:6>>*/ caml_call2
+        (Stdlib_Printf[3], _p_, _B_);
+        /*<<printexc.ml:354:6>>*/ print_raw_backtrace
+        (Stdlib[40], raw_backtrace$0);
+       var
+        _C_ =  /*<<printexc.ml:355:6>>*/ caml_call1(Stdlib[63], Stdlib[40]);
+      }
+      var _E_ = _C_;
+     }
+     catch(_G_){
+      var _z_ = caml_wrap_exception(_G_);
+      if(_z_ !== Stdlib[9]) throw caml_maybe_attach_backtrace(_z_, 0);
+      var
+       _E_ =
+          /*<<printexc.ml:358:8>>*/ caml_call1
+          (Stdlib[53], cst_Fatal_error_out_of_memory_);
+     }
+      /*<<printexc.ml:365:4>>*/ return _E_;
+    }
+    catch(_F_){ /*<<printexc.ml:368:4>>*/ return 0;}
+    /*<<printexc.ml:368:6>>*/ }
+    /*<<printexc.ml:374:2>>*/  /*<<printexc.ml:374:2>>*/ runtime.caml_register_named_value
+    ("Printexc.handle_uncaught_exception", handle_uncaught_exception);
+   function _q_(_y_){
+     /*<<?>>*/ return runtime.caml_raw_backtrace_next_slot(_y_);
+   }
+   function _r_(_x_){
+     /*<<?>>*/ return runtime.caml_convert_raw_backtrace_slot(_x_);
+   }
+   function _s_(_w_, _v_){
+     /*<<?>>*/ return runtime.caml_raw_backtrace_slot(_w_, _v_);
+   }
+   var
+    _t_ =
+      [0,
+       backtrace_slot_is_raise,
+       backtrace_slot_is_inline,
+       backtrace_slot_location,
+       backtrace_slot_defname,
+       format_backtrace_slot],
+    Stdlib_Printexc =
+      [0,
+       to_string,
+       to_string_default,
+       print,
+       catch$0,
+       print_backtrace,
+       get_backtrace,
+       runtime.caml_record_backtrace,
+       runtime.caml_backtrace_status,
+       register_printer,
+       use_printers,
+       raw_backtrace_entries,
+       function(_u_){ /*<<?>>*/ return caml_get_exception_raw_backtra(_u_);},
+       print_raw_backtrace,
+       raw_backtrace_to_string,
+       default_uncaught_exception_han,
+       set_uncaught_exception_handler,
+       backtrace_slots,
+       backtrace_slots_of_raw_entry,
+       _t_,
+       raw_backtrace_length,
+       _s_,
+       _r_,
+       _q_,
+       exn_slot_id,
+       exn_slot_name,
+       string_of_extension_constructo];
+   runtime.caml_register_global(42, Stdlib_Printexc, "Stdlib__Printexc");
+   return;
+   /*<<?>>*/ }
+  (globalThis));
+
+//# unitInfo: Provides: Stdlib__Fun
+//# unitInfo: Requires: Stdlib, Stdlib__Printexc
+(function
+  (globalThis){
+   "use strict";
+   var
+    runtime = globalThis.jsoo_runtime,
+    caml_maybe_attach_backtrace = runtime.caml_maybe_attach_backtrace,
+    caml_restore_raw_backtrace = runtime.caml_restore_raw_backtrace,
+    caml_wrap_exception = runtime.caml_wrap_exception;
+    /*<<?>>*/ function caml_call1(f, a0){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 1
+            ? f(a0)
+            : runtime.caml_call_gen(f, [a0]);
+   }
+    /*<<?>>*/ function caml_call2(f, a0, a1){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 2
+            ? f(a0, a1)
+            : runtime.caml_call_gen(f, [a0, a1]);
+   }
+   var
+    global_data = runtime.caml_get_global_data(),
+    Stdlib_Printexc = global_data.Stdlib__Printexc,
+    Stdlib = global_data.Stdlib,
+    cst_Fun_Finally_raised = "Fun.Finally_raised: ",
+    cst_Stdlib_Fun_Finally_raised = "Stdlib.Fun.Finally_raised";
+   function const$0(c, param){
+     /*<<fun.ml:17:16>>*/ return c;
+    /*<<fun.ml:17:17>>*/ }
+   function flip(f, x, y){
+     /*<<fun.ml:18:17>>*/ return  /*<<fun.ml:18:17>>*/ caml_call2(f, y, x);
+    /*<<fun.ml:18:22>>*/ }
+   function negate(p, v){
+     /*<<fun.ml:19:17>>*/ return 1 -  /*<<fun.ml:19:21>>*/ caml_call1(p, v);
+    /*<<fun.ml:19:26>>*/ }
+    /*<<fun.ml:21:0>>*/  /*<<fun.ml:21:0>>*/ var
+    Finally_raised =
+      [248, cst_Stdlib_Fun_Finally_raised, runtime.caml_fresh_oo_id(0)];
+   function _a_(param){
+     /*<<fun.ml:23:38>>*/ if(param[1] !== Finally_raised)
+      /*<<fun.ml:25:7>>*/ return 0;
+     /*<<fun.ml:24:55>>*/ var
+     exn = param[2],
+      /*<<fun.ml:24:55>>*/ _c_ =
+        /*<<fun.ml:24:55>>*/ caml_call1(Stdlib_Printexc[1], exn);
+     /*<<fun.ml:24:24>>*/ return [0,
+             /*<<fun.ml:24:29>>*/ caml_call2
+             (Stdlib[28], cst_Fun_Finally_raised, _c_)];
+    /*<<fun.ml:25:11>>*/ }
+    /*<<fun.ml:23:9>>*/  /*<<fun.ml:23:9>>*/ caml_call1
+    (Stdlib_Printexc[9], _a_);
+   function protect(finally$0, work){
+    function finally_no_exn(param){
+      /*<<fun.ml:29:4>>*/ try{
+       /*<<fun.ml:29:8>>*/  /*<<fun.ml:29:8>>*/ var
+       _b_ =  /*<<fun.ml:29:8>>*/ caml_call1(finally$0, 0);
+       /*<<fun.ml:29:8>>*/ return _b_;
+     }
+     catch(e$0){
+       /*<<fun.ml:30:15>>*/ var
+       e = caml_wrap_exception(e$0),
+        /*<<fun.ml:30:15>>*/ bt =
+          /*<<fun.ml:30:15>>*/ caml_call1(Stdlib_Printexc[12], 0),
+        /*<<fun.ml:31:36>>*/ exn = [0, Finally_raised, e];
+      caml_restore_raw_backtrace(exn, bt);
+       /*<<fun.ml:31:6>>*/ throw  /*<<fun.ml:31:6>>*/ caml_maybe_attach_backtrace
+             (exn, 0);
+     }
+     /*<<fun.ml:31:57>>*/ }
+     /*<<fun.ml:33:2>>*/ try{
+      /*<<fun.ml:33:8>>*/  /*<<fun.ml:33:8>>*/ var
+      result =  /*<<fun.ml:33:8>>*/ caml_call1(work, 0);
+    }
+    catch(work_exn$0){
+      /*<<fun.ml:36:20>>*/ var
+      work_exn = caml_wrap_exception(work_exn$0),
+       /*<<fun.ml:36:20>>*/ work_bt =
+         /*<<fun.ml:36:20>>*/ caml_call1(Stdlib_Printexc[12], 0);
+      /*<<fun.ml:37:6>>*/ finally_no_exn(0);
+     caml_restore_raw_backtrace(work_exn, work_bt);
+      /*<<fun.ml:38:6>>*/ throw  /*<<fun.ml:38:6>>*/ caml_maybe_attach_backtrace
+            (work_exn, 0);
+    }
+     /*<<fun.ml:34:14>>*/ finally_no_exn(0);
+     /*<<fun.ml:34:14>>*/ return result;
+    /*<<fun.ml:38:52>>*/ }
+   var Stdlib_Fun = [0, const$0, flip, negate, protect, Finally_raised];
+   runtime.caml_register_global(4, Stdlib_Fun, "Stdlib__Fun");
+   return;
+   /*<<?>>*/ }
+  (globalThis));
+
+//# unitInfo: Provides: Stdlib__Gc
+//# unitInfo: Requires: Stdlib, Stdlib__Atomic, Stdlib__Printf, Stdlib__Sys
+(function
+  (globalThis){
+   "use strict";
+   var
+    runtime = globalThis.jsoo_runtime,
+    cst = "\n",
+    caml_ml_string_length = runtime.caml_ml_string_length;
+    /*<<?>>*/ function caml_call1(f, a0){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 1
+            ? f(a0)
+            : runtime.caml_call_gen(f, [a0]);
+   }
+    /*<<?>>*/ function caml_call2(f, a0, a1){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 2
+            ? f(a0, a1)
+            : runtime.caml_call_gen(f, [a0, a1]);
+   }
+    /*<<?>>*/ function caml_call3(f, a0, a1, a2){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 3
+            ? f(a0, a1, a2)
+            : runtime.caml_call_gen(f, [a0, a1, a2]);
+   }
+    /*<<?>>*/ function caml_call4(f, a0, a1, a2, a3){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 4
+            ? f(a0, a1, a2, a3)
+            : runtime.caml_call_gen(f, [a0, a1, a2, a3]);
+   }
+   var
+    global_data = runtime.caml_get_global_data(),
+    Stdlib_Atomic = global_data.Stdlib__Atomic,
+    Stdlib = global_data.Stdlib,
+    Stdlib_Sys = global_data.Stdlib__Sys,
+    Stdlib_Printf = global_data.Stdlib__Printf,
+    _a_ =
+      [0,
+       [11, "minor_collections:      ", [4, 0, 0, 0, [12, 10, 0]]],
+       "minor_collections:      %d\n"],
+    _b_ =
+      [0,
+       [11, "major_collections:      ", [4, 0, 0, 0, [12, 10, 0]]],
+       "major_collections:      %d\n"],
+    _c_ =
+      [0,
+       [11, "compactions:            ", [4, 0, 0, 0, [12, 10, 0]]],
+       "compactions:            %d\n"],
+    _d_ =
+      [0,
+       [11, "forced_major_collections: ", [4, 0, 0, 0, [12, 10, 0]]],
+       "forced_major_collections: %d\n"],
+    _e_ = [0, [12, 10, 0], cst],
+    _f_ = [0, [8, [0, 0, 0], 0, [0, 0], 0], "%.0f"],
+    _g_ =
+      [0,
+       [11, "minor_words:    ", [8, [0, 0, 0], [1, 1], [0, 0], [12, 10, 0]]],
+       "minor_words:    %*.0f\n"],
+    _h_ =
+      [0,
+       [11, "promoted_words: ", [8, [0, 0, 0], [1, 1], [0, 0], [12, 10, 0]]],
+       "promoted_words: %*.0f\n"],
+    _i_ =
+      [0,
+       [11, "major_words:    ", [8, [0, 0, 0], [1, 1], [0, 0], [12, 10, 0]]],
+       "major_words:    %*.0f\n"],
+    _j_ = [0, [12, 10, 0], cst],
+    _k_ = [0, [4, 0, 0, 0, 0], "%d"],
+    _l_ =
+      [0,
+       [11, "top_heap_words: ", [4, 0, [1, 1], 0, [12, 10, 0]]],
+       "top_heap_words: %*d\n"],
+    _m_ =
+      [0,
+       [11, "heap_words:     ", [4, 0, [1, 1], 0, [12, 10, 0]]],
+       "heap_words:     %*d\n"],
+    _n_ =
+      [0,
+       [11, "live_words:     ", [4, 0, [1, 1], 0, [12, 10, 0]]],
+       "live_words:     %*d\n"],
+    _o_ =
+      [0,
+       [11, "free_words:     ", [4, 0, [1, 1], 0, [12, 10, 0]]],
+       "free_words:     %*d\n"],
+    _p_ =
+      [0,
+       [11, "largest_free:   ", [4, 0, [1, 1], 0, [12, 10, 0]]],
+       "largest_free:   %*d\n"],
+    _q_ =
+      [0,
+       [11, "fragments:      ", [4, 0, [1, 1], 0, [12, 10, 0]]],
+       "fragments:      %*d\n"],
+    _r_ = [0, [12, 10, 0], cst],
+    _s_ =
+      [0,
+       [11, "live_blocks: ", [4, 0, 0, 0, [12, 10, 0]]],
+       "live_blocks: %d\n"],
+    _t_ =
+      [0,
+       [11, "free_blocks: ", [4, 0, 0, 0, [12, 10, 0]]],
+       "free_blocks: %d\n"],
+    _u_ =
+      [0,
+       [11, "heap_chunks: ", [4, 0, 0, 0, [12, 10, 0]]],
+       "heap_chunks: %d\n"];
+   function eventlog_pause(param){
+     /*<<gc.ml:65:24>>*/ return 0;
+    /*<<gc.ml:65:26>>*/ }
+   function eventlog_resume(param){ /*<<gc.ml:66:25>>*/ return 0;
+    /*<<gc.ml:66:27>>*/ }
+   function print_stat(c){
+     /*<<gc.ml:71:2>>*/  /*<<gc.ml:71:11>>*/ var
+     st =  /*<<gc.ml:71:11>>*/ runtime.caml_gc_stat(0);
+     /*<<gc.ml:72:2>>*/  /*<<gc.ml:72:2>>*/ caml_call3
+     (Stdlib_Printf[1], c, _a_, st[4]);
+     /*<<gc.ml:73:2>>*/  /*<<gc.ml:73:2>>*/ caml_call3
+     (Stdlib_Printf[1], c, _b_, st[5]);
+     /*<<gc.ml:74:2>>*/  /*<<gc.ml:74:2>>*/ caml_call3
+     (Stdlib_Printf[1], c, _c_, st[14]);
+     /*<<gc.ml:75:2>>*/  /*<<gc.ml:75:2>>*/ caml_call3
+     (Stdlib_Printf[1], c, _d_, st[17]);
+     /*<<gc.ml:76:2>>*/  /*<<gc.ml:76:2>>*/ caml_call2
+     (Stdlib_Printf[1], c, _e_);
+     /*<<gc.ml:77:25>>*/  /*<<gc.ml:77:25>>*/ var
+     l1 =
+        /*<<gc.ml:77:25>>*/ caml_ml_string_length
+        ( /*<<gc.ml:77:25>>*/ caml_call2(Stdlib_Printf[4], _f_, st[1]));
+     /*<<gc.ml:78:2>>*/  /*<<gc.ml:78:2>>*/ caml_call4
+     (Stdlib_Printf[1], c, _g_, l1, st[1]);
+     /*<<gc.ml:79:2>>*/  /*<<gc.ml:79:2>>*/ caml_call4
+     (Stdlib_Printf[1], c, _h_, l1, st[2]);
+     /*<<gc.ml:80:2>>*/  /*<<gc.ml:80:2>>*/ caml_call4
+     (Stdlib_Printf[1], c, _i_, l1, st[3]);
+     /*<<gc.ml:81:2>>*/  /*<<gc.ml:81:2>>*/ caml_call2
+     (Stdlib_Printf[1], c, _j_);
+     /*<<gc.ml:82:25>>*/  /*<<gc.ml:82:25>>*/ var
+     l2 =
+        /*<<gc.ml:82:25>>*/ caml_ml_string_length
+        ( /*<<gc.ml:82:25>>*/ caml_call2(Stdlib_Printf[4], _k_, st[15]));
+     /*<<gc.ml:83:2>>*/  /*<<gc.ml:83:2>>*/ caml_call4
+     (Stdlib_Printf[1], c, _l_, l2, st[15]);
+     /*<<gc.ml:84:2>>*/  /*<<gc.ml:84:2>>*/ caml_call4
+     (Stdlib_Printf[1], c, _m_, l2, st[6]);
+     /*<<gc.ml:85:2>>*/  /*<<gc.ml:85:2>>*/ caml_call4
+     (Stdlib_Printf[1], c, _n_, l2, st[8]);
+     /*<<gc.ml:86:2>>*/  /*<<gc.ml:86:2>>*/ caml_call4
+     (Stdlib_Printf[1], c, _o_, l2, st[10]);
+     /*<<gc.ml:87:2>>*/  /*<<gc.ml:87:2>>*/ caml_call4
+     (Stdlib_Printf[1], c, _p_, l2, st[12]);
+     /*<<gc.ml:88:2>>*/  /*<<gc.ml:88:2>>*/ caml_call4
+     (Stdlib_Printf[1], c, _q_, l2, st[13]);
+     /*<<gc.ml:89:2>>*/  /*<<gc.ml:89:2>>*/ caml_call2
+     (Stdlib_Printf[1], c, _r_);
+     /*<<gc.ml:90:2>>*/  /*<<gc.ml:90:2>>*/ caml_call3
+     (Stdlib_Printf[1], c, _s_, st[9]);
+     /*<<gc.ml:91:2>>*/  /*<<gc.ml:91:2>>*/ caml_call3
+     (Stdlib_Printf[1], c, _t_, st[11]);
+    return caml_call3(Stdlib_Printf[1], c, _u_, st[7]);
+    /*<<gc.ml:92:46>>*/ }
+   function allocated_bytes(param){
+     /*<<gc.ml:96:2>>*/ var
+      /*<<gc.ml:96:22>>*/ match =
+        /*<<gc.ml:96:22>>*/ runtime.caml_gc_counters(0),
+     ma = match[3],
+     pro = match[2],
+     mi = match[1];
+     /*<<gc.ml:97:2>>*/ return (mi + ma - pro) * (Stdlib_Sys[9] / 8 | 0);
+    /*<<gc.ml:97:55>>*/ }
+   function create_alarm(f){
+     /*<<gc.ml:117:2>>*/ return  /*<<gc.ml:117:24>>*/ caml_call1
+            (Stdlib_Atomic[1], 1);
+    /*<<gc.ml:119:13>>*/ }
+   function delete_alarm(a){
+     /*<<gc.ml:122:21>>*/ return  /*<<gc.ml:122:21>>*/ caml_call2
+            (Stdlib_Atomic[3], a, 0);
+    /*<<gc.ml:122:39>>*/ }
+   function _v_(param){ /*<<gc.ml:146:32>>*/ return 0; /*<<gc.ml:146:34>>*/ }
+   function _w_(param){ /*<<gc.ml:145:32>>*/ return 0; /*<<gc.ml:145:34>>*/ }
+   function _x_(param){ /*<<gc.ml:144:26>>*/ return 0; /*<<gc.ml:144:30>>*/ }
+   function _y_(param){ /*<<gc.ml:143:30>>*/ return 0; /*<<gc.ml:143:34>>*/ }
+    /*<<gc.ml:141:23>>*/  /*<<gc.ml:141:23>>*/ var
+    null_tracker =
+      [0,
+       function(param){ /*<<gc.ml:142:30>>*/ return 0; /*<<gc.ml:142:34>>*/ },
+       _y_,
+       _x_,
+       _w_,
+       _v_];
+   function start(sampling_rate, opt, tracker){
+     /*<<gc.ml:157:6>>*/ if(opt)
+     var sth = opt[1], callstack_size = sth;
+    else
+     var callstack_size = Stdlib[19];
+     /*<<gc.ml:157:6>>*/ return  /*<<gc.ml:157:6>>*/ runtime.caml_memprof_start
+            (sampling_rate, callstack_size, tracker);
+    /*<<gc.ml:157:50>>*/ }
+   var _z_ = [0, null_tracker, start, runtime.caml_memprof_stop];
+   function _A_(_E_){ /*<<?>>*/ return runtime.caml_final_release(_E_);}
+   var
+    _B_ = runtime.caml_final_register_called_without_value,
+    Stdlib_Gc =
+      [0,
+       print_stat,
+       allocated_bytes,
+       function(_D_, _C_){
+         /*<<?>>*/ return runtime.caml_final_register(_D_, _C_);
+       },
+       _B_,
+       _A_,
+       create_alarm,
+       delete_alarm,
+       eventlog_pause,
+       eventlog_resume,
+       _z_];
+   runtime.caml_register_global(25, Stdlib_Gc, "Stdlib__Gc");
+   return;
+   /*<<?>>*/ }
+  (globalThis));
+
+//# unitInfo: Provides: Stdlib__Digest
+//# unitInfo: Requires: Stdlib, Stdlib__Bytes, Stdlib__Char, Stdlib__String
+(function
+  (globalThis){
+   "use strict";
+   var
+    runtime = globalThis.jsoo_runtime,
+    cst_Digest_from_hex$1 = "Digest.from_hex",
+    caml_bytes_unsafe_set = runtime.caml_bytes_unsafe_set,
+    caml_create_bytes = runtime.caml_create_bytes,
+    caml_maybe_attach_backtrace = runtime.caml_maybe_attach_backtrace,
+    caml_md5_string = runtime.caml_md5_string,
+    caml_ml_string_length = runtime.caml_ml_string_length,
+    caml_string_get = runtime.caml_string_get,
+    caml_wrap_exception = runtime.caml_wrap_exception;
+    /*<<?>>*/ function caml_call1(f, a0){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 1
+            ? f(a0)
+            : runtime.caml_call_gen(f, [a0]);
+   }
+    /*<<?>>*/ function caml_call2(f, a0, a1){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 2
+            ? f(a0, a1)
+            : runtime.caml_call_gen(f, [a0, a1]);
+   }
+   var
+    global_data = runtime.caml_get_global_data(),
+    Stdlib = global_data.Stdlib,
+    Stdlib_Char = global_data.Stdlib__Char,
+    Stdlib_Bytes = global_data.Stdlib__Bytes,
+    Stdlib_String = global_data.Stdlib__String,
+    compare = Stdlib_String[9],
+    equal = Stdlib_String[8],
+    cst_Digest_from_hex$0 = cst_Digest_from_hex$1,
+    cst_Digest_from_hex = cst_Digest_from_hex$1,
+    cst_Digest_to_hex = "Digest.to_hex",
+    cst_Digest_substring = "Digest.substring";
+   function string(str){
+     /*<<digest.ml:27:2>>*/ return  /*<<digest.ml:27:2>>*/ caml_md5_string
+            (str, 0, caml_ml_string_length(str));
+    /*<<digest.ml:27:41>>*/ }
+   function bytes(b){
+     /*<<digest.ml:29:14>>*/ return string
+            ( /*<<digest.ml:29:21>>*/ caml_call1(Stdlib_Bytes[44], b));
+    /*<<digest.ml:29:47>>*/ }
+   function substring(str, ofs, len){
+     /*<<digest.ml:32:2>>*/ if
+     (0 <= ofs && 0 <= len && (caml_ml_string_length(str) - len | 0) >= ofs)
+      /*<<digest.ml:34:7>>*/ return  /*<<digest.ml:34:7>>*/ caml_md5_string
+             (str, ofs, len);
+     /*<<digest.ml:33:7>>*/ return  /*<<digest.ml:33:7>>*/ caml_call1
+            (Stdlib[1], cst_Digest_substring);
+    /*<<digest.ml:34:32>>*/ }
+   function subbytes(b, ofs, len){
+     /*<<digest.ml:36:25>>*/ return substring
+            ( /*<<digest.ml:36:35>>*/ caml_call1(Stdlib_Bytes[44], b),
+             ofs,
+             len);
+    /*<<digest.ml:36:69>>*/ }
+   function file(filename){
+     /*<<digest.ml:39:2>>*/  /*<<digest.ml:39:11>>*/ var
+     ic =  /*<<digest.ml:39:11>>*/ caml_call1(Stdlib[80], filename);
+     /*<<digest.ml:40:2>>*/ try{
+      /*<<digest.ml:40:8>>*/  /*<<digest.ml:40:8>>*/ var
+      d =  /*<<digest.ml:40:8>>*/ runtime.caml_md5_chan(ic, -1);
+    }
+    catch(e$0){
+     var e = caml_wrap_exception(e$0);
+      /*<<digest.ml:42:21>>*/  /*<<digest.ml:42:21>>*/ caml_call1
+      (Stdlib[93], ic);
+      /*<<digest.ml:42:34>>*/ throw  /*<<digest.ml:42:34>>*/ caml_maybe_attach_backtrace
+            (e, 0);
+    }
+     /*<<digest.ml:41:11>>*/  /*<<digest.ml:41:11>>*/ caml_call1
+     (Stdlib[93], ic);
+     /*<<digest.ml:41:11>>*/ return d;
+    /*<<digest.ml:42:41>>*/ }
+   function output(chan, digest){
+     /*<<digest.ml:45:2>>*/ return  /*<<digest.ml:45:2>>*/ caml_call2
+            (Stdlib[66], chan, digest);
+    /*<<digest.ml:45:27>>*/ }
+   function input(chan){
+     /*<<digest.ml:47:17>>*/ return  /*<<digest.ml:47:17>>*/ caml_call2
+            (Stdlib[86], chan, 16);
+    /*<<digest.ml:47:44>>*/ }
+   function char_hex(n){
+     /*<<digest.ml:50:2>>*/ var _e_ = 10 <= n ? 87 : 48;
+    return n + _e_ | 0;
+    /*<<digest.ml:50:78>>*/ }
+   function to_hex(d){
+     /*<<digest.ml:53:2>>*/ if(16 !== caml_ml_string_length(d))
+      /*<<digest.ml:53:32>>*/  /*<<digest.ml:53:32>>*/ caml_call1
+      (Stdlib[1], cst_Digest_to_hex);
+     /*<<digest.ml:54:15>>*/ var
+      /*<<digest.ml:54:15>>*/ result =
+        /*<<digest.ml:54:15>>*/ caml_create_bytes(32),
+     i = 0;
+    for(;;){
+      /*<<digest.ml:56:22>>*/  /*<<digest.ml:56:22>>*/ var
+      x =  /*<<digest.ml:56:22>>*/ caml_string_get(d, i);
+     caml_bytes_unsafe_set(result, i * 2 | 0, char_hex(x >>> 4 | 0));
+     caml_bytes_unsafe_set(result, (i * 2 | 0) + 1 | 0, char_hex(x & 15));
+      /*<<digest.ml:55:2>>*/  /*<<digest.ml:55:2>>*/ var _d_ = i + 1 | 0;
+     if(15 === i)
+       /*<<digest.ml:60:2>>*/ return  /*<<digest.ml:60:2>>*/ caml_call1
+              (Stdlib_Bytes[44], result);
+     var i = _d_;
+    }
+    /*<<digest.ml:60:31>>*/ }
+   function from_hex(s){
+     /*<<digest.ml:63:2>>*/ if(32 !== caml_ml_string_length(s))
+      /*<<digest.ml:63:32>>*/  /*<<digest.ml:63:32>>*/ caml_call1
+      (Stdlib[1], cst_Digest_from_hex);
+     /*<<digest.ml:63:32>>*/ function digit(c){
+      /*<<digest.ml:65:4>>*/ if(65 <= c){
+      if(97 <= c){
+       if(103 > c) return (c - 97 | 0) + 10 | 0;
+      }
+      else if(71 > c) return (c - 65 | 0) + 10 | 0;
+     }
+     else if(9 >= c - 48 >>> 0) return c - 48 | 0;
+      /*<<digest.ml:69:11>>*/ throw  /*<<digest.ml:69:11>>*/ caml_maybe_attach_backtrace
+            ([0, Stdlib[6], cst_Digest_from_hex$0], 1);
+     /*<<digest.ml:69:53>>*/ }
+     /*<<digest.ml:72:15>>*/ var
+      /*<<digest.ml:72:15>>*/ result =
+        /*<<digest.ml:72:15>>*/ caml_create_bytes(16),
+     i = 0;
+    for(;;){
+      /*<<digest.ml:71:35>>*/ var
+      i$0 = 2 * i | 0,
+       /*<<digest.ml:71:35>>*/ _a_ =
+        digit( /*<<digest.ml:71:41>>*/ caml_string_get(s, i$0 + 1 | 0)),
+      _b_ =
+        (digit( /*<<digest.ml:71:21>>*/ caml_string_get(s, i$0)) << 4) + _a_
+        | 0;
+      /*<<digest.ml:74:4>>*/  /*<<digest.ml:74:4>>*/ runtime.caml_bytes_set
+      (result, i,  /*<<digest.ml:74:23>>*/ caml_call1(Stdlib_Char[1], _b_));
+      /*<<digest.ml:74:4>>*/  /*<<digest.ml:74:4>>*/ var _c_ = i + 1 | 0;
+     if(15 === i)
+       /*<<digest.ml:76:2>>*/ return  /*<<digest.ml:76:2>>*/ caml_call1
+              (Stdlib_Bytes[44], result);
+     var i = _c_;
+    }
+    /*<<digest.ml:76:31>>*/ }
+   var
+    Stdlib_Digest =
+      [0,
+       compare,
+       equal,
+       string,
+       bytes,
+       substring,
+       subbytes,
+       file,
+       output,
+       input,
+       to_hex,
+       from_hex];
+   runtime.caml_register_global(8, Stdlib_Digest, "Stdlib__Digest");
+   return;
+   /*<<?>>*/ }
+  (globalThis));
+
+//# unitInfo: Provides: Stdlib__Bigarray
+//# unitInfo: Requires: Stdlib, Stdlib__Array, Stdlib__Sys
+(function
+  (globalThis){
+   "use strict";
+   var
+    runtime = globalThis.jsoo_runtime,
+    cst_Bigarray_Array3_of_array_n$1 =
+      "Bigarray.Array3.of_array: non-cubic data",
+    caml_ba_change_layout = runtime.caml_ba_change_layout,
+    caml_ba_create = runtime.caml_ba_create,
+    caml_ba_dim_1 = runtime.caml_ba_dim_1,
+    caml_ba_dim_2 = runtime.caml_ba_dim_2,
+    caml_ba_kind = runtime.caml_ba_kind,
+    caml_ba_num_dims = runtime.caml_ba_num_dims,
+    caml_ba_reshape = runtime.caml_ba_reshape,
+    caml_ba_set_1 = runtime.caml_ba_set_1,
+    caml_ba_set_2 = runtime.caml_ba_set_2,
+    caml_ba_set_3 = runtime.caml_ba_set_3,
+    caml_ba_set_generic = runtime.caml_ba_set_generic,
+    caml_ba_slice = runtime.caml_ba_slice,
+    caml_check_bound = runtime.caml_check_bound,
+    caml_make_vect = runtime.caml_make_vect,
+    caml_mul = runtime.caml_mul;
+    /*<<?>>*/ function caml_call1(f, a0){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 1
+            ? f(a0)
+            : runtime.caml_call_gen(f, [a0]);
+   }
+    /*<<?>>*/ function caml_call2(f, a0, a1){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 2
+            ? f(a0, a1)
+            : runtime.caml_call_gen(f, [a0, a1]);
+   }
+    /*<<?>>*/ function caml_call3(f, a0, a1, a2){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 3
+            ? f(a0, a1, a2)
+            : runtime.caml_call_gen(f, [a0, a1, a2]);
+   }
+   var
+    global_data = runtime.caml_get_global_data(),
+    Stdlib = global_data.Stdlib,
+    Stdlib_Array = global_data.Stdlib__Array,
+    Stdlib_Sys = global_data.Stdlib__Sys,
+    cst_Bigarray_array3_of_genarra = "Bigarray.array3_of_genarray",
+    cst_Bigarray_array2_of_genarra = "Bigarray.array2_of_genarray",
+    cst_Bigarray_array1_of_genarra = "Bigarray.array1_of_genarray",
+    cst_Bigarray_array0_of_genarra = "Bigarray.array0_of_genarray",
+    cst_Bigarray_Array3_of_array_n = cst_Bigarray_Array3_of_array_n$1,
+    cst_Bigarray_Array3_of_array_n$0 = cst_Bigarray_Array3_of_array_n$1,
+    cst_Bigarray_Array2_of_array_n =
+      "Bigarray.Array2.of_array: non-rectangular data",
+    float32 = 0,
+    float64 = 1,
+    int8_signed = 2,
+    int8_unsigned = 3,
+    int16_signed = 4,
+    int16_unsigned = 5,
+    int32 = 6,
+    int64 = 7,
+    int$0 = 8,
+    nativeint = 9,
+    complex32 = 10,
+    complex64 = 11,
+    char$0 = 12;
+   function kind_size_in_bytes(param){
+     /*<<bigarray.ml:73:4>>*/ switch(param){
+      case 0:
+        /*<<bigarray.ml:74:15>>*/ return 4;
+      case 1:
+        /*<<bigarray.ml:75:15>>*/ return 8;
+      case 2:
+        /*<<bigarray.ml:76:19>>*/ return 1;
+      case 3:
+        /*<<bigarray.ml:77:21>>*/ return 1;
+      case 4:
+        /*<<bigarray.ml:78:20>>*/ return 2;
+      case 5:
+        /*<<bigarray.ml:79:22>>*/ return 2;
+      case 6:
+        /*<<bigarray.ml:80:13>>*/ return 4;
+      case 7:
+        /*<<bigarray.ml:81:13>>*/ return 8;
+      case 8:
+       return Stdlib_Sys[9] / 8 | 0;
+      case 9:
+       return Stdlib_Sys[9] / 8 | 0;
+      case 10:
+        /*<<bigarray.ml:84:17>>*/ return 8;
+      case 11:
+        /*<<bigarray.ml:85:17>>*/ return 16;
+      default:  /*<<bigarray.ml:86:12>>*/ return 1;
+    }
+    /*<<bigarray.ml:86:13>>*/ }
+    /*<<bigarray.ml:73:4>>*/ var
+     /*<<bigarray.ml:73:4>>*/ c_layout = 0,
+    fortran_layout = 1;
+   function cloop(arr, idx, f, col, max){
+     /*<<bigarray.ml:104:4>>*/ if(col === idx.length - 1)
+      /*<<bigarray.ml:104:35>>*/ return  /*<<bigarray.ml:104:35>>*/ caml_ba_set_generic
+             (arr, idx,  /*<<bigarray.ml:104:47>>*/ caml_call1(f, idx));
+     /*<<bigarray.ml:105:27>>*/ var
+      /*<<bigarray.ml:105:27>>*/ _am_ =
+       caml_check_bound(max, col)[1 + col] - 1 | 0,
+      /*<<bigarray.ml:105:9>>*/ _al_ = 0;
+    if(_am_ >= 0){
+     var j = _al_;
+     for(;;){
+       /*<<bigarray.ml:106:11>>*/ caml_check_bound(idx, col)[1 + col] = j;
+       /*<<bigarray.ml:107:11>>*/ cloop(arr, idx, f, col + 1 | 0, max);
+       /*<<bigarray.ml:107:11>>*/  /*<<bigarray.ml:107:11>>*/ var
+       _an_ = j + 1 | 0;
+      if(_am_ === j) break;
+      var j = _an_;
+     }
+    }
+    return 0;
+    /*<<bigarray.ml:108:13>>*/ }
+   function floop(arr, idx, f, col, max){
+     /*<<bigarray.ml:110:4>>*/ if(0 > col)
+      /*<<bigarray.ml:110:20>>*/ return  /*<<bigarray.ml:110:20>>*/ caml_ba_set_generic
+             (arr, idx,  /*<<bigarray.ml:110:32>>*/ caml_call1(f, idx));
+     /*<<bigarray.ml:111:22>>*/ var
+      /*<<bigarray.ml:111:22>>*/ _aj_ = caml_check_bound(max, col)[1 + col],
+      /*<<bigarray.ml:111:9>>*/ _ai_ = 1;
+    if(_aj_ >= 1){
+     var j = _ai_;
+     for(;;){
+       /*<<bigarray.ml:112:11>>*/ caml_check_bound(idx, col)[1 + col] = j;
+       /*<<bigarray.ml:113:11>>*/ floop(arr, idx, f, col - 1 | 0, max);
+       /*<<bigarray.ml:113:11>>*/  /*<<bigarray.ml:113:11>>*/ var
+       _ak_ = j + 1 | 0;
+      if(_aj_ === j) break;
+      var j = _ak_;
+     }
+    }
+    return 0;
+    /*<<bigarray.ml:114:13>>*/ }
+   function init(kind, layout, dims, f){
+     /*<<bigarray.ml:116:4>>*/ var
+      /*<<bigarray.ml:116:14>>*/ arr =
+        /*<<bigarray.ml:116:14>>*/ caml_ba_create(kind, layout, dims),
+      /*<<bigarray.ml:117:4>>*/ dlen = dims.length - 1;
+     /*<<bigarray.ml:118:4>>*/ return layout
+            ? (floop
+               (arr,
+                 /*<<bigarray.ml:120:34>>*/ caml_make_vect(dlen, 1),
+                f,
+                dlen - 1 | 0,
+                dims),
+              arr)
+            : (cloop
+               (arr,
+                 /*<<bigarray.ml:119:28>>*/ caml_make_vect(dlen, 0),
+                f,
+                0,
+                dims),
+              arr);
+    /*<<bigarray.ml:120:77>>*/ }
+   function dims(a){
+     /*<<bigarray.ml:125:4>>*/ var
+      /*<<bigarray.ml:125:12>>*/ n =
+        /*<<bigarray.ml:125:12>>*/ caml_ba_num_dims(a),
+      /*<<bigarray.ml:126:12>>*/ d =
+        /*<<bigarray.ml:126:12>>*/ caml_make_vect(n, 0),
+      /*<<bigarray.ml:127:4>>*/ _af_ = n - 1 | 0,
+      /*<<bigarray.ml:126:12>>*/ _ae_ = 0;
+    if(_af_ >= 0){
+     var i = _ae_;
+     for(;;){
+       /*<<bigarray.ml:127:33>>*/  /*<<bigarray.ml:127:33>>*/ var
+       _ag_ =  /*<<bigarray.ml:127:33>>*/ runtime.caml_ba_dim(a, i);
+       /*<<bigarray.ml:127:24>>*/ caml_check_bound(d, i)[1 + i] = _ag_;
+       /*<<bigarray.ml:127:24>>*/  /*<<bigarray.ml:127:24>>*/ var
+       _ah_ = i + 1 | 0;
+      if(_af_ === i) break;
+      var i = _ah_;
+     }
+    }
+     /*<<bigarray.ml:128:4>>*/ return d;
+    /*<<bigarray.ml:128:5>>*/ }
+   function size_in_bytes(arr){
+     /*<<bigarray.ml:136:4>>*/ var
+      /*<<bigarray.ml:136:63>>*/ _ac_ = dims(arr),
+      /*<<bigarray.ml:136:38>>*/ _ad_ =
+        /*<<bigarray.ml:136:38>>*/ caml_call3
+        (Stdlib_Array[15], caml_mul, 1, _ac_);
+     /*<<bigarray.ml:136:4>>*/ return  /*<<bigarray.ml:136:4>>*/ caml_mul
+            (kind_size_in_bytes( /*<<bigarray.ml:136:24>>*/ caml_ba_kind(arr)),
+             _ad_);
+    /*<<bigarray.ml:136:74>>*/ }
+   function create(kind, layout){
+     /*<<bigarray.ml:157:4>>*/ return  /*<<bigarray.ml:157:4>>*/ caml_ba_create
+            (kind, layout, [0]);
+    /*<<bigarray.ml:157:36>>*/ }
+   function get(arr){
+     /*<<bigarray.ml:158:16>>*/ return  /*<<bigarray.ml:158:16>>*/ runtime.caml_ba_get_generic
+            (arr, [0]);
+    /*<<bigarray.ml:158:37>>*/ }
+   function set(arr){
+     /*<<bigarray.ml:159:16>>*/  /*<<bigarray.ml:159:16>>*/ var _aa_ = [0];
+     /*<<bigarray.ml:159:33>>*/ return function(_ab_){
+      /*<<?>>*/ return caml_ba_set_generic(arr, _aa_, _ab_);};
+    /*<<bigarray.ml:159:37>>*/ }
+   function size_in_bytes$0(arr){
+     /*<<bigarray.ml:166:26>>*/ return kind_size_in_bytes
+            ( /*<<bigarray.ml:166:45>>*/ caml_ba_kind(arr));
+    /*<<bigarray.ml:166:55>>*/ }
+   function of_value(kind, layout, v){
+     /*<<bigarray.ml:172:4>>*/  /*<<bigarray.ml:172:12>>*/ var
+     a = create(kind, layout);
+     /*<<bigarray.ml:173:4>>*/ set(a)(v);
+     /*<<bigarray.ml:173:4>>*/ return a;
+    /*<<bigarray.ml:174:5>>*/ }
+   function create$0(kind, layout, dim){
+     /*<<bigarray.ml:181:4>>*/ return  /*<<bigarray.ml:181:4>>*/ caml_ba_create
+            (kind, layout, [0, dim]);
+    /*<<bigarray.ml:181:39>>*/ }
+   function size_in_bytes$1(arr){
+     /*<<bigarray.ml:195:4>>*/  /*<<bigarray.ml:195:38>>*/ var
+     _$_ =  /*<<bigarray.ml:195:38>>*/ caml_ba_dim_1(arr);
+     /*<<bigarray.ml:195:4>>*/ return  /*<<bigarray.ml:195:4>>*/ caml_mul
+            (kind_size_in_bytes( /*<<bigarray.ml:195:24>>*/ caml_ba_kind(arr)),
+             _$_);
+    /*<<bigarray.ml:195:47>>*/ }
+   function slice(a, n){
+     /*<<bigarray.ml:199:4>>*/ return  /*<<bigarray.ml:199:10>>*/ runtime.caml_ba_layout
+             (a)
+            ?  /*<<bigarray.ml:201:25>>*/ caml_ba_slice(a, [0, n])
+            :  /*<<bigarray.ml:200:19>>*/ caml_ba_slice(a, [0, n]);
+    /*<<bigarray.ml:201:76>>*/ }
+   function init$0(kind, layout, dim, f){
+     /*<<bigarray.ml:209:4>>*/  /*<<bigarray.ml:209:14>>*/ var
+     arr = create$0(kind, layout, dim);
+     /*<<bigarray.ml:210:4>>*/ if(layout){
+      /*<<bigarray.ml:207:4>>*/  /*<<bigarray.ml:207:4>>*/ var _Z_ = 1;
+     if(dim >= 1){
+      var i$0 = _Z_;
+      for(;;){
+        /*<<bigarray.ml:207:24>>*/  /*<<bigarray.ml:207:24>>*/ caml_ba_set_1
+        (arr, i$0,  /*<<bigarray.ml:207:41>>*/ caml_call1(f, i$0));
+        /*<<bigarray.ml:207:24>>*/  /*<<bigarray.ml:207:24>>*/ var
+        ___ = i$0 + 1 | 0;
+       if(dim === i$0) break;
+       var i$0 = ___;
+      }
+     }
+      /*<<bigarray.ml:212:24>>*/ return arr;
+    }
+     /*<<bigarray.ml:205:4>>*/ var
+     _X_ = dim - 1 | 0,
+      /*<<bigarray.ml:205:4>>*/ _W_ = 0;
+    if(_X_ >= 0){
+     var i = _W_;
+     for(;;){
+       /*<<bigarray.ml:205:29>>*/  /*<<bigarray.ml:205:29>>*/ caml_ba_set_1
+       (arr, i,  /*<<bigarray.ml:205:46>>*/ caml_call1(f, i));
+       /*<<bigarray.ml:205:29>>*/  /*<<bigarray.ml:205:29>>*/ var
+       _Y_ = i + 1 | 0;
+      if(_X_ === i) break;
+      var i = _Y_;
+     }
+    }
+     /*<<bigarray.ml:211:18>>*/ return arr;
+    /*<<bigarray.ml:212:51>>*/ }
+   function of_array(kind, layout, data){
+     /*<<bigarray.ml:214:4>>*/ var
+      /*<<bigarray.ml:214:13>>*/ ba = create$0(kind, layout, data.length - 1),
+      /*<<bigarray.ml:215:4>>*/ ofs = layout ? 1 : 0,
+     _U_ = data.length - 1 - 1 | 0,
+     _T_ = 0;
+    if(_U_ >= 0){
+     var i = _T_;
+     for(;;){
+       /*<<bigarray.ml:220:42>>*/  /*<<bigarray.ml:220:42>>*/ caml_ba_set_1
+       (ba, i + ofs | 0, caml_check_bound(data, i)[1 + i]);
+       /*<<bigarray.ml:220:42>>*/  /*<<bigarray.ml:220:42>>*/ var
+       _V_ = i + 1 | 0;
+      if(_U_ === i) break;
+      var i = _V_;
+     }
+    }
+     /*<<bigarray.ml:221:4>>*/ return ba;
+    /*<<bigarray.ml:221:6>>*/ }
+   function create$1(kind, layout, dim1, dim2){
+     /*<<bigarray.ml:227:4>>*/ return  /*<<bigarray.ml:227:4>>*/ caml_ba_create
+            (kind, layout, [0, dim1, dim2]);
+    /*<<bigarray.ml:227:46>>*/ }
+   function size_in_bytes$2(arr){
+     /*<<bigarray.ml:243:4>>*/ var
+      /*<<bigarray.ml:243:51>>*/ _R_ =
+        /*<<bigarray.ml:243:51>>*/ caml_ba_dim_2(arr),
+      /*<<bigarray.ml:243:38>>*/ _S_ =
+        /*<<bigarray.ml:243:38>>*/ caml_ba_dim_1(arr);
+    return caml_mul
+            ( /*<<bigarray.ml:243:4>>*/ caml_mul
+              (kind_size_in_bytes
+                ( /*<<bigarray.ml:243:24>>*/ caml_ba_kind(arr)),
+               _S_),
+             _R_);
+    /*<<bigarray.ml:243:61>>*/ }
+   function slice_left(a, n){
+     /*<<bigarray.ml:250:23>>*/ return  /*<<bigarray.ml:250:23>>*/ caml_ba_slice
+            (a, [0, n]);
+    /*<<bigarray.ml:250:50>>*/ }
+   function slice_right(a, n){
+     /*<<bigarray.ml:251:24>>*/ return  /*<<bigarray.ml:251:24>>*/ caml_ba_slice
+            (a, [0, n]);
+    /*<<bigarray.ml:251:52>>*/ }
+   function init$1(kind, layout, dim1, dim2, f){
+     /*<<bigarray.ml:267:4>>*/  /*<<bigarray.ml:267:14>>*/ var
+     arr = create$1(kind, layout, dim1, dim2);
+     /*<<bigarray.ml:268:4>>*/ if(layout){
+      /*<<bigarray.ml:261:4>>*/  /*<<bigarray.ml:261:4>>*/ var _N_ = 1;
+     if(dim2 >= 1){
+      var j$0 = _N_;
+      for(;;){
+        /*<<bigarray.ml:262:6>>*/  /*<<bigarray.ml:262:6>>*/ var _O_ = 1;
+       if(dim1 >= 1){
+        var i$0 = _O_;
+        for(;;){
+          /*<<bigarray.ml:263:8>>*/  /*<<bigarray.ml:263:8>>*/ caml_ba_set_2
+          (arr, i$0, j$0,  /*<<bigarray.ml:263:27>>*/ caml_call2(f, i$0, j$0));
+          /*<<bigarray.ml:263:8>>*/  /*<<bigarray.ml:263:8>>*/ var
+          _Q_ = i$0 + 1 | 0;
+         if(dim1 === i$0) break;
+         var i$0 = _Q_;
+        }
+       }
+        /*<<bigarray.ml:261:4>>*/  /*<<bigarray.ml:261:4>>*/ var
+        _P_ = j$0 + 1 | 0;
+       if(dim2 === j$0) break;
+       var j$0 = _P_;
+      }
+     }
+      /*<<bigarray.ml:270:24>>*/ return arr;
+    }
+     /*<<bigarray.ml:255:4>>*/ var
+     _I_ = dim1 - 1 | 0,
+      /*<<bigarray.ml:255:4>>*/ _H_ = 0;
+    if(_I_ >= 0){
+     var i = _H_;
+     for(;;){
+       /*<<bigarray.ml:256:6>>*/ var
+       _K_ = dim2 - 1 | 0,
+        /*<<bigarray.ml:256:6>>*/ _J_ = 0;
+      if(_K_ >= 0){
+       var j = _J_;
+       for(;;){
+         /*<<bigarray.ml:257:8>>*/  /*<<bigarray.ml:257:8>>*/ caml_ba_set_2
+         (arr, i, j,  /*<<bigarray.ml:257:27>>*/ caml_call2(f, i, j));
+         /*<<bigarray.ml:257:8>>*/  /*<<bigarray.ml:257:8>>*/ var
+         _M_ = j + 1 | 0;
+        if(_K_ === j) break;
+        var j = _M_;
+       }
+      }
+       /*<<bigarray.ml:255:4>>*/  /*<<bigarray.ml:255:4>>*/ var
+       _L_ = i + 1 | 0;
+      if(_I_ === i) break;
+      var i = _L_;
+     }
+    }
+     /*<<bigarray.ml:269:18>>*/ return arr;
+    /*<<bigarray.ml:270:57>>*/ }
+   function of_array$0(kind, layout, data){
+     /*<<bigarray.ml:272:4>>*/ var
+     dim1 = data.length - 1,
+      /*<<bigarray.ml:273:4>>*/ dim2 =
+       0 === dim1 ? 0 : caml_check_bound(data, 0)[1].length - 1,
+      /*<<bigarray.ml:274:13>>*/ ba = create$1(kind, layout, dim1, dim2),
+      /*<<bigarray.ml:275:4>>*/ ofs = layout ? 1 : 0,
+      /*<<bigarray.ml:280:4>>*/ _C_ = dim1 - 1 | 0,
+     _B_ = 0;
+    if(_C_ >= 0){
+     var i = _B_;
+     for(;;){
+       /*<<bigarray.ml:281:16>>*/  /*<<bigarray.ml:281:16>>*/ var
+       row = caml_check_bound(data, i)[1 + i];
+      if(row.length - 1 !== dim2)
+        /*<<bigarray.ml:283:8>>*/  /*<<bigarray.ml:283:8>>*/ caml_call1
+        (Stdlib[1], cst_Bigarray_Array2_of_array_n);
+       /*<<bigarray.ml:273:32>>*/ var
+        /*<<bigarray.ml:273:32>>*/ _E_ = dim2 - 1 | 0,
+        /*<<bigarray.ml:283:8>>*/ _D_ = 0;
+      if(_E_ >= 0){
+       var j = _D_;
+       for(;;){
+         /*<<bigarray.ml:285:8>>*/  /*<<bigarray.ml:285:8>>*/ caml_ba_set_2
+         (ba, i + ofs | 0, j + ofs | 0, caml_check_bound(row, j)[1 + j]);
+         /*<<bigarray.ml:285:8>>*/  /*<<bigarray.ml:285:8>>*/ var
+         _G_ = j + 1 | 0;
+        if(_E_ === j) break;
+        var j = _G_;
+       }
+      }
+       /*<<bigarray.ml:280:4>>*/  /*<<bigarray.ml:280:4>>*/ var
+       _F_ = i + 1 | 0;
+      if(_C_ === i) break;
+      var i = _F_;
+     }
+    }
+     /*<<bigarray.ml:288:4>>*/ return ba;
+    /*<<bigarray.ml:288:6>>*/ }
+   function create$2(kind, layout, dim1, dim2, dim3){
+     /*<<bigarray.ml:294:4>>*/ return  /*<<bigarray.ml:294:4>>*/ caml_ba_create
+            (kind, layout, [0, dim1, dim2, dim3]);
+    /*<<bigarray.ml:294:52>>*/ }
+   function size_in_bytes$3(arr){
+     /*<<bigarray.ml:312:4>>*/ var
+      /*<<bigarray.ml:312:64>>*/ _y_ =
+        /*<<bigarray.ml:312:64>>*/ runtime.caml_ba_dim_3(arr),
+      /*<<bigarray.ml:312:51>>*/ _z_ =
+        /*<<bigarray.ml:312:51>>*/ caml_ba_dim_2(arr),
+      /*<<bigarray.ml:312:38>>*/ _A_ =
+        /*<<bigarray.ml:312:38>>*/ caml_ba_dim_1(arr);
+    return caml_mul
+            (caml_mul
+              ( /*<<bigarray.ml:312:4>>*/ caml_mul
+                (kind_size_in_bytes
+                  ( /*<<bigarray.ml:312:24>>*/ caml_ba_kind(arr)),
+                 _A_),
+               _z_),
+             _y_);
+    /*<<bigarray.ml:312:74>>*/ }
+   function slice_left_1(a, n, m){
+     /*<<bigarray.ml:319:27>>*/ return  /*<<bigarray.ml:319:27>>*/ caml_ba_slice
+            (a, [0, n, m]);
+    /*<<bigarray.ml:319:57>>*/ }
+   function slice_right_1(a, n, m){
+     /*<<bigarray.ml:320:28>>*/ return  /*<<bigarray.ml:320:28>>*/ caml_ba_slice
+            (a, [0, n, m]);
+    /*<<bigarray.ml:320:59>>*/ }
+   function slice_left_2(a, n){
+     /*<<bigarray.ml:321:25>>*/ return  /*<<bigarray.ml:321:25>>*/ caml_ba_slice
+            (a, [0, n]);
+    /*<<bigarray.ml:321:52>>*/ }
+   function slice_right_2(a, n){
+     /*<<bigarray.ml:322:26>>*/ return  /*<<bigarray.ml:322:26>>*/ caml_ba_slice
+            (a, [0, n]);
+    /*<<bigarray.ml:322:54>>*/ }
+   function init$2(kind, layout, dim1, dim2, dim3, f){
+     /*<<bigarray.ml:342:4>>*/  /*<<bigarray.ml:342:14>>*/ var
+     arr = create$2(kind, layout, dim1, dim2, dim3);
+     /*<<bigarray.ml:343:4>>*/ if(layout){
+      /*<<bigarray.ml:334:4>>*/  /*<<bigarray.ml:334:4>>*/ var _s_ = 1;
+     if(dim3 >= 1){
+      var k$0 = _s_;
+      for(;;){
+        /*<<bigarray.ml:335:6>>*/  /*<<bigarray.ml:335:6>>*/ var _t_ = 1;
+       if(dim2 >= 1){
+        var j$0 = _t_;
+        for(;;){
+          /*<<bigarray.ml:336:8>>*/  /*<<bigarray.ml:336:8>>*/ var _v_ = 1;
+         if(dim1 >= 1){
+          var i$0 = _v_;
+          for(;;){
+            /*<<bigarray.ml:337:10>>*/  /*<<bigarray.ml:337:10>>*/ caml_ba_set_3
+            (arr,
+             i$0,
+             j$0,
+             k$0,
+              /*<<bigarray.ml:337:31>>*/ caml_call3(f, i$0, j$0, k$0));
+            /*<<bigarray.ml:337:10>>*/  /*<<bigarray.ml:337:10>>*/ var
+            _x_ = i$0 + 1 | 0;
+           if(dim1 === i$0) break;
+           var i$0 = _x_;
+          }
+         }
+          /*<<bigarray.ml:335:6>>*/  /*<<bigarray.ml:335:6>>*/ var
+          _w_ = j$0 + 1 | 0;
+         if(dim2 === j$0) break;
+         var j$0 = _w_;
+        }
+       }
+        /*<<bigarray.ml:334:4>>*/  /*<<bigarray.ml:334:4>>*/ var
+        _u_ = k$0 + 1 | 0;
+       if(dim3 === k$0) break;
+       var k$0 = _u_;
+      }
+     }
+      /*<<bigarray.ml:345:24>>*/ return arr;
+    }
+     /*<<bigarray.ml:326:4>>*/ var
+     _k_ = dim1 - 1 | 0,
+      /*<<bigarray.ml:326:4>>*/ _j_ = 0;
+    if(_k_ >= 0){
+     var i = _j_;
+     for(;;){
+       /*<<bigarray.ml:327:6>>*/ var
+       _m_ = dim2 - 1 | 0,
+        /*<<bigarray.ml:327:6>>*/ _l_ = 0;
+      if(_m_ >= 0){
+       var j = _l_;
+       for(;;){
+         /*<<bigarray.ml:328:8>>*/ var
+         _p_ = dim3 - 1 | 0,
+          /*<<bigarray.ml:328:8>>*/ _o_ = 0;
+        if(_p_ >= 0){
+         var k = _o_;
+         for(;;){
+           /*<<bigarray.ml:329:10>>*/  /*<<bigarray.ml:329:10>>*/ caml_ba_set_3
+           (arr, i, j, k,  /*<<bigarray.ml:329:31>>*/ caml_call3(f, i, j, k));
+           /*<<bigarray.ml:329:10>>*/  /*<<bigarray.ml:329:10>>*/ var
+           _r_ = k + 1 | 0;
+          if(_p_ === k) break;
+          var k = _r_;
+         }
+        }
+         /*<<bigarray.ml:327:6>>*/  /*<<bigarray.ml:327:6>>*/ var
+         _q_ = j + 1 | 0;
+        if(_m_ === j) break;
+        var j = _q_;
+       }
+      }
+       /*<<bigarray.ml:326:4>>*/  /*<<bigarray.ml:326:4>>*/ var
+       _n_ = i + 1 | 0;
+      if(_k_ === i) break;
+      var i = _n_;
+     }
+    }
+     /*<<bigarray.ml:344:18>>*/ return arr;
+    /*<<bigarray.ml:345:62>>*/ }
+   function of_array$1(kind, layout, data){
+     /*<<bigarray.ml:347:4>>*/ var
+     dim1 = data.length - 1,
+      /*<<bigarray.ml:348:4>>*/ dim2 =
+       0 === dim1 ? 0 : caml_check_bound(data, 0)[1].length - 1,
+      /*<<bigarray.ml:349:4>>*/ dim3 =
+       0 === dim2
+        ? 0
+        : caml_check_bound(caml_check_bound(data, 0)[1], 0)[1].length - 1,
+      /*<<bigarray.ml:350:13>>*/ ba = create$2(kind, layout, dim1, dim2, dim3),
+      /*<<bigarray.ml:351:4>>*/ ofs = layout ? 1 : 0,
+      /*<<bigarray.ml:356:4>>*/ _b_ = dim1 - 1 | 0,
+     _a_ = 0;
+    if(_b_ >= 0){
+     var i = _a_;
+     for(;;){
+       /*<<bigarray.ml:357:16>>*/  /*<<bigarray.ml:357:16>>*/ var
+       row = caml_check_bound(data, i)[1 + i];
+      if(row.length - 1 !== dim2)
+        /*<<bigarray.ml:359:8>>*/  /*<<bigarray.ml:359:8>>*/ caml_call1
+        (Stdlib[1], cst_Bigarray_Array3_of_array_n);
+       /*<<bigarray.ml:348:32>>*/ var
+        /*<<bigarray.ml:348:32>>*/ _d_ = dim2 - 1 | 0,
+        /*<<bigarray.ml:359:8>>*/ _c_ = 0;
+      if(_d_ >= 0){
+       var j = _c_;
+       for(;;){
+         /*<<bigarray.ml:361:18>>*/  /*<<bigarray.ml:361:18>>*/ var
+         col = caml_check_bound(row, j)[1 + j];
+        if(col.length - 1 !== dim3)
+          /*<<bigarray.ml:363:10>>*/  /*<<bigarray.ml:363:10>>*/ caml_call1
+          (Stdlib[1], cst_Bigarray_Array3_of_array_n$0);
+         /*<<bigarray.ml:349:32>>*/ var
+          /*<<bigarray.ml:349:32>>*/ _g_ = dim3 - 1 | 0,
+          /*<<bigarray.ml:363:10>>*/ _f_ = 0;
+        if(_g_ >= 0){
+         var k = _f_;
+         for(;;){
+           /*<<bigarray.ml:365:10>>*/  /*<<bigarray.ml:365:10>>*/ caml_ba_set_3
+           (ba,
+            i + ofs | 0,
+            j + ofs | 0,
+            k + ofs | 0,
+            caml_check_bound(col, k)[1 + k]);
+           /*<<bigarray.ml:365:10>>*/  /*<<bigarray.ml:365:10>>*/ var
+           _i_ = k + 1 | 0;
+          if(_g_ === k) break;
+          var k = _i_;
+         }
+        }
+         /*<<bigarray.ml:359:8>>*/  /*<<bigarray.ml:359:8>>*/ var
+         _h_ = j + 1 | 0;
+        if(_d_ === j) break;
+        var j = _h_;
+       }
+      }
+       /*<<bigarray.ml:356:4>>*/  /*<<bigarray.ml:356:4>>*/ var
+       _e_ = i + 1 | 0;
+      if(_b_ === i) break;
+      var i = _e_;
+     }
+    }
+     /*<<bigarray.ml:369:4>>*/ return ba;
+    /*<<bigarray.ml:369:6>>*/ }
+   function array0_of_genarray(a){
+     /*<<bigarray.ml:381:2>>*/ return 0
+            ===  /*<<bigarray.ml:381:5>>*/ caml_ba_num_dims(a)
+            ? a
+            :  /*<<bigarray.ml:382:7>>*/ caml_call1
+              (Stdlib[1], cst_Bigarray_array0_of_genarra);
+    /*<<bigarray.ml:382:48>>*/ }
+   function array1_of_genarray(a){
+     /*<<bigarray.ml:384:2>>*/ return 1
+            ===  /*<<bigarray.ml:384:5>>*/ caml_ba_num_dims(a)
+            ? a
+            :  /*<<bigarray.ml:385:7>>*/ caml_call1
+              (Stdlib[1], cst_Bigarray_array1_of_genarra);
+    /*<<bigarray.ml:385:48>>*/ }
+   function array2_of_genarray(a){
+     /*<<bigarray.ml:387:2>>*/ return 2
+            ===  /*<<bigarray.ml:387:5>>*/ caml_ba_num_dims(a)
+            ? a
+            :  /*<<bigarray.ml:388:7>>*/ caml_call1
+              (Stdlib[1], cst_Bigarray_array2_of_genarra);
+    /*<<bigarray.ml:388:48>>*/ }
+   function array3_of_genarray(a){
+     /*<<bigarray.ml:390:2>>*/ return 3
+            ===  /*<<bigarray.ml:390:5>>*/ caml_ba_num_dims(a)
+            ? a
+            :  /*<<bigarray.ml:391:7>>*/ caml_call1
+              (Stdlib[1], cst_Bigarray_array3_of_genarra);
+    /*<<bigarray.ml:391:48>>*/ }
+   function reshape_0(a){
+     /*<<bigarray.ml:396:18>>*/ return  /*<<bigarray.ml:396:18>>*/ caml_ba_reshape
+            (a, [0]);
+    /*<<bigarray.ml:396:32>>*/ }
+   function reshape_1(a, dim1){
+     /*<<bigarray.ml:397:23>>*/ return  /*<<bigarray.ml:397:23>>*/ caml_ba_reshape
+            (a, [0, dim1]);
+    /*<<bigarray.ml:397:41>>*/ }
+   function reshape_2(a, dim1, dim2){
+     /*<<bigarray.ml:398:28>>*/ return  /*<<bigarray.ml:398:28>>*/ caml_ba_reshape
+            (a, [0, dim1, dim2]);
+    /*<<bigarray.ml:398:51>>*/ }
+   function reshape_3(a, dim1, dim2, dim3){
+     /*<<bigarray.ml:399:33>>*/ return  /*<<bigarray.ml:399:33>>*/ caml_ba_reshape
+            (a, [0, dim1, dim2, dim3]);
+    /*<<bigarray.ml:399:61>>*/ }
+   var
+    Stdlib_Bigarray =
+      [0,
+       float32,
+       float64,
+       complex32,
+       complex64,
+       int8_signed,
+       int8_unsigned,
+       int16_signed,
+       int16_unsigned,
+       int$0,
+       int32,
+       int64,
+       nativeint,
+       char$0,
+       kind_size_in_bytes,
+       c_layout,
+       fortran_layout,
+       [0, init, dims, size_in_bytes],
+       [0,
+        create,
+        of_value,
+        caml_ba_change_layout,
+        size_in_bytes$0,
+        get,
+        set,
+        of_value],
+       [0,
+        create$0,
+        init$0,
+        caml_ba_change_layout,
+        size_in_bytes$1,
+        slice,
+        of_array],
+       [0,
+        create$1,
+        init$1,
+        caml_ba_change_layout,
+        size_in_bytes$2,
+        slice_left,
+        slice_right,
+        of_array$0],
+       [0,
+        create$2,
+        init$2,
+        caml_ba_change_layout,
+        size_in_bytes$3,
+        slice_left_1,
+        slice_right_1,
+        slice_left_2,
+        slice_right_2,
+        of_array$1],
+       array0_of_genarray,
+       array1_of_genarray,
+       array2_of_genarray,
+       array3_of_genarray,
+       caml_ba_reshape,
+       reshape_0,
+       reshape_1,
+       reshape_2,
+       reshape_3];
+   runtime.caml_register_global(10, Stdlib_Bigarray, "Stdlib__Bigarray");
+   return;
+   /*<<?>>*/ }
+  (globalThis));
+
+//# unitInfo: Provides: Stdlib__Random
+//# unitInfo: Requires: Stdlib, Stdlib__Bigarray, Stdlib__Bytes, Stdlib__Digest, Stdlib__Domain, Stdlib__Int32, Stdlib__Int64, Stdlib__Nativeint, Stdlib__String
+(function
+  (globalThis){
+   "use strict";
+   var
+    runtime = globalThis.jsoo_runtime,
+    caml_ba_blit = runtime.caml_ba_blit,
+    caml_ba_set_1 = runtime.caml_ba_set_1,
+    caml_bytes_set = runtime.caml_bytes_set,
+    caml_greaterthan = runtime.caml_greaterthan,
+    caml_int64_of_int32 = runtime.caml_int64_of_int32,
+    caml_int64_shift_right_unsigne = runtime.caml_int64_shift_right_unsigned,
+    caml_int64_sub = runtime.caml_int64_sub,
+    caml_int64_to_int32 = runtime.caml_int64_to_int32,
+    caml_lessequal = runtime.caml_lessequal,
+    caml_lxm_next = runtime.caml_lxm_next,
+    caml_mod = runtime.caml_mod,
+    caml_notequal = runtime.caml_notequal,
+    caml_sys_random_seed = runtime.caml_sys_random_seed;
+    /*<<?>>*/ function caml_call1(f, a0){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 1
+            ? f(a0)
+            : runtime.caml_call_gen(f, [a0]);
+   }
+    /*<<?>>*/ function caml_call2(f, a0, a1){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 2
+            ? f(a0, a1)
+            : runtime.caml_call_gen(f, [a0, a1]);
+   }
+    /*<<?>>*/ function caml_call3(f, a0, a1, a2){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 3
+            ? f(a0, a1, a2)
+            : runtime.caml_call_gen(f, [a0, a1, a2]);
+   }
+   var
+    global_data = runtime.caml_get_global_data(),
+    Stdlib_Domain = global_data.Stdlib__Domain,
+    Stdlib = global_data.Stdlib,
+    Stdlib_Int32 = global_data.Stdlib__Int32,
+    Stdlib_Int64 = global_data.Stdlib__Int64,
+    Stdlib_Bytes = global_data.Stdlib__Bytes,
+    Stdlib_Digest = global_data.Stdlib__Digest,
+    Stdlib_String = global_data.Stdlib__String,
+    Stdlib_Bigarray = global_data.Stdlib__Bigarray,
+    Stdlib_Nativeint = global_data.Stdlib__Nativeint,
+    _j_ = runtime.caml_int64_create_lo_mi_hi(14371852, 15349651, 22696),
+    _k_ = runtime.caml_int64_create_lo_mi_hi(12230193, 11438743, 35013),
+    _l_ = runtime.caml_int64_create_lo_mi_hi(1424933, 15549263, 2083),
+    _m_ = runtime.caml_int64_create_lo_mi_hi(9492471, 4696708, 43520),
+    _f_ = runtime.caml_int64_create_lo_mi_hi(1, 0, 0),
+    _h_ = runtime.caml_int64_create_lo_mi_hi(0, 0, 0),
+    _i_ = runtime.caml_int64_create_lo_mi_hi(0, 0, 0),
+    _g_ = runtime.caml_int64_create_lo_mi_hi(0, 0, 0),
+    cst_Random_int64 = "Random.int64",
+    cst_Random_int32 = "Random.int32",
+    cst_Random_full_int = "Random.full_int",
+    cst_Random_int = "Random.int",
+    _a_ = runtime.caml_int64_create_lo_mi_hi(1, 0, 0),
+    _b_ = runtime.caml_int64_create_lo_mi_hi(0, 0, 0),
+    _e_ = runtime.caml_int64_create_lo_mi_hi(1, 0, 0),
+    _c_ = runtime.caml_int64_create_lo_mi_hi(0, 0, 0),
+    _d_ = runtime.caml_int64_create_lo_mi_hi(2, 0, 0);
+   function create(param){
+     /*<<random.ml:31:4>>*/ return  /*<<random.ml:31:4>>*/ caml_call3
+            (Stdlib_Bigarray[19][1], 7, 0, 4);
+    /*<<random.ml:31:34>>*/ }
+   function set(s, i1, i2, i3, i4){
+     /*<<random.ml:34:4>>*/  /*<<random.ml:34:4>>*/ caml_ba_set_1
+     (s, 0,  /*<<random.ml:34:26>>*/ runtime.caml_int64_or(i1, _a_));
+     /*<<random.ml:35:4>>*/  /*<<random.ml:35:4>>*/ caml_ba_set_1(s, 1, i2);
+     /*<<random.ml:36:30>>*/  /*<<random.ml:36:30>>*/ var
+     i3$0 =  /*<<random.ml:36:30>>*/ caml_notequal(i3, _b_) ? i3 : _e_;
+     /*<<random.ml:36:4>>*/  /*<<random.ml:36:4>>*/ caml_ba_set_1(s, 2, i3$0);
+     /*<<random.ml:37:30>>*/  /*<<random.ml:37:30>>*/ var
+     i4$0 =  /*<<random.ml:37:30>>*/ caml_notequal(i4, _c_) ? i4 : _d_;
+     /*<<random.ml:37:4>>*/ return  /*<<random.ml:37:4>>*/ caml_ba_set_1
+            (s, 3, i4$0);
+    /*<<random.ml:37:55>>*/ }
+   function mk(i1, i2, i3, i4){
+     /*<<random.ml:40:4>>*/  /*<<random.ml:40:12>>*/ var s = create(0);
+     /*<<random.ml:41:4>>*/ set(s, i1, i2, i3, i4);
+     /*<<random.ml:41:4>>*/ return s;
+    /*<<random.ml:41:24>>*/ }
+   function copy(s){
+     /*<<random.ml:47:4>>*/  /*<<random.ml:47:13>>*/ var s$0 = create(0);
+     /*<<random.ml:47:25>>*/  /*<<random.ml:47:25>>*/ caml_ba_blit(s, s$0);
+     /*<<random.ml:47:25>>*/ return s$0;
+    /*<<random.ml:47:40>>*/ }
+   function reinit(s, seed){
+     /*<<random.ml:55:4>>*/ var
+     n = seed.length - 1,
+      /*<<random.ml:56:12>>*/ b =
+        /*<<random.ml:56:12>>*/ runtime.caml_create_bytes((n * 8 | 0) + 1 | 0),
+      /*<<random.ml:57:4>>*/ _p_ = n - 1 | 0,
+      /*<<random.ml:56:12>>*/ _o_ = 0;
+    if(_p_ >= 0){
+     var i = _o_;
+     for(;;){
+       /*<<random.ml:58:35>>*/  /*<<random.ml:58:35>>*/ var
+       _t_ =
+          /*<<random.ml:58:35>>*/ caml_int64_of_int32
+          (runtime.caml_check_bound(seed, i)[1 + i]);
+       /*<<random.ml:58:6>>*/  /*<<random.ml:58:6>>*/ caml_call3
+       (Stdlib_Bytes[86], b, i * 8 | 0, _t_);
+       /*<<random.ml:58:6>>*/  /*<<random.ml:58:6>>*/ var _u_ = i + 1 | 0;
+      if(_p_ === i) break;
+      var i = _u_;
+     }
+    }
+     /*<<random.ml:60:4>>*/  /*<<random.ml:60:4>>*/ caml_bytes_set
+     (b, n * 8 | 0, 1);
+     /*<<random.ml:61:13>>*/  /*<<random.ml:61:13>>*/ var
+     d1 =  /*<<random.ml:61:13>>*/ caml_call1(Stdlib_Digest[4], b);
+     /*<<random.ml:62:4>>*/  /*<<random.ml:62:4>>*/ caml_bytes_set
+     (b, n * 8 | 0, 2);
+     /*<<random.ml:63:13>>*/ var
+      /*<<random.ml:63:13>>*/ d2 =
+        /*<<random.ml:63:13>>*/ caml_call1(Stdlib_Digest[4], b),
+      /*<<random.ml:67:10>>*/ _q_ =
+        /*<<random.ml:67:10>>*/ caml_call2(Stdlib_String[64], d2, 8),
+      /*<<random.ml:66:10>>*/ _r_ =
+        /*<<random.ml:66:10>>*/ caml_call2(Stdlib_String[64], d2, 0),
+      /*<<random.ml:65:10>>*/ _s_ =
+        /*<<random.ml:65:10>>*/ caml_call2(Stdlib_String[64], d1, 8);
+     /*<<random.ml:67:10>>*/ return set
+            (s,
+              /*<<random.ml:64:10>>*/ caml_call2(Stdlib_String[64], d1, 0),
+             _s_,
+             _r_,
+             _q_);
+    /*<<random.ml:67:36>>*/ }
+   function make(seed){
+     /*<<random.ml:70:4>>*/  /*<<random.ml:70:12>>*/ var s = create(0);
+     /*<<random.ml:70:24>>*/ reinit(s, seed);
+     /*<<random.ml:70:24>>*/ return s;
+    /*<<random.ml:70:40>>*/ }
+   function make_self_init(param){
+     /*<<random.ml:73:4>>*/ return make
+            ( /*<<random.ml:73:9>>*/ caml_sys_random_seed(0));
+    /*<<random.ml:73:25>>*/ }
+   function bits(s){
+     /*<<random.ml:77:4>>*/ return  /*<<random.ml:77:17>>*/ caml_int64_to_int32
+            ( /*<<random.ml:77:17>>*/ caml_lxm_next(s))
+           & 1073741823;
+    /*<<random.ml:77:42>>*/ }
+   function intaux(s, n){
+     /*<<random.ml:81:4>>*/ for(;;){
+      /*<<random.ml:81:12>>*/ var
+       /*<<random.ml:81:12>>*/ r = bits(s),
+      v = caml_mod(r, n);
+     if(((1073741823 - n | 0) + 1 | 0) >= (r - v | 0))
+       /*<<random.ml:83:55>>*/ return v;
+    }
+    /*<<random.ml:83:56>>*/ }
+   function int$0(s, bound){
+     /*<<random.ml:86:4>>*/ if(1073741823 >= bound && 0 < bound)
+      /*<<random.ml:88:9>>*/ return intaux(s, bound);
+     /*<<random.ml:87:9>>*/ return  /*<<random.ml:87:9>>*/ caml_call1
+            (Stdlib[1], cst_Random_int);
+    /*<<random.ml:88:23>>*/ }
+   function full_int(s, bound){
+     /*<<random.ml:98:4>>*/ if(0 >= bound)
+      /*<<random.ml:99:6>>*/ return  /*<<random.ml:99:6>>*/ caml_call1
+             (Stdlib[1], cst_Random_full_int);
+    if(1073741823 >= bound)  /*<<random.ml:103:6>>*/ return intaux(s, bound);
+     /*<<random.ml:93:4>>*/ for(;;){
+      /*<<random.ml:93:4>>*/ var
+       /*<<random.ml:93:4>>*/ _n_ = Stdlib[19],
+      r =
+         /*<<random.ml:93:25>>*/ caml_int64_to_int32
+         ( /*<<random.ml:93:25>>*/ caml_lxm_next(s))
+        & _n_,
+      v = caml_mod(r, bound);
+     if(((Stdlib[19] - bound | 0) + 1 | 0) >= (r - v | 0))
+       /*<<random.ml:95:54>>*/ return v;
+    }
+    /*<<random.ml:103:20>>*/ }
+   function bits32(s){
+     /*<<random.ml:107:4>>*/ return  /*<<random.ml:107:4>>*/ caml_int64_to_int32
+            ( /*<<random.ml:107:19>>*/ caml_lxm_next(s));
+    /*<<random.ml:107:27>>*/ }
+   function int32(s, bound){
+     /*<<random.ml:118:4>>*/ if
+     ( /*<<random.ml:118:7>>*/ caml_lessequal(bound, 0))
+      /*<<random.ml:119:9>>*/ return  /*<<random.ml:119:9>>*/ caml_call1
+             (Stdlib[1], cst_Random_int32);
+     /*<<random.ml:111:4>>*/ for(;;){
+      /*<<random.ml:111:12>>*/ var
+       /*<<random.ml:111:12>>*/ r = bits32(s) >>> 1 | 0,
+       /*<<random.ml:112:12>>*/ v =
+         /*<<random.ml:112:12>>*/ caml_mod(r, bound);
+      /*<<random.ml:113:14>>*/ if
+      (!
+        /*<<random.ml:113:14>>*/ caml_greaterthan
+        (r - v | 0, (Stdlib_Int32[9] - bound | 0) + 1 | 0))
+       /*<<random.ml:115:9>>*/ return v;
+    }
+    /*<<random.ml:120:25>>*/ }
+   var bits64 = caml_lxm_next;
+   function int64(s, bound){
+     /*<<random.ml:135:4>>*/ if
+     ( /*<<random.ml:135:7>>*/ caml_lessequal(bound, _g_))
+      /*<<random.ml:136:9>>*/ return  /*<<random.ml:136:9>>*/ caml_call1
+             (Stdlib[1], cst_Random_int64);
+     /*<<random.ml:128:4>>*/ for(;;){
+      /*<<random.ml:128:12>>*/ var
+       /*<<random.ml:128:12>>*/ r =
+         /*<<random.ml:128:12>>*/ caml_int64_shift_right_unsigne
+         ( /*<<random.ml:128:38>>*/ caml_lxm_next(s), 1),
+       /*<<random.ml:129:12>>*/ v =
+         /*<<random.ml:129:12>>*/ runtime.caml_int64_mod(r, bound);
+      /*<<random.ml:130:14>>*/ if
+      (!
+        /*<<random.ml:130:14>>*/ caml_greaterthan
+        ( /*<<random.ml:130:14>>*/ caml_int64_sub(r, v),
+          /*<<random.ml:130:24>>*/ runtime.caml_int64_add
+          ( /*<<random.ml:130:28>>*/ caml_int64_sub(Stdlib_Int64[9], bound),
+           _f_)))
+       /*<<random.ml:132:9>>*/ return v;
+    }
+    /*<<random.ml:137:25>>*/ }
+   var
+    nativebits =
+      32 === Stdlib_Nativeint[9]
+       ? function
+        (s){
+          /*<<random.ml:142:18>>*/ return bits32(s);
+         /*<<random.ml:142:47>>*/ }
+       : function
+        (s){
+          /*<<random.ml:143:18>>*/ return  /*<<random.ml:143:18>>*/ caml_int64_to_int32
+                 ( /*<<random.ml:143:37>>*/ caml_lxm_next(s));
+         /*<<random.ml:143:47>>*/ },
+    nativeint =
+      32 === Stdlib_Nativeint[9]
+       ? function
+        (s, bound){
+          /*<<random.ml:148:24>>*/ return int32(s, bound);
+         /*<<random.ml:148:79>>*/ }
+       : function
+        (s, bound){
+          /*<<random.ml:149:24>>*/ return  /*<<random.ml:149:24>>*/ caml_int64_to_int32
+                 (int64
+                   (s,  /*<<random.ml:149:52>>*/ caml_int64_of_int32(bound)));
+         /*<<random.ml:149:79>>*/ };
+   function float$0(s, bound){
+     /*<<random.ml:159:22>>*/ for(;;){
+      /*<<random.ml:154:12>>*/ var
+       /*<<random.ml:154:12>>*/ b =  /*<<random.ml:154:12>>*/ caml_lxm_next(s),
+       /*<<random.ml:155:12>>*/ n =
+         /*<<random.ml:155:12>>*/ caml_int64_shift_right_unsigne(b, 11);
+      /*<<random.ml:156:7>>*/ if
+      ( /*<<random.ml:156:7>>*/ caml_notequal(n, _h_))
+       /*<<random.ml:159:22>>*/ return  /*<<random.ml:156:20>>*/ runtime.caml_int64_to_float
+              (n)
+             * 1.1102230246251565e-16
+             * bound;
+    }
+    /*<<random.ml:159:41>>*/ }
+   function bool(s){
+     /*<<random.ml:162:15>>*/ return  /*<<random.ml:162:15>>*/ runtime.caml_lessthan
+            ( /*<<random.ml:162:15>>*/ caml_lxm_next(s), _i_);
+    /*<<random.ml:162:26>>*/ }
+   function split(s){
+     /*<<random.ml:166:4>>*/ var
+      /*<<random.ml:166:13>>*/ i1 =  /*<<random.ml:166:13>>*/ caml_lxm_next(s),
+      /*<<random.ml:166:34>>*/ i2 =  /*<<random.ml:166:34>>*/ caml_lxm_next(s),
+      /*<<random.ml:167:13>>*/ i3 =  /*<<random.ml:167:13>>*/ caml_lxm_next(s),
+      /*<<random.ml:167:34>>*/ i4 =  /*<<random.ml:167:34>>*/ caml_lxm_next(s);
+     /*<<random.ml:168:4>>*/ return mk(i1, i2, i3, i4);
+    /*<<random.ml:168:18>>*/ }
+   function mk_default(param){
+     /*<<random.ml:173:2>>*/ return mk(_m_, _l_, _k_, _j_);
+    /*<<random.ml:176:31>>*/ }
+    /*<<random.ml:179:2>>*/  /*<<random.ml:179:2>>*/ var
+    random_key =
+       /*<<random.ml:179:2>>*/ caml_call2
+       (Stdlib_Domain[10][1], [0, split], mk_default);
+   function bits$0(param){
+     /*<<random.ml:181:14>>*/ return bits
+            ( /*<<random.ml:181:25>>*/ caml_call1
+              (Stdlib_Domain[10][2], random_key));
+    /*<<random.ml:181:52>>*/ }
+   function int$1(bound){
+     /*<<random.ml:182:16>>*/ return int$0
+            ( /*<<random.ml:182:26>>*/ caml_call1
+              (Stdlib_Domain[10][2], random_key),
+             bound);
+    /*<<random.ml:182:59>>*/ }
+   function full_int$0(bound){
+     /*<<random.ml:183:21>>*/ return full_int
+            ( /*<<random.ml:183:36>>*/ caml_call1
+              (Stdlib_Domain[10][2], random_key),
+             bound);
+    /*<<random.ml:183:69>>*/ }
+   function int32$0(bound){
+     /*<<random.ml:184:18>>*/ return int32
+            ( /*<<random.ml:184:30>>*/ caml_call1
+              (Stdlib_Domain[10][2], random_key),
+             bound);
+    /*<<random.ml:184:63>>*/ }
+   function nativeint$0(bound){
+     /*<<random.ml:185:22>>*/ return nativeint
+            ( /*<<random.ml:185:38>>*/ caml_call1
+              (Stdlib_Domain[10][2], random_key),
+             bound);
+    /*<<random.ml:185:71>>*/ }
+   function int64$0(bound){
+     /*<<random.ml:186:18>>*/ return int64
+            ( /*<<random.ml:186:30>>*/ caml_call1
+              (Stdlib_Domain[10][2], random_key),
+             bound);
+    /*<<random.ml:186:63>>*/ }
+   function float$1(scale){
+     /*<<random.ml:187:18>>*/ return float$0
+            ( /*<<random.ml:187:30>>*/ caml_call1
+              (Stdlib_Domain[10][2], random_key),
+             scale);
+    /*<<random.ml:187:63>>*/ }
+   function bool$0(param){
+     /*<<random.ml:188:14>>*/ return bool
+            ( /*<<random.ml:188:25>>*/ caml_call1
+              (Stdlib_Domain[10][2], random_key));
+    /*<<random.ml:188:52>>*/ }
+   function bits32$0(param){
+     /*<<random.ml:189:16>>*/ return bits32
+            ( /*<<random.ml:189:29>>*/ caml_call1
+              (Stdlib_Domain[10][2], random_key));
+    /*<<random.ml:189:56>>*/ }
+   function bits64$0(param){
+     /*<<random.ml:190:16>>*/ return  /*<<random.ml:190:29>>*/ caml_lxm_next
+            ( /*<<random.ml:190:29>>*/ caml_call1
+              (Stdlib_Domain[10][2], random_key));
+    /*<<random.ml:190:56>>*/ }
+   function nativebits$0(param){
+     /*<<random.ml:191:20>>*/ return nativebits
+            ( /*<<random.ml:191:37>>*/ caml_call1
+              (Stdlib_Domain[10][2], random_key));
+    /*<<random.ml:191:64>>*/ }
+   function full_init(seed){
+     /*<<random.ml:193:21>>*/ return reinit
+            ( /*<<random.ml:193:34>>*/ caml_call1
+              (Stdlib_Domain[10][2], random_key),
+             seed);
+    /*<<random.ml:193:66>>*/ }
+   function init(seed){
+     /*<<random.ml:194:16>>*/ return full_init([0, seed]);
+    /*<<random.ml:194:36>>*/ }
+   function self_init(param){
+     /*<<random.ml:195:19>>*/ return full_init
+            ( /*<<random.ml:195:29>>*/ caml_sys_random_seed(0));
+    /*<<random.ml:195:44>>*/ }
+   function split$0(param){
+     /*<<random.ml:199:15>>*/ return split
+            ( /*<<random.ml:199:27>>*/ caml_call1
+              (Stdlib_Domain[10][2], random_key));
+    /*<<random.ml:199:54>>*/ }
+   function get_state(param){
+     /*<<random.ml:203:19>>*/ return copy
+            ( /*<<random.ml:203:30>>*/ caml_call1
+              (Stdlib_Domain[10][2], random_key));
+    /*<<random.ml:203:57>>*/ }
+   function set_state(s){
+     /*<<random.ml:204:18>>*/ return  /*<<random.ml:204:18>>*/ caml_ba_blit
+            (s,
+              /*<<random.ml:204:31>>*/ caml_call1
+              (Stdlib_Domain[10][2], random_key));
+    /*<<random.ml:204:60>>*/ }
+   var
+    Stdlib_Random =
+      [0,
+       init,
+       full_init,
+       self_init,
+       bits$0,
+       int$1,
+       full_int$0,
+       int32$0,
+       nativeint$0,
+       int64$0,
+       float$1,
+       bool$0,
+       bits32$0,
+       bits64$0,
+       nativebits$0,
+       [0,
+        make,
+        make_self_init,
+        copy,
+        bits,
+        int$0,
+        full_int,
+        int32,
+        nativeint,
+        int64,
+        float$0,
+        bool,
+        bits32,
+        bits64,
+        nativebits,
+        split],
+       get_state,
+       set_state,
+       split$0];
+   runtime.caml_register_global(29, Stdlib_Random, "Stdlib__Random");
+   return;
+   /*<<?>>*/ }
+  (globalThis));
+
+//# unitInfo: Provides: Stdlib__Hashtbl
+//# unitInfo: Requires: Assert_failure, Stdlib, Stdlib__Array, Stdlib__Atomic, Stdlib__Domain, Stdlib__Int, Stdlib__Random, Stdlib__Seq, Stdlib__String, Stdlib__Sys
+(function
+  (globalThis){
+   "use strict";
+   var
+    runtime = globalThis.jsoo_runtime,
+    caml_check_bound = runtime.caml_check_bound,
+    caml_compare = runtime.caml_compare,
+    caml_hash = runtime.caml_hash,
+    caml_make_vect = runtime.caml_make_vect,
+    caml_maybe_attach_backtrace = runtime.caml_maybe_attach_backtrace,
+    caml_sys_getenv = runtime.caml_sys_getenv,
+    caml_wrap_exception = runtime.caml_wrap_exception;
+    /*<<?>>*/ function caml_call1(f, a0){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 1
+            ? f(a0)
+            : runtime.caml_call_gen(f, [a0]);
+   }
+    /*<<?>>*/ function caml_call2(f, a0, a1){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 2
+            ? f(a0, a1)
+            : runtime.caml_call_gen(f, [a0, a1]);
+   }
+    /*<<?>>*/ function caml_call3(f, a0, a1, a2){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 3
+            ? f(a0, a1, a2)
+            : runtime.caml_call_gen(f, [a0, a1, a2]);
+   }
+    /*<<?>>*/ function caml_call4(f, a0, a1, a2, a3){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 4
+            ? f(a0, a1, a2, a3)
+            : runtime.caml_call_gen(f, [a0, a1, a2, a3]);
+   }
+   var
+    global_data = runtime.caml_get_global_data(),
+    cst = "",
+    Stdlib_Sys = global_data.Stdlib__Sys,
+    Stdlib = global_data.Stdlib,
+    Stdlib_Atomic = global_data.Stdlib__Atomic,
+    Stdlib_Domain = global_data.Stdlib__Domain,
+    Stdlib_Random = global_data.Stdlib__Random,
+    Stdlib_Seq = global_data.Stdlib__Seq,
+    Stdlib_Int = global_data.Stdlib__Int,
+    Stdlib_Array = global_data.Stdlib__Array;
+   global_data.Assert_failure;
+   var
+    Stdlib_String = global_data.Stdlib__String,
+    cst_Hashtbl_unsupported_hash_t = "Hashtbl: unsupported hash table format",
+    _d_ = [0, 0];
+   function ongoing_traversal(h){
+     /*<<hashtbl.ml:41:2>>*/ var
+     _aB_ = h.length - 1 < 4 ? 1 : 0,
+     _aC_ = _aB_ || (h[4] < 0 ? 1 : 0);
+    return _aC_;
+    /*<<hashtbl.ml:42:23>>*/ }
+   function flip_ongoing_traversal(h){
+     /*<<hashtbl.ml:45:2>>*/ h[4] = - h[4] | 0;
+    return 0;
+    /*<<hashtbl.ml:45:36>>*/ }
+   try{
+     /*<<hashtbl.ml:51:8>>*/ var
+      /*<<hashtbl.ml:51:8>>*/ _f_ =
+        /*<<hashtbl.ml:51:8>>*/ caml_sys_getenv("OCAMLRUNPARAM"),
+     params = _f_;
+   }
+   catch(_az_){
+    var _a_ = caml_wrap_exception(_az_);
+    if(_a_ !== Stdlib[8]) throw caml_maybe_attach_backtrace(_a_, 0);
+     /*<<hashtbl.ml:52:4>>*/ try{
+      /*<<hashtbl.ml:52:8>>*/ var
+       /*<<hashtbl.ml:52:8>>*/ _e_ =
+         /*<<hashtbl.ml:52:8>>*/ caml_sys_getenv("CAMLRUNPARAM"),
+      _c_ = _e_;
+    }
+    catch(_aA_){
+     var _b_ = caml_wrap_exception(_aA_);
+     if(_b_ !== Stdlib[8]) throw caml_maybe_attach_backtrace(_b_, 0);
+     var _c_ = cst;
+    }
+    var params = _c_;
+   }
+    /*<<hashtbl.ml:53:2>>*/ var
+     /*<<hashtbl.ml:53:2>>*/ randomized_default =
+       /*<<hashtbl.ml:53:2>>*/ caml_call2(Stdlib_String[14], params, 82),
+     /*<<hashtbl.ml:55:17>>*/ randomized =
+       /*<<hashtbl.ml:55:17>>*/ caml_call1
+       (Stdlib_Atomic[1], randomized_default);
+   function randomize(param){
+     /*<<hashtbl.ml:57:19>>*/ return  /*<<hashtbl.ml:57:19>>*/ caml_call2
+            (Stdlib_Atomic[3], randomized, 1);
+    /*<<hashtbl.ml:57:45>>*/ }
+   function is_randomized(param){
+     /*<<hashtbl.ml:58:23>>*/ return caml_call1(Stdlib_Atomic[2], randomized);
+    /*<<hashtbl.ml:58:44>>*/ }
+    /*<<hashtbl.ml:60:15>>*/  /*<<hashtbl.ml:60:15>>*/ var
+    prng_key =
+       /*<<hashtbl.ml:60:15>>*/ caml_call2
+       (Stdlib_Domain[10][1], 0, Stdlib_Random[15][2]);
+   function power_2_above(x, n){
+     /*<<hashtbl.ml:69:2>>*/ var x$0 = x;
+     /*<<hashtbl.ml:69:2>>*/ for(;;){
+     if(n <= x$0)  /*<<hashtbl.ml:69:17>>*/ return x$0;
+     if(Stdlib_Sys[13] < (x$0 * 2 | 0))  /*<<hashtbl.ml:70:44>>*/ return x$0;
+     var x$1 = x$0 * 2 | 0, x$0 = x$1;
+    }
+    /*<<hashtbl.ml:71:30>>*/ }
+   function create(opt, initial_size){
+     /*<<hashtbl.ml:74:2>>*/ if(opt)
+     var sth = opt[1], random = sth;
+    else
+     var
+      random =
+         /*<<hashtbl.ml:73:22>>*/ caml_call1(Stdlib_Atomic[2], randomized);
+     /*<<hashtbl.ml:74:10>>*/  /*<<hashtbl.ml:74:10>>*/ var
+     s = power_2_above(16, initial_size);
+     /*<<hashtbl.ml:75:2>>*/ if(random)
+      /*<<hashtbl.ml:76:37>>*/ var
+       /*<<hashtbl.ml:76:37>>*/ _ay_ =
+         /*<<hashtbl.ml:76:37>>*/ caml_call1(Stdlib_Domain[10][2], prng_key),
+      seed =  /*<<hashtbl.ml:76:19>>*/ caml_call1(Stdlib_Random[15][4], _ay_);
+    else
+     var seed = 0;
+     /*<<hashtbl.ml:78:2>>*/ return [0,
+            0,
+             /*<<hashtbl.ml:78:52>>*/ caml_make_vect(s, 0),
+            seed,
+            s];
+    /*<<hashtbl.ml:78:72>>*/ }
+   function clear(h){
+     /*<<hashtbl.ml:81:2>>*/ var _ax_ = 0 < h[1] ? 1 : 0;
+    return _ax_
+            ? (h
+               [1]
+              = 0,
+               /*<<hashtbl.ml:83:4>>*/ caml_call4
+               (Stdlib_Array[7], h[2], 0, h[2].length - 1, 0))
+            : _ax_;
+    /*<<hashtbl.ml:84:5>>*/ }
+   function reset(h){
+     /*<<hashtbl.ml:87:2>>*/ var len = h[2].length - 1;
+    if
+     (4 <= h.length - 1
+      && len !==  /*<<hashtbl.ml:89:13>>*/ caml_call1(Stdlib[18], h[4])){
+     h[1] = 0;
+     h[2] =
+       /*<<hashtbl.ml:93:14>>*/ caml_make_vect
+       ( /*<<hashtbl.ml:93:25>>*/ caml_call1(Stdlib[18], h[4]), 0);
+     return 0;
+    }
+     /*<<hashtbl.ml:90:4>>*/ return clear(h);
+    /*<<hashtbl.ml:94:5>>*/ }
+   function copy_bucketlist(param){
+     /*<<hashtbl.ml:96:22>>*/ if(! param)  /*<<hashtbl.ml:97:13>>*/ return 0;
+     /*<<hashtbl.ml:109:19>>*/ var
+     key = param[1],
+     data = param[2],
+     next = param[3],
+      /*<<hashtbl.ml:109:19>>*/ prec$1 = [0, key, data, next],
+     prec = prec$1,
+     param$0 = next;
+    for(;;){
+     if(! param$0)  /*<<hashtbl.ml:110:6>>*/ return prec$1;
+      /*<<hashtbl.ml:102:25>>*/ var
+      key$0 = param$0[1],
+      data$0 = param$0[2],
+      next$0 = param$0[3],
+       /*<<hashtbl.ml:102:25>>*/ prec$0 = [0, key$0, data$0, next$0];
+     prec[3] = prec$0;
+     var prec = prec$0, param$0 = next$0;
+    }
+    /*<<hashtbl.ml:111:7>>*/ }
+   function copy(h){
+     /*<<hashtbl.ml:113:13>>*/ var
+     _au_ = h[4],
+     _av_ = h[3],
+      /*<<hashtbl.ml:113:29>>*/ _aw_ =
+        /*<<hashtbl.ml:113:29>>*/ caml_call2
+        (Stdlib_Array[13], copy_bucketlist, h[2]);
+     /*<<hashtbl.ml:113:13>>*/ return [0, h[1], _aw_, _av_, _au_];
+    /*<<hashtbl.ml:113:63>>*/ }
+   function length(h){
+     /*<<hashtbl.ml:115:15>>*/ return h[1];
+    /*<<hashtbl.ml:115:21>>*/ }
+   function insert_all_buckets(indexfun, inplace, odata, ndata){
+     /*<<hashtbl.ml:118:2>>*/ var
+     nsize = ndata.length - 1,
+      /*<<hashtbl.ml:119:19>>*/ ndata_tail =
+        /*<<hashtbl.ml:119:19>>*/ caml_make_vect(nsize, 0),
+     _ao_ = odata.length - 1 - 1 | 0,
+      /*<<hashtbl.ml:135:2>>*/ _an_ = 0;
+    if(_ao_ >= 0){
+     var i$0 = _an_;
+     a:
+     for(;;){
+       /*<<hashtbl.ml:136:18>>*/ var
+        /*<<hashtbl.ml:136:18>>*/ cell$1 =
+         caml_check_bound(odata, i$0)[1 + i$0],
+       cell = cell$1;
+       /*<<hashtbl.ml:120:26>>*/ for(;;){
+       if(! cell){
+         /*<<hashtbl.ml:136:4>>*/  /*<<hashtbl.ml:136:4>>*/ var
+         _at_ = i$0 + 1 | 0;
+        if(_ao_ === i$0) break a;
+        var i$0 = _at_;
+        break;
+       }
+        /*<<hashtbl.ml:123:8>>*/ var
+        key = cell[1],
+        data = cell[2],
+        next = cell[3],
+         /*<<hashtbl.ml:123:8>>*/ cell$0 = inplace ? cell : [0, key, data, 0],
+         /*<<hashtbl.ml:127:19>>*/ nidx =
+           /*<<hashtbl.ml:127:19>>*/ caml_call1(indexfun, key),
+         /*<<hashtbl.ml:128:20>>*/ match =
+          caml_check_bound(ndata_tail, nidx)[1 + nidx];
+       if(match)
+        match[3] = cell$0;
+       else
+         /*<<hashtbl.ml:129:19>>*/ caml_check_bound(ndata, nidx)[1 + nidx] = cell$0;
+        /*<<hashtbl.ml:132:8>>*/ caml_check_bound(ndata_tail, nidx)[1 + nidx]
+       = cell$0;
+       var cell = next;
+      }
+     }
+    }
+    if(inplace){
+      /*<<hashtbl.ml:139:4>>*/ var
+      _aq_ = nsize - 1 | 0,
+       /*<<hashtbl.ml:139:4>>*/ _ap_ = 0;
+     if(_aq_ >= 0){
+      var i = _ap_;
+      for(;;){
+        /*<<hashtbl.ml:140:12>>*/  /*<<hashtbl.ml:140:12>>*/ var
+        match$0 = caml_check_bound(ndata_tail, i)[1 + i];
+       if(match$0) match$0[3] = 0;
+        /*<<hashtbl.ml:139:4>>*/  /*<<hashtbl.ml:139:4>>*/ var
+        _as_ = i + 1 | 0;
+       if(_aq_ === i) break;
+       var i = _as_;
+      }
+     }
+     var _ar_ = 0;
+    }
+    else
+     var _ar_ = inplace;
+    return _ar_;
+    /*<<hashtbl.ml:143:8>>*/ }
+   function resize(indexfun, h){
+     /*<<hashtbl.ml:146:2>>*/ var
+     odata = h[2],
+      /*<<hashtbl.ml:147:2>>*/ osize = odata.length - 1,
+     nsize = osize * 2 | 0,
+     _am_ = nsize < Stdlib_Sys[13] ? 1 : 0;
+    if(! _am_) return _am_;
+     /*<<hashtbl.ml:150:16>>*/ var
+      /*<<hashtbl.ml:150:16>>*/ ndata =
+        /*<<hashtbl.ml:150:16>>*/ caml_make_vect(nsize, 0),
+      /*<<hashtbl.ml:151:22>>*/ inplace = 1 - ongoing_traversal(h);
+    h[2] = ndata;
+     /*<<hashtbl.ml:153:4>>*/ return insert_all_buckets
+            ( /*<<hashtbl.ml:153:23>>*/ caml_call1(indexfun, h),
+             inplace,
+             odata,
+             ndata);
+    /*<<hashtbl.ml:154:5>>*/ }
+   function iter(f, h){
+     /*<<hashtbl.ml:157:2>>*/  /*<<hashtbl.ml:162:17>>*/ var
+     old_trav = ongoing_traversal(h);
+    if(1 - old_trav)  /*<<hashtbl.ml:163:23>>*/ flip_ongoing_traversal(h);
+     /*<<hashtbl.ml:163:23>>*/ try{
+     var d = h[2], _ai_ = d.length - 1 - 1 | 0, _ah_ = 0;
+     if(_ai_ >= 0){
+      var i = _ah_;
+      a:
+      for(;;){
+       var param = caml_check_bound(d, i)[1 + i];
+        /*<<hashtbl.ml:157:22>>*/ for(;;){
+        if(! param){
+          /*<<hashtbl.ml:167:6>>*/  /*<<hashtbl.ml:167:6>>*/ var
+          _al_ = i + 1 | 0;
+         if(_ai_ === i) break a;
+         var i = _al_;
+         break;
+        }
+        var key = param[1], data = param[2], next = param[3];
+         /*<<hashtbl.ml:161:8>>*/  /*<<hashtbl.ml:161:8>>*/ caml_call2
+         (f, key, data);
+        var param = next;
+       }
+      }
+     }
+     var _aj_ = 1 - old_trav, _ak_ = _aj_ ? flip_ongoing_traversal(h) : _aj_;
+      /*<<hashtbl.ml:169:25>>*/ return _ak_;
+    }
+    catch(exn$0){
+     var exn = caml_wrap_exception(exn$0);
+      /*<<hashtbl.ml:170:16>>*/ if(old_trav)
+      throw caml_maybe_attach_backtrace(exn, 0);
+      /*<<hashtbl.ml:171:4>>*/ flip_ongoing_traversal(h);
+      /*<<hashtbl.ml:172:4>>*/ throw  /*<<hashtbl.ml:172:4>>*/ caml_maybe_attach_backtrace
+            (exn, 0);
+    }
+    /*<<hashtbl.ml:172:13>>*/ }
+   function filter_map_inplace(f, h){
+     /*<<hashtbl.ml:195:2>>*/ var
+     d = h[2],
+      /*<<hashtbl.ml:196:17>>*/ old_trav = ongoing_traversal(h);
+    if(1 - old_trav)  /*<<hashtbl.ml:197:23>>*/ flip_ongoing_traversal(h);
+     /*<<hashtbl.ml:197:23>>*/ try{
+     var _ad_ = d.length - 1 - 1 | 0, _ac_ = 0;
+     if(_ad_ >= 0){
+      var i = _ac_;
+      a:
+      for(;;){
+        /*<<hashtbl.ml:200:44>>*/ var
+         /*<<hashtbl.ml:200:44>>*/ slot$0 = caml_check_bound(h[2], i)[1 + i],
+        prec = 0,
+        slot = slot$0;
+       for(;;){
+        if(! slot){
+         if(prec)
+          prec[3] = 0;
+         else
+           /*<<hashtbl.ml:177:17>>*/ caml_check_bound(h[2], i)[1 + i] = 0;
+          /*<<hashtbl.ml:200:6>>*/  /*<<hashtbl.ml:200:6>>*/ var
+          _ag_ = i + 1 | 0;
+         if(_ad_ === i) break a;
+         var i = _ag_;
+         break;
+        }
+         /*<<hashtbl.ml:181:18>>*/ var
+         key = slot[1],
+         data = slot[2],
+         next = slot[3],
+          /*<<hashtbl.ml:181:18>>*/ match =
+            /*<<hashtbl.ml:181:18>>*/ caml_call2(f, key, data);
+        if(match){
+         var data$0 = match[1];
+          /*<<hashtbl.ml:186:10>>*/ if(prec)
+          prec[3] = slot;
+         else
+           /*<<hashtbl.ml:187:21>>*/ caml_check_bound(h[2], i)[1 + i] = slot;
+         slot[2] = data$0;
+         var prec = slot, slot = next;
+        }
+        else{h[1] = h[1] - 1 | 0; var slot = next;}
+       }
+      }
+     }
+     var _ae_ = 1 - old_trav, _af_ = _ae_ ? flip_ongoing_traversal(h) : _ae_;
+      /*<<hashtbl.ml:202:25>>*/ return _af_;
+    }
+    catch(exn$0){
+     var exn = caml_wrap_exception(exn$0);
+      /*<<hashtbl.ml:203:16>>*/ if(old_trav)
+      throw caml_maybe_attach_backtrace(exn, 0);
+      /*<<hashtbl.ml:204:4>>*/ flip_ongoing_traversal(h);
+      /*<<hashtbl.ml:205:4>>*/ throw  /*<<hashtbl.ml:205:4>>*/ caml_maybe_attach_backtrace
+            (exn, 0);
+    }
+    /*<<hashtbl.ml:205:13>>*/ }
+   function fold(f, h, init){
+     /*<<hashtbl.ml:208:2>>*/  /*<<hashtbl.ml:214:17>>*/ var
+     old_trav = ongoing_traversal(h);
+    if(1 - old_trav)  /*<<hashtbl.ml:215:23>>*/ flip_ongoing_traversal(h);
+     /*<<hashtbl.ml:215:23>>*/ try{
+      /*<<hashtbl.ml:218:15>>*/ var
+      d = h[2],
+       /*<<hashtbl.ml:218:15>>*/ accu$1 = [0, init],
+      _$_ = d.length - 1 - 1 | 0,
+       /*<<hashtbl.ml:218:15>>*/ ___ = 0;
+     if(_$_ >= 0){
+      var i = ___;
+      a:
+      for(;;){
+        /*<<hashtbl.ml:220:24>>*/ var
+        accu$2 = accu$1[1],
+         /*<<hashtbl.ml:220:24>>*/ b$0 = caml_check_bound(d, i)[1 + i],
+        b = b$0,
+        accu = accu$2;
+        /*<<hashtbl.ml:209:4>>*/ for(;;){
+        if(! b){
+         accu$1[1] = accu;
+          /*<<hashtbl.ml:219:4>>*/  /*<<hashtbl.ml:219:4>>*/ var
+          _ab_ = i + 1 | 0;
+         if(_$_ === i) break a;
+         var i = _ab_;
+         break;
+        }
+         /*<<hashtbl.ml:213:23>>*/ var
+         key = b[1],
+         data = b[2],
+         next = b[3],
+          /*<<hashtbl.ml:213:23>>*/ accu$0 =
+            /*<<hashtbl.ml:213:23>>*/ caml_call3(f, key, data, accu),
+         b = next,
+         accu = accu$0;
+       }
+      }
+     }
+     if(1 - old_trav)  /*<<hashtbl.ml:222:25>>*/ flip_ongoing_traversal(h);
+     var _aa_ = accu$1[1];
+     return _aa_;
+    }
+    catch(exn$0){
+     var exn = caml_wrap_exception(exn$0);
+      /*<<hashtbl.ml:224:16>>*/ if(old_trav)
+      throw caml_maybe_attach_backtrace(exn, 0);
+      /*<<hashtbl.ml:225:4>>*/ flip_ongoing_traversal(h);
+      /*<<hashtbl.ml:226:4>>*/ throw  /*<<hashtbl.ml:226:4>>*/ caml_maybe_attach_backtrace
+            (exn, 0);
+    }
+    /*<<hashtbl.ml:226:13>>*/ }
+   function bucket_length(accu, param){
+    var accu$0 = accu, param$0 = param;
+    for(;;){
+     if(! param$0)  /*<<hashtbl.ml:236:13>>*/ return accu$0;
+      /*<<hashtbl.ml:237:18>>*/ var
+      next = param$0[3],
+       /*<<hashtbl.ml:237:18>>*/ accu$1 = accu$0 + 1 | 0,
+      accu$0 = accu$1,
+      param$0 = next;
+    }
+   }
+   function stats(h){
+     /*<<hashtbl.ml:240:2>>*/ var _U_ = h[2], _V_ = 0;
+    function _W_(m, b){
+      /*<<hashtbl.ml:241:32>>*/  /*<<hashtbl.ml:241:42>>*/ var
+      _Z_ = bucket_length(0, b);
+      /*<<hashtbl.ml:241:42>>*/ return  /*<<hashtbl.ml:241:42>>*/ caml_call2
+             (Stdlib_Int[11], m, _Z_);
+     /*<<hashtbl.ml:241:61>>*/ }
+     /*<<hashtbl.ml:241:4>>*/ var
+      /*<<hashtbl.ml:241:4>>*/ mbl =
+        /*<<hashtbl.ml:241:4>>*/ caml_call3(Stdlib_Array[15], _W_, _V_, _U_),
+      /*<<hashtbl.ml:242:14>>*/ histo =
+        /*<<hashtbl.ml:242:14>>*/ caml_make_vect(mbl + 1 | 0, 0),
+      /*<<hashtbl.ml:243:2>>*/ _X_ = h[2];
+    function _Y_(b){
+      /*<<hashtbl.ml:245:6>>*/  /*<<hashtbl.ml:245:14>>*/ var
+      l = bucket_length(0, b);
+      /*<<hashtbl.ml:246:6>>*/ histo[1 + l] =
+      caml_check_bound(histo, l)[1 + l] + 1 | 0;
+      /*<<hashtbl.ml:246:6>>*/ return 0;
+     /*<<hashtbl.ml:246:32>>*/ }
+     /*<<hashtbl.ml:243:2>>*/  /*<<hashtbl.ml:243:2>>*/ caml_call2
+     (Stdlib_Array[11], _Y_, _X_);
+     /*<<hashtbl.ml:248:2>>*/ return [0, h[1], h[2].length - 1, mbl, histo];
+    /*<<hashtbl.ml:251:30>>*/ }
+   function to_seq(tbl){
+     /*<<hashtbl.ml:258:2>>*/ var tbl_data = tbl[2];
+     /*<<hashtbl.ml:260:2>>*/ function aux(i, buck, param){
+      /*<<hashtbl.ml:260:26>>*/ var i$0 = i, buck$0 = buck;
+      /*<<hashtbl.ml:260:26>>*/ for(;;){
+      if(buck$0){
+       var key = buck$0[1], data = buck$0[2], next = buck$0[3];
+        /*<<hashtbl.ml:266:8>>*/ return [0,
+               [0, key, data],
+               function(_T_){ /*<<?>>*/ return aux(i$0, next, _T_);}];
+      }
+      if(i$0 === tbl_data.length - 1)  /*<<hashtbl.ml:263:13>>*/ return 0;
+       /*<<hashtbl.ml:264:22>>*/ var
+        /*<<hashtbl.ml:264:22>>*/ buck$1 =
+         caml_check_bound(tbl_data, i$0)[1 + i$0],
+        /*<<hashtbl.ml:264:22>>*/ i$1 = i$0 + 1 | 0,
+       i$0 = i$1,
+       buck$0 = buck$1;
+     }
+     /*<<hashtbl.ml:266:42>>*/ }
+     /*<<hashtbl.ml:268:2>>*/ var  /*<<hashtbl.ml:268:2>>*/ _Q_ = 0, _R_ = 0;
+     /*<<hashtbl.ml:268:2>>*/ return function(_S_){
+      /*<<?>>*/ return aux(_R_, _Q_, _S_);};
+    /*<<hashtbl.ml:268:13>>*/ }
+   function to_seq_keys(m){
+     /*<<hashtbl.ml:270:20>>*/  /*<<hashtbl.ml:270:32>>*/ var _N_ = to_seq(m);
+    function _O_(_P_){ /*<<?>>*/ return _P_[1];}
+     /*<<hashtbl.ml:270:32>>*/ return  /*<<hashtbl.ml:270:32>>*/ caml_call2
+            (Stdlib_Seq[27], _O_, _N_);
+    /*<<hashtbl.ml:270:42>>*/ }
+   function to_seq_values(m){
+     /*<<hashtbl.ml:272:22>>*/  /*<<hashtbl.ml:272:34>>*/ var _K_ = to_seq(m);
+    function _L_(_M_){ /*<<?>>*/ return _M_[2];}
+     /*<<hashtbl.ml:272:34>>*/ return  /*<<hashtbl.ml:272:34>>*/ caml_call2
+            (Stdlib_Seq[27], _L_, _K_);
+    /*<<hashtbl.ml:272:44>>*/ }
+   function MakeSeeded(H){
+    function key_index(h, key){
+      /*<<hashtbl.ml:357:6>>*/ var _J_ = h[2].length - 1 - 1 | 0;
+      /*<<hashtbl.ml:357:6>>*/ return  /*<<hashtbl.ml:357:6>>*/ caml_call2
+             (H[2], h[3], key)
+            & _J_;
+     /*<<hashtbl.ml:357:63>>*/ }
+    function add(h, key, data){
+      /*<<hashtbl.ml:360:6>>*/ var
+       /*<<hashtbl.ml:360:14>>*/ i = key_index(h, key),
+       /*<<hashtbl.ml:361:23>>*/ bucket =
+        [0, key, data, caml_check_bound(h[2], i)[1 + i]];
+      /*<<hashtbl.ml:362:6>>*/ caml_check_bound(h[2], i)[1 + i] = bucket;
+     h[1] = h[1] + 1 | 0;
+     var _I_ = h[2].length - 1 << 1 < h[1] ? 1 : 0;
+     return _I_ ? resize(key_index, h) : _I_;
+     /*<<hashtbl.ml:364:67>>*/ }
+    function remove(h, key){
+      /*<<hashtbl.ml:380:6>>*/ var
+       /*<<hashtbl.ml:380:14>>*/ i = key_index(h, key),
+       /*<<hashtbl.ml:381:34>>*/ c = caml_check_bound(h[2], i)[1 + i],
+      prec$0 = 0,
+      prec = c;
+     for(;;){
+      if(! prec)  /*<<hashtbl.ml:368:10>>*/ return 0;
+      var k = prec[1], next = prec[3];
+       /*<<hashtbl.ml:370:13>>*/ if
+       ( /*<<hashtbl.ml:370:13>>*/ caml_call2(H[1], k, key)){
+       h[1] = h[1] - 1 | 0;
+       return prec$0
+               ? (prec$0[3] = next, 0)
+               : (caml_check_bound(h[2], i)[1 + i] = next, 0);
+      }
+      var prec$0 = prec, prec = next;
+     }
+     /*<<hashtbl.ml:381:44>>*/ }
+    function find(h, key){
+      /*<<hashtbl.ml:390:6>>*/ var
+       /*<<hashtbl.ml:390:20>>*/ _H_ = key_index(h, key),
+       /*<<hashtbl.ml:390:12>>*/ match = caml_check_bound(h[2], _H_)[1 + _H_];
+     if(! match)
+       /*<<hashtbl.ml:391:17>>*/ throw  /*<<hashtbl.ml:391:17>>*/ caml_maybe_attach_backtrace
+             (Stdlib[8], 1);
+     var k1 = match[1], d1 = match[2], next1 = match[3];
+      /*<<hashtbl.ml:393:13>>*/ if
+      ( /*<<hashtbl.ml:393:13>>*/ caml_call2(H[1], key, k1))
+       /*<<hashtbl.ml:393:33>>*/ return d1;
+     if(! next1)
+       /*<<hashtbl.ml:395:21>>*/ throw  /*<<hashtbl.ml:395:21>>*/ caml_maybe_attach_backtrace
+             (Stdlib[8], 1);
+     var k2 = next1[1], d2 = next1[2], next2 = next1[3];
+      /*<<hashtbl.ml:397:17>>*/ if
+      ( /*<<hashtbl.ml:397:17>>*/ caml_call2(H[1], key, k2))
+       /*<<hashtbl.ml:397:37>>*/ return d2;
+     if(! next2)
+       /*<<hashtbl.ml:399:25>>*/ throw  /*<<hashtbl.ml:399:25>>*/ caml_maybe_attach_backtrace
+             (Stdlib[8], 1);
+     var k3 = next2[1], d3 = next2[2], next3 = next2[3];
+      /*<<hashtbl.ml:401:21>>*/ if
+      ( /*<<hashtbl.ml:401:21>>*/ caml_call2(H[1], key, k3))
+       /*<<hashtbl.ml:401:41>>*/ return d3;
+     var param = next3;
+     for(;;){
+      if(! param)
+        /*<<hashtbl.ml:385:10>>*/ throw  /*<<hashtbl.ml:385:10>>*/ caml_maybe_attach_backtrace
+              (Stdlib[8], 1);
+      var k = param[1], data = param[2], next = param[3];
+       /*<<hashtbl.ml:387:13>>*/ if
+       ( /*<<hashtbl.ml:387:13>>*/ caml_call2(H[1], key, k))
+        /*<<hashtbl.ml:387:32>>*/ return data;
+      var param = next;
+     }
+     /*<<hashtbl.ml:401:67>>*/ }
+    function find_opt(h, key){
+      /*<<hashtbl.ml:410:6>>*/ var
+       /*<<hashtbl.ml:410:20>>*/ _G_ = key_index(h, key),
+       /*<<hashtbl.ml:410:12>>*/ match = caml_check_bound(h[2], _G_)[1 + _G_];
+     if(! match)  /*<<hashtbl.ml:411:17>>*/ return 0;
+     var k1 = match[1], d1 = match[2], next1 = match[3];
+      /*<<hashtbl.ml:413:13>>*/ if
+      ( /*<<hashtbl.ml:413:13>>*/ caml_call2(H[1], key, k1))
+       /*<<hashtbl.ml:413:33>>*/ return [0, d1];
+     if(! next1)  /*<<hashtbl.ml:415:21>>*/ return 0;
+     var k2 = next1[1], d2 = next1[2], next2 = next1[3];
+      /*<<hashtbl.ml:417:17>>*/ if
+      ( /*<<hashtbl.ml:417:17>>*/ caml_call2(H[1], key, k2))
+       /*<<hashtbl.ml:417:37>>*/ return [0, d2];
+     if(! next2)  /*<<hashtbl.ml:419:25>>*/ return 0;
+     var k3 = next2[1], d3 = next2[2], next3 = next2[3];
+      /*<<hashtbl.ml:421:21>>*/ if
+      ( /*<<hashtbl.ml:421:21>>*/ caml_call2(H[1], key, k3))
+       /*<<hashtbl.ml:421:41>>*/ return [0, d3];
+     var param = next3;
+     for(;;){
+      if(! param)  /*<<hashtbl.ml:405:10>>*/ return 0;
+      var k = param[1], data = param[2], next = param[3];
+       /*<<hashtbl.ml:407:13>>*/ if
+       ( /*<<hashtbl.ml:407:13>>*/ caml_call2(H[1], key, k))
+        /*<<hashtbl.ml:407:32>>*/ return [0, data];
+      var param = next;
+     }
+     /*<<hashtbl.ml:421:76>>*/ }
+    function find_all(h, key){
+     function find_in_bucket(param){
+       /*<<hashtbl.ml:424:31>>*/ var param$0 = param;
+       /*<<hashtbl.ml:424:31>>*/ for(;;){
+       if(! param$0)  /*<<hashtbl.ml:426:10>>*/ return 0;
+       var k = param$0[1], d = param$0[2], next = param$0[3];
+        /*<<hashtbl.ml:428:13>>*/ if
+        ( /*<<hashtbl.ml:428:13>>*/ caml_call2(H[1], k, key))
+         /*<<hashtbl.ml:429:15>>*/ return [0, d, find_in_bucket(next)];
+       var param$0 = next;
+      }
+      /*<<hashtbl.ml:430:34>>*/ }
+      /*<<hashtbl.ml:431:29>>*/  /*<<hashtbl.ml:431:29>>*/ var
+      _F_ = key_index(h, key);
+      /*<<hashtbl.ml:431:21>>*/ return find_in_bucket
+             (caml_check_bound(h[2], _F_)[1 + _F_]);
+     /*<<hashtbl.ml:431:45>>*/ }
+    function replace(h, key, data){
+      /*<<hashtbl.ml:442:6>>*/ var
+       /*<<hashtbl.ml:442:14>>*/ i = key_index(h, key),
+       /*<<hashtbl.ml:443:14>>*/ l = caml_check_bound(h[2], i)[1 + i],
+      slot = l;
+     for(;;){
+      if(slot){
+       var k = slot[1], next = slot[3];
+        /*<<hashtbl.ml:437:13>>*/ if
+        (!  /*<<hashtbl.ml:437:13>>*/ caml_call2(H[1], k, key)){var slot = next; continue;}
+       slot[1] = key;
+       slot[2] = data;
+       var _C_ = 0;
+      }
+      else
+       var _C_ = 1;
+       /*<<hashtbl.ml:444:9>>*/ if(_C_){
+        /*<<hashtbl.ml:445:8>>*/ caml_check_bound(h[2], i)[1 + i] = [0, key, data, l];
+       h[1] = h[1] + 1 | 0;
+       var _D_ = h[2].length - 1 << 1 < h[1] ? 1 : 0;
+       if(_D_)  /*<<hashtbl.ml:447:51>>*/ return resize(key_index, h);
+       var _E_ = _D_;
+      }
+      else
+       var _E_ = _C_;
+      return _E_;
+     }
+     /*<<hashtbl.ml:448:9>>*/ }
+    function mem(h, key){
+      /*<<hashtbl.ml:451:6>>*/ var
+       /*<<hashtbl.ml:456:28>>*/ _B_ = key_index(h, key),
+      param = caml_check_bound(h[2], _B_)[1 + _B_];
+      /*<<hashtbl.ml:451:30>>*/ for(;;){
+      if(! param)  /*<<hashtbl.ml:453:10>>*/ return 0;
+       /*<<hashtbl.ml:455:10>>*/ var
+       k = param[1],
+       next = param[3],
+        /*<<hashtbl.ml:455:10>>*/ _A_ =
+          /*<<hashtbl.ml:455:10>>*/ caml_call2(H[1], k, key);
+       /*<<hashtbl.ml:455:10>>*/ if(_A_)
+        /*<<hashtbl.ml:455:10>>*/ return _A_;
+      var param = next;
+     }
+     /*<<hashtbl.ml:456:44>>*/ }
+    function add_seq(tbl, i){
+     function _z_(param){
+       /*<<hashtbl.ml:459:15>>*/ var v = param[2], k = param[1];
+       /*<<hashtbl.ml:459:29>>*/ return add(tbl, k, v);
+      /*<<hashtbl.ml:459:41>>*/ }
+      /*<<hashtbl.ml:459:6>>*/ return  /*<<hashtbl.ml:459:6>>*/ caml_call2
+             (Stdlib_Seq[4], _z_, i);
+     /*<<hashtbl.ml:459:43>>*/ }
+    function replace_seq(tbl, i){
+     function _y_(param){
+       /*<<hashtbl.ml:462:15>>*/ var v = param[2], k = param[1];
+       /*<<hashtbl.ml:462:29>>*/ return replace(tbl, k, v);
+      /*<<hashtbl.ml:462:45>>*/ }
+      /*<<hashtbl.ml:462:6>>*/ return  /*<<hashtbl.ml:462:6>>*/ caml_call2
+             (Stdlib_Seq[4], _y_, i);
+     /*<<hashtbl.ml:462:47>>*/ }
+    function of_seq(i){
+      /*<<hashtbl.ml:465:6>>*/  /*<<hashtbl.ml:465:16>>*/ var
+      tbl = create(0, 16);
+      /*<<hashtbl.ml:466:6>>*/ replace_seq(tbl, i);
+      /*<<hashtbl.ml:466:6>>*/ return tbl;
+     /*<<hashtbl.ml:467:9>>*/ }
+     /*<<hashtbl.ml:347:2>>*/ return [0,
+            create,
+            clear,
+            reset,
+            copy,
+            add,
+            remove,
+            find,
+            find_opt,
+            find_all,
+            replace,
+            mem,
+            iter,
+            filter_map_inplace,
+            fold,
+            length,
+            stats,
+            to_seq,
+            to_seq_keys,
+            to_seq_values,
+            add_seq,
+            replace_seq,
+            of_seq];
+   }
+   function Make(H){
+    var equal = H[1];
+    function seeded_hash(seed, x){
+      /*<<hashtbl.ml:484:41>>*/ return  /*<<hashtbl.ml:484:41>>*/ caml_call1
+             (H[2], x);
+     /*<<hashtbl.ml:484:49>>*/ }
+    var
+     include = MakeSeeded([0, equal, seeded_hash]),
+     clear = include[2],
+     reset = include[3],
+     copy = include[4],
+     add = include[5],
+     remove = include[6],
+     find = include[7],
+     find_opt = include[8],
+     find_all = include[9],
+     replace = include[10],
+     mem = include[11],
+     iter = include[12],
+     filter_map_inplace = include[13],
+     fold = include[14],
+     length = include[15],
+     stats = include[16],
+     to_seq = include[17],
+     to_seq_keys = include[18],
+     to_seq_values = include[19],
+     add_seq = include[20],
+     replace_seq = include[21],
+     _x_ = include[1];
+    function create(sz){
+      /*<<hashtbl.ml:486:20>>*/ return  /*<<hashtbl.ml:486:20>>*/ caml_call2
+             (_x_, _d_, sz);
+     /*<<hashtbl.ml:486:43>>*/ }
+    function of_seq(i){
+      /*<<hashtbl.ml:488:6>>*/  /*<<hashtbl.ml:488:16>>*/ var
+      tbl = create(16);
+      /*<<hashtbl.ml:489:6>>*/  /*<<hashtbl.ml:489:6>>*/ caml_call2
+      (replace_seq, tbl, i);
+      /*<<hashtbl.ml:489:6>>*/ return tbl;
+     /*<<hashtbl.ml:490:9>>*/ }
+     /*<<hashtbl.ml:480:2>>*/ return [0,
+            create,
+            clear,
+            reset,
+            copy,
+            add,
+            remove,
+            find,
+            find_opt,
+            find_all,
+            replace,
+            mem,
+            iter,
+            filter_map_inplace,
+            fold,
+            length,
+            stats,
+            to_seq,
+            to_seq_keys,
+            to_seq_values,
+            add_seq,
+            replace_seq,
+            of_seq];
+   }
+   function hash(x){
+     /*<<hashtbl.ml:500:13>>*/ return  /*<<hashtbl.ml:500:13>>*/ caml_hash
+            (10, 100, 0, x);
+    /*<<hashtbl.ml:500:41>>*/ }
+   function hash_param(n1, n2, x){
+     /*<<hashtbl.ml:501:25>>*/ return  /*<<hashtbl.ml:501:25>>*/ caml_hash
+            (n1, n2, 0, x);
+    /*<<hashtbl.ml:501:52>>*/ }
+   function seeded_hash(seed, x){
+     /*<<hashtbl.ml:502:25>>*/ return  /*<<hashtbl.ml:502:25>>*/ caml_hash
+            (10, 100, seed, x);
+    /*<<hashtbl.ml:502:56>>*/ }
+   function key_index(h, key){
+     /*<<hashtbl.ml:505:2>>*/ return 4 <= h.length - 1
+            ?  /*<<hashtbl.ml:506:7>>*/ caml_hash
+              (10, 100, h[3], key)
+             & (h[2].length - 1 - 1 | 0)
+            :  /*<<hashtbl.ml:507:7>>*/ caml_call1
+              (Stdlib[1], cst_Hashtbl_unsupported_hash_t);
+    /*<<hashtbl.ml:507:59>>*/ }
+   function add(h, key, data){
+     /*<<hashtbl.ml:510:2>>*/ var
+      /*<<hashtbl.ml:510:10>>*/ i = key_index(h, key),
+      /*<<hashtbl.ml:511:19>>*/ bucket =
+       [0, key, data, caml_check_bound(h[2], i)[1 + i]];
+     /*<<hashtbl.ml:512:2>>*/ caml_check_bound(h[2], i)[1 + i] = bucket;
+    h[1] = h[1] + 1 | 0;
+    var _w_ = h[2].length - 1 << 1 < h[1] ? 1 : 0;
+    return _w_ ? resize(key_index, h) : _w_;
+    /*<<hashtbl.ml:514:63>>*/ }
+   function remove(h, key){
+     /*<<hashtbl.ml:530:2>>*/ var
+      /*<<hashtbl.ml:530:10>>*/ i = key_index(h, key),
+      /*<<hashtbl.ml:531:30>>*/ c = caml_check_bound(h[2], i)[1 + i],
+     prec$0 = 0,
+     prec = c;
+    for(;;){
+     if(! prec)  /*<<hashtbl.ml:518:6>>*/ return 0;
+     var k = prec[1], next = prec[3];
+      /*<<hashtbl.ml:520:9>>*/ if
+      (0 ===  /*<<hashtbl.ml:520:9>>*/ caml_compare(k, key)){
+      h[1] = h[1] - 1 | 0;
+      return prec$0
+              ? (prec$0[3] = next, 0)
+              : (caml_check_bound(h[2], i)[1 + i] = next, 0);
+     }
+     var prec$0 = prec, prec = next;
+    }
+    /*<<hashtbl.ml:531:40>>*/ }
+   function find(h, key){
+     /*<<hashtbl.ml:540:2>>*/ var
+      /*<<hashtbl.ml:540:16>>*/ _v_ = key_index(h, key),
+      /*<<hashtbl.ml:540:8>>*/ match = caml_check_bound(h[2], _v_)[1 + _v_];
+    if(! match)
+      /*<<hashtbl.ml:541:13>>*/ throw  /*<<hashtbl.ml:541:13>>*/ caml_maybe_attach_backtrace
+            (Stdlib[8], 1);
+    var k1 = match[1], d1 = match[2], next1 = match[3];
+     /*<<hashtbl.ml:543:9>>*/ if
+     (0 ===  /*<<hashtbl.ml:543:9>>*/ caml_compare(key, k1))
+      /*<<hashtbl.ml:543:33>>*/ return d1;
+    if(! next1)
+      /*<<hashtbl.ml:545:17>>*/ throw  /*<<hashtbl.ml:545:17>>*/ caml_maybe_attach_backtrace
+            (Stdlib[8], 1);
+    var k2 = next1[1], d2 = next1[2], next2 = next1[3];
+     /*<<hashtbl.ml:547:13>>*/ if
+     (0 ===  /*<<hashtbl.ml:547:13>>*/ caml_compare(key, k2))
+      /*<<hashtbl.ml:547:37>>*/ return d2;
+    if(! next2)
+      /*<<hashtbl.ml:549:21>>*/ throw  /*<<hashtbl.ml:549:21>>*/ caml_maybe_attach_backtrace
+            (Stdlib[8], 1);
+    var k3 = next2[1], d3 = next2[2], next3 = next2[3];
+     /*<<hashtbl.ml:551:17>>*/ if
+     (0 ===  /*<<hashtbl.ml:551:17>>*/ caml_compare(key, k3))
+      /*<<hashtbl.ml:551:41>>*/ return d3;
+    var param = next3;
+    for(;;){
+     if(! param)
+       /*<<hashtbl.ml:535:6>>*/ throw  /*<<hashtbl.ml:535:6>>*/ caml_maybe_attach_backtrace
+             (Stdlib[8], 1);
+     var k = param[1], data = param[2], next = param[3];
+      /*<<hashtbl.ml:537:9>>*/ if
+      (0 ===  /*<<hashtbl.ml:537:9>>*/ caml_compare(key, k))
+       /*<<hashtbl.ml:537:32>>*/ return data;
+     var param = next;
+    }
+    /*<<hashtbl.ml:551:67>>*/ }
+   function find_opt(h, key){
+     /*<<hashtbl.ml:560:2>>*/ var
+      /*<<hashtbl.ml:560:16>>*/ _u_ = key_index(h, key),
+      /*<<hashtbl.ml:560:8>>*/ match = caml_check_bound(h[2], _u_)[1 + _u_];
+    if(! match)  /*<<hashtbl.ml:561:13>>*/ return 0;
+    var k1 = match[1], d1 = match[2], next1 = match[3];
+     /*<<hashtbl.ml:563:9>>*/ if
+     (0 ===  /*<<hashtbl.ml:563:9>>*/ caml_compare(key, k1))
+      /*<<hashtbl.ml:563:33>>*/ return [0, d1];
+    if(! next1)  /*<<hashtbl.ml:565:17>>*/ return 0;
+    var k2 = next1[1], d2 = next1[2], next2 = next1[3];
+     /*<<hashtbl.ml:567:13>>*/ if
+     (0 ===  /*<<hashtbl.ml:567:13>>*/ caml_compare(key, k2))
+      /*<<hashtbl.ml:567:37>>*/ return [0, d2];
+    if(! next2)  /*<<hashtbl.ml:569:21>>*/ return 0;
+    var k3 = next2[1], d3 = next2[2], next3 = next2[3];
+     /*<<hashtbl.ml:571:17>>*/ if
+     (0 ===  /*<<hashtbl.ml:571:17>>*/ caml_compare(key, k3))
+      /*<<hashtbl.ml:571:41>>*/ return [0, d3];
+    var param = next3;
+    for(;;){
+     if(! param)  /*<<hashtbl.ml:555:6>>*/ return 0;
+     var k = param[1], data = param[2], next = param[3];
+      /*<<hashtbl.ml:557:9>>*/ if
+      (0 ===  /*<<hashtbl.ml:557:9>>*/ caml_compare(key, k))
+       /*<<hashtbl.ml:557:32>>*/ return [0, data];
+     var param = next;
+    }
+    /*<<hashtbl.ml:571:76>>*/ }
+   function find_all(h, key){
+    function find_in_bucket(param){
+      /*<<hashtbl.ml:574:27>>*/ var param$0 = param;
+      /*<<hashtbl.ml:574:27>>*/ for(;;){
+      if(! param$0)  /*<<hashtbl.ml:576:6>>*/ return 0;
+      var k = param$0[1], data = param$0[2], next = param$0[3];
+       /*<<hashtbl.ml:578:9>>*/ if
+       (0 ===  /*<<hashtbl.ml:578:9>>*/ caml_compare(k, key))
+        /*<<hashtbl.ml:579:11>>*/ return [0, data, find_in_bucket(next)];
+      var param$0 = next;
+     }
+     /*<<hashtbl.ml:580:30>>*/ }
+     /*<<hashtbl.ml:581:25>>*/  /*<<hashtbl.ml:581:25>>*/ var
+     _t_ = key_index(h, key);
+     /*<<hashtbl.ml:581:17>>*/ return find_in_bucket
+            (caml_check_bound(h[2], _t_)[1 + _t_]);
+    /*<<hashtbl.ml:581:41>>*/ }
+   function replace(h, key, data){
+     /*<<hashtbl.ml:592:2>>*/ var
+      /*<<hashtbl.ml:592:10>>*/ i = key_index(h, key),
+      /*<<hashtbl.ml:593:10>>*/ l = caml_check_bound(h[2], i)[1 + i],
+     slot = l;
+    for(;;){
+     if(slot){
+      var k = slot[1], next = slot[3];
+       /*<<hashtbl.ml:587:9>>*/ if
+       (0 !==  /*<<hashtbl.ml:587:9>>*/ caml_compare(k, key)){var slot = next; continue;}
+      slot[1] = key;
+      slot[2] = data;
+      var _q_ = 0;
+     }
+     else
+      var _q_ = 1;
+      /*<<hashtbl.ml:594:5>>*/ if(_q_){
+       /*<<hashtbl.ml:595:4>>*/ caml_check_bound(h[2], i)[1 + i] = [0, key, data, l];
+      h[1] = h[1] + 1 | 0;
+      var _r_ = h[2].length - 1 << 1 < h[1] ? 1 : 0;
+      if(_r_)  /*<<hashtbl.ml:597:47>>*/ return resize(key_index, h);
+      var _s_ = _r_;
+     }
+     else
+      var _s_ = _q_;
+     return _s_;
+    }
+    /*<<hashtbl.ml:598:5>>*/ }
+   function mem(h, key){
+     /*<<hashtbl.ml:601:2>>*/ var
+      /*<<hashtbl.ml:606:24>>*/ _p_ = key_index(h, key),
+     param = caml_check_bound(h[2], _p_)[1 + _p_];
+     /*<<hashtbl.ml:601:26>>*/ for(;;){
+     if(! param)  /*<<hashtbl.ml:603:6>>*/ return 0;
+     var
+      k = param[1],
+      next = param[3],
+      _o_ = 0 ===  /*<<hashtbl.ml:605:6>>*/ caml_compare(k, key) ? 1 : 0;
+     if(_o_) return _o_;
+     var param = next;
+    }
+    /*<<hashtbl.ml:606:40>>*/ }
+   function add_seq(tbl, i){
+    function _n_(param){
+      /*<<hashtbl.ml:609:11>>*/ var v = param[2], k = param[1];
+      /*<<hashtbl.ml:609:25>>*/ return add(tbl, k, v);
+     /*<<hashtbl.ml:609:37>>*/ }
+     /*<<hashtbl.ml:609:2>>*/ return  /*<<hashtbl.ml:609:2>>*/ caml_call2
+            (Stdlib_Seq[4], _n_, i);
+    /*<<hashtbl.ml:609:39>>*/ }
+   function replace_seq(tbl, i){
+    function _m_(param){
+      /*<<hashtbl.ml:612:11>>*/ var v = param[2], k = param[1];
+      /*<<hashtbl.ml:612:25>>*/ return replace(tbl, k, v);
+     /*<<hashtbl.ml:612:41>>*/ }
+     /*<<hashtbl.ml:612:2>>*/ return  /*<<hashtbl.ml:612:2>>*/ caml_call2
+            (Stdlib_Seq[4], _m_, i);
+    /*<<hashtbl.ml:612:43>>*/ }
+   function of_seq(i){
+     /*<<hashtbl.ml:615:2>>*/  /*<<hashtbl.ml:615:12>>*/ var
+     tbl = create(0, 16);
+     /*<<hashtbl.ml:616:2>>*/ replace_seq(tbl, i);
+     /*<<hashtbl.ml:616:2>>*/ return tbl;
+    /*<<hashtbl.ml:617:5>>*/ }
+   function rebuild(opt, h){
+     /*<<hashtbl.ml:620:2>>*/ if(opt)
+     var sth = opt[1], random = sth;
+    else
+     var
+      random =
+         /*<<hashtbl.ml:619:23>>*/ caml_call1(Stdlib_Atomic[2], randomized);
+     /*<<hashtbl.ml:620:10>>*/  /*<<hashtbl.ml:620:10>>*/ var
+     s = power_2_above(16, h[2].length - 1);
+     /*<<hashtbl.ml:621:2>>*/ if(random)
+      /*<<hashtbl.ml:622:37>>*/ var
+       /*<<hashtbl.ml:622:37>>*/ _g_ =
+         /*<<hashtbl.ml:622:37>>*/ caml_call1(Stdlib_Domain[10][2], prng_key),
+      seed =  /*<<hashtbl.ml:622:19>>*/ caml_call1(Stdlib_Random[15][4], _g_);
+    else
+     var seed = 4 <= h.length - 1 ? h[3] : 0;
+     /*<<hashtbl.ml:625:11>>*/ var
+     _h_ = 4 <= h.length - 1 ? h[4] : s,
+      /*<<hashtbl.ml:625:11>>*/ h$0 =
+       [0, h[1],  /*<<hashtbl.ml:627:11>>*/ caml_make_vect(s, 0), seed, _h_],
+     _i_ = h$0[2],
+     _j_ = h[2],
+     _k_ = 0;
+     /*<<hashtbl.ml:631:2>>*/ insert_all_buckets
+     (function(_l_){ /*<<?>>*/ return key_index(h$0, _l_);}, _k_, _j_, _i_);
+     /*<<hashtbl.ml:631:2>>*/ return h$0;
+    /*<<hashtbl.ml:632:4>>*/ }
+   var
+    Stdlib_Hashtbl =
+      [0,
+       create,
+       clear,
+       reset,
+       copy,
+       add,
+       find,
+       find_opt,
+       find_all,
+       mem,
+       remove,
+       replace,
+       iter,
+       filter_map_inplace,
+       fold,
+       length,
+       randomize,
+       is_randomized,
+       rebuild,
+       stats,
+       to_seq,
+       to_seq_keys,
+       to_seq_values,
+       add_seq,
+       replace_seq,
+       of_seq,
+       Make,
+       MakeSeeded,
+       hash,
+       seeded_hash,
+       hash_param,
+       caml_hash];
+   runtime.caml_register_global(16, Stdlib_Hashtbl, "Stdlib__Hashtbl");
+   return;
+   /*<<?>>*/ }
+  (globalThis));
+
+//# unitInfo: Provides: Stdlib__Weak
+//# unitInfo: Requires: Stdlib, Stdlib__Array, Stdlib__Int, Stdlib__Obj, Stdlib__Sys
+(function
+  (globalThis){
+   "use strict";
+   var
+    runtime = globalThis.jsoo_runtime,
+    caml_check_bound = runtime.caml_check_bound,
+    caml_make_vect = runtime.caml_make_vect,
+    caml_maybe_attach_backtrace = runtime.caml_maybe_attach_backtrace,
+    caml_mod = runtime.caml_mod;
+    /*<<?>>*/ function caml_call1(f, a0){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 1
+            ? f(a0)
+            : runtime.caml_call_gen(f, [a0]);
+   }
+    /*<<?>>*/ function caml_call2(f, a0, a1){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 2
+            ? f(a0, a1)
+            : runtime.caml_call_gen(f, [a0, a1]);
+   }
+    /*<<?>>*/ function caml_call3(f, a0, a1, a2){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 3
+            ? f(a0, a1, a2)
+            : runtime.caml_call_gen(f, [a0, a1, a2]);
+   }
+    /*<<?>>*/ function caml_call5(f, a0, a1, a2, a3, a4){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 5
+            ? f(a0, a1, a2, a3, a4)
+            : runtime.caml_call_gen(f, [a0, a1, a2, a3, a4]);
+   }
+   var
+    global_data = runtime.caml_get_global_data(),
+    Stdlib = global_data.Stdlib,
+    Stdlib_Sys = global_data.Stdlib__Sys,
+    Stdlib_Int = global_data.Stdlib__Int,
+    Stdlib_Array = global_data.Stdlib__Array,
+    Stdlib_Obj = global_data.Stdlib__Obj,
+    cst_Weak_Make_hash_bucket_cann = "Weak.Make: hash bucket cannot grow more",
+    cst_Weak_fill = "Weak.fill",
+    cst_Weak_blit = "Weak.blit",
+    cst_Weak_check = "Weak.check",
+    cst_Weak_get_copy = "Weak.get_copy",
+    cst_Weak_get = "Weak.get",
+    cst_Weak_set = "Weak.set",
+    cst_Weak_create = "Weak.create";
+   function create(l){
+     /*<<weak.ml:28:2>>*/ var
+     _W_ = 0 <= l ? 1 : 0,
+     _X_ = _W_ ? l <= Stdlib_Obj[24][15] ? 1 : 0 : _W_;
+    if(1 - _X_)
+      /*<<weak.ml:29:4>>*/  /*<<weak.ml:29:4>>*/ caml_call1
+      (Stdlib[1], cst_Weak_create);
+     /*<<weak.ml:30:2>>*/ return  /*<<weak.ml:30:2>>*/ runtime.caml_weak_create
+            (l);
+    /*<<weak.ml:30:10>>*/ }
+   function length(x){
+     /*<<weak.ml:33:15>>*/ return x.length - 1 - 2 | 0;
+    /*<<weak.ml:33:55>>*/ }
+   function raise_if_invalid_offset(e, o, msg){
+     /*<<weak.ml:36:2>>*/ var
+     _T_ = 0 <= o ? 1 : 0,
+     _U_ = _T_ ? o < length(e) ? 1 : 0 : _T_,
+     _V_ = 1 - _U_;
+    return _V_ ?  /*<<weak.ml:37:4>>*/ caml_call1(Stdlib[1], msg) : _V_;
+    /*<<weak.ml:37:20>>*/ }
+   function set(e, o, x){
+     /*<<weak.ml:42:2>>*/ raise_if_invalid_offset(e, o, cst_Weak_set);
+    if(! x)
+      /*<<weak.ml:44:12>>*/ return  /*<<weak.ml:44:12>>*/ runtime.caml_ephe_unset_key
+             (e, o);
+    var x$0 = x[1];
+     /*<<weak.ml:45:14>>*/ return  /*<<weak.ml:45:14>>*/ runtime.caml_ephe_set_key
+            (e, o, x$0);
+    /*<<weak.ml:45:24>>*/ }
+   function get(e, o){
+     /*<<weak.ml:49:2>>*/ raise_if_invalid_offset(e, o, cst_Weak_get);
+     /*<<weak.ml:50:2>>*/ return  /*<<weak.ml:50:2>>*/ runtime.caml_ephe_get_key
+            (e, o);
+    /*<<weak.ml:50:9>>*/ }
+   function get_copy(e, o){
+     /*<<weak.ml:54:2>>*/ raise_if_invalid_offset(e, o, cst_Weak_get_copy);
+     /*<<weak.ml:55:2>>*/ return  /*<<weak.ml:55:2>>*/ runtime.caml_ephe_get_key_copy
+            (e, o);
+    /*<<weak.ml:55:14>>*/ }
+   function check(e, o){
+     /*<<weak.ml:59:2>>*/ raise_if_invalid_offset(e, o, cst_Weak_check);
+     /*<<weak.ml:60:2>>*/ return  /*<<weak.ml:60:2>>*/ runtime.caml_ephe_check_key
+            (e, o);
+    /*<<weak.ml:60:11>>*/ }
+   function blit(e1, o1, e2, o2, l){
+     /*<<weak.ml:66:2>>*/ if
+     (0 <= l
+      &&
+       0 <= o1
+       && (length(e1) - l | 0) >= o1 && 0 <= o2 && (length(e2) - l | 0) >= o2){
+     var
+      _R_ = 0 !== l ? 1 : 0,
+      _S_ =
+        _R_
+         ?  /*<<weak.ml:69:22>>*/ runtime.caml_ephe_blit_key
+           (e1, o1, e2, o2, l)
+         : _R_;
+      /*<<weak.ml:69:22>>*/ return _S_;
+    }
+     /*<<weak.ml:68:7>>*/ return  /*<<weak.ml:68:7>>*/ caml_call1
+            (Stdlib[1], cst_Weak_blit);
+    /*<<weak.ml:69:40>>*/ }
+   function fill(ar, ofs, len, x){
+     /*<<weak.ml:72:2>>*/ if
+     (0 <= ofs && 0 <= len && (length(ar) - len | 0) >= ofs){
+     var _P_ = (ofs + len | 0) - 1 | 0;
+     if(_P_ >= ofs){
+      var i = ofs;
+      for(;;){
+        /*<<weak.ml:76:6>>*/ set(ar, i, x);
+        /*<<weak.ml:76:6>>*/  /*<<weak.ml:76:6>>*/ var _Q_ = i + 1 | 0;
+       if(_P_ === i) break;
+       var i = _Q_;
+      }
+     }
+     return 0;
+    }
+     /*<<weak.ml:73:7>>*/ throw  /*<<weak.ml:73:7>>*/ caml_maybe_attach_backtrace
+           ([0, Stdlib[6], cst_Weak_fill], 1);
+    /*<<weak.ml:78:5>>*/ }
+   function Make(H){
+     /*<<weak.ml:105:20>>*/  /*<<weak.ml:105:20>>*/ var
+     emptybucket = create(0);
+    function get_index(t, h){
+      /*<<weak.ml:117:22>>*/ return caml_mod(h & Stdlib[19], t[1].length - 1);
+     /*<<weak.ml:117:65>>*/ }
+    var limit = 7;
+    function create$0(sz){
+      /*<<weak.ml:123:4>>*/ var
+      sz$0 = 7 <= sz ? sz : 7,
+      sz$1 = Stdlib_Sys[13] < sz$0 ? Stdlib_Sys[13] : sz$0;
+      /*<<weak.ml:125:4>>*/ return [0,
+              /*<<weak.ml:126:14>>*/ caml_make_vect(sz$1, emptybucket),
+              /*<<weak.ml:127:15>>*/ caml_make_vect(sz$1, [0]),
+             limit,
+             0,
+             0];
+     /*<<weak.ml:131:5>>*/ }
+    function clear(t){
+      /*<<weak.ml:134:4>>*/ var
+      _N_ = t[1].length - 1 - 1 | 0,
+       /*<<weak.ml:134:4>>*/ _M_ = 0;
+     if(_N_ >= 0){
+      var i = _M_;
+      for(;;){
+        /*<<weak.ml:135:6>>*/ caml_check_bound(t[1], i)[1 + i] = emptybucket;
+        /*<<weak.ml:136:6>>*/ caml_check_bound(t[2], i)[1 + i] = [0];
+        /*<<weak.ml:136:6>>*/  /*<<weak.ml:136:6>>*/ var _O_ = i + 1 | 0;
+       if(_N_ === i) break;
+       var i = _O_;
+      }
+     }
+     t[3] = limit;
+     t[4] = 0;
+     return 0;
+     /*<<weak.ml:139:19>>*/ }
+    function fold(f, t, init){
+      /*<<weak.ml:143:4>>*/ var _K_ = t[1], i = 0;
+      /*<<weak.ml:149:21>>*/ function _L_(b, accu$1){
+      var i$0 = i, accu = accu$1;
+       /*<<weak.ml:144:6>>*/ for(;;){
+       if(length(b) <= i$0)  /*<<weak.ml:144:28>>*/ return accu;
+        /*<<weak.ml:145:12>>*/  /*<<weak.ml:145:12>>*/ var
+        match = get(b, i$0);
+       if(match)
+         /*<<weak.ml:146:38>>*/ var
+         v = match[1],
+          /*<<weak.ml:146:38>>*/ accu$0 =
+            /*<<weak.ml:146:38>>*/ caml_call2(f, v, accu),
+         i$1 = i$0 + 1 | 0,
+         i$0 = i$1,
+         accu = accu$0;
+       else
+        var i$2 = i$0 + 1 | 0, i$0 = i$2;
+      }
+     }
+      /*<<weak.ml:149:4>>*/ return  /*<<weak.ml:149:4>>*/ caml_call3
+             (Stdlib_Array[17], _L_, _K_, init);
+     /*<<weak.ml:149:49>>*/ }
+    function iter(f, t){
+      /*<<weak.ml:153:4>>*/ var _I_ = t[1], i = 0;
+      /*<<weak.ml:159:15>>*/ function _J_(b){
+      var i$0 = i;
+       /*<<weak.ml:154:6>>*/ for(;;){
+       if(length(b) <= i$0)  /*<<weak.ml:154:28>>*/ return 0;
+        /*<<weak.ml:155:12>>*/  /*<<weak.ml:155:12>>*/ var
+        match = get(b, i$0);
+       if(match){
+        var v = match[1];
+         /*<<weak.ml:156:18>>*/  /*<<weak.ml:156:18>>*/ caml_call1(f, v);
+        var i$1 = i$0 + 1 | 0, i$0 = i$1;
+       }
+       else
+        var i$2 = i$0 + 1 | 0, i$0 = i$2;
+      }
+     }
+      /*<<weak.ml:159:15>>*/ return  /*<<weak.ml:159:15>>*/ caml_call2
+             (Stdlib_Array[11], _J_, _I_);
+     /*<<weak.ml:159:38>>*/ }
+    function count_bucket(i, b, accu){
+      /*<<weak.ml:173:4>>*/ var i$0 = i, accu$0 = accu;
+      /*<<weak.ml:173:4>>*/ for(;;){
+      if(length(b) <= i$0)  /*<<weak.ml:173:26>>*/ return accu$0;
+       /*<<weak.ml:174:37>>*/ var
+        /*<<weak.ml:174:37>>*/ _H_ = check(b, i$0) ? 1 : 0,
+       accu$1 = accu$0 + _H_ | 0,
+       i$1 = i$0 + 1 | 0,
+       i$0 = i$1,
+       accu$0 = accu$1;
+     }
+     /*<<weak.ml:174:62>>*/ }
+    function count(t){
+      /*<<weak.ml:178:4>>*/ var
+       /*<<weak.ml:178:4>>*/ _B_ = 0,
+      _C_ = t[1],
+      _D_ = 0;
+      /*<<weak.ml:178:21>>*/ function _E_(_F_, _G_){
+       /*<<?>>*/ return count_bucket(_D_, _F_, _G_);
+     }
+      /*<<weak.ml:178:4>>*/ return  /*<<weak.ml:178:4>>*/ caml_call3
+             (Stdlib_Array[17], _E_, _C_, _B_);
+     /*<<weak.ml:178:47>>*/ }
+    function add_aux(t, setter, d, h, index){
+      /*<<weak.ml:238:4>>*/ var
+       /*<<weak.ml:238:17>>*/ bucket$0 =
+        caml_check_bound(t[1], index)[1 + index],
+       /*<<weak.ml:239:17>>*/ hashes =
+        caml_check_bound(t[2], index)[1 + index],
+       /*<<weak.ml:240:13>>*/ sz = length(bucket$0),
+      i$3 = 0;
+      /*<<weak.ml:242:6>>*/ for(;;){
+      if(sz <= i$3){
+        /*<<weak.ml:244:10>>*/  /*<<weak.ml:244:10>>*/ var
+        newsz =
+           /*<<weak.ml:244:10>>*/ caml_call2
+           (Stdlib_Int[10],
+            ((3 * sz | 0) / 2 | 0) + 3 | 0,
+            Stdlib_Sys[13] - 2 | 0);
+       if(newsz <= sz)
+         /*<<weak.ml:246:28>>*/  /*<<weak.ml:246:28>>*/ caml_call1
+         (Stdlib[2], cst_Weak_Make_hash_bucket_cann);
+        /*<<weak.ml:247:24>>*/ var
+         /*<<weak.ml:247:24>>*/ newbucket$0 = create(newsz),
+         /*<<weak.ml:248:24>>*/ newhashes =
+           /*<<weak.ml:248:24>>*/ caml_make_vect(newsz, 0);
+        /*<<weak.ml:249:8>>*/ blit(bucket$0, 0, newbucket$0, 0, sz);
+        /*<<weak.ml:250:8>>*/  /*<<weak.ml:250:8>>*/ caml_call5
+        (Stdlib_Array[8], hashes, 0, newhashes, 0, sz);
+        /*<<weak.ml:251:8>>*/  /*<<weak.ml:251:8>>*/ caml_call3
+        (setter, newbucket$0, sz, d);
+        /*<<weak.ml:252:8>>*/ caml_check_bound(newhashes, sz)[1 + sz] = h;
+        /*<<weak.ml:253:8>>*/ caml_check_bound(t[1], index)[1 + index] = newbucket$0;
+        /*<<weak.ml:254:8>>*/ caml_check_bound(t[2], index)[1 + index] = newhashes;
+       var _x_ = sz <= t[3] ? 1 : 0, _y_ = _x_ ? t[3] < newsz ? 1 : 0 : _x_;
+       if(_y_){
+        t[4] = t[4] + 1 | 0;
+        var i$4 = 0;
+        for(;;){
+          /*<<weak.ml:185:17>>*/ var
+          _n_ = t[5],
+           /*<<weak.ml:185:17>>*/ bucket =
+            caml_check_bound(t[1], _n_)[1 + _n_],
+           /*<<weak.ml:186:4>>*/ _o_ = t[5],
+           /*<<weak.ml:186:18>>*/ hbucket =
+            caml_check_bound(t[2], _o_)[1 + _o_],
+           /*<<weak.ml:187:14>>*/ len = length(bucket),
+          prev_len = (((len - 3 | 0) * 2 | 0) + 2 | 0) / 3 | 0,
+           /*<<weak.ml:189:15>>*/ live = count_bucket(0, bucket, 0);
+         if(live <= prev_len){
+           /*<<weak.ml:201:14>>*/ var
+            /*<<weak.ml:201:14>>*/ j$2 = length(bucket) - 1 | 0,
+           i$0 = 0,
+           j = j$2;
+           /*<<weak.ml:192:8>>*/ for(;;){
+           if(prev_len > j){
+            if(0 === prev_len){
+             var _q_ = t[5];
+              /*<<weak.ml:203:8>>*/ caml_check_bound(t[1], _q_)[1 + _q_] = emptybucket;
+             var _r_ = t[5];
+              /*<<weak.ml:204:8>>*/ caml_check_bound(t[2], _r_)[1 + _r_] = [0];
+            }
+            else{
+              /*<<weak.ml:206:24>>*/  /*<<weak.ml:206:24>>*/ var
+              newbucket = create(prev_len);
+              /*<<weak.ml:207:8>>*/ blit(bucket, 0, newbucket, 0, prev_len);
+             var _u_ = t[5];
+              /*<<weak.ml:208:8>>*/ caml_check_bound(t[1], _u_)[1 + _u_] = newbucket;
+              /*<<weak.ml:209:30>>*/ var
+               /*<<weak.ml:209:30>>*/ _v_ =
+                 /*<<weak.ml:209:30>>*/ caml_call3
+                 (Stdlib_Array[5], hbucket, 0, prev_len),
+              _w_ = t[5];
+              /*<<weak.ml:209:8>>*/ caml_check_bound(t[2], _w_)[1 + _w_] = _v_;
+            }
+            var
+             _s_ = t[3] < len ? 1 : 0,
+             _t_ = _s_ ? prev_len <= t[3] ? 1 : 0 : _s_;
+            if(_t_) t[4] = t[4] - 1 | 0;
+            break;
+           }
+            /*<<weak.ml:193:13>>*/ if(check(bucket, i$0))
+            var i$1 = i$0 + 1 | 0, i$0 = i$1;
+           else if(check(bucket, j)){
+             /*<<weak.ml:195:12>>*/ blit(bucket, j, bucket, i$0, 1);
+             /*<<weak.ml:196:27>>*/  /*<<weak.ml:196:27>>*/ var
+             _p_ = caml_check_bound(hbucket, j)[1 + j];
+             /*<<weak.ml:196:12>>*/ caml_check_bound(hbucket, i$0)[1 + i$0] = _p_;
+             /*<<weak.ml:196:12>>*/ var
+              /*<<weak.ml:196:12>>*/ j$0 = j - 1 | 0,
+             i$2 = i$0 + 1 | 0,
+             i$0 = i$2,
+             j = j$0;
+           }
+           else
+             /*<<weak.ml:198:19>>*/ var
+              /*<<weak.ml:198:19>>*/ j$1 = j - 1 | 0,
+             j = j$1;
+          }
+         }
+         t[5] = caml_mod(t[5] + 1 | 0, t[1].length - 1);
+          /*<<weak.ml:257:38>>*/  /*<<weak.ml:257:38>>*/ var
+          _A_ = i$4 + 1 | 0;
+         if(2 === i$4) break;
+         var i$4 = _A_;
+        }
+       }
+       var _z_ = ((t[1].length - 1) / 2 | 0) < t[4] ? 1 : 0;
+       if(! _z_) return _z_;
+        /*<<weak.ml:181:18>>*/ var
+        oldlen = t[1].length - 1,
+         /*<<weak.ml:181:18>>*/ newlen =
+           /*<<weak.ml:181:18>>*/ caml_call2
+           (Stdlib_Int[10],
+            ((3 * oldlen | 0) / 2 | 0) + 3 | 0,
+            Stdlib_Sys[13]);
+       if(oldlen < newlen){
+         /*<<weak.ml:220:17>>*/ var
+          /*<<weak.ml:220:17>>*/ newt = create$0(newlen),
+         _l_ = t[1],
+         i = 0,
+          /*<<weak.ml:169:16>>*/ _m_ =
+           function(j, ob){
+            var oi = i;
+             /*<<weak.ml:164:6>>*/ for(;;){
+             if(length(ob) <= oi)  /*<<weak.ml:164:28>>*/ return 0;
+             if(check(ob, oi)){
+               /*<<weak.ml:166:20>>*/ var
+                /*<<weak.ml:166:20>>*/ oh = caml_check_bound(t[2], j)[1 + j],
+               setter$0 =
+                 function(oi){
+                  function setter(nb, ni, param){
+                    /*<<weak.ml:222:29>>*/ return blit(ob, oi, nb, ni, 1);
+                   /*<<weak.ml:222:47>>*/ }
+                  return setter;
+                 },
+               setter = setter$0(oi),
+                /*<<weak.ml:223:16>>*/ h = caml_check_bound(oh, oi)[1 + oi];
+               /*<<weak.ml:224:35>>*/ add_aux
+               (newt, setter, 0, h, get_index(newt, h));
+              var i$0 = oi + 1 | 0, oi = i$0;
+             }
+             else
+              var i$1 = oi + 1 | 0, oi = i$1;
+            }
+           };
+         /*<<weak.ml:169:16>>*/  /*<<weak.ml:169:16>>*/ caml_call2
+         (Stdlib_Array[12], _m_, _l_);
+        t[1] = newt[1];
+        t[2] = newt[2];
+        t[3] = newt[3];
+        t[4] = newt[4];
+        t[5] = caml_mod(t[5], newt[1].length - 1);
+        return 0;
+       }
+       t[3] = Stdlib[19];
+       t[4] = 0;
+       return 0;
+      }
+       /*<<weak.ml:260:18>>*/ if(! check(bucket$0, i$3)){
+        /*<<weak.ml:263:8>>*/  /*<<weak.ml:263:8>>*/ caml_call3
+        (setter, bucket$0, i$3, d);
+        /*<<weak.ml:264:8>>*/ caml_check_bound(hashes, i$3)[1 + i$3] = h;
+        /*<<weak.ml:264:8>>*/ return 0;
+      }
+       /*<<weak.ml:260:38>>*/ var
+        /*<<weak.ml:260:38>>*/ i$5 = i$3 + 1 | 0,
+       i$3 = i$5;
+     }
+     /*<<weak.ml:267:10>>*/ }
+    function add(t, d){
+      /*<<weak.ml:271:4>>*/  /*<<weak.ml:271:12>>*/ var
+      h =  /*<<weak.ml:271:12>>*/ caml_call1(H[2], d);
+      /*<<weak.ml:272:29>>*/ return add_aux
+             (t, set, [0, d], h, get_index(t, h));
+     /*<<weak.ml:272:44>>*/ }
+    function find_or(t, d, ifnotfound){
+      /*<<weak.ml:276:4>>*/ var
+       /*<<weak.ml:276:12>>*/ h =  /*<<weak.ml:276:12>>*/ caml_call1(H[2], d),
+       /*<<weak.ml:277:16>>*/ index = get_index(t, h),
+       /*<<weak.ml:278:17>>*/ bucket =
+        caml_check_bound(t[1], index)[1 + index],
+       /*<<weak.ml:279:17>>*/ hashes =
+        caml_check_bound(t[2], index)[1 + index],
+       /*<<weak.ml:280:13>>*/ sz = length(bucket),
+      i = 0;
+      /*<<weak.ml:282:6>>*/ for(;;){
+      if(sz <= i)
+        /*<<weak.ml:277:16>>*/ return  /*<<weak.ml:277:16>>*/ caml_call2
+               (ifnotfound, h, index);
+      if(h === caml_check_bound(hashes, i)[1 + i]){
+        /*<<weak.ml:284:14>>*/  /*<<weak.ml:284:14>>*/ var
+        match = get_copy(bucket, i);
+       if(match){
+        var v = match[1];
+         /*<<weak.ml:285:22>>*/ if
+         ( /*<<weak.ml:285:22>>*/ caml_call2(H[1], v, d)){
+          /*<<weak.ml:286:26>>*/  /*<<weak.ml:286:26>>*/ var
+          match$0 = get(bucket, i);
+         if(match$0){
+          var v$0 = match$0[1];
+           /*<<weak.ml:287:26>>*/ return v$0;
+         }
+          /*<<weak.ml:288:24>>*/ var
+           /*<<weak.ml:288:24>>*/ i$0 = i + 1 | 0,
+          i = i$0;
+         continue;
+        }
+       }
+        /*<<weak.ml:290:15>>*/ var
+         /*<<weak.ml:290:15>>*/ i$1 = i + 1 | 0,
+        i = i$1;
+      }
+      else
+        /*<<weak.ml:291:15>>*/ var
+         /*<<weak.ml:291:15>>*/ i$2 = i + 1 | 0,
+        i = i$2;
+     }
+     /*<<weak.ml:293:10>>*/ }
+    function merge(t, d){
+      /*<<weak.ml:297:4>>*/ return find_or
+             (t,
+              d,
+              function(h, index){
+                /*<<weak.ml:297:32>>*/ add_aux(t, set, [0, d], h, index);
+                /*<<weak.ml:297:4>>*/ return d;
+               /*<<weak.ml:297:65>>*/ });
+     /*<<weak.ml:297:66>>*/ }
+    function find(t, d){
+      /*<<weak.ml:300:17>>*/ return find_or
+             (t,
+              d,
+              function(h, index){
+                /*<<weak.ml:300:47>>*/ throw  /*<<weak.ml:300:47>>*/ caml_maybe_attach_backtrace
+                      (Stdlib[8], 1);
+               /*<<weak.ml:300:62>>*/ });
+     /*<<weak.ml:300:63>>*/ }
+    function find_opt(t, d){
+      /*<<weak.ml:303:4>>*/ var
+       /*<<weak.ml:303:12>>*/ h =  /*<<weak.ml:303:12>>*/ caml_call1(H[2], d),
+       /*<<weak.ml:304:16>>*/ index = get_index(t, h),
+       /*<<weak.ml:305:17>>*/ bucket =
+        caml_check_bound(t[1], index)[1 + index],
+       /*<<weak.ml:306:17>>*/ hashes =
+        caml_check_bound(t[2], index)[1 + index],
+       /*<<weak.ml:307:13>>*/ sz = length(bucket),
+      i = 0;
+      /*<<weak.ml:309:6>>*/ for(;;){
+      if(sz <= i)  /*<<weak.ml:309:22>>*/ return 0;
+      if(h === caml_check_bound(hashes, i)[1 + i]){
+        /*<<weak.ml:311:14>>*/  /*<<weak.ml:311:14>>*/ var
+        match = get_copy(bucket, i);
+       if(match){
+        var v = match[1];
+         /*<<weak.ml:312:22>>*/ if
+         ( /*<<weak.ml:312:22>>*/ caml_call2(H[1], v, d)){
+          /*<<weak.ml:313:26>>*/  /*<<weak.ml:313:26>>*/ var
+          v$0 = get(bucket, i);
+         if(v$0)  /*<<weak.ml:314:31>>*/ return v$0;
+          /*<<weak.ml:315:24>>*/ var
+           /*<<weak.ml:315:24>>*/ i$0 = i + 1 | 0,
+          i = i$0;
+         continue;
+        }
+       }
+        /*<<weak.ml:317:15>>*/ var
+         /*<<weak.ml:317:15>>*/ i$1 = i + 1 | 0,
+        i = i$1;
+      }
+      else
+        /*<<weak.ml:318:15>>*/ var
+         /*<<weak.ml:318:15>>*/ i$2 = i + 1 | 0,
+        i = i$2;
+     }
+     /*<<weak.ml:320:10>>*/ }
+    function find_shadow(t, d, iffound, ifnotfound){
+      /*<<weak.ml:324:4>>*/ var
+       /*<<weak.ml:324:12>>*/ h =  /*<<weak.ml:324:12>>*/ caml_call1(H[2], d),
+       /*<<weak.ml:325:16>>*/ index = get_index(t, h),
+       /*<<weak.ml:326:17>>*/ bucket =
+        caml_check_bound(t[1], index)[1 + index],
+       /*<<weak.ml:327:17>>*/ hashes =
+        caml_check_bound(t[2], index)[1 + index],
+       /*<<weak.ml:328:13>>*/ sz = length(bucket),
+      i = 0;
+      /*<<weak.ml:330:6>>*/ for(;;){
+      if(sz <= i) return ifnotfound;
+      if(h === caml_check_bound(hashes, i)[1 + i]){
+        /*<<weak.ml:332:14>>*/  /*<<weak.ml:332:14>>*/ var
+        match = get_copy(bucket, i);
+       if(match){
+        var v = match[1];
+         /*<<weak.ml:333:22>>*/ if
+         ( /*<<weak.ml:333:22>>*/ caml_call2(H[1], v, d))
+          /*<<weak.ml:333:37>>*/ return  /*<<weak.ml:333:37>>*/ caml_call2
+                 (iffound, bucket, i);
+       }
+        /*<<weak.ml:334:15>>*/ var
+         /*<<weak.ml:334:15>>*/ i$0 = i + 1 | 0,
+        i = i$0;
+      }
+      else
+        /*<<weak.ml:335:15>>*/ var
+         /*<<weak.ml:335:15>>*/ i$1 = i + 1 | 0,
+        i = i$1;
+     }
+     /*<<weak.ml:337:10>>*/ }
+    function remove(t, d){
+      /*<<weak.ml:340:19>>*/  /*<<weak.ml:340:19>>*/ var _k_ = 0;
+      /*<<weak.ml:340:19>>*/ return find_shadow
+             (t,
+              d,
+              function(w, i){
+                /*<<weak.ml:340:47>>*/ return set(w, i, 0);
+               /*<<weak.ml:340:59>>*/ },
+              _k_);
+     /*<<weak.ml:340:63>>*/ }
+    function mem(t, d){
+      /*<<weak.ml:343:16>>*/  /*<<weak.ml:343:16>>*/ var _j_ = 0;
+      /*<<weak.ml:343:16>>*/ return find_shadow
+             (t,
+              d,
+              function(w, i){
+                /*<<weak.ml:343:46>>*/ return 1;
+               /*<<weak.ml:343:50>>*/ },
+              _j_);
+     /*<<weak.ml:343:57>>*/ }
+    function find_all(t, d){
+      /*<<weak.ml:347:4>>*/ var
+       /*<<weak.ml:347:12>>*/ h =  /*<<weak.ml:347:12>>*/ caml_call1(H[2], d),
+       /*<<weak.ml:348:16>>*/ index = get_index(t, h),
+       /*<<weak.ml:349:17>>*/ bucket =
+        caml_check_bound(t[1], index)[1 + index],
+       /*<<weak.ml:350:17>>*/ hashes =
+        caml_check_bound(t[2], index)[1 + index],
+       /*<<weak.ml:351:13>>*/ sz = length(bucket),
+      i = 0,
+      accu = 0;
+      /*<<weak.ml:353:6>>*/ for(;;){
+      if(sz <= i)  /*<<weak.ml:353:22>>*/ return accu;
+      if(h === caml_check_bound(hashes, i)[1 + i]){
+        /*<<weak.ml:355:14>>*/  /*<<weak.ml:355:14>>*/ var
+        match = get_copy(bucket, i);
+       if(match){
+        var v = match[1];
+         /*<<weak.ml:356:22>>*/ if
+         ( /*<<weak.ml:356:22>>*/ caml_call2(H[1], v, d)){
+          /*<<weak.ml:357:26>>*/  /*<<weak.ml:357:26>>*/ var
+          match$0 = get(bucket, i);
+         if(match$0){
+           /*<<weak.ml:358:39>>*/ var
+           v$0 = match$0[1],
+            /*<<weak.ml:358:39>>*/ accu$0 = [0, v$0, accu],
+            /*<<weak.ml:358:39>>*/ i$0 = i + 1 | 0,
+           i = i$0,
+           accu = accu$0;
+          continue;
+         }
+         var i$1 = i + 1 | 0, i = i$1;
+         continue;
+        }
+       }
+       var i$2 = i + 1 | 0, i = i$2;
+      }
+      else
+       var i$3 = i + 1 | 0, i = i$3;
+     }
+     /*<<weak.ml:364:13>>*/ }
+    function stats(t){
+      /*<<weak.ml:368:4>>*/ var
+      len = t[1].length - 1,
+       /*<<weak.ml:369:15>>*/ lens =
+         /*<<weak.ml:369:15>>*/ caml_call2(Stdlib_Array[13], length, t[1]);
+      /*<<weak.ml:370:4>>*/  /*<<weak.ml:370:4>>*/ caml_call2
+      (Stdlib_Array[30], runtime.caml_int_compare, lens);
+     var _a_ = 0;
+     function _b_(_i_, _h_){ /*<<?>>*/ return _i_ + _h_ | 0;}
+      /*<<weak.ml:371:17>>*/ var
+       /*<<weak.ml:371:17>>*/ totlen =
+         /*<<weak.ml:371:17>>*/ caml_call3(Stdlib_Array[15], _b_, _a_, lens),
+       /*<<weak.ml:371:17>>*/ _c_ = len - 1 | 0,
+      _e_ = len / 2 | 0,
+       /*<<weak.ml:372:51>>*/ _d_ = caml_check_bound(lens, _c_)[1 + _c_],
+       /*<<weak.ml:372:37>>*/ _f_ = caml_check_bound(lens, _e_)[1 + _e_],
+       /*<<weak.ml:372:27>>*/ _g_ = caml_check_bound(lens, 0)[1];
+      /*<<weak.ml:372:4>>*/ return [0, len, count(t), totlen, _g_, _f_, _d_];
+     /*<<weak.ml:372:64>>*/ }
+     /*<<weak.ml:101:66>>*/ return [0,
+            create$0,
+            clear,
+            merge,
+            add,
+            remove,
+            find,
+            find_opt,
+            find_all,
+            mem,
+            iter,
+            fold,
+            count,
+            stats];
+   }
+   var
+    Stdlib_Weak =
+      [0, create, length, set, get, get_copy, check, fill, blit, Make];
+   runtime.caml_register_global(13, Stdlib_Weak, "Stdlib__Weak");
+   return;
+   /*<<?>>*/ }
+  (globalThis));
+
+//# unitInfo: Provides: Stdlib__Format
+//# unitInfo: Requires: CamlinternalFormat, Stdlib, Stdlib__Buffer, Stdlib__Bytes, Stdlib__Domain, Stdlib__Int, Stdlib__List, Stdlib__Queue, Stdlib__Stack, Stdlib__String
+(function
+  (globalThis){
+   "use strict";
+   var
+    runtime = globalThis.jsoo_runtime,
+    cst$16 = "",
+    cst$15 = ">",
+    caml_maybe_attach_backtrace = runtime.caml_maybe_attach_backtrace,
+    caml_ml_string_length = runtime.caml_ml_string_length;
+    /*<<?>>*/ function caml_call1(f, a0){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 1
+            ? f(a0)
+            : runtime.caml_call_gen(f, [a0]);
+   }
+    /*<<?>>*/ function caml_call2(f, a0, a1){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 2
+            ? f(a0, a1)
+            : runtime.caml_call_gen(f, [a0, a1]);
+   }
+    /*<<?>>*/ function caml_call3(f, a0, a1, a2){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 3
+            ? f(a0, a1, a2)
+            : runtime.caml_call_gen(f, [a0, a1, a2]);
+   }
+    /*<<?>>*/ function caml_call4(f, a0, a1, a2, a3){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 4
+            ? f(a0, a1, a2, a3)
+            : runtime.caml_call_gen(f, [a0, a1, a2, a3]);
+   }
+   var
+    global_data = runtime.caml_get_global_data(),
+    cst$14 = ".",
+    cst$11 = cst$15,
+    cst$12 = "<\/",
+    cst$13 = cst$16,
+    cst$8 = cst$15,
+    cst$9 = "<",
+    cst$10 = cst$16,
+    cst$7 = "\n",
+    cst$3 = cst$16,
+    cst$4 = cst$16,
+    cst$5 = cst$16,
+    cst$6 = cst$16,
+    cst = cst$16,
+    cst$0 = cst$16,
+    cst$1 = cst$16,
+    cst$2 = cst$16,
+    Stdlib_Queue = global_data.Stdlib__Queue,
+    CamlinternalFormat = global_data.CamlinternalFormat,
+    Stdlib = global_data.Stdlib,
+    Stdlib_String = global_data.Stdlib__String,
+    Stdlib_Domain = global_data.Stdlib__Domain,
+    Stdlib_Buffer = global_data.Stdlib__Buffer,
+    Stdlib_List = global_data.Stdlib__List,
+    Stdlib_Stack = global_data.Stdlib__Stack,
+    Stdlib_Int = global_data.Stdlib__Int,
+    Stdlib_Bytes = global_data.Stdlib__Bytes,
+    _f_ = [3, 0, 3],
+    cst_Format_pp_set_geometry = "Format.pp_set_geometry: ",
+    _e_ = [1, "max_indent < 2"],
+    _c_ = [1, "margin <= max_indent"],
+    _d_ = [0, 0],
+    _b_ = [0, cst$16],
+    _a_ = [0, cst$16, 0, cst$16],
+    cst_Stdlib_Format_String_tag = "Stdlib.Format.String_tag";
+   function id(x){ /*<<format.ml:23:11>>*/ return x; /*<<format.ml:23:12>>*/ }
+    /*<<format.ml:91:13>>*/ var
+     /*<<format.ml:91:13>>*/ String_tag =
+      [248, cst_Stdlib_Format_String_tag, runtime.caml_fresh_oo_id(0)],
+    zero = 0,
+    unknown = -1;
+   function pp_enqueue(state, token){
+     /*<<format.ml:219:2>>*/ state[13] = state[13] + token[3] | 0;
+    return caml_call2(Stdlib_Queue[3], token, state[28]);
+    /*<<format.ml:220:32>>*/ }
+   var pp_infinity = 1000000010;
+   function pp_output_string(state, s){
+     /*<<format.ml:251:31>>*/ return caml_call3
+            (state[17], s, 0, caml_ml_string_length(s));
+    /*<<format.ml:251:72>>*/ }
+   function pp_output_newline(state){
+     /*<<format.ml:252:30>>*/ return  /*<<format.ml:252:30>>*/ caml_call1
+            (state[19], 0);
+    /*<<format.ml:252:53>>*/ }
+   function format_pp_text(state, size, text){
+     /*<<format.ml:258:2>>*/ state[9] = state[9] - size | 0;
+     /*<<format.ml:259:2>>*/ pp_output_string(state, text);
+    state[11] = 0;
+    return 0;
+    /*<<format.ml:260:31>>*/ }
+   function format_string(state, s){
+     /*<<format.ml:264:2>>*/  /*<<format.ml:264:5>>*/ var
+     _bQ_ =  /*<<format.ml:264:5>>*/ runtime.caml_string_notequal(s, cst$16);
+     /*<<format.ml:264:5>>*/ return _bQ_
+            ? format_pp_text(state, caml_ml_string_length(s), s)
+            : _bQ_;
+    /*<<format.ml:264:58>>*/ }
+   function break_new_line(state, param, width){
+    var after = param[3], offset = param[2], before = param[1];
+     /*<<format.ml:268:2>>*/ format_string(state, before);
+     /*<<format.ml:269:2>>*/ pp_output_newline(state);
+    state[11] = 1;
+     /*<<format.ml:273:20>>*/ var
+     indent = (state[6] - width | 0) + offset | 0,
+      /*<<format.ml:273:20>>*/ real_indent =
+        /*<<format.ml:273:20>>*/ caml_call2(Stdlib_Int[10], state[8], indent);
+    state[10] = real_indent;
+    state[9] = state[6] - state[10] | 0;
+    var n = state[10];
+     /*<<format.ml:254:31>>*/  /*<<format.ml:254:31>>*/ caml_call1
+     (state[21], n);
+     /*<<format.ml:276:2>>*/ return format_string(state, after);
+   }
+   function break_line(state, width){
+     /*<<format.ml:281:29>>*/ return break_new_line(state, _a_, width);
+    /*<<format.ml:281:67>>*/ }
+   function break_same_line(state, param){
+    var after = param[3], width = param[2], before = param[1];
+     /*<<format.ml:285:2>>*/ format_string(state, before);
+    state[9] = state[9] - width | 0;
+     /*<<format.ml:253:31>>*/  /*<<format.ml:253:31>>*/ caml_call1
+     (state[20], width);
+     /*<<format.ml:287:2>>*/ return format_string(state, after);
+   }
+   function format_pp_token(state, size$0, param){
+     /*<<?>>*/ if(typeof param === "number")
+     switch(param){
+       case 0:
+         /*<<format.ml:348:16>>*/  /*<<format.ml:348:16>>*/ var
+         match$3 =
+            /*<<format.ml:348:16>>*/ caml_call1(Stdlib_Stack[7], state[3]);
+        if(! match$3)  /*<<format.ml:349:14>>*/ return 0;
+         /*<<format.ml:351:6>>*/ var
+         tabs = match$3[1][1],
+          /*<<format.ml:351:6>>*/ add_tab =
+           function(n, ls){
+             /*<<?>>*/ if(! ls)  /*<<format.ml:352:16>>*/ return [0, n, 0];
+            var l = ls[2], x = ls[1];
+             /*<<format.ml:353:29>>*/ return  /*<<format.ml:353:29>>*/ runtime.caml_lessthan
+                     (n, x)
+                    ? [0, n, ls]
+                    : [0, x, add_tab(n, l)];
+           };
+        tabs[1] = add_tab(state[6] - state[9] | 0, tabs[1]);
+        return 0;
+       case 1:
+         /*<<format.ml:339:4>>*/  /*<<format.ml:339:4>>*/ caml_call1
+         (Stdlib_Stack[5], state[2]);
+         /*<<format.ml:339:4>>*/ return 0;
+       case 2:
+         /*<<format.ml:345:4>>*/  /*<<format.ml:345:4>>*/ caml_call1
+         (Stdlib_Stack[5], state[3]);
+         /*<<format.ml:345:4>>*/ return 0;
+       case 3:
+         /*<<format.ml:378:16>>*/  /*<<format.ml:378:16>>*/ var
+         match$4 =
+            /*<<format.ml:378:16>>*/ caml_call1(Stdlib_Stack[7], state[2]);
+        if(! match$4)
+          /*<<format.ml:379:14>>*/ return pp_output_newline(state);
+        var width$0 = match$4[1][2];
+         /*<<format.ml:380:26>>*/ return break_line(state, width$0);
+       case 4:
+        var _bO_ = state[10] !== (state[6] - state[9] | 0) ? 1 : 0;
+        if(! _bO_) return _bO_;
+         /*<<format.ml:306:8>>*/  /*<<format.ml:306:8>>*/ var
+         match$1 =
+            /*<<format.ml:306:8>>*/ caml_call1(Stdlib_Queue[6], state[28]);
+        if(! match$1)  /*<<format.ml:307:12>>*/ return 0;
+        var match$2 = match$1[1], size = match$2[1], length = match$2[3];
+        state[12] = state[12] - length | 0;
+        state[9] = state[9] + size | 0;
+        return 0;
+       default:
+         /*<<format.ml:419:17>>*/  /*<<format.ml:419:17>>*/ var
+         match$5 =
+            /*<<format.ml:419:17>>*/ caml_call1(Stdlib_Stack[5], state[5]);
+        if(! match$5)  /*<<format.ml:420:15>>*/ return 0;
+         /*<<format.ml:422:20>>*/ var
+         tag_name = match$5[1],
+          /*<<format.ml:422:20>>*/ marker =
+            /*<<format.ml:422:20>>*/ caml_call1(state[25], tag_name);
+         /*<<format.ml:423:7>>*/ return pp_output_string(state, marker);
+     }
+    switch(param[0]){
+      case 0:
+       var s = param[1];
+        /*<<format.ml:323:4>>*/ return format_pp_text(state, size$0, s);
+      case 1:
+        /*<<format.ml:388:4>>*/ var
+        breaks = param[2],
+        fits = param[1],
+         /*<<format.ml:388:4>>*/ off = breaks[2],
+        before = breaks[1],
+         /*<<format.ml:389:16>>*/ match$6 =
+           /*<<format.ml:389:16>>*/ caml_call1(Stdlib_Stack[7], state[2]);
+       if(! match$6)  /*<<format.ml:390:14>>*/ return 0;
+       var
+        match$7 = match$6[1],
+        width$1 = match$7[2],
+        box_type$0 = match$7[1];
+        /*<<format.ml:392:6>>*/ switch(box_type$0){
+         case 0:
+           /*<<format.ml:409:19>>*/ return break_same_line(state, fits);
+         case 1:
+           /*<<format.ml:408:19>>*/ return break_new_line
+                  (state, breaks, width$1);
+         case 2:
+           /*<<format.ml:406:20>>*/ return break_new_line
+                  (state, breaks, width$1);
+         case 3:
+          return state[9] < (size$0 + caml_ml_string_length(before) | 0)
+                  ? break_new_line(state, breaks, width$1)
+                  : break_same_line(state, fits);
+         case 4:
+          return state[11]
+                  ? break_same_line(state, fits)
+                  : state
+                     [9]
+                    < (size$0 + caml_ml_string_length(before) | 0)
+                    ? break_new_line(state, breaks, width$1)
+                    : ((state
+                       [6]
+                      - width$1
+                      | 0)
+                      + off
+                      | 0)
+                      < state[10]
+                      ? break_new_line(state, breaks, width$1)
+                      : break_same_line(state, fits);
+         default:
+           /*<<format.ml:407:19>>*/ return break_same_line(state, fits);
+       }
+      case 2:
+        /*<<format.ml:359:16>>*/ var
+        off$0 = param[2],
+        n = param[1],
+        insertion_point = state[6] - state[9] | 0,
+         /*<<format.ml:359:16>>*/ match$8 =
+           /*<<format.ml:359:16>>*/ caml_call1(Stdlib_Stack[7], state[3]);
+       if(! match$8)  /*<<format.ml:360:14>>*/ return 0;
+        /*<<format.ml:362:6>>*/ var
+        tabs$0 = match$8[1][1],
+         /*<<format.ml:362:6>>*/ match$9 = tabs$0[1];
+       if(match$9){
+        var first = match$9[1], param$0 = tabs$0[1];
+         /*<<format.ml:366:25>>*/ for(;;){
+         if(param$0){
+          var tail = param$0[2], head = param$0[1];
+          if(insertion_point > head){var param$0 = tail; continue;}
+          var _bP_ = head;
+         }
+         else
+          var _bP_ = first;
+         var tab = _bP_;
+         break;
+        }
+       }
+       else
+        var tab = insertion_point;
+       var offset = tab - insertion_point | 0;
+        /*<<format.ml:372:6>>*/ return 0 <= offset
+               ? break_same_line(state, [0, cst$0, offset + n | 0, cst])
+               : break_new_line
+                 (state, [0, cst$2, tab + off$0 | 0, cst$1], state[6]);
+      case 3:
+       var
+        ty = param[2],
+        off$1 = param[1],
+        insertion_point$0 = state[6] - state[9] | 0;
+       if(state[8] < insertion_point$0){
+         /*<<format.ml:295:8>>*/  /*<<format.ml:295:8>>*/ var
+         match =
+            /*<<format.ml:295:8>>*/ caml_call1(Stdlib_Stack[7], state[2]);
+        if(match){
+         var match$0 = match[1], width = match$0[2], box_type = match$0[1];
+         if(state[9] < width && 3 >= box_type - 1 >>> 0)
+           /*<<format.ml:301:51>>*/ break_line(state, width);
+        }
+        else
+          /*<<format.ml:296:12>>*/ pp_output_newline(state);
+       }
+        /*<<format.ml:331:4>>*/ var
+        width$2 = state[9] - off$1 | 0,
+         /*<<format.ml:331:4>>*/ box_type$1 =
+          1 === ty ? 1 : state[9] < size$0 ? ty : 5;
+        /*<<format.ml:336:4>>*/ return  /*<<format.ml:336:4>>*/ caml_call2
+               (Stdlib_Stack[3], [0, box_type$1, width$2], state[2]);
+      case 4:
+       var tbox = param[1];
+        /*<<format.ml:342:4>>*/ return  /*<<format.ml:342:4>>*/ caml_call2
+               (Stdlib_Stack[3], tbox, state[3]);
+      default:
+        /*<<format.ml:414:18>>*/ var
+        tag_name$0 = param[1],
+         /*<<format.ml:414:18>>*/ marker$0 =
+           /*<<format.ml:414:18>>*/ caml_call1(state[24], tag_name$0);
+        /*<<format.ml:415:5>>*/ pp_output_string(state, marker$0);
+       return caml_call2(Stdlib_Stack[3], tag_name$0, state[5]);
+    }
+   }
+   function advance_left(state){
+     /*<<format.ml:431:2>>*/ for(;;){
+      /*<<format.ml:431:8>>*/  /*<<format.ml:431:8>>*/ var
+      match =  /*<<format.ml:431:8>>*/ caml_call1(Stdlib_Queue[9], state[28]);
+     if(! match)  /*<<format.ml:432:12>>*/ return 0;
+      /*<<format.ml:435:7>>*/ var
+      match$0 = match[1],
+      size = match$0[1],
+      length = match$0[3],
+      token = match$0[2],
+      pending_count = state[13] - state[12] | 0,
+       /*<<format.ml:435:7>>*/ _bM_ = 0 <= size ? 1 : 0,
+       /*<<format.ml:435:7>>*/ _bN_ =
+        _bM_ || (state[9] <= pending_count ? 1 : 0);
+     if(! _bN_)  /*<<format.ml:435:7>>*/ return _bN_;
+      /*<<format.ml:436:6>>*/  /*<<format.ml:436:6>>*/ caml_call1
+      (Stdlib_Queue[5], state[28]);
+      /*<<format.ml:437:20>>*/  /*<<format.ml:437:20>>*/ var
+      size$0 = 0 <= size ? size : pp_infinity;
+      /*<<format.ml:438:6>>*/ format_pp_token(state, size$0, token);
+     state[12] = length + state[12] | 0;
+    }
+    /*<<format.ml:441:7>>*/ }
+   function enqueue_advance(state, tok){
+     /*<<format.ml:445:32>>*/ pp_enqueue(state, tok);
+     /*<<format.ml:445:32>>*/ return advance_left(state);
+    /*<<format.ml:445:72>>*/ }
+   function enqueue_string_as(state, size, s){
+     /*<<format.ml:450:2>>*/ return enqueue_advance
+            (state, [0, size, [0, s], size]);
+    /*<<format.ml:450:78>>*/ }
+   function initialize_scan_stack(stack){
+     /*<<format.ml:462:2>>*/  /*<<format.ml:462:2>>*/ caml_call1
+     (Stdlib_Stack[8], stack);
+     /*<<format.ml:463:19>>*/  /*<<format.ml:463:19>>*/ var
+     queue_elem = [0, unknown, _b_, 0];
+     /*<<format.ml:464:2>>*/ return  /*<<format.ml:464:2>>*/ caml_call2
+            (Stdlib_Stack[3], [0, -1, queue_elem], stack);
+    /*<<format.ml:464:50>>*/ }
+   function set_size(state, ty){
+     /*<<format.ml:476:2>>*/  /*<<format.ml:476:8>>*/ var
+     match =  /*<<format.ml:476:8>>*/ caml_call1(Stdlib_Stack[7], state[1]);
+    if(! match)  /*<<format.ml:477:12>>*/ return 0;
+     /*<<format.ml:479:4>>*/ var
+     match$0 = match[1],
+     queue_elem = match$0[2],
+     left_total = match$0[1],
+      /*<<format.ml:479:4>>*/ size = queue_elem[1];
+    if(left_total < state[12]) return initialize_scan_stack(state[1]);
+    var _bI_ = queue_elem[2];
+    if(typeof _bI_ !== "number")
+     switch(_bI_[0]){
+       case 3:
+        var
+         _bK_ = 1 - ty,
+         _bL_ =
+           _bK_
+            ? (queue_elem
+               [1]
+              = state[13] + size | 0,
+               /*<<format.ml:493:10>>*/ caml_call1(Stdlib_Stack[5], state[1]),
+              0)
+            : _bK_;
+         /*<<format.ml:493:10>>*/ return _bL_;
+       case 1:
+       case 2:
+        var
+         _bJ_ =
+           ty
+            ? (queue_elem
+               [1]
+              = state[13] + size | 0,
+               /*<<format.ml:488:10>>*/ caml_call1(Stdlib_Stack[5], state[1]),
+              0)
+            : ty;
+         /*<<format.ml:488:10>>*/ return _bJ_;
+     }
+     /*<<format.ml:497:8>>*/ return 0;
+    /*<<format.ml:497:10>>*/ }
+   function scan_push(state, b, token){
+     /*<<format.ml:503:2>>*/ pp_enqueue(state, token);
+    if(b)  /*<<format.ml:504:12>>*/ set_size(state, 1);
+     /*<<format.ml:505:13>>*/  /*<<format.ml:505:13>>*/ var
+     elem = [0, state[13], token];
+     /*<<format.ml:506:2>>*/ return  /*<<format.ml:506:2>>*/ caml_call2
+            (Stdlib_Stack[3], elem, state[1]);
+    /*<<format.ml:506:37>>*/ }
+   function pp_open_box_gen(state, indent, br_ty){
+     /*<<format.ml:513:2>>*/ state[14] = state[14] + 1 | 0;
+    if(state[14] < state[15]){
+      /*<<format.ml:516:15>>*/ var
+      size = - state[13] | 0,
+       /*<<format.ml:516:15>>*/ elem = [0, size, [3, indent, br_ty], 0];
+      /*<<format.ml:517:4>>*/ return scan_push(state, 0, elem);
+    }
+    var _bH_ = state[14] === state[15] ? 1 : 0;
+    if(! _bH_) return _bH_;
+    var s = state[16];
+     /*<<format.ml:454:2>>*/ return enqueue_string_as
+            (state, caml_ml_string_length(s), s);
+    /*<<format.ml:519:45>>*/ }
+   function pp_close_box(state, param){
+     /*<<format.ml:527:2>>*/ var _bF_ = 1 < state[14] ? 1 : 0;
+    if(_bF_){
+     if(state[14] < state[15]){
+       /*<<format.ml:531:6>>*/ pp_enqueue(state, [0, zero, 1, 0]);
+       /*<<format.ml:532:6>>*/ set_size(state, 1);
+       /*<<format.ml:532:27>>*/ set_size(state, 0);
+     }
+     state[14] = state[14] - 1 | 0;
+     var _bG_ = 0;
+    }
+    else
+     var _bG_ = _bF_;
+    return _bG_;
+    /*<<format.ml:535:5>>*/ }
+   function pp_open_stag(state, tag_name){
+     /*<<format.ml:540:2>>*/ if(state[22]){
+      /*<<format.ml:542:4>>*/  /*<<format.ml:542:4>>*/ caml_call2
+      (Stdlib_Stack[3], tag_name, state[4]);
+      /*<<format.ml:543:4>>*/  /*<<format.ml:543:4>>*/ caml_call1
+      (state[26], tag_name);
+    }
+    var _bE_ = state[23];
+    if(! _bE_) return _bE_;
+     /*<<format.ml:546:16>>*/  /*<<format.ml:546:16>>*/ var
+     token = [5, tag_name];
+     /*<<format.ml:547:21>>*/ return pp_enqueue(state, [0, zero, token, 0]);
+    /*<<format.ml:547:60>>*/ }
+   function pp_close_stag(state, param){
+     /*<<format.ml:552:2>>*/ if(state[23])
+      /*<<format.ml:553:4>>*/ pp_enqueue(state, [0, zero, 5, 0]);
+    var _bC_ = state[22];
+    if(_bC_){
+      /*<<format.ml:555:10>>*/  /*<<format.ml:555:10>>*/ var
+      match =  /*<<format.ml:555:10>>*/ caml_call1(Stdlib_Stack[5], state[4]);
+     if(match){
+      var tag_name = match[1];
+       /*<<format.ml:558:6>>*/ return  /*<<format.ml:558:6>>*/ caml_call1
+              (state[27], tag_name);
+     }
+     var _bD_ = 0;
+    }
+    else
+     var _bD_ = _bC_;
+     /*<<format.ml:556:14>>*/ return _bD_;
+    /*<<format.ml:558:39>>*/ }
+   function pp_set_print_tags(state, b){
+     /*<<format.ml:560:32>>*/ state[22] = b;
+    return 0;
+    /*<<format.ml:560:56>>*/ }
+   function pp_set_mark_tags(state, b){
+     /*<<format.ml:561:31>>*/ state[23] = b;
+    return 0;
+    /*<<format.ml:561:54>>*/ }
+   function pp_get_print_tags(state, param){
+     /*<<format.ml:562:33>>*/ return state[22];
+    /*<<format.ml:562:52>>*/ }
+   function pp_get_mark_tags(state, param){
+     /*<<format.ml:563:32>>*/ return state[23];
+    /*<<format.ml:563:50>>*/ }
+   function pp_set_tags(state, b){
+     /*<<format.ml:565:2>>*/ pp_set_print_tags(state, b);
+     /*<<format.ml:565:2>>*/ return pp_set_mark_tags(state, b);
+    /*<<format.ml:565:53>>*/ }
+   function pp_get_formatter_stag_function(state, param){
+     /*<<format.ml:569:47>>*/ return [0,
+            state[24],
+            state[25],
+            state[26],
+            state[27]];
+    /*<<format.ml:574:1>>*/ }
+   function pp_set_formatter_stag_function(state, param){
+    var pct = param[4], pot = param[3], mct = param[2], mot = param[1];
+    state[24] = mot;
+    state[25] = mct;
+    state[26] = pot;
+    state[27] = pct;
+    return 0;
+   }
+   function pp_rinit(state){
+     /*<<format.ml:591:2>>*/ state[12] = 1;
+    state[13] = 1;
+    caml_call1(Stdlib_Queue[11], state[28]);
+     /*<<format.ml:592:2>>*/ initialize_scan_stack(state[1]);
+     /*<<format.ml:593:2>>*/  /*<<format.ml:593:2>>*/ caml_call1
+     (Stdlib_Stack[8], state[2]);
+     /*<<format.ml:594:2>>*/  /*<<format.ml:594:2>>*/ caml_call1
+     (Stdlib_Stack[8], state[3]);
+     /*<<format.ml:595:2>>*/  /*<<format.ml:595:2>>*/ caml_call1
+     (Stdlib_Stack[8], state[4]);
+     /*<<format.ml:596:2>>*/  /*<<format.ml:596:2>>*/ caml_call1
+     (Stdlib_Stack[8], state[5]);
+    state[10] = 0;
+    state[14] = 0;
+    state[9] = state[6];
+     /*<<format.ml:523:28>>*/ return pp_open_box_gen(state, 0, 3);
+    /*<<format.ml:600:23>>*/ }
+   function pp_flush_queue(state, b){
+     /*<<format.ml:608:2>>*/ var _bA_ = state[4];
+    function _bB_(param){
+      /*<<format.ml:603:23>>*/ return pp_close_stag(state, 0);
+     /*<<format.ml:603:45>>*/ }
+     /*<<format.ml:603:13>>*/  /*<<format.ml:603:13>>*/ caml_call2
+     (Stdlib_Stack[12], _bB_, _bA_);
+     /*<<format.ml:610:4>>*/ for(;;){
+     if(1 >= state[14]){
+      state[13] = pp_infinity;
+       /*<<format.ml:613:2>>*/ advance_left(state);
+      if(b)  /*<<format.ml:614:12>>*/ pp_output_newline(state);
+       /*<<format.ml:614:12>>*/ return pp_rinit(state);
+     }
+      /*<<format.ml:610:4>>*/ pp_close_box(state, 0);
+    }
+    /*<<format.ml:615:16>>*/ }
+   function pp_print_as_size(state, size, s){
+     /*<<format.ml:625:2>>*/ var _bz_ = state[14] < state[15] ? 1 : 0;
+    return _bz_ ? enqueue_string_as(state, size, s) : _bz_;
+    /*<<format.ml:626:37>>*/ }
+   function pp_print_as(state, isize, s){
+     /*<<format.ml:630:2>>*/ return pp_print_as_size(state, isize, s);
+    /*<<format.ml:630:46>>*/ }
+   function pp_print_string(state, s){
+     /*<<format.ml:634:2>>*/ return pp_print_as
+            (state, caml_ml_string_length(s), s);
+    /*<<format.ml:634:39>>*/ }
+   function pp_print_bytes(state, s){
+     /*<<format.ml:637:2>>*/ return pp_print_as
+            (state,
+             runtime.caml_ml_bytes_length(s),
+              /*<<format.ml:637:37>>*/ caml_call1(Stdlib_Bytes[6], s));
+    /*<<format.ml:637:56>>*/ }
+   function pp_print_int(state, i){
+     /*<<format.ml:640:27>>*/ return pp_print_string
+            (state,  /*<<format.ml:640:49>>*/ caml_call1(Stdlib_Int[12], i));
+    /*<<format.ml:640:66>>*/ }
+   function pp_print_float(state, f){
+     /*<<format.ml:643:29>>*/ return pp_print_string
+            (state,  /*<<format.ml:643:51>>*/ caml_call1(Stdlib[35], f));
+    /*<<format.ml:643:70>>*/ }
+   function pp_print_bool(state, b){
+     /*<<format.ml:646:28>>*/ return pp_print_string
+            (state,  /*<<format.ml:646:50>>*/ caml_call1(Stdlib[30], b));
+    /*<<format.ml:646:68>>*/ }
+   function pp_print_char(state, c){
+     /*<<format.ml:650:2>>*/ return pp_print_as
+            (state,
+             1,
+              /*<<format.ml:650:22>>*/ caml_call2(Stdlib_String[1], 1, c));
+    /*<<format.ml:650:39>>*/ }
+   function pp_open_hbox(state, param){
+     /*<<format.ml:654:28>>*/ return pp_open_box_gen(state, 0, 0);
+    /*<<format.ml:654:59>>*/ }
+   function pp_open_vbox(state, indent){
+     /*<<format.ml:655:32>>*/ return pp_open_box_gen(state, indent, 1);
+    /*<<format.ml:655:68>>*/ }
+   function pp_open_hvbox(state, indent){
+     /*<<format.ml:657:33>>*/ return pp_open_box_gen(state, indent, 2);
+    /*<<format.ml:657:70>>*/ }
+   function pp_open_hovbox(state, indent){
+     /*<<format.ml:658:34>>*/ return pp_open_box_gen(state, indent, 3);
+    /*<<format.ml:658:72>>*/ }
+   function pp_open_box(state, indent){
+     /*<<format.ml:659:31>>*/ return pp_open_box_gen(state, indent, 4);
+    /*<<format.ml:659:66>>*/ }
+   function pp_print_newline(state, param){
+     /*<<format.ml:671:2>>*/ pp_flush_queue(state, 1);
+     /*<<format.ml:671:2>>*/ return  /*<<format.ml:671:2>>*/ caml_call1
+            (state[18], 0);
+    /*<<format.ml:671:50>>*/ }
+   function pp_print_flush(state, param){
+     /*<<format.ml:673:2>>*/ pp_flush_queue(state, 0);
+     /*<<format.ml:673:2>>*/ return  /*<<format.ml:673:2>>*/ caml_call1
+            (state[18], 0);
+    /*<<format.ml:673:51>>*/ }
+   function pp_force_newline(state, param){
+     /*<<format.ml:678:2>>*/ var _by_ = state[14] < state[15] ? 1 : 0;
+    return _by_ ? enqueue_advance(state, [0, zero, 3, 0]) : _by_;
+    /*<<format.ml:679:78>>*/ }
+   function pp_print_if_newline(state, param){
+     /*<<format.ml:684:2>>*/ var _bx_ = state[14] < state[15] ? 1 : 0;
+    return _bx_ ? enqueue_advance(state, [0, zero, 4, 0]) : _bx_;
+    /*<<format.ml:686:61>>*/ }
+   function pp_print_custom_break(state, fits, breaks){
+     /*<<format.ml:692:2>>*/ var
+     after = fits[3],
+     width = fits[2],
+     before = fits[1],
+     _bw_ = state[14] < state[15] ? 1 : 0;
+    if(! _bw_) return _bw_;
+     /*<<format.ml:695:25>>*/ var
+     size = - state[13] | 0,
+      /*<<format.ml:695:25>>*/ token = [1, fits, breaks],
+     length =
+       (caml_ml_string_length(before) + width | 0)
+       +  /*<<format.ml:696:4>>*/ caml_ml_string_length(after)
+       | 0,
+      /*<<format.ml:697:15>>*/ elem = [0, size, token, length];
+     /*<<format.ml:698:4>>*/ return scan_push(state, 1, elem);
+    /*<<format.ml:698:29>>*/ }
+   function pp_print_break(state, width, offset){
+     /*<<format.ml:705:2>>*/ return pp_print_custom_break
+            (state, [0, cst$6, width, cst$5], [0, cst$4, offset, cst$3]);
+    /*<<format.ml:706:50>>*/ }
+   function pp_print_space(state, param){
+     /*<<format.ml:714:30>>*/ return pp_print_break(state, 1, 0);
+    /*<<format.ml:714:54>>*/ }
+   function pp_print_cut(state, param){
+     /*<<format.ml:715:28>>*/ return pp_print_break(state, 0, 0);
+    /*<<format.ml:715:52>>*/ }
+   function pp_open_tbox(state, param){
+     /*<<format.ml:720:2>>*/ state[14] = state[14] + 1 | 0;
+    var _bv_ = state[14] < state[15] ? 1 : 0;
+    if(! _bv_) return _bv_;
+     /*<<format.ml:723:15>>*/  /*<<format.ml:723:15>>*/ var
+     elem = [0, zero, [4, [0, [0, 0]]], 0];
+     /*<<format.ml:724:4>>*/ return enqueue_advance(state, elem);
+    /*<<format.ml:724:30>>*/ }
+   function pp_close_tbox(state, param){
+     /*<<format.ml:729:2>>*/ var _bs_ = 1 < state[14] ? 1 : 0;
+    if(_bs_){
+     var _bt_ = state[14] < state[15] ? 1 : 0;
+     if(_bt_){
+       /*<<format.ml:732:16>>*/  /*<<format.ml:732:16>>*/ var
+       elem = [0, zero, 2, 0];
+       /*<<format.ml:733:5>>*/ enqueue_advance(state, elem);
+      state[14] = state[14] - 1 | 0;
+      var _bu_ = 0;
+     }
+     else
+      var _bu_ = _bt_;
+    }
+    else
+     var _bu_ = _bs_;
+    return _bu_;
+    /*<<format.ml:735:5>>*/ }
+   function pp_print_tbreak(state, width, offset){
+     /*<<format.ml:740:2>>*/ var _br_ = state[14] < state[15] ? 1 : 0;
+    if(! _br_) return _br_;
+     /*<<format.ml:742:15>>*/ var
+     size = - state[13] | 0,
+      /*<<format.ml:742:15>>*/ elem = [0, size, [2, width, offset], width];
+     /*<<format.ml:743:4>>*/ return scan_push(state, 1, elem);
+    /*<<format.ml:743:29>>*/ }
+   function pp_print_tab(state, param){
+     /*<<format.ml:746:28>>*/ return pp_print_tbreak(state, 0, 0);
+    /*<<format.ml:746:53>>*/ }
+   function pp_set_tab(state, param){
+     /*<<format.ml:749:2>>*/ var _bq_ = state[14] < state[15] ? 1 : 0;
+    if(! _bq_) return _bq_;
+     /*<<format.ml:750:15>>*/  /*<<format.ml:750:15>>*/ var
+     elem = [0, zero, 0, 0];
+     /*<<format.ml:751:4>>*/ return enqueue_advance(state, elem);
+    /*<<format.ml:751:30>>*/ }
+   function pp_set_max_boxes(state, n){
+     /*<<format.ml:761:31>>*/ var
+     _bo_ = 1 < n ? 1 : 0,
+     _bp_ = _bo_ ? (state[15] = n, 0) : _bo_;
+    return _bp_;
+    /*<<format.ml:761:68>>*/ }
+   function pp_get_max_boxes(state, param){
+     /*<<format.ml:764:32>>*/ return state[15];
+    /*<<format.ml:764:50>>*/ }
+   function pp_over_max_boxes(state, param){
+     /*<<format.ml:766:33>>*/ return state[14] === state[15] ? 1 : 0;
+    /*<<format.ml:766:73>>*/ }
+   function pp_set_ellipsis_text(state, s){
+     /*<<format.ml:769:35>>*/ state[16] = s;
+    return 0;
+    /*<<format.ml:769:57>>*/ }
+   function pp_get_ellipsis_text(state, param){
+     /*<<format.ml:770:36>>*/ return state[16];
+    /*<<format.ml:770:53>>*/ }
+   function pp_limit(n){
+     /*<<format.ml:775:2>>*/ return n < 1000000010 ? n : 1000000009;
+    /*<<format.ml:775:49>>*/ }
+   function pp_set_max_indent(state, n$0){
+     /*<<format.ml:791:2>>*/ var _bn_ = 1 < n$0 ? 1 : 0;
+    if(! _bn_) return _bn_;
+    var n$1 = state[6] - n$0 | 0, _bm_ = 1 <= n$1 ? 1 : 0;
+    if(! _bm_) return _bm_;
+     /*<<format.ml:781:12>>*/  /*<<format.ml:781:12>>*/ var n = pp_limit(n$1);
+    state[7] = n;
+    state[8] = state[6] - state[7] | 0;
+     /*<<format.ml:784:4>>*/ return pp_rinit(state);
+    /*<<format.ml:792:53>>*/ }
+   function pp_get_max_indent(state, param){
+     /*<<format.ml:795:33>>*/ return state[8];
+    /*<<format.ml:795:52>>*/ }
+   function pp_set_margin(state, n){
+     /*<<format.ml:798:2>>*/ var _bk_ = 1 <= n ? 1 : 0;
+    if(! _bk_) return _bk_;
+     /*<<format.ml:799:12>>*/  /*<<format.ml:799:12>>*/ var n$0 = pp_limit(n);
+    state[6] = n$0;
+    if(state[8] <= state[6])
+     var new_max_indent = state[8];
+    else
+      /*<<format.ml:808:15>>*/ var
+       /*<<format.ml:808:15>>*/ _bl_ =
+         /*<<format.ml:808:15>>*/ caml_call2
+         (Stdlib_Int[11], state[6] - state[7] | 0, state[6] / 2 | 0),
+      new_max_indent =
+         /*<<format.ml:808:7>>*/ caml_call2(Stdlib_Int[11], _bl_, 1);
+     /*<<format.ml:811:4>>*/ return pp_set_max_indent(state, new_max_indent);
+    /*<<format.ml:811:42>>*/ }
+   function validate_geometry(param){
+    var margin = param[2], max_indent = param[1];
+     /*<<format.ml:818:2>>*/ return 2 <= max_indent
+            ? margin <= max_indent ? _c_ : _d_
+            : _e_;
+   }
+   function check_geometry(geometry){
+     /*<<format.ml:825:2>>*/ return 0 === validate_geometry(geometry)[0]
+            ? 1
+            : 0;
+    /*<<format.ml:827:20>>*/ }
+   function pp_get_margin(state, param){
+     /*<<format.ml:829:29>>*/ return state[6];
+    /*<<format.ml:829:44>>*/ }
+   function pp_set_full_geometry(state, param){
+    var margin = param[2], max_indent = param[1];
+     /*<<format.ml:832:2>>*/ pp_set_margin(state, margin);
+     /*<<format.ml:833:2>>*/ pp_set_max_indent(state, max_indent);
+     /*<<format.ml:833:2>>*/ return 0;
+   }
+   function pp_set_geometry(state, max_indent, margin){
+     /*<<format.ml:837:2>>*/ var
+      /*<<format.ml:837:17>>*/ geometry = [0, max_indent, margin],
+      /*<<format.ml:838:8>>*/ match = validate_geometry(geometry);
+    if(0 === match[0])
+      /*<<format.ml:842:4>>*/ return pp_set_full_geometry(state, geometry);
+     /*<<format.ml:840:28>>*/ var
+     msg = match[1],
+      /*<<format.ml:840:28>>*/ _bj_ =
+        /*<<format.ml:840:28>>*/ caml_call2
+        (Stdlib[28], cst_Format_pp_set_geometry, msg);
+     /*<<format.ml:840:4>>*/ throw  /*<<format.ml:840:4>>*/ caml_maybe_attach_backtrace
+           ([0, Stdlib[6], _bj_], 1);
+    /*<<format.ml:842:39>>*/ }
+   function pp_safe_set_geometry(state, max_indent, margin){
+     /*<<format.ml:845:2>>*/  /*<<format.ml:845:17>>*/ var
+     geometry = [0, max_indent, margin];
+    return 0 === validate_geometry(geometry)[0]
+            ? pp_set_full_geometry(state, geometry)
+            : 0;
+    /*<<format.ml:850:39>>*/ }
+   function pp_get_geometry(state, param){
+     /*<<format.ml:853:2>>*/ return [0, state[8], state[6]];
+    /*<<format.ml:853:78>>*/ }
+   function pp_update_geometry(state, update){
+     /*<<format.ml:856:2>>*/  /*<<format.ml:856:17>>*/ var
+     geometry = pp_get_geometry(state, 0);
+     /*<<format.ml:857:29>>*/ return pp_set_full_geometry
+            (state,  /*<<format.ml:857:29>>*/ caml_call1(update, geometry));
+    /*<<format.ml:857:46>>*/ }
+   function pp_set_formatter_out_functions(state, param){
+    var j = param[5], i = param[4], h = param[3], g = param[2], f = param[1];
+    state[17] = f;
+    state[18] = g;
+    state[19] = h;
+    state[20] = i;
+    state[21] = j;
+    return 0;
+   }
+   function pp_get_formatter_out_functions(state, param){
+     /*<<format.ml:873:46>>*/ return [0,
+            state[17],
+            state[18],
+            state[19],
+            state[20],
+            state[21]];
+    /*<<format.ml:879:1>>*/ }
+   function pp_set_formatter_output_functi(state, f, g){
+     /*<<format.ml:884:2>>*/ state[17] = f;
+    state[18] = g;
+    return 0;
+    /*<<format.ml:884:51>>*/ }
+   function pp_get_formatter_output_functi(state, param){
+     /*<<format.ml:887:2>>*/ return [0, state[17], state[18]];
+    /*<<format.ml:887:43>>*/ }
+   function display_newline(state, param){
+     /*<<format.ml:891:31>>*/ return  /*<<format.ml:891:31>>*/ caml_call3
+            (state[17], cst$7, 0, 1);
+    /*<<format.ml:891:60>>*/ }
+    /*<<format.ml:894:17>>*/  /*<<format.ml:894:17>>*/ var
+    blank_line =
+       /*<<format.ml:894:17>>*/ caml_call2(Stdlib_String[1], 80, 32);
+   function display_blanks(state, n){
+     /*<<format.ml:896:2>>*/ var n$0 = n;
+     /*<<format.ml:896:2>>*/ for(;;){
+     var _bi_ = 0 < n$0 ? 1 : 0;
+     if(! _bi_) return _bi_;
+     if(80 >= n$0)
+       /*<<format.ml:897:18>>*/ return  /*<<format.ml:897:18>>*/ caml_call3
+              (state[17], blank_line, 0, n$0);
+      /*<<format.ml:899:4>>*/  /*<<format.ml:899:4>>*/ caml_call3
+      (state[17], blank_line, 0, 80);
+      /*<<format.ml:899:4>>*/ var
+       /*<<format.ml:899:4>>*/ n$1 = n$0 - 80 | 0,
+      n$0 = n$1;
+    }
+    /*<<format.ml:901:5>>*/ }
+   function pp_set_formatter_out_channel(state, oc){
+     /*<<format.ml:910:2>>*/ state[17] =
+      /*<<format.ml:910:25>>*/ caml_call1(Stdlib[69], oc);
+    state[18] =
+     function(param){
+       /*<<format.ml:911:35>>*/ return  /*<<format.ml:911:2>>*/ caml_call1
+              (Stdlib[63], oc);
+      /*<<format.ml:911:43>>*/ };
+    state[19] =
+     function(_bh_){ /*<<?>>*/ return display_newline(state, _bh_);};
+    state[20] = function(_bg_){ /*<<?>>*/ return display_blanks(state, _bg_);};
+    state[21] = function(_bf_){ /*<<?>>*/ return display_blanks(state, _bf_);};
+    return 0;
+    /*<<format.ml:914:45>>*/ }
+   function default_pp_mark_open_tag(param){
+     /*<<format.ml:922:31>>*/ if(param[1] !== String_tag)
+      /*<<format.ml:924:9>>*/ return cst$10;
+     /*<<format.ml:923:26>>*/ var
+     s = param[2],
+      /*<<format.ml:923:26>>*/ _be_ =
+        /*<<format.ml:923:26>>*/ caml_call2(Stdlib[28], s, cst$8);
+     /*<<format.ml:923:26>>*/ return  /*<<format.ml:923:26>>*/ caml_call2
+            (Stdlib[28], cst$9, _be_);
+    /*<<format.ml:924:11>>*/ }
+   function default_pp_mark_close_tag(param){
+     /*<<format.ml:925:32>>*/ if(param[1] !== String_tag)
+      /*<<format.ml:927:9>>*/ return cst$13;
+     /*<<format.ml:926:27>>*/ var
+     s = param[2],
+      /*<<format.ml:926:27>>*/ _bd_ =
+        /*<<format.ml:926:27>>*/ caml_call2(Stdlib[28], s, cst$11);
+     /*<<format.ml:926:27>>*/ return  /*<<format.ml:926:27>>*/ caml_call2
+            (Stdlib[28], cst$12, _bd_);
+    /*<<format.ml:927:11>>*/ }
+   function default_pp_print_open_tag(_bc_){ /*<<?>>*/ return 0;}
+   function default_pp_print_close_tag(_bb_){ /*<<?>>*/ return 0;}
+   function pp_make_formatter(f, g, h, i, j){
+     /*<<format.ml:936:17>>*/ var
+      /*<<format.ml:936:17>>*/ pp_queue =
+        /*<<format.ml:936:17>>*/ caml_call1(Stdlib_Queue[2], 0),
+      /*<<format.ml:938:4>>*/ sys_tok = [0, unknown, _f_, 0];
+     /*<<format.ml:939:2>>*/  /*<<format.ml:939:2>>*/ caml_call2
+     (Stdlib_Queue[3], sys_tok, pp_queue);
+     /*<<format.ml:940:19>>*/  /*<<format.ml:940:19>>*/ var
+     scan_stack =  /*<<format.ml:940:19>>*/ caml_call1(Stdlib_Stack[2], 0);
+     /*<<format.ml:941:2>>*/ initialize_scan_stack(scan_stack);
+     /*<<format.ml:942:2>>*/  /*<<format.ml:942:2>>*/ caml_call2
+     (Stdlib_Stack[3], [0, 1, sys_tok], scan_stack);
+     /*<<format.ml:950:20>>*/ var
+     _a9_ = Stdlib[19],
+      /*<<format.ml:950:20>>*/ _a__ =
+        /*<<format.ml:950:20>>*/ caml_call1(Stdlib_Stack[2], 0),
+      /*<<format.ml:949:19>>*/ _a$_ =
+        /*<<format.ml:949:19>>*/ caml_call1(Stdlib_Stack[2], 0),
+      /*<<format.ml:948:20>>*/ _ba_ =
+        /*<<format.ml:948:20>>*/ caml_call1(Stdlib_Stack[2], 0);
+     /*<<format.ml:945:2>>*/ return [0,
+            scan_stack,
+             /*<<format.ml:947:22>>*/ caml_call1(Stdlib_Stack[2], 0),
+            _ba_,
+            _a$_,
+            _a__,
+            78,
+            10,
+            68,
+            78,
+            0,
+            1,
+            1,
+            1,
+            1,
+            _a9_,
+            cst$14,
+            f,
+            g,
+            h,
+            i,
+            j,
+            0,
+            0,
+            default_pp_mark_open_tag,
+            default_pp_mark_close_tag,
+            default_pp_print_open_tag,
+            default_pp_print_close_tag,
+            pp_queue];
+   }
+   function formatter_of_out_functions(out_funs){
+     /*<<format.ml:979:2>>*/ return pp_make_formatter
+            (out_funs[1], out_funs[2], out_funs[3], out_funs[4], out_funs[5]);
+    /*<<format.ml:984:23>>*/ }
+   function make_formatter(output, flush){
+    function _a1_(_a8_){ /*<<?>>*/ return 0;}
+    function _a2_(_a7_){ /*<<?>>*/ return 0;}
+     /*<<format.ml:990:12>>*/  /*<<format.ml:990:12>>*/ var
+     ppf =
+       pp_make_formatter
+        (output, flush, function(_a6_){ /*<<?>>*/ return 0;}, _a2_, _a1_);
+    ppf[19] = function(_a5_){ /*<<?>>*/ return display_newline(ppf, _a5_);};
+    ppf[20] = function(_a4_){ /*<<?>>*/ return display_blanks(ppf, _a4_);};
+    ppf[21] = function(_a3_){ /*<<?>>*/ return display_blanks(ppf, _a3_);};
+     /*<<format.ml:994:2>>*/ return ppf;
+    /*<<format.ml:994:5>>*/ }
+   function formatter_of_out_channel(oc){
+    function _a0_(param){
+      /*<<format.ml:999:50>>*/ return  /*<<format.ml:999:2>>*/ caml_call1
+             (Stdlib[63], oc);
+     /*<<format.ml:999:58>>*/ }
+     /*<<format.ml:999:39>>*/ return make_formatter
+            ( /*<<format.ml:999:17>>*/ caml_call1(Stdlib[69], oc), _a0_);
+    /*<<format.ml:999:59>>*/ }
+   function formatter_of_buffer(b){
+     /*<<format.ml:1004:2>>*/ function _aY_(_aZ_){ /*<<?>>*/ return 0;}
+     /*<<format.ml:1004:42>>*/ return make_formatter
+            ( /*<<format.ml:1004:17>>*/ caml_call1(Stdlib_Buffer[18], b),
+             _aY_);
+    /*<<format.ml:1004:48>>*/ }
+   var pp_buffer_size = 512;
+   function pp_make_buffer(param){
+     /*<<format.ml:1011:24>>*/ return caml_call1
+            (Stdlib_Buffer[1], pp_buffer_size);
+    /*<<format.ml:1011:52>>*/ }
+    /*<<format.ml:1014:13>>*/ var
+     /*<<format.ml:1014:13>>*/ stdbuf = pp_make_buffer(0),
+     /*<<format.ml:1018:20>>*/ std_formatter =
+      formatter_of_out_channel(Stdlib[39]),
+     /*<<format.ml:1019:20>>*/ err_formatter =
+      formatter_of_out_channel(Stdlib[40]),
+     /*<<format.ml:1020:20>>*/ str_formatter = formatter_of_buffer(stdbuf),
+     /*<<format.ml:1025:17>>*/ stdbuf_key =
+       /*<<format.ml:1025:17>>*/ caml_call2
+       (Stdlib_Domain[10][1], 0, pp_make_buffer);
+    /*<<format.ml:1026:8>>*/  /*<<format.ml:1026:8>>*/ caml_call2
+    (Stdlib_Domain[10][3], stdbuf_key, stdbuf);
+   function _g_(param){
+     /*<<format.ml:1029:2>>*/ return formatter_of_buffer
+            ( /*<<format.ml:1029:22>>*/ caml_call1
+              (Stdlib_Domain[10][2], stdbuf_key));
+    /*<<format.ml:1029:42>>*/ }
+    /*<<format.ml:1028:24>>*/  /*<<format.ml:1028:24>>*/ var
+    str_formatter_key =
+       /*<<format.ml:1028:24>>*/ caml_call2(Stdlib_Domain[10][1], 0, _g_);
+    /*<<format.ml:1030:8>>*/  /*<<format.ml:1030:8>>*/ caml_call2
+    (Stdlib_Domain[10][3], str_formatter_key, str_formatter);
+    /*<<format.ml:1030:8>>*/ function buffered_out_string(key, str, ofs, len){
+     /*<<format.ml:1033:2>>*/  /*<<format.ml:1033:23>>*/ var
+     _aX_ =  /*<<format.ml:1033:23>>*/ caml_call1(Stdlib_Domain[10][2], key);
+     /*<<format.ml:1033:2>>*/ return  /*<<format.ml:1033:2>>*/ caml_call4
+            (Stdlib_Buffer[18], _aX_, str, ofs, len);
+    /*<<format.ml:1033:55>>*/ }
+   function buffered_out_flush(oc, key, param){
+     /*<<format.ml:1036:2>>*/ var
+      /*<<format.ml:1036:12>>*/ buf =
+        /*<<format.ml:1036:12>>*/ caml_call1(Stdlib_Domain[10][2], key),
+      /*<<format.ml:1037:12>>*/ len =
+        /*<<format.ml:1037:12>>*/ caml_call1(Stdlib_Buffer[7], buf),
+      /*<<format.ml:1038:12>>*/ str =
+        /*<<format.ml:1038:12>>*/ caml_call1(Stdlib_Buffer[2], buf);
+     /*<<format.ml:1039:2>>*/  /*<<format.ml:1039:2>>*/ caml_call4
+     (Stdlib[69], oc, str, 0, len);
+     /*<<format.ml:1040:2>>*/  /*<<format.ml:1040:2>>*/ caml_call1
+     (Stdlib[63], oc);
+     /*<<format.ml:1040:2>>*/ return  /*<<format.ml:1040:2>>*/ caml_call1
+            (Stdlib_Buffer[8], buf);
+    /*<<format.ml:1041:18>>*/ }
+   function _h_(param){
+     /*<<format.ml:1043:48>>*/ return caml_call1
+            (Stdlib_Buffer[1], pp_buffer_size);
+    /*<<format.ml:1043:76>>*/ }
+    /*<<format.ml:1043:18>>*/  /*<<format.ml:1043:18>>*/ var
+    std_buf_key =
+       /*<<format.ml:1043:18>>*/ caml_call2(Stdlib_Domain[10][1], 0, _h_);
+   function _i_(param){
+     /*<<format.ml:1044:48>>*/ return  /*<<format.ml:1043:18>>*/ caml_call1
+            (Stdlib_Buffer[1], pp_buffer_size);
+    /*<<format.ml:1044:76>>*/ }
+    /*<<format.ml:1044:18>>*/  /*<<format.ml:1044:18>>*/ var
+    err_buf_key =
+       /*<<format.ml:1044:18>>*/ caml_call2(Stdlib_Domain[10][1], 0, _i_);
+   function _j_(param){
+    function _aG_(_aW_){ /*<<?>>*/ return 0;}
+    function _aH_(_aV_){ /*<<?>>*/ return 0;}
+    function _aI_(_aU_){ /*<<?>>*/ return 0;}
+    var _aJ_ = Stdlib[39];
+     /*<<format.ml:1049:6>>*/ function _aK_(_aT_){
+      /*<<?>>*/ return buffered_out_flush(_aJ_, std_buf_key, _aT_);
+    }
+     /*<<format.ml:1048:4>>*/  /*<<format.ml:1048:4>>*/ var
+     ppf =
+       pp_make_formatter
+        (function(_aQ_, _aR_, _aS_){
+           /*<<?>>*/ return buffered_out_string(std_buf_key, _aQ_, _aR_, _aS_);
+         },
+         _aK_,
+         _aI_,
+         _aH_,
+         _aG_);
+    ppf[19] = function(_aP_){ /*<<?>>*/ return display_newline(ppf, _aP_);};
+    ppf[20] = function(_aO_){ /*<<?>>*/ return display_blanks(ppf, _aO_);};
+    ppf[21] = function(_aN_){ /*<<?>>*/ return display_blanks(ppf, _aN_);};
+     /*<<format.ml:1054:17>>*/ function _aL_(_aM_){
+      /*<<?>>*/ return pp_print_flush(ppf, _aM_);
+    }
+     /*<<format.ml:1054:2>>*/  /*<<format.ml:1054:2>>*/ caml_call1
+     (Stdlib_Domain[6], _aL_);
+     /*<<format.ml:1054:2>>*/ return ppf;
+    /*<<format.ml:1055:5>>*/ }
+    /*<<format.ml:1046:24>>*/  /*<<format.ml:1046:24>>*/ var
+    std_formatter_key =
+       /*<<format.ml:1046:24>>*/ caml_call2(Stdlib_Domain[10][1], 0, _j_);
+    /*<<format.ml:1056:8>>*/  /*<<format.ml:1056:8>>*/ caml_call2
+    (Stdlib_Domain[10][3], std_formatter_key, std_formatter);
+   function _k_(param){
+    function _ap_(_aF_){ /*<<?>>*/ return 0;}
+    function _aq_(_aE_){ /*<<?>>*/ return 0;}
+    function _ar_(_aD_){ /*<<?>>*/ return 0;}
+    var _as_ = Stdlib[40];
+     /*<<format.ml:1061:6>>*/ function _at_(_aC_){
+      /*<<?>>*/ return buffered_out_flush(_as_, err_buf_key, _aC_);
+    }
+     /*<<format.ml:1060:4>>*/  /*<<format.ml:1060:4>>*/ var
+     ppf =
+       pp_make_formatter
+        (function(_az_, _aA_, _aB_){
+           /*<<?>>*/ return buffered_out_string(err_buf_key, _az_, _aA_, _aB_);
+         },
+         _at_,
+         _ar_,
+         _aq_,
+         _ap_);
+    ppf[19] = function(_ay_){ /*<<?>>*/ return display_newline(ppf, _ay_);};
+    ppf[20] = function(_ax_){ /*<<?>>*/ return display_blanks(ppf, _ax_);};
+    ppf[21] = function(_aw_){ /*<<?>>*/ return display_blanks(ppf, _aw_);};
+     /*<<format.ml:1066:17>>*/ function _au_(_av_){
+      /*<<?>>*/ return pp_print_flush(ppf, _av_);
+    }
+     /*<<format.ml:1066:2>>*/  /*<<format.ml:1066:2>>*/ caml_call1
+     (Stdlib_Domain[6], _au_);
+     /*<<format.ml:1066:2>>*/ return ppf;
+    /*<<format.ml:1067:5>>*/ }
+    /*<<format.ml:1058:24>>*/  /*<<format.ml:1058:24>>*/ var
+    err_formatter_key =
+       /*<<format.ml:1058:24>>*/ caml_call2(Stdlib_Domain[10][1], 0, _k_);
+    /*<<format.ml:1068:8>>*/  /*<<format.ml:1068:8>>*/ caml_call2
+    (Stdlib_Domain[10][3], err_formatter_key, err_formatter);
+   function get_std_formatter(param){
+     /*<<format.ml:1070:27>>*/ return  /*<<format.ml:1068:8>>*/ caml_call1
+            (Stdlib_Domain[10][2], std_formatter_key);
+    /*<<format.ml:1070:52>>*/ }
+   function get_err_formatter(param){
+     /*<<format.ml:1071:27>>*/ return caml_call1
+            (Stdlib_Domain[10][2], err_formatter_key);
+    /*<<format.ml:1071:52>>*/ }
+   function get_str_formatter(param){
+     /*<<format.ml:1072:27>>*/ return caml_call1
+            (Stdlib_Domain[10][2], str_formatter_key);
+    /*<<format.ml:1072:52>>*/ }
+   function get_stdbuf(param){
+     /*<<format.ml:1073:20>>*/ return caml_call1
+            (Stdlib_Domain[10][2], stdbuf_key);
+    /*<<format.ml:1073:38>>*/ }
+   function flush_buffer_formatter(buf, ppf){
+     /*<<format.ml:1080:2>>*/ pp_flush_queue(ppf, 0);
+     /*<<format.ml:1081:10>>*/  /*<<format.ml:1081:10>>*/ var
+     s =  /*<<format.ml:1081:10>>*/ caml_call1(Stdlib_Buffer[2], buf);
+     /*<<format.ml:1082:2>>*/  /*<<format.ml:1082:2>>*/ caml_call1
+     (Stdlib_Buffer[9], buf);
+     /*<<format.ml:1082:2>>*/ return s;
+    /*<<format.ml:1083:3>>*/ }
+   function flush_str_formatter(param){
+     /*<<format.ml:1087:2>>*/ var
+      /*<<format.ml:1087:15>>*/ stdbuf =
+        /*<<format.ml:1087:15>>*/ caml_call1(Stdlib_Domain[10][2], stdbuf_key),
+      /*<<format.ml:1088:22>>*/ str_formatter =
+        /*<<format.ml:1088:22>>*/ caml_call1
+        (Stdlib_Domain[10][2], str_formatter_key);
+     /*<<format.ml:1089:2>>*/ return flush_buffer_formatter
+            (stdbuf, str_formatter);
+    /*<<format.ml:1089:45>>*/ }
+   function make_synchronized_formatter(output, flush){
+    function _an_(param){
+      /*<<format.ml:1093:4>>*/ var
+       /*<<format.ml:1093:14>>*/ buf =
+         /*<<format.ml:1093:14>>*/ caml_call1
+         (Stdlib_Buffer[1], pp_buffer_size),
+       /*<<format.ml:1094:18>>*/ output$0 =
+         /*<<format.ml:1094:18>>*/ caml_call1(Stdlib_Buffer[18], buf);
+     function flush$0(param){
+       /*<<format.ml:1096:6>>*/  /*<<format.ml:1096:37>>*/ var
+       _ao_ =  /*<<format.ml:1096:37>>*/ caml_call1(Stdlib_Buffer[7], buf);
+       /*<<format.ml:1096:6>>*/  /*<<format.ml:1096:6>>*/ caml_call3
+       (output,
+         /*<<format.ml:1096:13>>*/ caml_call1(Stdlib_Buffer[2], buf),
+        0,
+        _ao_);
+       /*<<format.ml:1097:6>>*/  /*<<format.ml:1097:6>>*/ caml_call1
+       (Stdlib_Buffer[8], buf);
+       /*<<format.ml:1097:6>>*/ return  /*<<format.ml:1097:6>>*/ caml_call1
+              (flush, 0);
+      /*<<format.ml:1098:14>>*/ }
+      /*<<format.ml:1100:4>>*/ return make_formatter(output$0, flush$0);
+     /*<<format.ml:1100:33>>*/ }
+     /*<<format.ml:1092:14>>*/ return  /*<<format.ml:1092:14>>*/ caml_call2
+            (Stdlib_Domain[10][1], 0, _an_);
+    /*<<format.ml:1100:34>>*/ }
+   function synchronized_formatter_of_out_(oc){
+    function _am_(param){
+      /*<<format.ml:1103:63>>*/ return  /*<<format.ml:1103:2>>*/ caml_call1
+             (Stdlib[63], oc);
+     /*<<format.ml:1103:71>>*/ }
+     /*<<format.ml:1103:52>>*/ return make_synchronized_formatter
+            ( /*<<format.ml:1103:30>>*/ caml_call1(Stdlib[69], oc), _am_);
+    /*<<format.ml:1103:72>>*/ }
+   function make_symbolic_output_buffer(param){ /*<<format.ml:1130:2>>*/ return [0, 0];
+    /*<<format.ml:1130:35>>*/ }
+   function clear_symbolic_output_buffer(sob){
+     /*<<format.ml:1133:2>>*/ sob[1] = 0;
+    return 0;
+    /*<<format.ml:1133:36>>*/ }
+   function get_symbolic_output_buffer(sob){
+     /*<<format.ml:1136:2>>*/ return caml_call1(Stdlib_List[9], sob[1]);
+    /*<<format.ml:1136:39>>*/ }
+   function flush_symbolic_output_buffer(sob){
+     /*<<format.ml:1139:2>>*/  /*<<format.ml:1139:14>>*/ var
+     items = get_symbolic_output_buffer(sob);
+     /*<<format.ml:1140:2>>*/ clear_symbolic_output_buffer(sob);
+     /*<<format.ml:1140:2>>*/ return items;
+    /*<<format.ml:1141:7>>*/ }
+   function add_symbolic_output_item(sob, item){
+     /*<<format.ml:1144:2>>*/ sob[1] = [0, item, sob[1]];
+    return 0;
+    /*<<format.ml:1144:70>>*/ }
+   function formatter_of_symbolic_output_b(sob){
+     /*<<format.ml:1158:10>>*/ function f(s, i, n){
+      /*<<format.ml:1152:33>>*/ return add_symbolic_output_item
+             (sob,
+              [0,
+                /*<<format.ml:1152:48>>*/ caml_call3
+                (Stdlib_String[15], s, i, n)]);
+    }
+     /*<<format.ml:1159:10>>*/ function g(_al_){
+      /*<<format.ml:1148:4>>*/ return add_symbolic_output_item(sob, 0);
+    }
+     /*<<format.ml:1160:10>>*/ function h(_ak_){
+      /*<<format.ml:1150:4>>*/ return add_symbolic_output_item(sob, 1);
+    }
+     /*<<format.ml:1161:10>>*/ function i(n){
+      /*<<format.ml:1154:33>>*/ return add_symbolic_output_item(sob, [1, n]);
+    }
+     /*<<format.ml:1162:10>>*/ function j(n){
+      /*<<format.ml:1156:33>>*/ return add_symbolic_output_item(sob, [2, n]);
+    }
+     /*<<format.ml:1163:2>>*/ return pp_make_formatter(f, g, h, i, j);
+    /*<<format.ml:1163:29>>*/ }
+   function open_hbox(v){
+     /*<<format.ml:1172:18>>*/ return pp_open_hbox
+            ( /*<<format.ml:1172:31>>*/ caml_call1
+              (Stdlib_Domain[10][2], std_formatter_key),
+             v);
+    /*<<format.ml:1172:60>>*/ }
+   function open_vbox(v){
+     /*<<format.ml:1173:18>>*/ return pp_open_vbox
+            ( /*<<format.ml:1173:31>>*/ caml_call1
+              (Stdlib_Domain[10][2], std_formatter_key),
+             v);
+    /*<<format.ml:1173:60>>*/ }
+   function open_hvbox(v){
+     /*<<format.ml:1174:19>>*/ return pp_open_hvbox
+            ( /*<<format.ml:1174:33>>*/ caml_call1
+              (Stdlib_Domain[10][2], std_formatter_key),
+             v);
+    /*<<format.ml:1174:62>>*/ }
+   function open_hovbox(v){
+     /*<<format.ml:1175:20>>*/ return pp_open_hovbox
+            ( /*<<format.ml:1175:35>>*/ caml_call1
+              (Stdlib_Domain[10][2], std_formatter_key),
+             v);
+    /*<<format.ml:1175:64>>*/ }
+   function open_box(v){
+     /*<<format.ml:1176:17>>*/ return pp_open_box
+            ( /*<<format.ml:1176:29>>*/ caml_call1
+              (Stdlib_Domain[10][2], std_formatter_key),
+             v);
+    /*<<format.ml:1176:58>>*/ }
+   function close_box(v){
+     /*<<format.ml:1177:18>>*/ return pp_close_box
+            ( /*<<format.ml:1177:31>>*/ caml_call1
+              (Stdlib_Domain[10][2], std_formatter_key),
+             v);
+    /*<<format.ml:1177:60>>*/ }
+   function open_stag(v){
+     /*<<format.ml:1178:18>>*/ return pp_open_stag
+            ( /*<<format.ml:1178:31>>*/ caml_call1
+              (Stdlib_Domain[10][2], std_formatter_key),
+             v);
+    /*<<format.ml:1178:60>>*/ }
+   function close_stag(v){
+     /*<<format.ml:1179:19>>*/ return pp_close_stag
+            ( /*<<format.ml:1179:33>>*/ caml_call1
+              (Stdlib_Domain[10][2], std_formatter_key),
+             v);
+    /*<<format.ml:1179:62>>*/ }
+   function print_as(v, w){
+     /*<<format.ml:1180:19>>*/ return pp_print_as
+            ( /*<<format.ml:1180:31>>*/ caml_call1
+              (Stdlib_Domain[10][2], std_formatter_key),
+             v,
+             w);
+    /*<<format.ml:1180:62>>*/ }
+   function print_string(v){
+     /*<<format.ml:1181:21>>*/ return pp_print_string
+            ( /*<<format.ml:1181:37>>*/ caml_call1
+              (Stdlib_Domain[10][2], std_formatter_key),
+             v);
+    /*<<format.ml:1181:66>>*/ }
+   function print_bytes(v){
+     /*<<format.ml:1182:20>>*/ return pp_print_bytes
+            ( /*<<format.ml:1182:35>>*/ caml_call1
+              (Stdlib_Domain[10][2], std_formatter_key),
+             v);
+    /*<<format.ml:1182:64>>*/ }
+   function print_int(v){
+     /*<<format.ml:1183:18>>*/ return pp_print_int
+            ( /*<<format.ml:1183:31>>*/ caml_call1
+              (Stdlib_Domain[10][2], std_formatter_key),
+             v);
+    /*<<format.ml:1183:60>>*/ }
+   function print_float(v){
+     /*<<format.ml:1184:20>>*/ return pp_print_float
+            ( /*<<format.ml:1184:35>>*/ caml_call1
+              (Stdlib_Domain[10][2], std_formatter_key),
+             v);
+    /*<<format.ml:1184:64>>*/ }
+   function print_char(v){
+     /*<<format.ml:1185:19>>*/ return pp_print_char
+            ( /*<<format.ml:1185:33>>*/ caml_call1
+              (Stdlib_Domain[10][2], std_formatter_key),
+             v);
+    /*<<format.ml:1185:62>>*/ }
+   function print_bool(v){
+     /*<<format.ml:1186:19>>*/ return pp_print_bool
+            ( /*<<format.ml:1186:33>>*/ caml_call1
+              (Stdlib_Domain[10][2], std_formatter_key),
+             v);
+    /*<<format.ml:1186:62>>*/ }
+   function print_break(v, w){
+     /*<<format.ml:1187:22>>*/ return pp_print_break
+            ( /*<<format.ml:1187:37>>*/ caml_call1
+              (Stdlib_Domain[10][2], std_formatter_key),
+             v,
+             w);
+    /*<<format.ml:1187:68>>*/ }
+   function print_cut(v){
+     /*<<format.ml:1188:18>>*/ return pp_print_cut
+            ( /*<<format.ml:1188:31>>*/ caml_call1
+              (Stdlib_Domain[10][2], std_formatter_key),
+             v);
+    /*<<format.ml:1188:60>>*/ }
+   function print_space(v){
+     /*<<format.ml:1189:20>>*/ return pp_print_space
+            ( /*<<format.ml:1189:35>>*/ caml_call1
+              (Stdlib_Domain[10][2], std_formatter_key),
+             v);
+    /*<<format.ml:1189:64>>*/ }
+   function force_newline(v){
+     /*<<format.ml:1190:22>>*/ return pp_force_newline
+            ( /*<<format.ml:1190:39>>*/ caml_call1
+              (Stdlib_Domain[10][2], std_formatter_key),
+             v);
+    /*<<format.ml:1190:68>>*/ }
+   function print_flush(v){
+     /*<<format.ml:1191:20>>*/ return pp_print_flush
+            ( /*<<format.ml:1191:35>>*/ caml_call1
+              (Stdlib_Domain[10][2], std_formatter_key),
+             v);
+    /*<<format.ml:1191:64>>*/ }
+   function print_newline(v){
+     /*<<format.ml:1192:22>>*/ return pp_print_newline
+            ( /*<<format.ml:1192:39>>*/ caml_call1
+              (Stdlib_Domain[10][2], std_formatter_key),
+             v);
+    /*<<format.ml:1192:68>>*/ }
+   function print_if_newline(v){
+     /*<<format.ml:1193:25>>*/ return pp_print_if_newline
+            ( /*<<format.ml:1193:45>>*/ caml_call1
+              (Stdlib_Domain[10][2], std_formatter_key),
+             v);
+    /*<<format.ml:1193:74>>*/ }
+   function open_tbox(v){
+     /*<<format.ml:1195:18>>*/ return pp_open_tbox
+            ( /*<<format.ml:1195:31>>*/ caml_call1
+              (Stdlib_Domain[10][2], std_formatter_key),
+             v);
+    /*<<format.ml:1195:60>>*/ }
+   function close_tbox(v){
+     /*<<format.ml:1196:19>>*/ return pp_close_tbox
+            ( /*<<format.ml:1196:33>>*/ caml_call1
+              (Stdlib_Domain[10][2], std_formatter_key),
+             v);
+    /*<<format.ml:1196:62>>*/ }
+   function print_tbreak(v, w){
+     /*<<format.ml:1197:23>>*/ return pp_print_tbreak
+            ( /*<<format.ml:1197:39>>*/ caml_call1
+              (Stdlib_Domain[10][2], std_formatter_key),
+             v,
+             w);
+    /*<<format.ml:1197:70>>*/ }
+   function set_tab(v){
+     /*<<format.ml:1199:16>>*/ return pp_set_tab
+            ( /*<<format.ml:1199:27>>*/ caml_call1
+              (Stdlib_Domain[10][2], std_formatter_key),
+             v);
+    /*<<format.ml:1199:56>>*/ }
+   function print_tab(v){
+     /*<<format.ml:1200:18>>*/ return pp_print_tab
+            ( /*<<format.ml:1200:31>>*/ caml_call1
+              (Stdlib_Domain[10][2], std_formatter_key),
+             v);
+    /*<<format.ml:1200:60>>*/ }
+   function set_margin(v){
+     /*<<format.ml:1202:19>>*/ return pp_set_margin
+            ( /*<<format.ml:1202:33>>*/ caml_call1
+              (Stdlib_Domain[10][2], std_formatter_key),
+             v);
+    /*<<format.ml:1202:62>>*/ }
+   function get_margin(v){
+     /*<<format.ml:1203:19>>*/ return  /*<<format.ml:1203:33>>*/ caml_call1
+             (Stdlib_Domain[10][2], std_formatter_key)
+            [6];
+    /*<<format.ml:1203:62>>*/ }
+   function set_max_indent(v){
+     /*<<format.ml:1205:23>>*/ return pp_set_max_indent
+            ( /*<<format.ml:1205:41>>*/ caml_call1
+              (Stdlib_Domain[10][2], std_formatter_key),
+             v);
+    /*<<format.ml:1205:70>>*/ }
+   function get_max_indent(v){
+     /*<<format.ml:1206:23>>*/ return  /*<<format.ml:1206:41>>*/ caml_call1
+             (Stdlib_Domain[10][2], std_formatter_key)
+            [8];
+    /*<<format.ml:1206:70>>*/ }
+   function set_geometry(max_indent, margin){
+     /*<<format.ml:1209:2>>*/ return pp_set_geometry
+            ( /*<<format.ml:1209:18>>*/ caml_call1
+              (Stdlib_Domain[10][2], std_formatter_key),
+             max_indent,
+             margin);
+    /*<<format.ml:1209:65>>*/ }
+   function safe_set_geometry(max_indent, margin){
+     /*<<format.ml:1211:2>>*/ return pp_safe_set_geometry
+            ( /*<<format.ml:1211:23>>*/ caml_call1
+              (Stdlib_Domain[10][2], std_formatter_key),
+             max_indent,
+             margin);
+    /*<<format.ml:1211:70>>*/ }
+   function get_geometry(v){
+     /*<<format.ml:1212:21>>*/ return pp_get_geometry
+            ( /*<<format.ml:1212:37>>*/ caml_call1
+              (Stdlib_Domain[10][2], std_formatter_key),
+             v);
+    /*<<format.ml:1212:66>>*/ }
+   function update_geometry(v){
+     /*<<format.ml:1213:24>>*/ return pp_update_geometry
+            ( /*<<format.ml:1213:43>>*/ caml_call1
+              (Stdlib_Domain[10][2], std_formatter_key),
+             v);
+    /*<<format.ml:1213:72>>*/ }
+   function set_max_boxes(v){
+     /*<<format.ml:1215:22>>*/ return pp_set_max_boxes
+            ( /*<<format.ml:1215:39>>*/ caml_call1
+              (Stdlib_Domain[10][2], std_formatter_key),
+             v);
+    /*<<format.ml:1215:68>>*/ }
+   function get_max_boxes(v){
+     /*<<format.ml:1216:22>>*/ return  /*<<format.ml:1216:39>>*/ caml_call1
+             (Stdlib_Domain[10][2], std_formatter_key)
+            [15];
+    /*<<format.ml:1216:68>>*/ }
+   function over_max_boxes(v){
+     /*<<format.ml:1217:23>>*/ return pp_over_max_boxes
+            ( /*<<format.ml:1217:41>>*/ caml_call1
+              (Stdlib_Domain[10][2], std_formatter_key),
+             v);
+    /*<<format.ml:1217:70>>*/ }
+   function set_ellipsis_text(v){
+     /*<<format.ml:1219:26>>*/ return pp_set_ellipsis_text
+            ( /*<<format.ml:1219:47>>*/ caml_call1
+              (Stdlib_Domain[10][2], std_formatter_key),
+             v);
+    /*<<format.ml:1219:76>>*/ }
+   function get_ellipsis_text(v){
+     /*<<format.ml:1220:26>>*/ return  /*<<format.ml:1220:47>>*/ caml_call1
+             (Stdlib_Domain[10][2], std_formatter_key)
+            [16];
+    /*<<format.ml:1220:76>>*/ }
+   function set_formatter_out_channel(v){
+     /*<<format.ml:1223:2>>*/ return pp_set_formatter_out_channel
+            ( /*<<format.ml:1223:31>>*/ caml_call1
+              (Stdlib_Domain[10][2], std_formatter_key),
+             v);
+    /*<<format.ml:1223:60>>*/ }
+   function set_formatter_out_functions(v){
+     /*<<format.ml:1226:2>>*/ return pp_set_formatter_out_functions
+            ( /*<<format.ml:1226:33>>*/ caml_call1
+              (Stdlib_Domain[10][2], std_formatter_key),
+             v);
+    /*<<format.ml:1226:62>>*/ }
+   function get_formatter_out_functions(v){
+     /*<<format.ml:1228:2>>*/ return pp_get_formatter_out_functions
+            ( /*<<format.ml:1228:33>>*/ caml_call1
+              (Stdlib_Domain[10][2], std_formatter_key),
+             v);
+    /*<<format.ml:1228:62>>*/ }
+   function set_formatter_output_functions(v, w){
+     /*<<format.ml:1231:2>>*/ return pp_set_formatter_output_functi
+            ( /*<<format.ml:1231:36>>*/ caml_call1
+              (Stdlib_Domain[10][2], std_formatter_key),
+             v,
+             w);
+    /*<<format.ml:1231:67>>*/ }
+   function get_formatter_output_functions(v){
+     /*<<format.ml:1233:2>>*/ return pp_get_formatter_output_functi
+            ( /*<<format.ml:1233:36>>*/ caml_call1
+              (Stdlib_Domain[10][2], std_formatter_key),
+             v);
+    /*<<format.ml:1233:65>>*/ }
+   function set_formatter_stag_functions(v){
+     /*<<format.ml:1236:2>>*/ return pp_set_formatter_stag_function
+            ( /*<<format.ml:1236:34>>*/ caml_call1
+              (Stdlib_Domain[10][2], std_formatter_key),
+             v);
+    /*<<format.ml:1236:63>>*/ }
+   function get_formatter_stag_functions(v){
+     /*<<format.ml:1238:2>>*/ return pp_get_formatter_stag_function
+            ( /*<<format.ml:1238:34>>*/ caml_call1
+              (Stdlib_Domain[10][2], std_formatter_key),
+             v);
+    /*<<format.ml:1238:63>>*/ }
+   function set_print_tags(v){
+     /*<<format.ml:1240:2>>*/ return pp_set_print_tags
+            ( /*<<format.ml:1240:20>>*/ caml_call1
+              (Stdlib_Domain[10][2], std_formatter_key),
+             v);
+    /*<<format.ml:1240:49>>*/ }
+   function get_print_tags(v){
+     /*<<format.ml:1242:2>>*/ return  /*<<format.ml:1242:20>>*/ caml_call1
+             (Stdlib_Domain[10][2], std_formatter_key)
+            [22];
+    /*<<format.ml:1242:49>>*/ }
+   function set_mark_tags(v){
+     /*<<format.ml:1244:2>>*/ return pp_set_mark_tags
+            ( /*<<format.ml:1244:19>>*/ caml_call1
+              (Stdlib_Domain[10][2], std_formatter_key),
+             v);
+    /*<<format.ml:1244:48>>*/ }
+   function get_mark_tags(v){
+     /*<<format.ml:1246:2>>*/ return  /*<<format.ml:1246:19>>*/ caml_call1
+             (Stdlib_Domain[10][2], std_formatter_key)
+            [23];
+    /*<<format.ml:1246:48>>*/ }
+   function set_tags(v){
+     /*<<format.ml:1248:2>>*/ return pp_set_tags
+            ( /*<<format.ml:1248:14>>*/ caml_call1
+              (Stdlib_Domain[10][2], std_formatter_key),
+             v);
+    /*<<format.ml:1248:43>>*/ }
+   function pp_print_list(opt, pp_v, ppf, param){
+    var opt$0 = opt, param$0 = param;
+    for(;;){
+      /*<<format.ml:1254:58>>*/ if(opt$0)
+      var sth = opt$0[1], pp_sep = sth;
+     else
+      var pp_sep = pp_print_cut;
+      /*<<format.ml:1254:58>>*/ if(! param$0)
+       /*<<format.ml:1255:10>>*/ return 0;
+     var v = param$0[1];
+     if(! param$0[2])
+       /*<<format.ml:1256:11>>*/ return  /*<<format.ml:1256:11>>*/ caml_call2
+              (pp_v, ppf, v);
+     var vs = param$0[2];
+      /*<<format.ml:1258:4>>*/  /*<<format.ml:1258:4>>*/ caml_call2
+      (pp_v, ppf, v);
+      /*<<format.ml:1259:4>>*/  /*<<format.ml:1259:4>>*/ caml_call2
+      (pp_sep, ppf, 0);
+      /*<<format.ml:1260:19>>*/ var
+       /*<<format.ml:1260:19>>*/ opt$1 = [0, pp_sep],
+      opt$0 = opt$1,
+      param$0 = vs;
+    }
+   }
+   function pp_print_seq(opt, pp_v, ppf, seq$1){
+     /*<<format.ml:1272:2>>*/ if(opt)
+     var sth = opt[1], pp_sep = sth;
+    else
+     var pp_sep = pp_print_cut;
+     /*<<format.ml:1272:8>>*/  /*<<format.ml:1272:8>>*/ var
+     match$0 =  /*<<format.ml:1272:8>>*/ caml_call1(seq$1, 0);
+    if(! match$0)  /*<<format.ml:1273:15>>*/ return 0;
+    var seq$2 = match$0[2], v$0 = match$0[1];
+     /*<<format.ml:1275:4>>*/  /*<<format.ml:1275:4>>*/ caml_call2
+     (pp_v, ppf, v$0);
+    var seq = seq$2;
+     /*<<format.ml:1264:2>>*/ for(;;){
+      /*<<format.ml:1264:8>>*/  /*<<format.ml:1264:8>>*/ var
+      match =  /*<<format.ml:1264:8>>*/ caml_call1(seq, 0);
+     if(! match)  /*<<format.ml:1265:15>>*/ return 0;
+     var seq$0 = match[2], v = match[1];
+      /*<<format.ml:1267:4>>*/  /*<<format.ml:1267:4>>*/ caml_call2
+      (pp_sep, ppf, 0);
+      /*<<format.ml:1268:4>>*/  /*<<format.ml:1268:4>>*/ caml_call2
+      (pp_v, ppf, v);
+     var seq = seq$0;
+    }
+    /*<<format.ml:1276:40>>*/ }
+   function pp_print_text(ppf, s){
+     /*<<format.ml:1280:2>>*/ var
+     len = caml_ml_string_length(s),
+      /*<<format.ml:1281:13>>*/ left = [0, 0],
+      /*<<format.ml:1282:14>>*/ right = [0, 0];
+    function flush(param){
+      /*<<format.ml:1284:4>>*/ pp_print_string
+      (ppf,
+        /*<<format.ml:1284:24>>*/ caml_call3
+        (Stdlib_String[15], s, left[1], right[1] - left[1] | 0));
+     right[1]++;
+     left[1] = right[1];
+     return 0;
+     /*<<format.ml:1285:31>>*/ }
+    for(;;){
+     if(right[1] === len){
+      var _aj_ = left[1] !== len ? 1 : 0;
+      return _aj_ ? flush(0) : _aj_;
+     }
+      /*<<format.ml:1288:10>>*/  /*<<format.ml:1288:10>>*/ var
+      match =  /*<<format.ml:1288:10>>*/ runtime.caml_string_get(s, right[1]);
+     if(10 === match){
+       /*<<format.ml:1290:8>>*/ flush(0);
+       /*<<format.ml:1291:8>>*/ pp_force_newline(ppf, 0);
+     }
+     else if(32 === match){
+       /*<<format.ml:1293:8>>*/ flush(0);
+       /*<<format.ml:1293:18>>*/ pp_print_space(ppf, 0);
+     }
+     else
+      right[1]++;
+    }
+    /*<<format.ml:1298:31>>*/ }
+   function pp_print_option(opt, pp_v, ppf, param){
+     /*<<format.ml:1300:56>>*/ if(opt)
+     var sth = opt[1], none = sth;
+    else
+     var
+      none =
+        function(param, _ai_){
+          /*<<format.ml:1300:41>>*/ return 0;
+         /*<<format.ml:1300:43>>*/ };
+     /*<<format.ml:1300:56>>*/ if(! param)
+      /*<<format.ml:1301:10>>*/ return  /*<<format.ml:1301:10>>*/ caml_call2
+             (none, ppf, 0);
+    var v = param[1];
+     /*<<format.ml:1302:12>>*/ return  /*<<format.ml:1302:12>>*/ caml_call2
+            (pp_v, ppf, v);
+   }
+   function pp_print_result(ok, error, ppf, param){
+     /*<<?>>*/ if(0 === param[0]){
+     var v = param[1];
+      /*<<format.ml:1305:10>>*/ return  /*<<format.ml:1305:10>>*/ caml_call2
+             (ok, ppf, v);
+    }
+    var e = param[1];
+     /*<<format.ml:1306:13>>*/ return  /*<<format.ml:1306:13>>*/ caml_call2
+            (error, ppf, e);
+   }
+   function pp_print_either(left, right, ppf, param){
+     /*<<?>>*/ if(0 === param[0]){
+     var l = param[1];
+      /*<<format.ml:1309:19>>*/ return  /*<<format.ml:1309:19>>*/ caml_call2
+             (left, ppf, l);
+    }
+    var r = param[1];
+     /*<<format.ml:1310:20>>*/ return  /*<<format.ml:1310:20>>*/ caml_call2
+            (right, ppf, r);
+   }
+   function compute_tag(output, tag_acc){
+     /*<<format.ml:1315:2>>*/ var
+      /*<<format.ml:1315:12>>*/ buf =
+        /*<<format.ml:1315:12>>*/ caml_call1(Stdlib_Buffer[1], 16),
+      /*<<format.ml:1316:12>>*/ ppf = formatter_of_buffer(buf);
+     /*<<format.ml:1317:2>>*/  /*<<format.ml:1317:2>>*/ caml_call2
+     (output, ppf, tag_acc);
+     /*<<format.ml:1318:2>>*/ pp_print_flush(ppf, 0);
+     /*<<format.ml:1319:12>>*/  /*<<format.ml:1319:12>>*/ var
+     len =  /*<<format.ml:1319:12>>*/ caml_call1(Stdlib_Buffer[7], buf);
+     /*<<format.ml:1320:2>>*/ return 2 <= len
+            ?  /*<<format.ml:1321:7>>*/ caml_call3
+              (Stdlib_Buffer[4], buf, 1, len - 2 | 0)
+            :  /*<<format.ml:1320:18>>*/ caml_call1(Stdlib_Buffer[2], buf);
+    /*<<format.ml:1321:33>>*/ }
+   function output_formatting_lit(ppf, fmting_lit){
+     /*<<format.ml:1334:43>>*/ if(typeof fmting_lit === "number")
+     switch(fmting_lit){
+       case 0:
+         /*<<format.ml:1335:33>>*/ return pp_close_box(ppf, 0);
+       case 1:
+         /*<<format.ml:1336:33>>*/ return pp_close_stag(ppf, 0);
+       case 2:
+         /*<<format.ml:1338:33>>*/ return pp_print_flush(ppf, 0);
+       case 3:
+         /*<<format.ml:1339:33>>*/ return pp_force_newline(ppf, 0);
+       case 4:
+         /*<<format.ml:1340:33>>*/ return pp_print_newline(ppf, 0);
+       case 5:
+         /*<<format.ml:1342:33>>*/ return pp_print_char(ppf, 64);
+       default:  /*<<format.ml:1343:33>>*/ return pp_print_char(ppf, 37);
+     }
+    switch(fmting_lit[0]){
+      case 0:
+       var offset = fmting_lit[3], width = fmting_lit[2];
+        /*<<format.ml:1337:33>>*/ return pp_print_break(ppf, width, offset);
+      case 1:
+        /*<<format.ml:1341:33>>*/ return 0;
+      default:
+       var c = fmting_lit[1];
+        /*<<format.ml:1344:33>>*/ pp_print_char(ppf, 64);
+        /*<<format.ml:1344:33>>*/ return pp_print_char(ppf, c);
+    }
+    /*<<format.ml:1344:75>>*/ }
+   function output_acc(ppf, acc){
+     /*<<format.ml:1350:29>>*/ if(typeof acc === "number")
+      /*<<format.ml:1376:32>>*/ return 0;
+    a:
+    {
+     b:
+     {
+      c:
+      {
+       switch(acc[0]){
+         case 0:
+          var f = acc[2], p = acc[1];
+           /*<<format.ml:1360:4>>*/ output_acc(ppf, p);
+           /*<<format.ml:1360:4>>*/ return output_formatting_lit(ppf, f);
+         case 1:
+          var match = acc[2], p$0 = acc[1];
+          if(0 === match[0]){
+           var acc$0 = match[1];
+            /*<<format.ml:1363:4>>*/ output_acc(ppf, p$0);
+            /*<<format.ml:1364:21>>*/ return pp_open_stag
+                   (ppf, [0, String_tag, compute_tag(output_acc, acc$0)]);
+          }
+          var acc$1 = match[1];
+           /*<<format.ml:1366:4>>*/ output_acc(ppf, p$0);
+           /*<<format.ml:1367:43>>*/ var
+            /*<<format.ml:1367:43>>*/ _$_ = compute_tag(output_acc, acc$1),
+            /*<<format.ml:1367:24>>*/ match$0 =
+              /*<<format.ml:1367:24>>*/ caml_call1
+              (CamlinternalFormat[20], _$_),
+           bty = match$0[2],
+           indent = match$0[1];
+           /*<<format.ml:1368:4>>*/ return pp_open_box_gen(ppf, indent, bty);
+         case 2:
+          var _aa_ = acc[1];
+          if(typeof _aa_ !== "number" && 0 === _aa_[0]){
+           var _ab_ = _aa_[2];
+           if(typeof _ab_ !== "number" && 1 === _ab_[0]){
+            var s$0 = acc[2], size = _ab_[2], p$2 = _aa_[1];
+            break b;
+           }
+          }
+          var s = acc[2], p$1 = _aa_;
+          break a;
+         case 3:
+          var _ac_ = acc[1];
+          if(typeof _ac_ !== "number" && 0 === _ac_[0]){
+           var _ad_ = _ac_[2];
+           if(typeof _ad_ !== "number" && 1 === _ad_[0]){
+            var c$0 = acc[2], size$0 = _ad_[2], p$4 = _ac_[1];
+            break;
+           }
+          }
+          var c = acc[2], p$3 = _ac_;
+          break c;
+         case 4:
+          var _ae_ = acc[1];
+          if(typeof _ae_ !== "number" && 0 === _ae_[0]){
+           var _af_ = _ae_[2];
+           if(typeof _af_ !== "number" && 1 === _af_[0]){
+            var s$0 = acc[2], size = _af_[2], p$2 = _ae_[1];
+            break b;
+           }
+          }
+          var s = acc[2], p$1 = _ae_;
+          break a;
+         case 5:
+          var _ag_ = acc[1];
+          if(typeof _ag_ !== "number" && 0 === _ag_[0]){
+           var _ah_ = _ag_[2];
+           if(typeof _ah_ !== "number" && 1 === _ah_[0]){
+            var c$0 = acc[2], size$0 = _ah_[2], p$4 = _ag_[1];
+            break;
+           }
+          }
+          var c = acc[2], p$3 = _ag_;
+          break c;
+         case 6:
+          var f$0 = acc[2], p$5 = acc[1];
+           /*<<format.ml:1373:32>>*/ output_acc(ppf, p$5);
+           /*<<format.ml:1373:32>>*/ return  /*<<format.ml:1373:32>>*/ caml_call1
+                  (f$0, ppf);
+         case 7:
+          var p$6 = acc[1];
+           /*<<format.ml:1374:32>>*/ output_acc(ppf, p$6);
+           /*<<format.ml:1374:32>>*/ return pp_print_flush(ppf, 0);
+         default:
+          var msg = acc[2], p$7 = acc[1];
+           /*<<format.ml:1375:32>>*/ output_acc(ppf, p$7);
+           /*<<format.ml:1375:32>>*/ return  /*<<format.ml:1375:32>>*/ caml_call1
+                  (Stdlib[1], msg);
+       }
+        /*<<format.ml:1357:4>>*/ output_acc(ppf, p$4);
+        /*<<format.ml:1358:44>>*/ return pp_print_as_size
+               (ppf,
+                size$0,
+                 /*<<format.ml:1358:44>>*/ caml_call2
+                 (Stdlib_String[1], 1, c$0));
+      }
+       /*<<format.ml:1372:32>>*/ output_acc(ppf, p$3);
+       /*<<format.ml:1372:32>>*/ return pp_print_char(ppf, c);
+     }
+      /*<<format.ml:1353:4>>*/ output_acc(ppf, p$2);
+      /*<<format.ml:1353:4>>*/ return pp_print_as_size(ppf, size, s$0);
+    }
+     /*<<format.ml:1370:32>>*/ output_acc(ppf, p$1);
+     /*<<format.ml:1370:32>>*/ return pp_print_string(ppf, s);
+    /*<<format.ml:1376:34>>*/ }
+   function strput_acc(ppf, acc){
+     /*<<format.ml:1382:29>>*/ if(typeof acc === "number")
+      /*<<format.ml:1411:32>>*/ return 0;
+    a:
+    {
+     b:
+     {
+      c:
+      {
+       switch(acc[0]){
+         case 0:
+          var f = acc[2], p = acc[1];
+           /*<<format.ml:1395:4>>*/ strput_acc(ppf, p);
+           /*<<format.ml:1395:4>>*/ return output_formatting_lit(ppf, f);
+         case 1:
+          var match = acc[2], p$0 = acc[1];
+          if(0 === match[0]){
+           var acc$0 = match[1];
+            /*<<format.ml:1398:4>>*/ strput_acc(ppf, p$0);
+            /*<<format.ml:1399:21>>*/ return pp_open_stag
+                   (ppf, [0, String_tag, compute_tag(strput_acc, acc$0)]);
+          }
+          var acc$1 = match[1];
+           /*<<format.ml:1401:4>>*/ strput_acc(ppf, p$0);
+           /*<<format.ml:1402:43>>*/ var
+            /*<<format.ml:1402:43>>*/ _S_ = compute_tag(strput_acc, acc$1),
+            /*<<format.ml:1402:24>>*/ match$0 =
+              /*<<format.ml:1402:24>>*/ caml_call1
+              (CamlinternalFormat[20], _S_),
+           bty = match$0[2],
+           indent = match$0[1];
+           /*<<format.ml:1403:4>>*/ return pp_open_box_gen(ppf, indent, bty);
+         case 2:
+          var _T_ = acc[1];
+          if(typeof _T_ !== "number" && 0 === _T_[0]){
+           var _U_ = _T_[2];
+           if(typeof _U_ !== "number" && 1 === _U_[0]){
+            var s$0 = acc[2], size = _U_[2], p$2 = _T_[1];
+            break b;
+           }
+          }
+          var s = acc[2], p$1 = _T_;
+          break a;
+         case 3:
+          var _V_ = acc[1];
+          if(typeof _V_ !== "number" && 0 === _V_[0]){
+           var _W_ = _V_[2];
+           if(typeof _W_ !== "number" && 1 === _W_[0]){
+            var c$0 = acc[2], size$0 = _W_[2], p$4 = _V_[1];
+            break;
+           }
+          }
+          var c = acc[2], p$3 = _V_;
+          break c;
+         case 4:
+          var _X_ = acc[1];
+          if(typeof _X_ !== "number" && 0 === _X_[0]){
+           var _Y_ = _X_[2];
+           if(typeof _Y_ !== "number" && 1 === _Y_[0]){
+            var s$0 = acc[2], size = _Y_[2], p$2 = _X_[1];
+            break b;
+           }
+          }
+          var s = acc[2], p$1 = _X_;
+          break a;
+         case 5:
+          var _Z_ = acc[1];
+          if(typeof _Z_ !== "number" && 0 === _Z_[0]){
+           var ___ = _Z_[2];
+           if(typeof ___ !== "number" && 1 === ___[0]){
+            var c$0 = acc[2], size$0 = ___[2], p$4 = _Z_[1];
+            break;
+           }
+          }
+          var c = acc[2], p$3 = _Z_;
+          break c;
+         case 6:
+          var p$5 = acc[1];
+          if(typeof p$5 !== "number" && 0 === p$5[0]){
+           var match$1 = p$5[2];
+           if(typeof match$1 !== "number" && 1 === match$1[0]){
+            var f$1 = acc[2], size$1 = match$1[2], p$6 = p$5[1];
+             /*<<format.ml:1392:4>>*/ strput_acc(ppf, p$6);
+             /*<<format.ml:1393:44>>*/ return pp_print_as_size
+                    (ppf, size$1,  /*<<format.ml:1393:44>>*/ caml_call1(f$1, 0));
+           }
+          }
+          var f$0 = acc[2];
+           /*<<format.ml:1408:32>>*/ strput_acc(ppf, p$5);
+           /*<<format.ml:1408:70>>*/ return pp_print_string
+                  (ppf,  /*<<format.ml:1408:70>>*/ caml_call1(f$0, 0));
+         case 7:
+          var p$7 = acc[1];
+           /*<<format.ml:1409:32>>*/ strput_acc(ppf, p$7);
+           /*<<format.ml:1409:32>>*/ return pp_print_flush(ppf, 0);
+         default:
+          var msg = acc[2], p$8 = acc[1];
+           /*<<format.ml:1410:32>>*/ strput_acc(ppf, p$8);
+           /*<<format.ml:1410:32>>*/ return  /*<<format.ml:1410:32>>*/ caml_call1
+                  (Stdlib[1], msg);
+       }
+        /*<<format.ml:1389:4>>*/ strput_acc(ppf, p$4);
+        /*<<format.ml:1390:44>>*/ return pp_print_as_size
+               (ppf,
+                size$0,
+                 /*<<format.ml:1390:44>>*/ caml_call2
+                 (Stdlib_String[1], 1, c$0));
+      }
+       /*<<format.ml:1407:32>>*/ strput_acc(ppf, p$3);
+       /*<<format.ml:1407:32>>*/ return pp_print_char(ppf, c);
+     }
+      /*<<format.ml:1385:4>>*/ strput_acc(ppf, p$2);
+      /*<<format.ml:1385:4>>*/ return pp_print_as_size(ppf, size, s$0);
+    }
+     /*<<format.ml:1405:32>>*/ strput_acc(ppf, p$1);
+     /*<<format.ml:1405:32>>*/ return pp_print_string(ppf, s);
+    /*<<format.ml:1411:34>>*/ }
+   function kfprintf(k, ppf, param){
+     /*<<format.ml:1420:2>>*/ var
+     fmt = param[1],
+      /*<<format.ml:1420:2>>*/ _Q_ = 0;
+    function _R_(acc){
+      /*<<format.ml:1421:16>>*/ output_acc(ppf, acc);
+     return caml_call1(k, ppf);
+     /*<<format.ml:1421:41>>*/ }
+     /*<<format.ml:1420:2>>*/ return  /*<<format.ml:1420:2>>*/ caml_call3
+            (CamlinternalFormat[7], _R_, _Q_, fmt);
+   }
+   function ikfprintf(k, ppf, param){
+    var fmt = param[1];
+     /*<<format.ml:1425:2>>*/ return  /*<<format.ml:1425:2>>*/ caml_call3
+            (CamlinternalFormat[8], k, ppf, fmt);
+   }
+   function ifprintf(ppf, param){
+     /*<<format.ml:1428:2>>*/ var
+     fmt = param[1],
+      /*<<format.ml:1428:2>>*/ _N_ = 0;
+    function _O_(_P_){ /*<<?>>*/ return 0;}
+     /*<<format.ml:1428:2>>*/ return  /*<<format.ml:1428:2>>*/ caml_call3
+            (CamlinternalFormat[8], _O_, _N_, fmt);
+   }
+   function fprintf(ppf){
+    function _K_(_M_){ /*<<?>>*/ return 0;}
+     /*<<format.ml:1430:18>>*/ return function(_L_){
+      /*<<?>>*/ return kfprintf(_K_, ppf, _L_);};
+    /*<<format.ml:1430:37>>*/ }
+   function printf(param){
+     /*<<format.ml:1433:2>>*/ var
+     fmt = param[1],
+      /*<<format.ml:1433:2>>*/ _I_ = 0;
+    function _J_(acc){
+      /*<<format.ml:1434:16>>*/ return output_acc
+             ( /*<<format.ml:1434:27>>*/ caml_call1
+               (Stdlib_Domain[10][2], std_formatter_key),
+              acc);
+     /*<<format.ml:1434:58>>*/ }
+     /*<<format.ml:1433:2>>*/ return  /*<<format.ml:1433:2>>*/ caml_call3
+            (CamlinternalFormat[7], _J_, _I_, fmt);
+   }
+   function eprintf(param){
+     /*<<format.ml:1438:2>>*/ var
+     fmt = param[1],
+      /*<<format.ml:1438:2>>*/ _G_ = 0;
+    function _H_(acc){
+      /*<<format.ml:1439:16>>*/ return output_acc
+             ( /*<<format.ml:1439:27>>*/ caml_call1
+               (Stdlib_Domain[10][2], err_formatter_key),
+              acc);
+     /*<<format.ml:1439:58>>*/ }
+     /*<<format.ml:1438:2>>*/ return  /*<<format.ml:1438:2>>*/ caml_call3
+            (CamlinternalFormat[7], _H_, _G_, fmt);
+   }
+   function kdprintf(k, param){
+     /*<<format.ml:1443:2>>*/ var
+     fmt = param[1],
+      /*<<format.ml:1443:2>>*/ _E_ = 0;
+    function _F_(acc){
+      /*<<format.ml:1444:16>>*/ return  /*<<format.ml:1444:18>>*/ caml_call1
+             (k,
+              function(ppf){
+                /*<<format.ml:1444:30>>*/ return output_acc(ppf, acc);
+               /*<<format.ml:1444:48>>*/ });
+     /*<<format.ml:1444:49>>*/ }
+     /*<<format.ml:1443:2>>*/ return  /*<<format.ml:1443:2>>*/ caml_call3
+            (CamlinternalFormat[7], _F_, _E_, fmt);
+   }
+   function dprintf(fmt){
+     /*<<format.ml:1447:18>>*/ return kdprintf
+            (function(i){
+               /*<<format.ml:1447:37>>*/ return i;
+              /*<<format.ml:1447:38>>*/ },
+             fmt);
+    /*<<format.ml:1447:43>>*/ }
+   function ksprintf(k, param){
+     /*<<format.ml:1450:10>>*/ var
+     fmt = param[1],
+      /*<<format.ml:1450:10>>*/ b = pp_make_buffer(0),
+      /*<<format.ml:1451:12>>*/ ppf = formatter_of_buffer(b);
+    function k$0(acc){
+      /*<<format.ml:1453:4>>*/ strput_acc(ppf, acc);
+      /*<<format.ml:1454:6>>*/ return  /*<<format.ml:1454:6>>*/ caml_call1
+             (k, flush_buffer_formatter(b, ppf));
+     /*<<format.ml:1454:36>>*/ }
+     /*<<format.ml:1455:2>>*/ return  /*<<format.ml:1455:2>>*/ caml_call3
+            (CamlinternalFormat[7], k$0, 0, fmt);
+   }
+   function sprintf(fmt){
+     /*<<format.ml:1458:18>>*/ return ksprintf(id, fmt);
+    /*<<format.ml:1458:33>>*/ }
+   function kasprintf(k, param){
+     /*<<format.ml:1461:10>>*/ var
+     fmt = param[1],
+      /*<<format.ml:1461:10>>*/ b = pp_make_buffer(0),
+      /*<<format.ml:1462:12>>*/ ppf = formatter_of_buffer(b);
+    function k$0(acc){
+      /*<<format.ml:1464:4>>*/ output_acc(ppf, acc);
+      /*<<format.ml:1465:6>>*/ return  /*<<format.ml:1465:6>>*/ caml_call1
+             (k, flush_buffer_formatter(b, ppf));
+     /*<<format.ml:1465:36>>*/ }
+     /*<<format.ml:1466:2>>*/ return  /*<<format.ml:1466:2>>*/ caml_call3
+            (CamlinternalFormat[7], k$0, 0, fmt);
+   }
+   function asprintf(fmt){
+     /*<<format.ml:1469:19>>*/ return kasprintf(id, fmt);
+    /*<<format.ml:1469:35>>*/ }
+   function flush_standard_formatters(param){
+     /*<<format.ml:1474:2>>*/ pp_print_flush
+     ( /*<<format.ml:1474:17>>*/ caml_call1
+       (Stdlib_Domain[10][2], std_formatter_key),
+      0);
+     /*<<format.ml:1474:2>>*/ return pp_print_flush
+            ( /*<<format.ml:1475:17>>*/ caml_call1
+              (Stdlib_Domain[10][2], err_formatter_key),
+             0);
+    /*<<format.ml:1475:47>>*/ }
+    /*<<format.ml:1477:9>>*/  /*<<format.ml:1477:9>>*/ caml_call1
+    (Stdlib[100], flush_standard_formatters);
+   function _l_(param){
+     /*<<format.ml:1480:2>>*/ flush_standard_formatters(0);
+     /*<<format.ml:1481:11>>*/ var
+      /*<<format.ml:1481:11>>*/ fs =
+       pp_get_formatter_out_functions(std_formatter, 0),
+     _m_ = fs[5],
+     _n_ = fs[4],
+     _o_ = fs[3],
+     _p_ = Stdlib[39];
+     /*<<format.ml:1484:25>>*/ function _q_(_D_){
+      /*<<?>>*/ return buffered_out_flush(_p_, std_buf_key, _D_);
+    }
+     /*<<format.ml:1482:2>>*/ pp_set_formatter_out_functions
+     (std_formatter,
+      [0,
+       function(_A_, _B_, _C_){
+         /*<<?>>*/ return buffered_out_string(std_buf_key, _A_, _B_, _C_);
+       },
+       _q_,
+       _o_,
+       _n_,
+       _m_]);
+     /*<<format.ml:1486:11>>*/ var
+      /*<<format.ml:1486:11>>*/ fs$0 =
+       pp_get_formatter_out_functions(err_formatter, 0),
+     _r_ = fs$0[5],
+     _s_ = fs$0[4],
+     _t_ = fs$0[3],
+     _u_ = Stdlib[40];
+     /*<<format.ml:1489:25>>*/ function _v_(_z_){
+      /*<<?>>*/ return buffered_out_flush(_u_, err_buf_key, _z_);
+    }
+     /*<<format.ml:1488:4>>*/ return pp_set_formatter_out_functions
+            (err_formatter,
+             [0,
+              function(_w_, _x_, _y_){
+                /*<<?>>*/ return buffered_out_string
+                       (err_buf_key, _w_, _x_, _y_);
+              },
+              _v_,
+              _t_,
+              _s_,
+              _r_]);
+    /*<<format.ml:1489:71>>*/ }
+    /*<<format.ml:1479:9>>*/  /*<<format.ml:1479:9>>*/ caml_call1
+    (Stdlib_Domain[5], _l_);
+   var
+    Stdlib_Format =
+      [0,
+       pp_open_box,
+       open_box,
+       pp_close_box,
+       close_box,
+       pp_open_hbox,
+       open_hbox,
+       pp_open_vbox,
+       open_vbox,
+       pp_open_hvbox,
+       open_hvbox,
+       pp_open_hovbox,
+       open_hovbox,
+       pp_print_string,
+       print_string,
+       pp_print_bytes,
+       print_bytes,
+       pp_print_as,
+       print_as,
+       pp_print_int,
+       print_int,
+       pp_print_float,
+       print_float,
+       pp_print_char,
+       print_char,
+       pp_print_bool,
+       print_bool,
+       pp_print_space,
+       print_space,
+       pp_print_cut,
+       print_cut,
+       pp_print_break,
+       print_break,
+       pp_print_custom_break,
+       pp_force_newline,
+       force_newline,
+       pp_print_if_newline,
+       print_if_newline,
+       pp_print_flush,
+       print_flush,
+       pp_print_newline,
+       print_newline,
+       pp_set_margin,
+       set_margin,
+       pp_get_margin,
+       get_margin,
+       pp_set_max_indent,
+       set_max_indent,
+       pp_get_max_indent,
+       get_max_indent,
+       check_geometry,
+       pp_set_geometry,
+       set_geometry,
+       pp_safe_set_geometry,
+       safe_set_geometry,
+       pp_update_geometry,
+       update_geometry,
+       pp_get_geometry,
+       get_geometry,
+       pp_set_max_boxes,
+       set_max_boxes,
+       pp_get_max_boxes,
+       get_max_boxes,
+       pp_over_max_boxes,
+       over_max_boxes,
+       pp_open_tbox,
+       open_tbox,
+       pp_close_tbox,
+       close_tbox,
+       pp_set_tab,
+       set_tab,
+       pp_print_tab,
+       print_tab,
+       pp_print_tbreak,
+       print_tbreak,
+       pp_set_ellipsis_text,
+       set_ellipsis_text,
+       pp_get_ellipsis_text,
+       get_ellipsis_text,
+       String_tag,
+       pp_open_stag,
+       open_stag,
+       pp_close_stag,
+       close_stag,
+       pp_set_tags,
+       set_tags,
+       pp_set_print_tags,
+       set_print_tags,
+       pp_set_mark_tags,
+       set_mark_tags,
+       pp_get_print_tags,
+       get_print_tags,
+       pp_get_mark_tags,
+       get_mark_tags,
+       pp_set_formatter_out_channel,
+       set_formatter_out_channel,
+       pp_set_formatter_output_functi,
+       set_formatter_output_functions,
+       pp_get_formatter_output_functi,
+       get_formatter_output_functions,
+       pp_set_formatter_out_functions,
+       set_formatter_out_functions,
+       pp_get_formatter_out_functions,
+       get_formatter_out_functions,
+       pp_set_formatter_stag_function,
+       set_formatter_stag_functions,
+       pp_get_formatter_stag_function,
+       get_formatter_stag_functions,
+       formatter_of_out_channel,
+       synchronized_formatter_of_out_,
+       std_formatter,
+       get_std_formatter,
+       err_formatter,
+       get_err_formatter,
+       formatter_of_buffer,
+       stdbuf,
+       get_stdbuf,
+       str_formatter,
+       get_str_formatter,
+       flush_str_formatter,
+       make_formatter,
+       make_synchronized_formatter,
+       formatter_of_out_functions,
+       make_symbolic_output_buffer,
+       clear_symbolic_output_buffer,
+       get_symbolic_output_buffer,
+       flush_symbolic_output_buffer,
+       add_symbolic_output_item,
+       formatter_of_symbolic_output_b,
+       pp_print_list,
+       pp_print_seq,
+       pp_print_text,
+       pp_print_option,
+       pp_print_result,
+       pp_print_either,
+       fprintf,
+       printf,
+       eprintf,
+       sprintf,
+       asprintf,
+       dprintf,
+       ifprintf,
+       kfprintf,
+       kdprintf,
+       ikfprintf,
+       ksprintf,
+       kasprintf];
+   runtime.caml_register_global(35, Stdlib_Format, "Stdlib__Format");
+   return;
+   /*<<?>>*/ }
+  (globalThis));
+
+//# unitInfo: Provides: Stdlib__Scanf
+//# unitInfo: Requires: Assert_failure, CamlinternalFormat, CamlinternalFormatBasics, Stdlib, Stdlib__Buffer, Stdlib__Bytes, Stdlib__Int, Stdlib__Printf, Stdlib__String
+(function
+  (globalThis){
+   "use strict";
+   var
+    runtime = globalThis.jsoo_runtime,
+    cst$5 = '"',
+    cst$6 = "-",
+    cst_character = "character ",
+    cst_scanf_ml = "scanf.ml",
+    cst_scanf_bad_conversion$3 = 'scanf: bad conversion "%*"',
+    cst_scanning_of = "scanning of ",
+    caml_bytes_get = runtime.caml_bytes_get,
+    caml_int_of_string = runtime.caml_int_of_string,
+    caml_maybe_attach_backtrace = runtime.caml_maybe_attach_backtrace,
+    caml_ml_string_length = runtime.caml_ml_string_length,
+    caml_string_get = runtime.caml_string_get,
+    caml_string_notequal = runtime.caml_string_notequal,
+    caml_trampoline = runtime.caml_trampoline,
+    caml_trampoline_return = runtime.caml_trampoline_return,
+    caml_wrap_exception = runtime.caml_wrap_exception;
+    /*<<?>>*/ function caml_call1(f, a0){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 1
+            ? f(a0)
+            : runtime.caml_call_gen(f, [a0]);
+   }
+    /*<<?>>*/ function caml_call2(f, a0, a1){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 2
+            ? f(a0, a1)
+            : runtime.caml_call_gen(f, [a0, a1]);
+   }
+    /*<<?>>*/ function caml_call3(f, a0, a1, a2){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 3
+            ? f(a0, a1, a2)
+            : runtime.caml_call_gen(f, [a0, a1, a2]);
+   }
+    /*<<?>>*/ function caml_call4(f, a0, a1, a2, a3){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 4
+            ? f(a0, a1, a2, a3)
+            : runtime.caml_call_gen(f, [a0, a1, a2, a3]);
+   }
+   var
+    global_data = runtime.caml_get_global_data(),
+    cst$3 = cst$5,
+    cst$4 = cst$5,
+    cst$1 = cst$5,
+    cst$2 = cst$5,
+    cst$0 = cst$5,
+    cst = cst$6,
+    CamlinternalFormat = global_data.CamlinternalFormat,
+    CamlinternalFormatBasics = global_data.CamlinternalFormatBasics,
+    Stdlib_String = global_data.Stdlib__String,
+    Stdlib = global_data.Stdlib,
+    Assert_failure = global_data.Assert_failure,
+    Stdlib_Printf = global_data.Stdlib__Printf,
+    Stdlib_Int = global_data.Stdlib__Int,
+    Stdlib_Buffer = global_data.Stdlib__Buffer,
+    _r_ = [0, 91],
+    _q_ = [0, 123],
+    cst_end_of_input_not_found = "end of input not found",
+    cst_scanf_bad_conversion_a = 'scanf: bad conversion "%a"',
+    cst_scanf_bad_conversion_t = 'scanf: bad conversion "%t"',
+    cst_scanf_missing_reader = "scanf: missing reader",
+    _s_ = [0, cst_scanf_ml, 1414, 13],
+    cst_scanf_bad_conversion_custo =
+      'scanf: bad conversion "%?" (custom converter)',
+    cst_scanf_bad_conversion = cst_scanf_bad_conversion$3,
+    cst_scanf_bad_conversion$0 = cst_scanf_bad_conversion$3,
+    cst_scanf_bad_conversion$1 = 'scanf: bad conversion "%-"',
+    cst_scanf_bad_conversion$2 = cst_scanf_bad_conversion$3,
+    _t_ = [0, [3, 0, [10, 0]], "%S%!"],
+    cst_in_format = ' in format "',
+    _p_ = [0, 37, ""],
+    _o_ =
+      [0,
+       [11,
+        "scanf: bad input at char number ",
+        [4, 3, 0, 0, [11, ": ", [2, 0, 0]]]],
+       "scanf: bad input at char number %i: %s"],
+    _n_ =
+      [0,
+       [11, "the character ", [1, [11, " cannot start a boolean", 0]]],
+       "the character %C cannot start a boolean"],
+    _m_ =
+      [0,
+       [11, "bad character hexadecimal encoding \\", [0, [0, 0]]],
+       "bad character hexadecimal encoding \\%c%c"],
+    _l_ =
+      [0,
+       [11, "bad character decimal encoding \\", [0, [0, [0, 0]]]],
+       "bad character decimal encoding \\%c%c%c"],
+    cst_an = "an",
+    cst_x = "x",
+    cst_nfinity = "nfinity",
+    cst_digits = "digits",
+    _k_ =
+      [0,
+       [11,
+        cst_character,
+        [1, [11, " is not a valid ", [2, 0, [11, " digit", 0]]]]],
+       "character %C is not a valid %s digit"],
+    cst_decimal_digits = "decimal digits",
+    _j_ =
+      [0,
+       [11, cst_character, [1, [11, " is not a decimal digit", 0]]],
+       "character %C is not a decimal digit"],
+    cst_0b = "0b",
+    cst_0o = "0o",
+    cst_0u = "0u",
+    cst_0x = "0x",
+    _i_ = [0, cst_scanf_ml, 516, 9],
+    _h_ =
+      [0,
+       [11, "invalid boolean '", [2, 0, [12, 39, 0]]],
+       "invalid boolean '%s'"],
+    _g_ =
+      [0,
+       [11, "looking for ", [1, [11, ", found ", [1, 0]]]],
+       "looking for %C, found %C"],
+    cst_not_a_valid_float_in_hexad =
+      "not a valid float in hexadecimal notation",
+    cst_no_dot_or_exponent_part_fo =
+      "no dot or exponent part found in float token",
+    _f_ =
+      [0,
+       [11,
+        cst_scanning_of,
+        [2,
+         0,
+         [11,
+          " failed: premature end of file occurred before end of token",
+          0]]],
+       "scanning of %s failed: premature end of file occurred before end of token"],
+    _e_ =
+      [0,
+       [11,
+        cst_scanning_of,
+        [2,
+         0,
+         [11, " failed: the specified length was too short for token", 0]]],
+       "scanning of %s failed: the specified length was too short for token"],
+    _d_ =
+      [0,
+       [11, "illegal escape character ", [1, 0]],
+       "illegal escape character %C"],
+    cst_unnamed_function = "unnamed function",
+    cst_unnamed_character_string = "unnamed character string",
+    cst_unnamed_Stdlib_input_chann = "unnamed Stdlib input channel",
+    cst_Stdlib_Scanf_Scan_failure = "Stdlib.Scanf.Scan_failure",
+    cst_binary = "binary",
+    cst_octal = "octal",
+    cst_hexadecimal = "hexadecimal",
+    cst_a_Char = "a Char",
+    cst_a_String = "a String",
+    null_char = 0;
+   function next_char(ib){
+     /*<<scanf.ml:165:4>>*/ try{
+      /*<<scanf.ml:166:14>>*/  /*<<scanf.ml:166:14>>*/ var
+      c =  /*<<scanf.ml:166:14>>*/ caml_call1(ib[7], 0);
+     ib[2] = c;
+     ib[3] = 1;
+     ib[4] = ib[4] + 1 | 0;
+     if(10 === c) ib[5] = ib[5] + 1 | 0;
+      /*<<scanf.ml:171:6>>*/ return c;
+    }
+    catch(_bb_){
+     var _ba_ = caml_wrap_exception(_bb_);
+     if(_ba_ !== Stdlib[12]) throw caml_maybe_attach_backtrace(_ba_, 0);
+     ib[2] = null_char;
+     ib[3] = 0;
+     ib[1] = 1;
+      /*<<scanf.ml:177:6>>*/ return null_char;
+    }
+    /*<<scanf.ml:177:7>>*/ }
+   function peek_char(ib){
+     /*<<scanf.ml:181:4>>*/ return ib[3] ? ib[2] : next_char(ib);
+    /*<<scanf.ml:183:21>>*/ }
+   function checked_peek_char(ib){
+     /*<<scanf.ml:192:4>>*/  /*<<scanf.ml:192:12>>*/ var c = peek_char(ib);
+    if(ib[1])
+      /*<<scanf.ml:193:22>>*/ throw  /*<<scanf.ml:193:22>>*/ caml_maybe_attach_backtrace
+            (Stdlib[12], 1);
+     /*<<scanf.ml:194:4>>*/ return c;
+    /*<<scanf.ml:194:5>>*/ }
+   function end_of_input(ib){
+     /*<<scanf.ml:198:4>>*/ peek_char(ib);
+    return ib[1];
+    /*<<scanf.ml:199:13>>*/ }
+   function beginning_of_input(ib){
+     /*<<scanf.ml:204:30>>*/ return 0 === ib[4] ? 1 : 0;
+    /*<<scanf.ml:204:50>>*/ }
+   function name_of_input(ib){
+     /*<<scanf.ml:207:4>>*/ var match = ib[9];
+    if(typeof match === "number")
+     return 0 === match ? cst_unnamed_function : cst_unnamed_character_string;
+    if(0 === match[0])
+      /*<<scanf.ml:208:26>>*/ return cst_unnamed_Stdlib_input_chann;
+    var fname = match[1];
+     /*<<scanf.ml:209:32>>*/ return fname;
+    /*<<scanf.ml:211:47>>*/ }
+   function char_count(ib){
+     /*<<scanf.ml:215:4>>*/ return ib[3] ? ib[4] - 1 | 0 : ib[4];
+    /*<<scanf.ml:217:25>>*/ }
+   function invalidate_current_char(ib){
+     /*<<scanf.ml:224:35>>*/ ib[3] = 0;
+    return 0;
+    /*<<scanf.ml:224:71>>*/ }
+   function token_string(ib){
+     /*<<scanf.ml:227:4>>*/ var
+     token_buffer = ib[8],
+      /*<<scanf.ml:228:14>>*/ tok =
+        /*<<scanf.ml:228:14>>*/ caml_call1(Stdlib_Buffer[2], token_buffer);
+     /*<<scanf.ml:229:4>>*/  /*<<scanf.ml:229:4>>*/ caml_call1
+     (Stdlib_Buffer[8], token_buffer);
+    ib[6] = ib[6] + 1 | 0;
+     /*<<scanf.ml:231:4>>*/ return tok;
+    /*<<scanf.ml:231:7>>*/ }
+   function skip_char(width, ib){
+     /*<<scanf.ml:237:4>>*/ invalidate_current_char(ib);
+     /*<<scanf.ml:237:4>>*/ return width;
+    /*<<scanf.ml:238:9>>*/ }
+   function ignore_char(width, ib){
+     /*<<scanf.ml:241:29>>*/ return skip_char(width - 1 | 0, ib);
+    /*<<scanf.ml:241:53>>*/ }
+   function store_char(width, ib, c){
+     /*<<scanf.ml:244:4>>*/  /*<<scanf.ml:244:4>>*/ caml_call2
+     (Stdlib_Buffer[12], ib[8], c);
+     /*<<scanf.ml:244:4>>*/ return ignore_char(width, ib);
+    /*<<scanf.ml:245:24>>*/ }
+   var default_token_buffer_size = 1024;
+   function create(iname, next){
+     /*<<scanf.ml:250:26>>*/ return [0,
+            0,
+            null_char,
+            0,
+            0,
+            0,
+            0,
+            next,
+             /*<<scanf.ml:258:22>>*/ caml_call1
+             (Stdlib_Buffer[1], default_token_buffer_size),
+            iname];
+    /*<<scanf.ml:260:3>>*/ }
+   function from_string(s){
+     /*<<scanf.ml:264:4>>*/ var
+      /*<<scanf.ml:264:12>>*/ i = [0, 0],
+      /*<<scanf.ml:265:4>>*/ len =
+        /*<<scanf.ml:265:4>>*/ caml_ml_string_length(s);
+    function next(param){
+      /*<<scanf.ml:267:6>>*/ if(len <= i[1])
+       /*<<scanf.ml:267:24>>*/ throw  /*<<scanf.ml:267:24>>*/ caml_maybe_attach_backtrace
+             (Stdlib[12], 1);
+      /*<<scanf.ml:268:14>>*/  /*<<scanf.ml:268:14>>*/ var
+      c =  /*<<scanf.ml:268:14>>*/ caml_string_get(s, i[1]);
+      /*<<scanf.ml:269:6>>*/ i[1]++;
+      /*<<scanf.ml:270:6>>*/ return c;
+     /*<<scanf.ml:270:7>>*/ }
+     /*<<scanf.ml:271:4>>*/ return create(1, next);
+    /*<<scanf.ml:271:27>>*/ }
+   var _a_ = 0;
+    /*<<scanf.ml:274:22>>*/ function from_function(_a$_){
+     /*<<?>>*/ return create(_a_, _a$_);
+   }
+    /*<<scanf.ml:274:22>>*/  /*<<scanf.ml:274:22>>*/ var len = 1024;
+   function scan_close_at_end(ic){
+     /*<<scanf.ml:320:29>>*/  /*<<scanf.ml:320:29>>*/ caml_call1
+     (Stdlib[93], ic);
+     /*<<scanf.ml:320:49>>*/ throw  /*<<scanf.ml:320:49>>*/ caml_maybe_attach_backtrace
+           (Stdlib[12], 1);
+    /*<<scanf.ml:320:66>>*/ }
+   function scan_raise_at_end(ic){
+     /*<<scanf.ml:324:30>>*/ throw  /*<<scanf.ml:324:30>>*/ caml_maybe_attach_backtrace
+           (Stdlib[12], 1);
+    /*<<scanf.ml:324:47>>*/ }
+   function from_ic(scan_close_ic, iname, ic){
+     /*<<scanf.ml:327:4>>*/ var
+      /*<<scanf.ml:328:14>>*/ buf =
+        /*<<scanf.ml:328:14>>*/ runtime.caml_create_bytes(1024),
+      /*<<scanf.ml:329:12>>*/ i = [0, 0],
+      /*<<scanf.ml:330:14>>*/ lim = [0, 0],
+      /*<<scanf.ml:331:14>>*/ eof = [0, 0];
+    function next(param){
+      /*<<scanf.ml:333:6>>*/ if(i[1] < lim[1]){
+       /*<<scanf.ml:333:38>>*/  /*<<scanf.ml:333:38>>*/ var
+       c =  /*<<scanf.ml:333:38>>*/ caml_bytes_get(buf, i[1]);
+       /*<<scanf.ml:333:58>>*/ i[1]++;
+       /*<<scanf.ml:333:66>>*/ return c;
+     }
+     if(eof[1])
+       /*<<scanf.ml:334:19>>*/ throw  /*<<scanf.ml:334:19>>*/ caml_maybe_attach_backtrace
+             (Stdlib[12], 1);
+     lim[1] =  /*<<scanf.ml:335:15>>*/ caml_call4(Stdlib[84], ic, buf, 0, len);
+     return 0 === lim[1]
+             ? (eof[1] = 1, caml_call1(scan_close_ic, ic))
+             : (i[1] = 1,  /*<<scanf.ml:338:10>>*/ caml_bytes_get(buf, 0));
+     /*<<scanf.ml:340:9>>*/ }
+     /*<<scanf.ml:341:4>>*/ return create(iname, next);
+    /*<<scanf.ml:341:21>>*/ }
+    /*<<scanf.ml:363:4>>*/  /*<<scanf.ml:363:4>>*/ var
+    stdin = from_ic(scan_raise_at_end, [1, cst, Stdlib[38]], Stdlib[38]);
+   function open_in_file(open_in, fname){
+     /*<<scanf.ml:367:4>>*/ if(! caml_string_notequal(fname, cst$6))
+      /*<<scanf.ml:363:4>>*/ return stdin;
+     /*<<scanf.ml:370:15>>*/  /*<<scanf.ml:370:15>>*/ var
+     ic =  /*<<scanf.ml:370:15>>*/ caml_call1(open_in, fname);
+    return from_ic(scan_close_at_end, [1, fname, ic], ic);
+    /*<<scanf.ml:371:53>>*/ }
+   var _b_ = Stdlib[79];
+    /*<<scanf.ml:374:16>>*/ function open_in(_a__){
+     /*<<?>>*/ return open_in_file(_b_, _a__);
+   }
+    /*<<scanf.ml:374:16>>*/  /*<<scanf.ml:374:16>>*/ var _c_ = Stdlib[80];
+    /*<<scanf.ml:375:20>>*/ function open_in_bin(_a9_){
+     /*<<?>>*/ return open_in_file(_c_, _a9_);
+   }
+   function from_channel(ic){
+     /*<<scanf.ml:381:4>>*/ return from_ic(scan_raise_at_end, [0, ic], ic);
+    /*<<scanf.ml:381:45>>*/ }
+   function close_in(ib){
+     /*<<scanf.ml:385:4>>*/ var match = ib[9];
+    if(typeof match === "number")  /*<<scanf.ml:389:37>>*/ return 0;
+    if(0 === match[0]){
+     var ic = match[1];
+      /*<<scanf.ml:387:6>>*/ return  /*<<scanf.ml:387:6>>*/ caml_call1
+             (Stdlib[93], ic);
+    }
+    var ic$0 = match[2];
+     /*<<scanf.ml:388:32>>*/ return  /*<<scanf.ml:388:32>>*/ caml_call1
+            (Stdlib[93], ic$0);
+    /*<<scanf.ml:389:39>>*/ }
+    /*<<scanf.ml:403:0>>*/  /*<<scanf.ml:403:0>>*/ var
+    Scan_failure =
+      [248, cst_Stdlib_Scanf_Scan_failure, runtime.caml_fresh_oo_id(0)];
+   function bad_input(s){
+     /*<<scanf.ml:405:18>>*/ throw  /*<<scanf.ml:405:18>>*/ caml_maybe_attach_backtrace
+           ([0, Scan_failure, s], 1);
+    /*<<scanf.ml:405:40>>*/ }
+   function bad_input_escape(c){
+     /*<<scanf.ml:408:2>>*/ return bad_input
+            ( /*<<scanf.ml:408:12>>*/ caml_call2(Stdlib_Printf[4], _d_, c));
+    /*<<scanf.ml:408:60>>*/ }
+   function bad_token_length(message){
+     /*<<scanf.ml:412:2>>*/ return bad_input
+            ( /*<<scanf.ml:413:4>>*/ caml_call2
+              (Stdlib_Printf[4], _e_, message));
+    /*<<scanf.ml:416:15>>*/ }
+   function bad_float(param){
+     /*<<scanf.ml:428:2>>*/ return bad_input(cst_no_dot_or_exponent_part_fo);
+    /*<<scanf.ml:428:58>>*/ }
+   function bad_hex_float(param){
+     /*<<scanf.ml:432:2>>*/ return bad_input(cst_not_a_valid_float_in_hexad);
+    /*<<scanf.ml:432:55>>*/ }
+   function character_mismatch(c, ci){
+     /*<<scanf.ml:440:2>>*/ return bad_input
+            ( /*<<scanf.ml:436:2>>*/ caml_call3(Stdlib_Printf[4], _g_, c, ci));
+    /*<<scanf.ml:440:41>>*/ }
+   function check_this_char(ib, c){
+     /*<<scanf.ml:474:2>>*/  /*<<scanf.ml:474:11>>*/ var
+     ci = checked_peek_char(ib);
+    return ci === c ? invalidate_current_char(ib) : character_mismatch(c, ci);
+    /*<<scanf.ml:476:25>>*/ }
+   function check_char(ib, c$0){
+     /*<<scanf.ml:468:2>>*/ if(10 === c$0){
+      /*<<scanf.ml:479:11>>*/  /*<<scanf.ml:479:11>>*/ var
+      ci = checked_peek_char(ib);
+      /*<<scanf.ml:480:2>>*/ return 10 === ci
+             ? invalidate_current_char(ib)
+             : 13
+               === ci
+               ? (invalidate_current_char(ib), check_this_char(ib, 10))
+               : character_mismatch(10, ci);
+    }
+    if(32 !== c$0)  /*<<scanf.ml:471:9>>*/ return check_this_char(ib, c$0);
+     /*<<scanf.ml:444:2>>*/ for(;;){
+      /*<<scanf.ml:444:10>>*/ var
+       /*<<scanf.ml:444:10>>*/ c = peek_char(ib),
+       /*<<scanf.ml:445:9>>*/ _a7_ = 1 - ib[1];
+     if(! _a7_)  /*<<scanf.ml:445:9>>*/ return _a7_;
+      /*<<scanf.ml:445:32>>*/  /*<<scanf.ml:445:32>>*/ var _a8_ = c - 9 | 0;
+     a:
+     {
+      if(4 < _a8_ >>> 0){
+       if(23 === _a8_) break a;
+      }
+      else if(1 < _a8_ - 2 >>> 0) break a;
+       /*<<scanf.ml:449:11>>*/ return 0;
+     }
+      /*<<scanf.ml:448:6>>*/ invalidate_current_char(ib);
+    }
+    /*<<scanf.ml:471:29>>*/ }
+   function token_char(ib){
+     /*<<scanf.ml:488:20>>*/ return  /*<<scanf.ml:488:20>>*/ caml_string_get
+            (token_string(ib), 0);
+    /*<<scanf.ml:488:43>>*/ }
+   function token_bool(ib){
+     /*<<scanf.ml:493:2>>*/  /*<<scanf.ml:493:8>>*/ var s = token_string(ib);
+    return caml_string_notequal(s, "false")
+            ? caml_string_notequal
+               (s, "true")
+              ? bad_input
+                ( /*<<scanf.ml:496:19>>*/ caml_call2(Stdlib_Printf[4], _h_, s))
+              : 1
+            : 0;
+    /*<<scanf.ml:496:60>>*/ }
+   function integer_conversion_of_char(param){
+     /*<<scanf.ml:509:33>>*/  /*<<scanf.ml:509:33>>*/ var
+     switcher = param - 88 | 0;
+    if(32 >= switcher >>> 0)
+     switch(switcher){
+       case 10:
+         /*<<scanf.ml:510:11>>*/ return 0;
+       case 12:
+         /*<<scanf.ml:511:11>>*/ return 1;
+       case 17:
+         /*<<scanf.ml:512:11>>*/ return 2;
+       case 23:
+         /*<<scanf.ml:513:11>>*/ return 3;
+       case 29:
+         /*<<scanf.ml:514:11>>*/ return 4;
+       case 0:
+       case 32:
+         /*<<scanf.ml:515:17>>*/ return 5;
+     }
+     /*<<scanf.ml:516:9>>*/ throw  /*<<scanf.ml:516:9>>*/ caml_maybe_attach_backtrace
+           ([0, Assert_failure, _i_], 1);
+    /*<<scanf.ml:516:21>>*/ }
+   function token_int_literal(conv, ib){
+     /*<<scanf.ml:523:2>>*/ switch(conv){
+      case 0:
+        /*<<scanf.ml:529:29>>*/ var
+         /*<<scanf.ml:529:29>>*/ _a3_ = token_string(ib),
+        tok =  /*<<scanf.ml:529:22>>*/ caml_call2(Stdlib[28], cst_0b, _a3_);
+       break;
+      case 3:
+        /*<<scanf.ml:527:29>>*/ var
+         /*<<scanf.ml:527:29>>*/ _a4_ = token_string(ib),
+        tok =  /*<<scanf.ml:527:22>>*/ caml_call2(Stdlib[28], cst_0o, _a4_);
+       break;
+      case 4:
+        /*<<scanf.ml:526:29>>*/ var
+         /*<<scanf.ml:526:29>>*/ _a5_ = token_string(ib),
+        tok =  /*<<scanf.ml:526:22>>*/ caml_call2(Stdlib[28], cst_0u, _a5_);
+       break;
+      case 5:
+        /*<<scanf.ml:528:29>>*/ var
+         /*<<scanf.ml:528:29>>*/ _a6_ = token_string(ib),
+        tok =  /*<<scanf.ml:528:22>>*/ caml_call2(Stdlib[28], cst_0x, _a6_);
+       break;
+      default: var tok = token_string(ib);
+    }
+     /*<<scanf.ml:530:2>>*/  /*<<scanf.ml:530:2>>*/ var
+     l =  /*<<scanf.ml:530:2>>*/ caml_ml_string_length(tok);
+     /*<<scanf.ml:531:14>>*/ if
+     (0 !== l && 43 ===  /*<<scanf.ml:531:14>>*/ caml_string_get(tok, 0))
+      /*<<scanf.ml:531:43>>*/ return  /*<<scanf.ml:531:43>>*/ caml_call3
+             (Stdlib_String[15], tok, 1, l - 1 | 0);
+     /*<<scanf.ml:531:34>>*/ return tok;
+    /*<<scanf.ml:531:67>>*/ }
+   function token_float(ib){
+     /*<<scanf.ml:539:21>>*/ return  /*<<scanf.ml:539:21>>*/ runtime.caml_float_of_string
+            (token_string(ib));
+    /*<<scanf.ml:539:56>>*/ }
+   function scan_decimal_digit_star(width, ib){
+     /*<<scanf.ml:575:2>>*/ var width$0 = width;
+     /*<<scanf.ml:575:2>>*/ for(;;){
+     if(0 === width$0)  /*<<scanf.ml:575:20>>*/ return width$0;
+      /*<<scanf.ml:576:10>>*/  /*<<scanf.ml:576:10>>*/ var c = peek_char(ib);
+      /*<<scanf.ml:577:5>>*/ if(ib[1])
+       /*<<scanf.ml:577:26>>*/ return width$0;
+     if(58 <= c){
+      if(95 === c){
+        /*<<scanf.ml:583:16>>*/ var
+         /*<<scanf.ml:583:16>>*/ width$1 = ignore_char(width$0, ib),
+        width$0 = width$1;
+       continue;
+      }
+     }
+     else if(48 <= c){
+       /*<<scanf.ml:580:16>>*/ var
+        /*<<scanf.ml:580:16>>*/ width$2 = store_char(width$0, ib, c),
+       width$0 = width$2;
+      continue;
+     }
+      /*<<scanf.ml:585:9>>*/ return width$0;
+    }
+    /*<<scanf.ml:585:14>>*/ }
+   function scan_decimal_digit_plus(width, ib){
+     /*<<scanf.ml:589:2>>*/ if(0 === width)
+      /*<<scanf.ml:589:20>>*/ return bad_token_length(cst_decimal_digits);
+     /*<<scanf.ml:590:10>>*/  /*<<scanf.ml:590:10>>*/ var
+     c = checked_peek_char(ib);
+    if(9 < c - 48 >>> 0)
+      /*<<scanf.ml:596:14>>*/ return bad_input
+             ( /*<<scanf.ml:596:14>>*/ caml_call2(Stdlib_Printf[4], _j_, c));
+     /*<<scanf.ml:593:16>>*/  /*<<scanf.ml:593:16>>*/ var
+     width$0 = store_char(width, ib, c);
+     /*<<scanf.ml:594:4>>*/ return scan_decimal_digit_star(width$0, ib);
+    /*<<scanf.ml:596:70>>*/ }
+   function scan_digit_plus(basis, digitp, width$2, ib){
+     /*<<scanf.ml:620:2>>*/ if(0 === width$2)
+      /*<<scanf.ml:620:20>>*/ return bad_token_length(cst_digits);
+     /*<<scanf.ml:621:10>>*/  /*<<scanf.ml:621:10>>*/ var
+     c$0 = checked_peek_char(ib);
+     /*<<scanf.ml:622:5>>*/ if
+     (!  /*<<scanf.ml:622:5>>*/ caml_call1(digitp, c$0))
+      /*<<scanf.ml:626:14>>*/ return bad_input
+             ( /*<<scanf.ml:626:14>>*/ caml_call3
+               (Stdlib_Printf[4], _k_, c$0, basis));
+     /*<<scanf.ml:623:16>>*/ var
+      /*<<scanf.ml:623:16>>*/ width$3 = store_char(width$2, ib, c$0),
+     width = width$3;
+     /*<<scanf.ml:603:4>>*/ for(;;){
+     if(0 === width)  /*<<scanf.ml:603:22>>*/ return width;
+      /*<<scanf.ml:604:12>>*/  /*<<scanf.ml:604:12>>*/ var c = peek_char(ib);
+      /*<<scanf.ml:605:7>>*/ if(ib[1])  /*<<scanf.ml:605:28>>*/ return width;
+      /*<<scanf.ml:607:13>>*/ if
+      ( /*<<scanf.ml:607:13>>*/ caml_call1(digitp, c))
+       /*<<scanf.ml:608:18>>*/ var
+        /*<<scanf.ml:608:18>>*/ width$0 = store_char(width, ib, c),
+       width = width$0;
+     else{
+      if(95 !== c)  /*<<scanf.ml:613:11>>*/ return width;
+       /*<<scanf.ml:611:18>>*/ var
+        /*<<scanf.ml:611:18>>*/ width$1 = ignore_char(width, ib),
+       width = width$1;
+     }
+    }
+    /*<<scanf.ml:626:77>>*/ }
+   function is_binary_digit(param){
+     /*<<scanf.ml:629:22>>*/ return 1 < param - 48 >>> 0 ? 0 : 1;
+    /*<<scanf.ml:631:14>>*/ }
+    /*<<scanf.ml:634:22>>*/ function scan_binary_int(_a1_, _a2_){
+     /*<<?>>*/ return scan_digit_plus(cst_binary, is_binary_digit, _a1_, _a2_);
+   }
+   function is_octal_digit(param){
+     /*<<scanf.ml:636:21>>*/ return 7 < param - 48 >>> 0 ? 0 : 1;
+    /*<<scanf.ml:638:14>>*/ }
+    /*<<scanf.ml:641:21>>*/ function scan_octal_int(_aZ_, _a0_){
+     /*<<?>>*/ return scan_digit_plus(cst_octal, is_octal_digit, _aZ_, _a0_);
+   }
+   function is_hexa_digit(param){
+     /*<<scanf.ml:643:20>>*/  /*<<scanf.ml:643:20>>*/ var
+     _aY_ = param - 48 | 0;
+    a:
+    {
+     if(22 < _aY_ >>> 0){
+      if(5 < _aY_ - 49 >>> 0) break a;
+     }
+     else if(6 >= _aY_ - 10 >>> 0) break a;
+      /*<<scanf.ml:644:44>>*/ return 1;
+    }
+     /*<<scanf.ml:645:9>>*/ return 0;
+    /*<<scanf.ml:645:14>>*/ }
+    /*<<scanf.ml:648:27>>*/ function scan_hexadecimal_int(_aW_, _aX_){
+     /*<<?>>*/ return scan_digit_plus
+            (cst_hexadecimal, is_hexa_digit, _aW_, _aX_);
+   }
+   function scan_sign(width, ib){
+     /*<<scanf.ml:654:2>>*/ var
+      /*<<scanf.ml:654:10>>*/ c = checked_peek_char(ib),
+      /*<<scanf.ml:654:10>>*/ switcher = c - 43 | 0;
+    if(2 >= switcher >>> 0)
+     switch(switcher){
+       case 0:
+         /*<<scanf.ml:656:11>>*/ return store_char(width, ib, c);
+       case 1: break;
+       default:  /*<<scanf.ml:657:11>>*/ return store_char(width, ib, c);
+     }
+     /*<<scanf.ml:658:9>>*/ return width;
+    /*<<scanf.ml:658:14>>*/ }
+   function scan_optionally_signed_decimal(width, ib){
+     /*<<scanf.ml:662:2>>*/  /*<<scanf.ml:662:14>>*/ var
+     width$0 = scan_sign(width, ib);
+     /*<<scanf.ml:663:2>>*/ return scan_decimal_digit_plus(width$0, ib);
+    /*<<scanf.ml:663:36>>*/ }
+   function scan_int_conversion(conv, width$1, ib){
+     /*<<scanf.ml:691:2>>*/ switch(conv){
+      case 0:
+        /*<<scanf.ml:692:20>>*/ return scan_binary_int(width$1, ib);
+      case 1:
+        /*<<scanf.ml:693:20>>*/ return scan_optionally_signed_decimal
+               (width$1, ib);
+      case 2:
+        /*<<scanf.ml:686:14>>*/ var
+         /*<<scanf.ml:686:14>>*/ width$0 = scan_sign(width$1, ib),
+         /*<<scanf.ml:671:8>>*/ c = checked_peek_char(ib);
+       if(48 !== c)
+         /*<<scanf.ml:682:9>>*/ return scan_decimal_digit_plus(width$0, ib);
+        /*<<scanf.ml:673:16>>*/  /*<<scanf.ml:673:16>>*/ var
+        width = store_char(width$0, ib, c);
+        /*<<scanf.ml:674:4>>*/ if(0 === width)
+         /*<<scanf.ml:674:22>>*/ return width;
+        /*<<scanf.ml:675:12>>*/  /*<<scanf.ml:675:12>>*/ var
+        c$0 = peek_char(ib);
+        /*<<scanf.ml:676:7>>*/ if(ib[1])
+         /*<<scanf.ml:676:28>>*/ return width;
+       a:
+       {
+        if(99 <= c$0){
+         if(111 === c$0)
+           /*<<scanf.ml:679:13>>*/ return scan_octal_int
+                  (store_char(width, ib, c$0), ib);
+         if(120 === c$0) break a;
+        }
+        else{
+         if(88 === c$0) break a;
+         if(98 <= c$0)
+           /*<<scanf.ml:680:13>>*/ return scan_binary_int
+                  (store_char(width, ib, c$0), ib);
+        }
+         /*<<scanf.ml:681:11>>*/ return scan_decimal_digit_star(width, ib);
+       }
+        /*<<scanf.ml:678:19>>*/ return scan_hexadecimal_int
+               (store_char(width, ib, c$0), ib);
+      case 3:
+        /*<<scanf.ml:695:20>>*/ return scan_octal_int(width$1, ib);
+      case 4:
+        /*<<scanf.ml:696:20>>*/ return scan_decimal_digit_plus(width$1, ib);
+      default:
+        /*<<scanf.ml:697:20>>*/ return scan_hexadecimal_int(width$1, ib);
+    }
+    /*<<scanf.ml:697:49>>*/ }
+   function scan_fractional_part(width, ib){
+     /*<<scanf.ml:704:2>>*/ if(0 === width)
+      /*<<scanf.ml:704:20>>*/ return width;
+     /*<<scanf.ml:705:10>>*/  /*<<scanf.ml:705:10>>*/ var c = peek_char(ib);
+     /*<<scanf.ml:706:5>>*/ return ib[1]
+            ? width
+            : 9
+              < c - 48 >>> 0
+              ? width
+              : scan_decimal_digit_star(store_char(width, ib, c), ib);
+    /*<<scanf.ml:710:14>>*/ }
+   function scan_exponent_part(width, ib){
+     /*<<scanf.ml:715:2>>*/ if(0 === width)
+      /*<<scanf.ml:715:20>>*/ return width;
+     /*<<scanf.ml:716:10>>*/  /*<<scanf.ml:716:10>>*/ var c = peek_char(ib);
+     /*<<scanf.ml:717:5>>*/ if(ib[1])  /*<<scanf.ml:717:26>>*/ return width;
+    if(69 !== c && 101 !== c)  /*<<scanf.ml:721:9>>*/ return width;
+     /*<<scanf.ml:720:4>>*/ return scan_optionally_signed_decimal
+            (store_char(width, ib, c), ib);
+    /*<<scanf.ml:721:14>>*/ }
+   function scan_float(width$1, precision, ib){
+     /*<<scanf.ml:765:2>>*/ var
+      /*<<scanf.ml:729:14>>*/ width = scan_sign(width$1, ib),
+      /*<<scanf.ml:730:2>>*/ width$0 = scan_decimal_digit_star(width, ib);
+     /*<<scanf.ml:766:2>>*/ if(0 === width$0)
+      /*<<scanf.ml:766:20>>*/ return [0, width$0, precision];
+     /*<<scanf.ml:767:10>>*/  /*<<scanf.ml:767:10>>*/ var c = peek_char(ib);
+     /*<<scanf.ml:768:5>>*/ if(ib[1])
+      /*<<scanf.ml:768:26>>*/ return [0, width$0, precision];
+    if(46 !== c)
+      /*<<scanf.ml:776:4>>*/ return [0,
+             scan_exponent_part(width$0, ib),
+             precision];
+     /*<<scanf.ml:771:16>>*/ var
+      /*<<scanf.ml:771:16>>*/ width$2 = store_char(width$0, ib, c),
+      /*<<scanf.ml:772:20>>*/ precision$0 =
+        /*<<scanf.ml:772:20>>*/ caml_call2(Stdlib_Int[10], width$2, precision),
+     width$3 =
+       width$2 - (precision$0 - scan_fractional_part(precision$0, ib) | 0) | 0;
+     /*<<scanf.ml:774:4>>*/ return [0,
+            scan_exponent_part(width$3, ib),
+            precision$0];
+    /*<<scanf.ml:776:42>>*/ }
+   function check_case_insensitive_string(width, ib, error, str){
+     /*<<scanf.ml:780:2>>*/ function lowercase(c){
+      /*<<scanf.ml:781:4>>*/ return 25 < c - 65 >>> 0
+             ? c
+             : caml_call1(Stdlib[29], (c - 65 | 0) + 97 | 0);
+     /*<<scanf.ml:784:12>>*/ }
+     /*<<scanf.ml:785:2>>*/ var
+      /*<<scanf.ml:785:2>>*/ len =
+        /*<<scanf.ml:785:2>>*/ caml_ml_string_length(str),
+      /*<<scanf.ml:786:14>>*/ width$0 = [0, width],
+      /*<<scanf.ml:787:2>>*/ _aT_ = len - 1 | 0,
+      /*<<scanf.ml:786:14>>*/ _aS_ = 0;
+    if(_aT_ >= 0){
+     var i = _aS_;
+     for(;;){
+       /*<<scanf.ml:788:12>>*/ var
+        /*<<scanf.ml:788:12>>*/ c = peek_char(ib),
+        /*<<scanf.ml:789:22>>*/ _aU_ =
+         lowercase( /*<<scanf.ml:789:32>>*/ caml_string_get(str, i));
+      if(lowercase(c) !== _aU_)
+        /*<<scanf.ml:789:45>>*/  /*<<scanf.ml:789:45>>*/ caml_call1(error, 0);
+      if(0 === width$0[1])
+        /*<<scanf.ml:790:23>>*/  /*<<scanf.ml:790:23>>*/ caml_call1(error, 0);
+      width$0[1] = store_char(width$0[1], ib, c);
+       /*<<scanf.ml:787:2>>*/  /*<<scanf.ml:787:2>>*/ var _aV_ = i + 1 | 0;
+      if(_aT_ === i) break;
+      var i = _aV_;
+     }
+    }
+    return width$0[1];
+    /*<<scanf.ml:793:8>>*/ }
+   function scan_hex_float(width, precision, ib){
+     /*<<scanf.ml:797:2>>*/ var
+     _aF_ = 0 === width ? 1 : 0,
+     _aG_ = _aF_ || end_of_input(ib);
+     /*<<scanf.ml:797:18>>*/ if(_aG_)
+      /*<<scanf.ml:797:48>>*/ bad_hex_float(0);
+     /*<<scanf.ml:798:14>>*/ var
+      /*<<scanf.ml:798:14>>*/ width$0 = scan_sign(width, ib),
+     _aH_ = 0 === width$0 ? 1 : 0,
+     _aI_ = _aH_ || end_of_input(ib);
+     /*<<scanf.ml:799:18>>*/ if(_aI_)
+      /*<<scanf.ml:799:48>>*/ bad_hex_float(0);
+     /*<<scanf.ml:800:8>>*/  /*<<scanf.ml:800:8>>*/ var c = peek_char(ib);
+    a:
+    {
+     if(78 <= c){
+       /*<<scanf.ml:800:8>>*/  /*<<scanf.ml:800:8>>*/ var
+       switcher = c - 79 | 0;
+      if(30 < switcher >>> 0){
+       if(32 <= switcher) break a;
+        /*<<scanf.ml:830:16>>*/ var
+         /*<<scanf.ml:830:16>>*/ width$1 = store_char(width$0, ib, c),
+        _aJ_ = 0 === width$1 ? 1 : 0,
+        _aK_ = _aJ_ || end_of_input(ib);
+        /*<<scanf.ml:831:20>>*/ if(_aK_)
+         /*<<scanf.ml:831:50>>*/ bad_hex_float(0);
+        /*<<scanf.ml:831:50>>*/ return check_case_insensitive_string
+               (width$1, ib, bad_hex_float, cst_an);
+      }
+      if(26 !== switcher) break a;
+     }
+     else{
+      if(48 === c){
+        /*<<scanf.ml:802:16>>*/ var
+         /*<<scanf.ml:802:16>>*/ width$3 = store_char(width$0, ib, c),
+        _aN_ = 0 === width$3 ? 1 : 0,
+        _aO_ = _aN_ || end_of_input(ib);
+        /*<<scanf.ml:803:20>>*/ if(_aO_)
+         /*<<scanf.ml:803:50>>*/ bad_hex_float(0);
+        /*<<scanf.ml:804:16>>*/  /*<<scanf.ml:804:16>>*/ var
+        width$4 =
+          check_case_insensitive_string(width$3, ib, bad_hex_float, cst_x);
+        /*<<scanf.ml:805:20>>*/ if(0 !== width$4 && ! end_of_input(ib)){
+         /*<<scanf.ml:806:24>>*/  /*<<scanf.ml:806:24>>*/ var
+         _aP_ = peek_char(ib) - 46 | 0;
+        b:
+        {
+         c:
+         {
+          if(34 < _aP_ >>> 0){
+           if(66 === _aP_) break c;
+          }
+          else if(32 < _aP_ - 1 >>> 0) break c;
+          var width$5 = scan_hexadecimal_int(width$4, ib);
+          break b;
+         }
+         var width$5 = width$4;
+        }
+         /*<<scanf.ml:809:22>>*/ if(0 !== width$5 && ! end_of_input(ib)){
+          /*<<scanf.ml:810:26>>*/  /*<<scanf.ml:810:26>>*/ var
+          c$0 = peek_char(ib);
+         if(46 === c$0){
+           /*<<scanf.ml:812:24>>*/  /*<<scanf.ml:812:24>>*/ var
+           width$6 = store_char(width$5, ib, c$0);
+          b:
+          {
+            /*<<scanf.ml:813:28>>*/ if(0 !== width$6 && ! end_of_input(ib)){
+             /*<<scanf.ml:814:20>>*/  /*<<scanf.ml:814:20>>*/ var
+             match = peek_char(ib);
+            c:
+            {
+             if(80 !== match && 112 !== match){
+               /*<<scanf.ml:817:32>>*/ var
+                /*<<scanf.ml:817:32>>*/ precision$0 =
+                  /*<<scanf.ml:817:32>>*/ caml_call2
+                  (Stdlib_Int[10], width$6, precision),
+               width$10 =
+                 width$6
+                 - (precision$0 - scan_hexadecimal_int(precision$0, ib) | 0)
+                 | 0;
+              break c;
+             }
+             var width$10 = width$6;
+            }
+            var width$7 = width$10;
+            break b;
+           }
+           var width$7 = width$6;
+          }
+          var width$8 = width$7;
+         }
+         else
+          var width$8 = width$5;
+          /*<<scanf.ml:821:24>>*/ if(0 !== width$8 && ! end_of_input(ib)){
+           /*<<scanf.ml:822:16>>*/  /*<<scanf.ml:822:16>>*/ var
+           c$1 = peek_char(ib);
+          if(80 !== c$1 && 112 !== c$1)
+            /*<<scanf.ml:827:17>>*/ return width$8;
+           /*<<scanf.ml:824:24>>*/ var
+            /*<<scanf.ml:824:24>>*/ width$9 = store_char(width$8, ib, c$1),
+           _aQ_ = 0 === width$9 ? 1 : 0,
+           _aR_ = _aQ_ || end_of_input(ib);
+           /*<<scanf.ml:825:28>>*/ if(_aR_)
+            /*<<scanf.ml:825:58>>*/ bad_hex_float(0);
+           /*<<scanf.ml:825:58>>*/ return scan_optionally_signed_decimal
+                  (width$9, ib);
+         }
+          /*<<scanf.ml:821:54>>*/ return width$8;
+        }
+         /*<<scanf.ml:809:52>>*/ return width$5;
+       }
+        /*<<scanf.ml:805:50>>*/ return width$4;
+      }
+      if(73 !== c) break a;
+     }
+      /*<<scanf.ml:834:16>>*/ var
+       /*<<scanf.ml:834:16>>*/ width$2 = store_char(width$0, ib, c),
+      _aL_ = 0 === width$2 ? 1 : 0,
+      _aM_ = _aL_ || end_of_input(ib);
+      /*<<scanf.ml:835:20>>*/ if(_aM_)
+       /*<<scanf.ml:835:50>>*/ bad_hex_float(0);
+      /*<<scanf.ml:835:50>>*/ return check_case_insensitive_string
+             (width$2, ib, bad_hex_float, cst_nfinity);
+    }
+     /*<<scanf.ml:837:9>>*/ return bad_hex_float(0);
+    /*<<scanf.ml:837:25>>*/ }
+   function scan_caml_float_rest(width, precision, ib){
+     /*<<scanf.ml:841:2>>*/ var
+     _aB_ = 0 === width ? 1 : 0,
+     _aC_ = _aB_ || end_of_input(ib);
+     /*<<scanf.ml:841:18>>*/ if(_aC_)  /*<<scanf.ml:841:48>>*/ bad_float(0);
+     /*<<scanf.ml:842:14>>*/ var
+      /*<<scanf.ml:842:14>>*/ width$0 = scan_decimal_digit_star(width, ib),
+     _aD_ = 0 === width$0 ? 1 : 0,
+     _aE_ = _aD_ || end_of_input(ib);
+     /*<<scanf.ml:843:18>>*/ if(_aE_)  /*<<scanf.ml:843:48>>*/ bad_float(0);
+     /*<<scanf.ml:844:10>>*/ var
+      /*<<scanf.ml:844:10>>*/ c = peek_char(ib),
+      /*<<scanf.ml:844:10>>*/ switcher = c - 69 | 0;
+    if(32 < switcher >>> 0){
+     if(-23 === switcher){
+       /*<<scanf.ml:847:16>>*/ var
+        /*<<scanf.ml:847:16>>*/ width$1 = store_char(width$0, ib, c),
+        /*<<scanf.ml:850:20>>*/ precision$0 =
+          /*<<scanf.ml:850:20>>*/ caml_call2
+          (Stdlib_Int[10], width$1, precision),
+        /*<<scanf.ml:853:26>>*/ width_precision =
+         scan_fractional_part(precision$0, ib),
+       frac_width = precision$0 - width_precision | 0,
+       width$2 = width$1 - frac_width | 0;
+       /*<<scanf.ml:859:4>>*/ return scan_exponent_part(width$2, ib);
+     }
+    }
+    else if(30 < switcher - 1 >>> 0)
+      /*<<scanf.ml:861:4>>*/ return scan_exponent_part(width$0, ib);
+     /*<<scanf.ml:862:9>>*/ return bad_float(0);
+    /*<<scanf.ml:862:21>>*/ }
+   function scan_caml_float(width, precision, ib){
+     /*<<scanf.ml:866:2>>*/ var
+     _an_ = 0 === width ? 1 : 0,
+     _ao_ = _an_ || end_of_input(ib);
+     /*<<scanf.ml:866:18>>*/ if(_ao_)  /*<<scanf.ml:866:48>>*/ bad_float(0);
+     /*<<scanf.ml:867:14>>*/ var
+      /*<<scanf.ml:867:14>>*/ width$0 = scan_sign(width, ib),
+     _ap_ = 0 === width$0 ? 1 : 0,
+     _aq_ = _ap_ || end_of_input(ib);
+     /*<<scanf.ml:868:18>>*/ if(_aq_)  /*<<scanf.ml:868:48>>*/ bad_float(0);
+     /*<<scanf.ml:869:8>>*/  /*<<scanf.ml:869:8>>*/ var c = peek_char(ib);
+    if(49 <= c){
+     if(58 > c){
+       /*<<scanf.ml:903:16>>*/ var
+        /*<<scanf.ml:903:16>>*/ width$1 = store_char(width$0, ib, c),
+       _ar_ = 0 === width$1 ? 1 : 0,
+       _as_ = _ar_ || end_of_input(ib);
+       /*<<scanf.ml:904:20>>*/ if(_as_)  /*<<scanf.ml:904:50>>*/ bad_float(0);
+       /*<<scanf.ml:904:50>>*/ return scan_caml_float_rest
+              (width$1, precision, ib);
+     }
+    }
+    else if(48 <= c){
+      /*<<scanf.ml:871:16>>*/ var
+       /*<<scanf.ml:871:16>>*/ width$2 = store_char(width$0, ib, c),
+      _at_ = 0 === width$2 ? 1 : 0,
+      _au_ = _at_ || end_of_input(ib);
+      /*<<scanf.ml:872:20>>*/ if(_au_)  /*<<scanf.ml:872:50>>*/ bad_float(0);
+      /*<<scanf.ml:873:10>>*/  /*<<scanf.ml:873:10>>*/ var
+      c$0 = peek_char(ib);
+     if(88 !== c$0 && 120 !== c$0)
+       /*<<scanf.ml:900:6>>*/ return scan_caml_float_rest
+              (width$2, precision, ib);
+      /*<<scanf.ml:875:18>>*/ var
+       /*<<scanf.ml:875:18>>*/ width$3 = store_char(width$2, ib, c$0),
+      _av_ = 0 === width$3 ? 1 : 0,
+      _aw_ = _av_ || end_of_input(ib);
+      /*<<scanf.ml:876:22>>*/ if(_aw_)  /*<<scanf.ml:876:52>>*/ bad_float(0);
+      /*<<scanf.ml:877:18>>*/ var
+       /*<<scanf.ml:877:18>>*/ width$4 = scan_hexadecimal_int(width$3, ib),
+      _ax_ = 0 === width$4 ? 1 : 0,
+      _ay_ = _ax_ || end_of_input(ib);
+      /*<<scanf.ml:878:22>>*/ if(_ay_)  /*<<scanf.ml:878:52>>*/ bad_float(0);
+      /*<<scanf.ml:879:24>>*/ var
+       /*<<scanf.ml:879:24>>*/ c$1 = peek_char(ib),
+       /*<<scanf.ml:879:24>>*/ switcher = c$1 - 80 | 0;
+     a:
+     {
+      b:
+      {
+       if(32 < switcher >>> 0){
+        if(-34 === switcher){
+          /*<<scanf.ml:881:22>>*/  /*<<scanf.ml:881:22>>*/ var
+          width$5 = store_char(width$4, ib, c$1);
+         c:
+         {
+           /*<<scanf.ml:882:26>>*/ if(0 !== width$5 && ! end_of_input(ib)){
+            /*<<scanf.ml:883:18>>*/  /*<<scanf.ml:883:18>>*/ var
+            match = peek_char(ib);
+           d:
+           {
+            if(80 !== match && 112 !== match){
+              /*<<scanf.ml:886:30>>*/ var
+               /*<<scanf.ml:886:30>>*/ precision$0 =
+                 /*<<scanf.ml:886:30>>*/ caml_call2
+                 (Stdlib_Int[10], width$5, precision),
+              width$10 =
+                width$5
+                - (precision$0 - scan_hexadecimal_int(precision$0, ib) | 0)
+                | 0;
+             break d;
+            }
+            var width$10 = width$5;
+           }
+           var width$6 = width$10;
+           break c;
+          }
+          var width$6 = width$5;
+         }
+         var width$7 = width$6;
+         break b;
+        }
+       }
+       else if(30 < switcher - 1 >>> 0){var width$7 = width$4; break b;}
+       var width$8 = bad_float(0);
+       break a;
+      }
+      var width$8 = width$7;
+     }
+      /*<<scanf.ml:891:22>>*/ if(0 !== width$8 && ! end_of_input(ib)){
+       /*<<scanf.ml:892:14>>*/  /*<<scanf.ml:892:14>>*/ var
+       c$2 = peek_char(ib);
+      if(80 !== c$2 && 112 !== c$2)  /*<<scanf.ml:897:15>>*/ return width$8;
+       /*<<scanf.ml:894:22>>*/ var
+        /*<<scanf.ml:894:22>>*/ width$9 = store_char(width$8, ib, c$2),
+       _az_ = 0 === width$9 ? 1 : 0,
+       _aA_ = _az_ || end_of_input(ib);
+       /*<<scanf.ml:895:26>>*/ if(_aA_)
+        /*<<scanf.ml:895:56>>*/ bad_hex_float(0);
+       /*<<scanf.ml:895:56>>*/ return scan_optionally_signed_decimal
+              (width$9, ib);
+     }
+      /*<<scanf.ml:891:52>>*/ return width$8;
+    }
+     /*<<scanf.ml:910:9>>*/ return bad_float(0);
+    /*<<scanf.ml:910:21>>*/ }
+   function scan_string(stp, width, ib){
+     /*<<scanf.ml:920:2>>*/ var width$0 = width;
+     /*<<scanf.ml:921:4>>*/ for(;;){
+     if(0 === width$0)  /*<<scanf.ml:921:22>>*/ return width$0;
+      /*<<scanf.ml:922:12>>*/  /*<<scanf.ml:922:12>>*/ var c = peek_char(ib);
+      /*<<scanf.ml:923:7>>*/ if(ib[1])
+       /*<<scanf.ml:923:28>>*/ return width$0;
+     if(! stp){
+       /*<<scanf.ml:928:8>>*/  /*<<scanf.ml:928:8>>*/ var _am_ = c - 9 | 0;
+      a:
+      {
+       if(4 < _am_ >>> 0){
+        if(23 === _am_) break a;
+       }
+       else if(1 < _am_ - 2 >>> 0) break a;
+        /*<<scanf.ml:930:20>>*/ var
+         /*<<scanf.ml:930:20>>*/ width$2 = store_char(width$0, ib, c),
+        width$0 = width$2;
+       continue;
+      }
+       /*<<scanf.ml:929:38>>*/ return width$0;
+     }
+     var c$0 = stp[1];
+     if(c === c$0)  /*<<scanf.ml:920:2>>*/ return skip_char(width$0, ib);
+      /*<<scanf.ml:926:23>>*/ var
+       /*<<scanf.ml:926:23>>*/ width$1 = store_char(width$0, ib, c),
+      width$0 = width$1;
+    }
+    /*<<scanf.ml:931:12>>*/ }
+   function hexadecimal_value_of_char(c){
+     /*<<scanf.ml:969:2>>*/ return 97 <= c
+            ? c - 87 | 0
+            : 65 <= c ? c - 55 | 0 : c - 48 | 0;
+    /*<<scanf.ml:979:23>>*/ }
+   function check_next_char(message, width, ib){
+     /*<<scanf.ml:995:2>>*/ if(0 === width)
+      /*<<scanf.ml:995:20>>*/ return bad_token_length(message);
+     /*<<scanf.ml:996:10>>*/  /*<<scanf.ml:996:10>>*/ var c = peek_char(ib);
+     /*<<scanf.ml:997:5>>*/ return ib[1]
+            ? bad_input
+              ( /*<<scanf.ml:421:4>>*/ caml_call2
+                (Stdlib_Printf[4], _f_, message))
+            : c;
+    /*<<scanf.ml:998:3>>*/ }
+    /*<<scanf.ml:1001:31>>*/ function check_next_char_for_char(_ak_, _al_){
+     /*<<?>>*/ return check_next_char(cst_a_Char, _ak_, _al_);
+   }
+    /*<<scanf.ml:1002:33>>*/ function check_next_char_for_string(_ai_, _aj_){
+     /*<<?>>*/ return check_next_char(cst_a_String, _ai_, _aj_);
+   }
+   function scan_backslash_char(width, ib){
+     /*<<scanf.ml:1005:2>>*/  /*<<scanf.ml:1005:8>>*/ var
+     c0 = check_next_char_for_char(width, ib);
+    a:
+    {
+     if(40 <= c0){
+      if(58 > c0){
+       if(48 > c0) break a;
+        /*<<scanf.ml:1015:13>>*/ var
+        get_digit$0 =
+          function(param){
+            /*<<scanf.ml:1010:6>>*/  /*<<scanf.ml:1010:14>>*/ var
+            c = next_char(ib);
+           return 9 < c - 48 >>> 0 ? bad_input_escape(c) : c;
+           /*<<scanf.ml:1013:31>>*/ },
+         /*<<scanf.ml:1015:13>>*/ c1$0 = get_digit$0(0),
+         /*<<scanf.ml:1016:13>>*/ c2$0 = get_digit$0(0),
+        c =
+          ((100 * (c0 - 48 | 0) | 0) + (10 * (c1$0 - 48 | 0) | 0) | 0)
+          + (c2$0 - 48 | 0)
+          | 0;
+       b:
+       {
+        if(0 <= c && 255 >= c){
+         var _ag_ =  /*<<scanf.ml:963:2>>*/ caml_call1(Stdlib[29], c);
+         break b;
+        }
+        var
+         _ag_ =
+           bad_input
+            ( /*<<scanf.ml:961:6>>*/ caml_call4
+              (Stdlib_Printf[4], _l_, c0, c1$0, c2$0));
+       }
+        /*<<scanf.ml:1017:39>>*/ return store_char(width - 2 | 0, ib, _ag_);
+      }
+       /*<<scanf.ml:1005:8>>*/  /*<<scanf.ml:1005:8>>*/ var
+       switcher = c0 - 92 | 0;
+      if(28 < switcher >>> 0) break a;
+      switch(switcher){
+        case 28:
+          /*<<scanf.ml:1024:13>>*/ var
+          get_digit =
+            function(param){
+              /*<<scanf.ml:1020:6>>*/ var
+               /*<<scanf.ml:1020:14>>*/ c = next_char(ib),
+               /*<<scanf.ml:1020:14>>*/ _ah_ = c - 48 | 0;
+             a:
+             {
+              if(22 < _ah_ >>> 0){
+               if(5 < _ah_ - 49 >>> 0) break a;
+              }
+              else if(6 >= _ah_ - 10 >>> 0) break a;
+               /*<<scanf.ml:1022:53>>*/ return c;
+             }
+              /*<<scanf.ml:1023:13>>*/ return bad_input_escape(c);
+             /*<<scanf.ml:1023:31>>*/ },
+           /*<<scanf.ml:1024:13>>*/ c1 = get_digit(0),
+           /*<<scanf.ml:1025:13>>*/ c2 = get_digit(0),
+           /*<<scanf.ml:985:9>>*/ _ad_ = hexadecimal_value_of_char(c2),
+          c$0 = (16 * hexadecimal_value_of_char(c1) | 0) + _ad_ | 0;
+         b:
+         {
+          if(0 <= c$0 && 255 >= c$0){
+           var _af_ =  /*<<scanf.ml:989:2>>*/ caml_call1(Stdlib[29], c$0);
+           break b;
+          }
+          var
+           _af_ =
+             bad_input
+              ( /*<<scanf.ml:988:6>>*/ caml_call3
+                (Stdlib_Printf[4], _m_, c1, c2));
+         }
+          /*<<scanf.ml:1026:39>>*/ return store_char(width - 2 | 0, ib, _af_);
+        case 0:
+        case 6:
+        case 18:
+        case 22:
+        case 24: break;
+        default: break a;
+      }
+     }
+     else if(34 !== c0 && 39 > c0) break a;
+     b:
+     {
+      if(110 <= c0){
+       if(117 > c0)
+        switch(c0 - 110 | 0){
+          case 0:
+           var _ae_ = 10; break b;
+          case 4:
+           var _ae_ = 13; break b;
+          case 6:
+           var _ae_ = 9; break b;
+        }
+      }
+      else if(98 === c0){var _ae_ = 8; break b;}
+      var _ae_ = c0;
+     }
+      /*<<scanf.ml:1007:33>>*/ return store_char(width, ib, _ae_);
+    }
+     /*<<scanf.ml:1028:4>>*/ return bad_input_escape(c0);
+    /*<<scanf.ml:1028:22>>*/ }
+   function scan_caml_string(width, ib){
+    function find_stop$0(counter, width){
+      /*<<scanf.ml:1063:4>>*/ var width$0 = width;
+      /*<<scanf.ml:1063:4>>*/ for(;;){
+       /*<<scanf.ml:1063:10>>*/  /*<<scanf.ml:1063:10>>*/ var
+       c = check_next_char_for_string(width$0, ib);
+      if(34 === c)  /*<<scanf.ml:1057:2>>*/ return ignore_char(width$0, ib);
+      if(92 === c){
+        /*<<scanf.ml:1065:29>>*/ var
+         /*<<scanf.ml:1065:29>>*/ width$1 = ignore_char(width$0, ib),
+         /*<<scanf.ml:1069:10>>*/ match =
+          check_next_char_for_string(width$1, ib);
+       if(10 === match){
+         /*<<scanf.ml:1071:26>>*/  /*<<scanf.ml:1071:26>>*/ var
+         _ab_ = ignore_char(width$1, ib);
+         /*<<scanf.ml:1071:26>>*/ if(counter >= 50)
+          /*<<scanf.ml:1071:26>>*/ return  /*<<scanf.ml:1071:26>>*/ caml_trampoline_return
+                 (skip_spaces, [0, _ab_]);
+        var counter$0 = counter + 1 | 0;
+         /*<<scanf.ml:1071:26>>*/ return skip_spaces(counter$0, _ab_);
+       }
+       if(13 === match){
+         /*<<scanf.ml:1070:27>>*/  /*<<scanf.ml:1070:27>>*/ var
+         width$3 = ignore_char(width$1, ib);
+        if(10 === check_next_char_for_string(width$3, ib)){
+          /*<<scanf.ml:1076:26>>*/  /*<<scanf.ml:1076:26>>*/ var
+          _ac_ = ignore_char(width$3, ib);
+          /*<<scanf.ml:1076:26>>*/ if(counter >= 50)
+           /*<<scanf.ml:1076:26>>*/ return  /*<<scanf.ml:1076:26>>*/ caml_trampoline_return
+                  (skip_spaces, [0, _ac_]);
+         var counter$1 = counter + 1 | 0;
+          /*<<scanf.ml:1076:26>>*/ return skip_spaces(counter$1, _ac_);
+        }
+         /*<<scanf.ml:1077:21>>*/ var
+          /*<<scanf.ml:1077:21>>*/ width$5 = store_char(width$3, ib, 13),
+         width$0 = width$5;
+       }
+       else
+         /*<<scanf.ml:1072:21>>*/ var
+          /*<<scanf.ml:1072:21>>*/ width$4 = scan_backslash_char(width$1, ib),
+         width$0 = width$4;
+      }
+      else
+        /*<<scanf.ml:1066:21>>*/ var
+         /*<<scanf.ml:1066:21>>*/ width$2 = store_char(width$0, ib, c),
+        width$0 = width$2;
+     }
+     /*<<scanf.ml:1066:53>>*/ }
+    function skip_spaces(counter, width){
+      /*<<scanf.ml:1080:4>>*/ var width$0 = width;
+      /*<<scanf.ml:1080:4>>*/ for(;;){
+      if(32 !== check_next_char_for_string(width$0, ib)){
+        /*<<scanf.ml:1082:11>>*/ if(counter >= 50)
+         /*<<scanf.ml:1082:11>>*/ return  /*<<scanf.ml:1082:11>>*/ caml_trampoline_return
+                (find_stop$0, [0, width$0]);
+       var counter$0 = counter + 1 | 0;
+        /*<<scanf.ml:1082:11>>*/ return find_stop$0(counter$0, width$0);
+      }
+       /*<<scanf.ml:1081:25>>*/ var
+        /*<<scanf.ml:1081:25>>*/ width$1 = ignore_char(width$0, ib),
+       width$0 = width$1;
+     }
+     /*<<scanf.ml:1082:26>>*/ }
+    function find_stop(width){
+      /*<<?>>*/ return caml_trampoline(find_stop$0(0, width));
+    }
+     /*<<scanf.ml:1058:10>>*/  /*<<scanf.ml:1058:10>>*/ var
+     c = checked_peek_char(ib);
+    return 34 === c
+            ? find_stop(ignore_char(width, ib))
+            : character_mismatch(34, c);
+    /*<<scanf.ml:1084:18>>*/ }
+   function scan_chars_in_char_set(char_set, scan_indic, width, ib){
+    function scan_chars(i, stp){
+      /*<<scanf.ml:1104:4>>*/ var i$0 = i;
+      /*<<scanf.ml:1104:4>>*/ for(;;){
+       /*<<scanf.ml:1104:12>>*/ var
+        /*<<scanf.ml:1104:12>>*/ c = peek_char(ib),
+       _Z_ = 0 < i$0 ? 1 : 0;
+      if(_Z_){
+        /*<<scanf.ml:1105:20>>*/  /*<<scanf.ml:1105:20>>*/ var
+        ___ = 1 - ib[1];
+       if(___)
+         /*<<scanf.ml:1106:7>>*/ var
+          /*<<scanf.ml:1106:7>>*/ _$_ =
+            /*<<scanf.ml:1106:7>>*/ caml_call2
+            (CamlinternalFormat[1], char_set, c),
+          /*<<scanf.ml:1106:7>>*/ _aa_ = _$_ ? c !== stp ? 1 : 0 : _$_;
+       else
+        var _aa_ = ___;
+      }
+      else
+       var _aa_ = _Z_;
+      if(! _aa_) return _aa_;
+       /*<<scanf.ml:1108:14>>*/ store_char(Stdlib[19], ib, c);
+      var i$1 = i$0 - 1 | 0, i$0 = i$1;
+     }
+     /*<<scanf.ml:1109:28>>*/ }
+    if(! scan_indic)  /*<<scanf.ml:1111:12>>*/ return scan_chars(width, -1);
+    var c = scan_indic[1];
+     /*<<scanf.ml:1113:4>>*/ scan_chars(width, c);
+     /*<<scanf.ml:1114:11>>*/  /*<<scanf.ml:1114:11>>*/ var _Y_ = 1 - ib[1];
+    if(! _Y_)  /*<<scanf.ml:1114:11>>*/ return _Y_;
+     /*<<scanf.ml:1115:15>>*/  /*<<scanf.ml:1115:15>>*/ var
+     ci = peek_char(ib);
+    return c === ci ? invalidate_current_char(ib) : character_mismatch(c, ci);
+    /*<<scanf.ml:1118:34>>*/ }
+   function scanf_bad_input(ib, x){
+     /*<<?>>*/ if(x[1] === Scan_failure)
+     var s = x[2];
+    else{
+     if(x[1] !== Stdlib[7])
+       /*<<scanf.ml:1126:9>>*/ throw  /*<<scanf.ml:1126:9>>*/ caml_maybe_attach_backtrace
+             (x, 1);
+     var s = x[2];
+    }
+     /*<<scanf.ml:1124:12>>*/  /*<<scanf.ml:1124:12>>*/ var
+     i = char_count(ib);
+     /*<<scanf.ml:1125:14>>*/ return bad_input
+            ( /*<<scanf.ml:1125:14>>*/ caml_call3(Stdlib_Printf[4], _o_, i, s));
+   }
+   function width_of_pad_opt(pad_opt){
+     /*<<scanf.ml:1138:31>>*/ if(! pad_opt)
+      /*<<scanf.ml:1139:12>>*/ return Stdlib[19];
+    var width = pad_opt[1];
+     /*<<scanf.ml:1140:18>>*/ return width;
+    /*<<scanf.ml:1140:23>>*/ }
+   function stopper_of_formatting_lit(fmting){
+     /*<<scanf.ml:1144:2>>*/ if(6 === fmting)
+      /*<<scanf.ml:1144:35>>*/ return _p_;
+     /*<<scanf.ml:1145:14>>*/ var
+      /*<<scanf.ml:1145:14>>*/ str =
+        /*<<scanf.ml:1145:14>>*/ caml_call1(CamlinternalFormat[17], fmting),
+      /*<<scanf.ml:1146:14>>*/ stp =
+        /*<<scanf.ml:1146:14>>*/ caml_string_get(str, 1),
+      /*<<scanf.ml:1147:18>>*/ sub_str =
+        /*<<scanf.ml:1147:18>>*/ caml_call3
+        (Stdlib_String[15],
+         str,
+         2,
+          /*<<scanf.ml:1147:4>>*/ caml_ml_string_length(str) - 2 | 0);
+     /*<<scanf.ml:1148:4>>*/ return [0, stp, sub_str];
+    /*<<scanf.ml:1148:16>>*/ }
+   function take_format_readers$0(counter, k, fmt){
+     /*<<scanf.ml:1161:13>>*/ var fmt$0 = fmt;
+     /*<<scanf.ml:1161:13>>*/ for(;;){
+     if(typeof fmt$0 === "number")
+       /*<<scanf.ml:1198:40>>*/ return  /*<<scanf.ml:1198:40>>*/ caml_call1
+              (k, 0);
+     switch(fmt$0[0]){
+       case 0:
+        var rest = fmt$0[1], fmt$0 = rest; break;
+       case 1:
+        var rest$0 = fmt$0[1], fmt$0 = rest$0; break;
+       case 2:
+        var rest$1 = fmt$0[2], fmt$0 = rest$1; break;
+       case 3:
+        var rest$2 = fmt$0[2], fmt$0 = rest$2; break;
+       case 4:
+        var rest$3 = fmt$0[4], fmt$0 = rest$3; break;
+       case 5:
+        var rest$4 = fmt$0[4], fmt$0 = rest$4; break;
+       case 6:
+        var rest$5 = fmt$0[4], fmt$0 = rest$5; break;
+       case 7:
+        var rest$6 = fmt$0[4], fmt$0 = rest$6; break;
+       case 8:
+        var rest$7 = fmt$0[4], fmt$0 = rest$7; break;
+       case 9:
+        var rest$8 = fmt$0[2], fmt$0 = rest$8; break;
+       case 10:
+        var rest$9 = fmt$0[1], fmt$0 = rest$9; break;
+       case 11:
+        var rest$10 = fmt$0[2], fmt$0 = rest$10; break;
+       case 12:
+        var rest$11 = fmt$0[2], fmt$0 = rest$11; break;
+       case 13:
+        var rest$12 = fmt$0[3], fmt$0 = rest$12; break;
+       case 14:
+         /*<<scanf.ml:1195:44>>*/ var
+         rest$13 = fmt$0[3],
+         fmtty = fmt$0[2],
+          /*<<scanf.ml:1195:44>>*/ _V_ =
+            /*<<scanf.ml:1195:44>>*/ caml_call1(CamlinternalFormat[21], fmtty),
+          /*<<scanf.ml:1195:33>>*/ _W_ =
+            /*<<scanf.ml:1195:33>>*/ caml_call1
+            (CamlinternalFormatBasics[2], _V_);
+         /*<<scanf.ml:1195:5>>*/ if(counter >= 50)
+          /*<<scanf.ml:1195:5>>*/ return  /*<<scanf.ml:1195:5>>*/ caml_trampoline_return
+                 (take_fmtty_format_readers$0, [0, k, _W_, rest$13]);
+        var counter$0 = counter + 1 | 0;
+         /*<<scanf.ml:1195:5>>*/ return take_fmtty_format_readers$0
+                (counter$0, k, _W_, rest$13);
+       case 15:
+        var rest$14 = fmt$0[1], fmt$0 = rest$14; break;
+       case 16:
+        var rest$15 = fmt$0[1], fmt$0 = rest$15; break;
+       case 17:
+        var rest$16 = fmt$0[2], fmt$0 = rest$16; break;
+       case 18:
+        var _X_ = fmt$0[1];
+        if(0 === _X_[0])
+          /*<<scanf.ml:1189:28>>*/ var
+          rest$17 = fmt$0[2],
+          fmt$1 = _X_[1][1],
+           /*<<scanf.ml:1189:28>>*/ fmt$2 =
+             /*<<scanf.ml:1189:28>>*/ caml_call2
+             (CamlinternalFormatBasics[3], fmt$1, rest$17),
+          fmt$0 = fmt$2;
+        else
+          /*<<scanf.ml:1191:28>>*/ var
+          rest$18 = fmt$0[2],
+          fmt$3 = _X_[1][1],
+           /*<<scanf.ml:1191:28>>*/ fmt$4 =
+             /*<<scanf.ml:1191:28>>*/ caml_call2
+             (CamlinternalFormatBasics[3], fmt$3, rest$18),
+          fmt$0 = fmt$4;
+        break;
+       case 19:
+        var fmt_rest = fmt$0[1];
+         /*<<scanf.ml:1163:4>>*/ return function(reader){
+         function new_k(readers_rest){
+           /*<<scanf.ml:1164:31>>*/ return  /*<<scanf.ml:1164:33>>*/ caml_call1
+                  (k, [0, reader, readers_rest]);
+          /*<<scanf.ml:1164:62>>*/ }
+          /*<<scanf.ml:1165:6>>*/ return take_format_readers(new_k, fmt_rest); /*<<scanf.ml:1165:40>>*/ };
+       case 20:
+        var rest$19 = fmt$0[3], fmt$0 = rest$19; break;
+       case 21:
+        var rest$20 = fmt$0[2], fmt$0 = rest$20; break;
+       case 22:
+        var rest$21 = fmt$0[1], fmt$0 = rest$21; break;
+       case 23:
+        var rest$22 = fmt$0[2], ign = fmt$0[1];
+        if(typeof ign === "number")
+         switch(ign){
+           case 0:
+            var fmt$0 = rest$22; break;
+           case 1:
+            var fmt$0 = rest$22; break;
+           case 2:
+             /*<<scanf.ml:1236:4>>*/ return function(reader){
+             function new_k(readers_rest){
+               /*<<scanf.ml:1237:31>>*/ return  /*<<scanf.ml:1237:33>>*/ caml_call1
+                      (k, [0, reader, readers_rest]);
+              /*<<scanf.ml:1237:62>>*/ }
+              /*<<scanf.ml:1238:6>>*/ return take_format_readers
+                     (new_k, rest$22); /*<<scanf.ml:1238:35>>*/ };
+           default: var fmt$0 = rest$22;
+         }
+        else
+         switch(ign[0]){
+           case 0:
+            var fmt$0 = rest$22; break;
+           case 1:
+            var fmt$0 = rest$22; break;
+           case 2:
+            var fmt$0 = rest$22; break;
+           case 3:
+            var fmt$0 = rest$22; break;
+           case 4:
+            var fmt$0 = rest$22; break;
+           case 5:
+            var fmt$0 = rest$22; break;
+           case 6:
+            var fmt$0 = rest$22; break;
+           case 7:
+            var fmt$0 = rest$22; break;
+           case 8:
+            var fmt$0 = rest$22; break;
+           case 9:
+            var fmtty$0 = ign[2];
+             /*<<scanf.ml:1250:39>>*/ if(counter >= 50)
+              /*<<scanf.ml:1250:39>>*/ return  /*<<scanf.ml:1250:39>>*/ caml_trampoline_return
+                     (take_fmtty_format_readers$0, [0, k, fmtty$0, rest$22]);
+            var counter$1 = counter + 1 | 0;
+             /*<<scanf.ml:1250:39>>*/ return take_fmtty_format_readers$0
+                    (counter$1, k, fmtty$0, rest$22);
+           case 10:
+            var fmt$0 = rest$22; break;
+           default: var fmt$0 = rest$22;
+         }
+        break;
+       default: var rest$23 = fmt$0[3], fmt$0 = rest$23;
+     }
+    }
+    /*<<scanf.ml:1198:45>>*/ }
+   function take_fmtty_format_readers$0(counter, k, fmtty, fmt){
+     /*<<scanf.ml:1204:19>>*/ var fmtty$0 = fmtty;
+     /*<<scanf.ml:1204:19>>*/ for(;;){
+     if(typeof fmtty$0 === "number"){
+       /*<<scanf.ml:1225:35>>*/ if(counter >= 50)
+        /*<<scanf.ml:1225:35>>*/ return  /*<<scanf.ml:1225:35>>*/ caml_trampoline_return
+               (take_format_readers$0, [0, k, fmt]);
+      var counter$0 = counter + 1 | 0;
+       /*<<scanf.ml:1225:35>>*/ return take_format_readers$0
+              (counter$0, k, fmt);
+     }
+     switch(fmtty$0[0]){
+       case 0:
+        var fmtty$1 = fmtty$0[1], fmtty$0 = fmtty$1; break;
+       case 1:
+        var fmtty$2 = fmtty$0[1], fmtty$0 = fmtty$2; break;
+       case 2:
+        var fmtty$3 = fmtty$0[1], fmtty$0 = fmtty$3; break;
+       case 3:
+        var fmtty$4 = fmtty$0[1], fmtty$0 = fmtty$4; break;
+       case 4:
+        var fmtty$5 = fmtty$0[1], fmtty$0 = fmtty$5; break;
+       case 5:
+        var fmtty$6 = fmtty$0[1], fmtty$0 = fmtty$6; break;
+       case 6:
+        var fmtty$7 = fmtty$0[1], fmtty$0 = fmtty$7; break;
+       case 7:
+        var fmtty$8 = fmtty$0[1], fmtty$0 = fmtty$8; break;
+       case 8:
+        var fmtty$9 = fmtty$0[2], fmtty$0 = fmtty$9; break;
+       case 9:
+         /*<<scanf.ml:1227:19>>*/ var
+         rest = fmtty$0[3],
+         ty2 = fmtty$0[2],
+         ty1 = fmtty$0[1],
+          /*<<scanf.ml:1227:19>>*/ _U_ =
+            /*<<scanf.ml:1227:19>>*/ caml_call1(CamlinternalFormat[21], ty1),
+          /*<<scanf.ml:1227:13>>*/ ty =
+            /*<<scanf.ml:1227:13>>*/ caml_call2
+            (CamlinternalFormat[22], _U_, ty2),
+          /*<<scanf.ml:1228:32>>*/ fmtty$10 =
+            /*<<scanf.ml:1228:32>>*/ caml_call2
+            (CamlinternalFormatBasics[1], ty, rest),
+         fmtty$0 = fmtty$10;
+        break;
+       case 10:
+        var fmtty$11 = fmtty$0[1], fmtty$0 = fmtty$11; break;
+       case 11:
+        var fmtty$12 = fmtty$0[1], fmtty$0 = fmtty$12; break;
+       case 12:
+        var fmtty$13 = fmtty$0[1], fmtty$0 = fmtty$13; break;
+       case 13:
+        var fmt_rest = fmtty$0[1];
+         /*<<scanf.ml:1206:4>>*/ return function(reader){
+         function new_k(readers_rest){
+           /*<<scanf.ml:1207:31>>*/ return  /*<<scanf.ml:1207:33>>*/ caml_call1
+                  (k, [0, reader, readers_rest]);
+          /*<<scanf.ml:1207:62>>*/ }
+          /*<<scanf.ml:1208:6>>*/ return take_fmtty_format_readers
+                 (new_k, fmt_rest, fmt); /*<<scanf.ml:1208:50>>*/ };
+       default:
+        var fmt_rest$0 = fmtty$0[1];
+         /*<<scanf.ml:1210:4>>*/ return function(reader){
+         function new_k(readers_rest){
+           /*<<scanf.ml:1211:31>>*/ return  /*<<scanf.ml:1211:33>>*/ caml_call1
+                  (k, [0, reader, readers_rest]);
+          /*<<scanf.ml:1211:62>>*/ }
+          /*<<scanf.ml:1212:6>>*/ return take_fmtty_format_readers
+                 (new_k, fmt_rest$0, fmt); /*<<scanf.ml:1212:50>>*/ };
+     }
+    }
+    /*<<scanf.ml:1228:58>>*/ }
+   function take_format_readers(k, fmt){
+     /*<<?>>*/ return caml_trampoline(take_format_readers$0(0, k, fmt));
+   }
+   function take_fmtty_format_readers(k, fmtty, fmt){
+     /*<<?>>*/ return caml_trampoline
+            (take_fmtty_format_readers$0(0, k, fmtty, fmt));
+   }
+   function pad_prec_scanf(ib, fmt, readers, pad, prec, scan, token){
+     /*<<scanf.ml:1429:42>>*/ if(typeof pad === "number"){
+     if(typeof prec !== "number"){
+      var p = prec[1];
+       /*<<scanf.ml:1435:12>>*/  /*<<scanf.ml:1435:12>>*/ caml_call3
+       (scan, Stdlib[19], p, ib);
+       /*<<scanf.ml:1436:12>>*/  /*<<scanf.ml:1436:12>>*/ var
+       x$0 =  /*<<scanf.ml:1436:12>>*/ caml_call1(token, ib);
+       /*<<scanf.ml:1437:4>>*/ return [0, x$0, make_scanf(ib, fmt, readers)];
+     }
+     if(prec)
+       /*<<scanf.ml:1453:4>>*/ return  /*<<scanf.ml:1453:4>>*/ caml_call1
+              (Stdlib[1], cst_scanf_bad_conversion);
+      /*<<scanf.ml:1431:12>>*/  /*<<scanf.ml:1431:12>>*/ caml_call3
+      (scan, Stdlib[19], Stdlib[19], ib);
+      /*<<scanf.ml:1432:12>>*/  /*<<scanf.ml:1432:12>>*/ var
+      x =  /*<<scanf.ml:1432:12>>*/ caml_call1(token, ib);
+      /*<<scanf.ml:1433:4>>*/ return [0, x, make_scanf(ib, fmt, readers)];
+    }
+    if(0 !== pad[0])
+      /*<<scanf.ml:1451:4>>*/ return  /*<<scanf.ml:1451:4>>*/ caml_call1
+             (Stdlib[1], cst_scanf_bad_conversion$2);
+    if(! pad[1])
+      /*<<scanf.ml:1447:4>>*/ return  /*<<scanf.ml:1447:4>>*/ caml_call1
+             (Stdlib[1], cst_scanf_bad_conversion$1);
+    var w = pad[2];
+    if(typeof prec !== "number"){
+     var p$0 = prec[1];
+      /*<<scanf.ml:1443:12>>*/  /*<<scanf.ml:1443:12>>*/ caml_call3
+      (scan, w, p$0, ib);
+      /*<<scanf.ml:1444:12>>*/  /*<<scanf.ml:1444:12>>*/ var
+      x$2 =  /*<<scanf.ml:1444:12>>*/ caml_call1(token, ib);
+      /*<<scanf.ml:1445:4>>*/ return [0, x$2, make_scanf(ib, fmt, readers)];
+    }
+    if(prec)
+      /*<<scanf.ml:1449:4>>*/ return  /*<<scanf.ml:1449:4>>*/ caml_call1
+             (Stdlib[1], cst_scanf_bad_conversion$0);
+     /*<<scanf.ml:1439:12>>*/  /*<<scanf.ml:1439:12>>*/ caml_call3
+     (scan, w, Stdlib[19], ib);
+     /*<<scanf.ml:1440:12>>*/  /*<<scanf.ml:1440:12>>*/ var
+     x$1 =  /*<<scanf.ml:1440:12>>*/ caml_call1(token, ib);
+     /*<<scanf.ml:1441:4>>*/ return [0, x$1, make_scanf(ib, fmt, readers)];
+    /*<<scanf.ml:1453:46>>*/ }
+   function make_scanf(ib, fmt, readers){
+     /*<<scanf.ml:1266:22>>*/ var fmt$0 = fmt;
+     /*<<scanf.ml:1266:22>>*/ for(;;){
+     if(typeof fmt$0 === "number")  /*<<scanf.ml:1418:4>>*/ return 0;
+     switch(fmt$0[0]){
+       case 0:
+        var rest = fmt$0[1];
+         /*<<scanf.ml:939:31>>*/ store_char(0, ib, checked_peek_char(ib));
+         /*<<scanf.ml:1269:12>>*/  /*<<scanf.ml:1269:12>>*/ var
+         c$1 = token_char(ib);
+         /*<<scanf.ml:1270:4>>*/ return [0,
+                c$1,
+                make_scanf(ib, rest, readers)];
+       case 1:
+         /*<<scanf.ml:1272:4>>*/ var
+         rest$0 = fmt$0[1],
+          /*<<scanf.ml:1272:4>>*/ width$0 = 0,
+         find_stop =
+           function(width){
+             /*<<scanf.ml:1047:4>>*/  /*<<scanf.ml:1047:10>>*/ var
+             c = check_next_char_for_char(width, ib);
+            return 39 === c
+                    ? ignore_char(width, ib)
+                    : character_mismatch(39, c);
+            /*<<scanf.ml:1049:36>>*/ },
+          /*<<scanf.ml:1035:10>>*/ c = checked_peek_char(ib);
+        if(39 === c){
+          /*<<scanf.ml:1036:24>>*/ var
+           /*<<scanf.ml:1036:24>>*/ width = ignore_char(width$0, ib),
+           /*<<scanf.ml:1040:10>>*/ c$0 = check_next_char_for_char(width, ib);
+         if(92 === c$0)
+           /*<<scanf.ml:1042:16>>*/ find_stop
+           (scan_backslash_char(ignore_char(width, ib), ib));
+         else
+           /*<<scanf.ml:1044:16>>*/ find_stop(store_char(width, ib, c$0));
+        }
+        else
+          /*<<scanf.ml:1037:11>>*/ character_mismatch(39, c);
+         /*<<scanf.ml:1273:12>>*/  /*<<scanf.ml:1273:12>>*/ var
+         c$2 = token_char(ib);
+         /*<<scanf.ml:1274:4>>*/ return [0,
+                c$2,
+                make_scanf(ib, rest$0, readers)];
+       case 2:
+        var pad = fmt$0[1], match = fmt$0[2];
+        if(typeof match !== "number")
+         switch(match[0]){
+           case 17:
+             /*<<scanf.ml:1277:19>>*/ var
+             rest$2 = match[2],
+             fmting_lit = match[1],
+              /*<<scanf.ml:1277:19>>*/ match$0 =
+               stopper_of_formatting_lit(fmting_lit),
+             str = match$0[2],
+             stp = match$0[1],
+             scan$0 =
+               function(width, param, ib){
+                 /*<<scanf.ml:1278:26>>*/ return scan_string
+                        ([0, stp], width, ib);
+                /*<<scanf.ml:1278:57>>*/ },
+              /*<<scanf.ml:1279:19>>*/ str_rest = [11, str, rest$2];
+             /*<<scanf.ml:1280:4>>*/ return pad_prec_scanf
+                    (ib, str_rest, readers, pad, 0, scan$0, token_string);
+           case 18:
+            var _G_ = match[1];
+            if(0 === _G_[0]){
+              /*<<scanf.ml:1282:4>>*/ var
+              rest$3 = match[2],
+              fmt$1 = _G_[1][1],
+               /*<<scanf.ml:1282:4>>*/ scan$1 =
+                function(width, param, ib){
+                  /*<<scanf.ml:1282:26>>*/ return scan_string(_q_, width, ib);
+                 /*<<scanf.ml:1282:57>>*/ };
+              /*<<scanf.ml:1283:4>>*/ return pad_prec_scanf
+                     (ib,
+                       /*<<scanf.ml:1283:22>>*/ caml_call2
+                       (CamlinternalFormatBasics[3], fmt$1, rest$3),
+                      readers,
+                      pad,
+                      0,
+                      scan$1,
+                      token_string);
+            }
+             /*<<scanf.ml:1286:4>>*/ var
+             rest$4 = match[2],
+             fmt$2 = _G_[1][1],
+              /*<<scanf.ml:1286:4>>*/ scan$2 =
+               function(width, param, ib){
+                 /*<<scanf.ml:1286:26>>*/ return scan_string(_r_, width, ib);
+                /*<<scanf.ml:1286:57>>*/ };
+             /*<<scanf.ml:1287:4>>*/ return pad_prec_scanf
+                    (ib,
+                      /*<<scanf.ml:1287:22>>*/ caml_call2
+                      (CamlinternalFormatBasics[3], fmt$2, rest$4),
+                     readers,
+                     pad,
+                     0,
+                     scan$2,
+                     token_string);
+         }
+         /*<<scanf.ml:1290:4>>*/ var
+         rest$1 = fmt$0[2],
+          /*<<scanf.ml:1290:4>>*/ scan =
+           function(width, param, ib){
+             /*<<scanf.ml:1290:26>>*/ return scan_string(0, width, ib);
+            /*<<scanf.ml:1290:51>>*/ };
+         /*<<scanf.ml:1291:4>>*/ return pad_prec_scanf
+                (ib, rest$1, readers, pad, 0, scan, token_string);
+       case 3:
+         /*<<scanf.ml:1294:4>>*/ var
+         rest$5 = fmt$0[2],
+         pad$0 = fmt$0[1],
+          /*<<scanf.ml:1294:4>>*/ scan$3 =
+           function(width, param, ib){
+             /*<<scanf.ml:1294:26>>*/ return scan_caml_string(width, ib);
+            /*<<scanf.ml:1294:51>>*/ };
+         /*<<scanf.ml:1295:4>>*/ return pad_prec_scanf
+                (ib, rest$5, readers, pad$0, 0, scan$3, token_string);
+       case 4:
+         /*<<scanf.ml:1297:12>>*/ var
+         rest$6 = fmt$0[4],
+         prec = fmt$0[3],
+         pad$1 = fmt$0[2],
+         iconv = fmt$0[1],
+          /*<<scanf.ml:1297:12>>*/ conv =
+           integer_conversion_of_char
+            ( /*<<scanf.ml:1297:39>>*/ caml_call1
+              (CamlinternalFormat[16], iconv)),
+         scan$4 =
+           function(width, param, ib){
+             /*<<scanf.ml:1298:26>>*/ return scan_int_conversion
+                    (conv, width, ib);
+            /*<<scanf.ml:1298:56>>*/ };
+         /*<<scanf.ml:1299:49>>*/ return pad_prec_scanf
+                (ib,
+                 rest$6,
+                 readers,
+                 pad$1,
+                 prec,
+                 scan$4,
+                 function(ib){
+                   /*<<scanf.ml:537:24>>*/ return  /*<<scanf.ml:537:24>>*/ caml_int_of_string
+                          (token_int_literal(conv, ib));
+                 });
+       case 5:
+         /*<<scanf.ml:1301:12>>*/ var
+         rest$7 = fmt$0[4],
+         prec$0 = fmt$0[3],
+         pad$2 = fmt$0[2],
+         iconv$0 = fmt$0[1],
+          /*<<scanf.ml:1301:12>>*/ conv$0 =
+           integer_conversion_of_char
+            ( /*<<scanf.ml:1301:39>>*/ caml_call1
+              (CamlinternalFormat[16], iconv$0)),
+         scan$5 =
+           function(width, param, ib){
+             /*<<scanf.ml:1302:26>>*/ return scan_int_conversion
+                    (conv$0, width, ib);
+            /*<<scanf.ml:1302:56>>*/ };
+         /*<<scanf.ml:1303:49>>*/ return pad_prec_scanf
+                (ib,
+                 rest$7,
+                 readers,
+                 pad$2,
+                 prec$0,
+                 scan$5,
+                 function(ib){
+                   /*<<scanf.ml:558:26>>*/ return  /*<<scanf.ml:558:26>>*/ caml_int_of_string
+                          (token_int_literal(conv$0, ib));
+                 });
+       case 6:
+         /*<<scanf.ml:1305:12>>*/ var
+         rest$8 = fmt$0[4],
+         prec$1 = fmt$0[3],
+         pad$3 = fmt$0[2],
+         iconv$1 = fmt$0[1],
+          /*<<scanf.ml:1305:12>>*/ conv$1 =
+           integer_conversion_of_char
+            ( /*<<scanf.ml:1305:39>>*/ caml_call1
+              (CamlinternalFormat[16], iconv$1)),
+         scan$6 =
+           function(width, param, ib){
+             /*<<scanf.ml:1306:26>>*/ return scan_int_conversion
+                    (conv$1, width, ib);
+            /*<<scanf.ml:1306:56>>*/ };
+         /*<<scanf.ml:1307:49>>*/ return pad_prec_scanf
+                (ib,
+                 rest$8,
+                 readers,
+                 pad$3,
+                 prec$1,
+                 scan$6,
+                 function(ib){
+                   /*<<scanf.ml:557:30>>*/ return  /*<<scanf.ml:557:30>>*/ caml_int_of_string
+                          (token_int_literal(conv$1, ib));
+                 });
+       case 7:
+         /*<<scanf.ml:1309:12>>*/ var
+         rest$9 = fmt$0[4],
+         prec$2 = fmt$0[3],
+         pad$4 = fmt$0[2],
+         iconv$2 = fmt$0[1],
+          /*<<scanf.ml:1309:12>>*/ conv$2 =
+           integer_conversion_of_char
+            ( /*<<scanf.ml:1309:39>>*/ caml_call1
+              (CamlinternalFormat[16], iconv$2)),
+         scan$7 =
+           function(width, param, ib){
+             /*<<scanf.ml:1310:26>>*/ return scan_int_conversion
+                    (conv$2, width, ib);
+            /*<<scanf.ml:1310:56>>*/ };
+         /*<<scanf.ml:1311:49>>*/ return pad_prec_scanf
+                (ib,
+                 rest$9,
+                 readers,
+                 pad$4,
+                 prec$2,
+                 scan$7,
+                 function(ib){
+                   /*<<scanf.ml:559:26>>*/ return  /*<<scanf.ml:559:26>>*/ runtime.caml_int64_of_string
+                          (token_int_literal(conv$2, ib));
+                 });
+       case 8:
+        switch(fmt$0[1][2]){
+          case 5:
+          case 8:
+           var rest$11 = fmt$0[4], prec$4 = fmt$0[3], pad$6 = fmt$0[2];
+            /*<<scanf.ml:1313:4>>*/ return pad_prec_scanf
+                   (ib,
+                    rest$11,
+                    readers,
+                    pad$6,
+                    prec$4,
+                    scan_caml_float,
+                    token_float);
+          case 6:
+          case 7:
+           var rest$12 = fmt$0[4], prec$5 = fmt$0[3], pad$7 = fmt$0[2];
+            /*<<scanf.ml:1318:4>>*/ return pad_prec_scanf
+                   (ib,
+                    rest$12,
+                    readers,
+                    pad$7,
+                    prec$5,
+                    scan_hex_float,
+                    token_float);
+          default:
+           var rest$10 = fmt$0[4], prec$3 = fmt$0[3], pad$5 = fmt$0[2];
+            /*<<scanf.ml:1316:4>>*/ return pad_prec_scanf
+                   (ib,
+                    rest$10,
+                    readers,
+                    pad$5,
+                    prec$3,
+                    scan_float,
+                    token_float);
+        }
+       case 9:
+         /*<<scanf.ml:1320:4>>*/ var
+         rest$13 = fmt$0[2],
+         pad$8 = fmt$0[1],
+          /*<<scanf.ml:1320:4>>*/ scan$8 =
+           function(param, _T_, ib){
+             /*<<scanf.ml:1320:22>>*/ var
+              /*<<scanf.ml:1089:10>>*/ c = checked_peek_char(ib),
+              /*<<scanf.ml:1090:2>>*/ m =
+               102 === c
+                ? 5
+                : 116
+                  === c
+                  ? 4
+                  : bad_input
+                    ( /*<<scanf.ml:1096:8>>*/ caml_call2
+                      (Stdlib_Printf[4], _n_, c));
+             /*<<scanf.ml:1097:2>>*/ return scan_string(0, m, ib);
+            /*<<scanf.ml:1320:34>>*/ };
+         /*<<scanf.ml:1321:4>>*/ return pad_prec_scanf
+                (ib, rest$13, readers, pad$8, 0, scan$8, token_bool);
+       case 10:
+        var rest$14 = fmt$0[1];
+         /*<<scanf.ml:1337:7>>*/ if(! end_of_input(ib))
+          /*<<scanf.ml:1338:9>>*/ return bad_input(cst_end_of_input_not_found);
+        var fmt$0 = rest$14;
+        break;
+       case 11:
+         /*<<scanf.ml:1341:16>>*/ var
+         rest$15 = fmt$0[2],
+         str$0 = fmt$0[1],
+          /*<<scanf.ml:1341:16>>*/ _H_ =
+           function(_S_){ /*<<?>>*/ return check_char(ib, _S_);};
+         /*<<scanf.ml:1341:4>>*/  /*<<scanf.ml:1341:4>>*/ caml_call2
+         (Stdlib_String[29], _H_, str$0);
+        var fmt$0 = rest$15;
+        break;
+       case 12:
+        var rest$16 = fmt$0[2], chr = fmt$0[1];
+         /*<<scanf.ml:1344:4>>*/ check_char(ib, chr);
+        var fmt$0 = rest$16;
+        break;
+       case 13:
+        var rest$17 = fmt$0[3], fmtty = fmt$0[2], pad_opt = fmt$0[1];
+         /*<<scanf.ml:1348:12>>*/ scan_caml_string
+         (width_of_pad_opt(pad_opt), ib);
+         /*<<scanf.ml:1349:12>>*/  /*<<scanf.ml:1349:12>>*/ var
+         s = token_string(ib);
+         /*<<scanf.ml:1350:4>>*/ try{
+          /*<<scanf.ml:1351:10>>*/ var
+           /*<<scanf.ml:1351:10>>*/ _I_ =
+             /*<<scanf.ml:1351:10>>*/ caml_call2
+             (CamlinternalFormat[14], s, fmtty),
+          fmt$3 = _I_;
+        }
+        catch(exn$0){
+         var exn = caml_wrap_exception(exn$0);
+         if(exn[1] !== Stdlib[7]) throw caml_maybe_attach_backtrace(exn, 0);
+         var msg = exn[2], fmt$3 = bad_input(msg);
+        }
+         /*<<scanf.ml:1354:4>>*/ return [0,
+                fmt$3,
+                make_scanf(ib, rest$17, readers)];
+       case 14:
+        var rest$18 = fmt$0[3], fmtty$0 = fmt$0[2], pad_opt$0 = fmt$0[1];
+         /*<<scanf.ml:1356:12>>*/ scan_caml_string
+         (width_of_pad_opt(pad_opt$0), ib);
+         /*<<scanf.ml:1357:12>>*/  /*<<scanf.ml:1357:12>>*/ var
+         s$0 = token_string(ib);
+        try{
+          /*<<scanf.ml:1375:36>>*/ var
+          fmt$6 =
+             /*<<scanf.ml:1360:26>>*/ caml_call2
+              (CamlinternalFormat[13], 0, s$0)
+             [1],
+          fmt$7 =
+             /*<<scanf.ml:1361:27>>*/ caml_call2
+              (CamlinternalFormat[13], 0, s$0)
+             [1],
+           /*<<scanf.ml:1375:36>>*/ _K_ =
+             /*<<scanf.ml:1375:36>>*/ caml_call1
+             (CamlinternalFormat[21], fmtty$0),
+           /*<<scanf.ml:1375:25>>*/ _L_ =
+             /*<<scanf.ml:1375:25>>*/ caml_call1
+             (CamlinternalFormatBasics[2], _K_),
+           /*<<scanf.ml:1375:8>>*/ fmt$8 =
+             /*<<scanf.ml:1375:8>>*/ caml_call2
+             (CamlinternalFormat[12], fmt$7, _L_),
+           /*<<scanf.ml:1374:24>>*/ _M_ =
+             /*<<scanf.ml:1374:24>>*/ caml_call1
+             (CamlinternalFormatBasics[2], fmtty$0),
+           /*<<scanf.ml:1374:8>>*/ _N_ =
+             /*<<scanf.ml:1374:8>>*/ caml_call2
+             (CamlinternalFormat[12], fmt$6, _M_),
+          fmt$5 = fmt$8,
+          fmt$4 = _N_;
+        }
+        catch(exn){
+         var exn$0 = caml_wrap_exception(exn);
+         if(exn$0[1] !== Stdlib[7])
+          throw caml_maybe_attach_backtrace(exn$0, 0);
+         var
+          msg$0 = exn$0[2],
+          _J_ = bad_input(msg$0),
+          fmt$5 = _J_[2],
+          fmt$4 = _J_[1];
+        }
+         /*<<scanf.ml:1378:4>>*/ return [0,
+                [0, fmt$4, s$0],
+                make_scanf
+                 (ib,
+                   /*<<scanf.ml:1379:24>>*/ caml_call2
+                   (CamlinternalFormatBasics[3], fmt$5, rest$18),
+                  readers)];
+       case 15:
+         /*<<scanf.ml:1323:4>>*/ return  /*<<scanf.ml:1323:4>>*/ caml_call1
+                (Stdlib[1], cst_scanf_bad_conversion_a);
+       case 16:
+         /*<<scanf.ml:1325:4>>*/ return  /*<<scanf.ml:1325:4>>*/ caml_call1
+                (Stdlib[1], cst_scanf_bad_conversion_t);
+       case 17:
+         /*<<scanf.ml:1401:32>>*/ var
+         rest$19 = fmt$0[2],
+         formatting_lit = fmt$0[1],
+          /*<<scanf.ml:1401:32>>*/ _O_ =
+            /*<<scanf.ml:1401:32>>*/ caml_call1
+            (CamlinternalFormat[17], formatting_lit),
+          /*<<scanf.ml:1401:16>>*/ _P_ =
+           function(_R_){ /*<<?>>*/ return check_char(ib, _R_);};
+         /*<<scanf.ml:1401:4>>*/  /*<<scanf.ml:1401:4>>*/ caml_call2
+         (Stdlib_String[29], _P_, _O_);
+        var fmt$0 = rest$19;
+        break;
+       case 18:
+        var _Q_ = fmt$0[1];
+        if(0 === _Q_[0]){
+         var rest$20 = fmt$0[2], fmt$9 = _Q_[1][1];
+          /*<<scanf.ml:1404:4>>*/ check_char(ib, 64);
+          /*<<scanf.ml:1404:23>>*/ check_char(ib, 123);
+          /*<<scanf.ml:1405:18>>*/ var
+           /*<<scanf.ml:1405:18>>*/ fmt$10 =
+             /*<<scanf.ml:1405:18>>*/ caml_call2
+             (CamlinternalFormatBasics[3], fmt$9, rest$20),
+          fmt$0 = fmt$10;
+        }
+        else{
+         var rest$21 = fmt$0[2], fmt$11 = _Q_[1][1];
+          /*<<scanf.ml:1407:4>>*/ check_char(ib, 64);
+          /*<<scanf.ml:1407:23>>*/ check_char(ib, 91);
+          /*<<scanf.ml:1408:18>>*/ var
+           /*<<scanf.ml:1408:18>>*/ fmt$12 =
+             /*<<scanf.ml:1408:18>>*/ caml_call2
+             (CamlinternalFormatBasics[3], fmt$11, rest$21),
+          fmt$0 = fmt$12;
+        }
+        break;
+       case 19:
+        var fmt_rest = fmt$0[1];
+         /*<<scanf.ml:1329:4>>*/ if(! readers)
+          /*<<scanf.ml:1334:8>>*/ return  /*<<scanf.ml:1334:8>>*/ caml_call1
+                 (Stdlib[1], cst_scanf_missing_reader);
+         /*<<scanf.ml:1331:16>>*/ var
+         readers_rest = readers[2],
+         reader = readers[1],
+          /*<<scanf.ml:1331:16>>*/ x =
+            /*<<scanf.ml:1331:16>>*/ caml_call1(reader, ib);
+         /*<<scanf.ml:1332:8>>*/ return [0,
+                x,
+                make_scanf(ib, fmt_rest, readers_rest)];
+       case 20:
+        var width_opt = fmt$0[1], match$1 = fmt$0[3];
+        if(typeof match$1 !== "number" && 17 === match$1[0]){
+          /*<<scanf.ml:1382:19>>*/ var
+          rest$23 = match$1[2],
+          fmting_lit$0 = match$1[1],
+          char_set$0 = fmt$0[2],
+           /*<<scanf.ml:1382:19>>*/ match$2 =
+            stopper_of_formatting_lit(fmting_lit$0),
+          str$1 = match$2[2],
+          stp$0 = match$2[1],
+           /*<<scanf.ml:1383:16>>*/ width$2 = width_of_pad_opt(width_opt);
+          /*<<scanf.ml:1384:4>>*/ scan_chars_in_char_set
+          (char_set$0, [0, stp$0], width$2, ib);
+          /*<<scanf.ml:1385:12>>*/ var
+           /*<<scanf.ml:1385:12>>*/ s$2 = token_string(ib),
+           /*<<scanf.ml:1386:19>>*/ str_rest$0 = [11, str$1, rest$23];
+          /*<<scanf.ml:1387:4>>*/ return [0,
+                 s$2,
+                 make_scanf(ib, str_rest$0, readers)];
+        }
+         /*<<scanf.ml:1389:16>>*/ var
+         rest$22 = fmt$0[3],
+         char_set = fmt$0[2],
+          /*<<scanf.ml:1389:16>>*/ width$1 = width_of_pad_opt(width_opt);
+         /*<<scanf.ml:1390:4>>*/ scan_chars_in_char_set
+         (char_set, 0, width$1, ib);
+         /*<<scanf.ml:1391:12>>*/  /*<<scanf.ml:1391:12>>*/ var
+         s$1 = token_string(ib);
+         /*<<scanf.ml:1392:4>>*/ return [0,
+                s$1,
+                make_scanf(ib, rest$22, readers)];
+       case 21:
+        var rest$24 = fmt$0[2], counter = fmt$0[1];
+        switch(counter){
+          case 0:
+           var count = ib[5]; break;
+          case 1:
+           var count = char_count(ib); break;
+          default: var count = ib[6];
+        }
+         /*<<scanf.ml:1395:4>>*/ return [0,
+                count,
+                make_scanf(ib, rest$24, readers)];
+       case 22:
+         /*<<scanf.ml:1397:12>>*/ var
+         rest$25 = fmt$0[1],
+          /*<<scanf.ml:1397:12>>*/ c$3 = checked_peek_char(ib);
+         /*<<scanf.ml:1398:4>>*/ return [0,
+                c$3,
+                make_scanf(ib, rest$25, readers)];
+       case 23:
+         /*<<scanf.ml:1412:16>>*/ var
+         rest$26 = fmt$0[2],
+         ign = fmt$0[1],
+         fmt$13 =
+            /*<<scanf.ml:1411:32>>*/ caml_call2
+             (CamlinternalFormat[6], ign, rest$26)
+            [1],
+          /*<<scanf.ml:1412:16>>*/ match$3 = make_scanf(ib, fmt$13, readers);
+        if(! match$3)
+          /*<<scanf.ml:1414:13>>*/ throw  /*<<scanf.ml:1414:13>>*/ caml_maybe_attach_backtrace
+                ([0, Assert_failure, _s_], 1);
+        var arg_rest = match$3[2];
+         /*<<scanf.ml:1413:28>>*/ return arg_rest;
+       default:
+         /*<<scanf.ml:1327:4>>*/ return  /*<<scanf.ml:1327:4>>*/ caml_call1
+                (Stdlib[1], cst_scanf_bad_conversion_custo);
+     }
+    }
+    /*<<scanf.ml:1418:7>>*/ }
+   function kscanf_gen(ib, ef, af, param){
+    var str = param[2], fmt = param[1];
+    function k(readers, f$1){
+      /*<<scanf.ml:1465:4>>*/ caml_call1(Stdlib_Buffer[9], ib[8]);
+      /*<<scanf.ml:1465:4>>*/ try{
+       /*<<scanf.ml:1466:10>>*/  /*<<scanf.ml:1466:10>>*/ var
+       args$1 = make_scanf(ib, fmt, readers);
+     }
+     catch(exc$0){
+      var exc = caml_wrap_exception(exc$0);
+      if
+       (exc[1] !== Scan_failure && exc[1] !== Stdlib[7] && exc !== Stdlib[12]){
+       if(exc[1] !== Stdlib[6]) throw caml_maybe_attach_backtrace(exc, 0);
+        /*<<scanf.ml:1470:45>>*/ var
+        msg = exc[2],
+         /*<<scanf.ml:1470:45>>*/ _C_ =
+           /*<<scanf.ml:1470:45>>*/ caml_call1(Stdlib_String[24], str),
+         /*<<scanf.ml:1470:45>>*/ _D_ =
+           /*<<scanf.ml:1470:45>>*/ caml_call2(Stdlib[28], _C_, cst$0),
+         /*<<scanf.ml:1470:27>>*/ _E_ =
+           /*<<scanf.ml:1470:27>>*/ caml_call2(Stdlib[28], cst_in_format, _D_),
+         /*<<scanf.ml:1470:20>>*/ _F_ =
+           /*<<scanf.ml:1470:20>>*/ caml_call2(Stdlib[28], msg, _E_);
+        /*<<scanf.ml:1470:20>>*/ return  /*<<scanf.ml:1470:20>>*/ caml_call1
+               (Stdlib[1], _F_);
+      }
+       /*<<scanf.ml:1468:8>>*/ return  /*<<scanf.ml:1468:8>>*/ caml_call2
+              (ef, ib, exc);
+     }
+     var f = f$1, args = args$1;
+      /*<<scanf.ml:1460:18>>*/ for(;;){
+      if(! args)
+        /*<<scanf.ml:1472:11>>*/ return  /*<<scanf.ml:1472:11>>*/ caml_call1
+               (af, f);
+       /*<<scanf.ml:1461:27>>*/ var
+       args$0 = args[2],
+       x = args[1],
+        /*<<scanf.ml:1461:27>>*/ f$0 =
+          /*<<scanf.ml:1461:27>>*/ caml_call1(f, x),
+       f = f$0,
+       args = args$0;
+     }
+     /*<<scanf.ml:1472:25>>*/ }
+     /*<<scanf.ml:1474:2>>*/ return take_format_readers(k, fmt);
+   }
+   function kscanf(ib, ef, fmt){
+     /*<<scanf.ml:1477:2>>*/ return kscanf_gen
+            (ib,
+             ef,
+             function(x){
+               /*<<scanf.ml:1477:29>>*/ return x;
+              /*<<scanf.ml:1477:30>>*/ },
+             fmt);
+    /*<<scanf.ml:1477:35>>*/ }
+   function kscanf_opt(ib, fmt){
+    function _A_(x){
+      /*<<scanf.ml:1480:44>>*/ return [0, x];
+     /*<<scanf.ml:1480:50>>*/ }
+     /*<<scanf.ml:1480:2>>*/ return kscanf_gen
+            (ib,
+             function(param, _B_){
+               /*<<scanf.ml:1480:28>>*/ return 0;
+              /*<<scanf.ml:1480:32>>*/ },
+             _A_,
+             fmt);
+    /*<<scanf.ml:1480:55>>*/ }
+   function bscanf(ib, fmt){
+     /*<<scanf.ml:1485:20>>*/ return kscanf(ib, scanf_bad_input, fmt);
+    /*<<scanf.ml:1485:50>>*/ }
+   function bscanf_opt(ib, fmt){
+     /*<<scanf.ml:1486:24>>*/ return kscanf_opt(ib, fmt);
+    /*<<scanf.ml:1486:41>>*/ }
+   function ksscanf(s, ef, fmt){
+     /*<<scanf.ml:1488:23>>*/ return kscanf(from_string(s), ef, fmt);
+    /*<<scanf.ml:1488:62>>*/ }
+   function sscanf(s, fmt){
+     /*<<scanf.ml:1489:19>>*/ return kscanf
+            (from_string(s), scanf_bad_input, fmt);
+    /*<<scanf.ml:1489:71>>*/ }
+   function sscanf_opt(s, fmt){
+     /*<<scanf.ml:1490:23>>*/ return kscanf_opt(from_string(s), fmt);
+    /*<<scanf.ml:1490:62>>*/ }
+   function scanf(fmt){
+     /*<<scanf.ml:1492:16>>*/ return kscanf(stdin, scanf_bad_input, fmt);
+    /*<<scanf.ml:1492:57>>*/ }
+   function scanf_opt(fmt){
+     /*<<scanf.ml:1493:20>>*/ return kscanf_opt(stdin, fmt);
+    /*<<scanf.ml:1493:49>>*/ }
+   function bscanf_format(ib, format, f){
+     /*<<scanf.ml:1502:4>>*/ scan_caml_string(Stdlib[19], ib);
+     /*<<scanf.ml:1503:14>>*/  /*<<scanf.ml:1503:14>>*/ var
+     str = token_string(ib);
+     /*<<scanf.ml:1504:4>>*/ try{
+      /*<<scanf.ml:1505:10>>*/ var
+       /*<<scanf.ml:1505:10>>*/ _z_ =
+         /*<<scanf.ml:1505:10>>*/ caml_call2
+         (CamlinternalFormat[15], str, format),
+      fmt = _z_;
+    }
+    catch(exn$0){
+     var exn = caml_wrap_exception(exn$0);
+     if(exn[1] !== Stdlib[7]) throw caml_maybe_attach_backtrace(exn, 0);
+     var msg = exn[2], fmt = bad_input(msg);
+    }
+     /*<<scanf.ml:1507:4>>*/ return  /*<<scanf.ml:1507:4>>*/ caml_call1
+            (f, fmt);
+    /*<<scanf.ml:1507:10>>*/ }
+   function sscanf_format(s, format, f){
+     /*<<scanf.ml:1513:20>>*/ return bscanf_format(from_string(s), format, f);
+    /*<<scanf.ml:1513:67>>*/ }
+   function format_from_string(s, fmt){
+     /*<<scanf.ml:1517:2>>*/ function _w_(x){
+      /*<<scanf.ml:1517:63>>*/ return x;
+     /*<<scanf.ml:1517:64>>*/ }
+     /*<<scanf.ml:1517:24>>*/ var
+      /*<<scanf.ml:1517:24>>*/ _x_ =
+        /*<<scanf.ml:1517:24>>*/ caml_call1(Stdlib_String[24], s),
+      /*<<scanf.ml:1517:24>>*/ _y_ =
+        /*<<scanf.ml:1517:24>>*/ caml_call2(Stdlib[28], _x_, cst$1);
+     /*<<scanf.ml:1517:53>>*/ return sscanf_format
+            ( /*<<scanf.ml:1517:16>>*/ caml_call2(Stdlib[28], cst$2, _y_),
+             fmt,
+             _w_);
+    /*<<scanf.ml:1517:65>>*/ }
+   function unescaped(s){
+     /*<<scanf.ml:1521:2>>*/ function _u_(x){
+      /*<<scanf.ml:1521:44>>*/ return x;
+     /*<<scanf.ml:1521:45>>*/ }
+     /*<<scanf.ml:1521:17>>*/  /*<<scanf.ml:1521:17>>*/ var
+     _v_ =  /*<<scanf.ml:1521:17>>*/ caml_call2(Stdlib[28], s, cst$3);
+     /*<<scanf.ml:1521:34>>*/ return  /*<<scanf.ml:1521:34>>*/ caml_call1
+            (sscanf
+              ( /*<<scanf.ml:1521:9>>*/ caml_call2(Stdlib[28], cst$4, _v_),
+               _t_),
+             _u_);
+    /*<<scanf.ml:1521:46>>*/ }
+   var
+    Stdlib_Scanf =
+      [0,
+       [0,
+        stdin,
+        open_in,
+        open_in_bin,
+        close_in,
+        open_in,
+        open_in_bin,
+        from_string,
+        from_function,
+        from_channel,
+        end_of_input,
+        beginning_of_input,
+        name_of_input],
+       Scan_failure,
+       bscanf,
+       bscanf_opt,
+       sscanf,
+       sscanf_opt,
+       scanf,
+       scanf_opt,
+       kscanf,
+       ksscanf,
+       bscanf_format,
+       sscanf_format,
+       format_from_string,
+       unescaped];
+   runtime.caml_register_global(64, Stdlib_Scanf, "Stdlib__Scanf");
+   return;
+   /*<<?>>*/ }
+  (globalThis));
+
+//# unitInfo: Provides: Stdlib__Callback
+//# unitInfo: Requires: Stdlib, Stdlib__Obj
+(function
+  (globalThis){
+   "use strict";
+   var
+    runtime = globalThis.jsoo_runtime,
+    caml_register_named_value = runtime.caml_register_named_value,
+    global_data = runtime.caml_get_global_data(),
+    Stdlib_Obj = global_data.Stdlib__Obj,
+    register = caml_register_named_value;
+   function register_exception(name, exn){
+     /*<<callback.ml:25:2>>*/ var
+     _a_ = Stdlib_Obj[10],
+     slot =
+        /*<<callback.ml:26:16>>*/ runtime.caml_obj_tag(exn) === _a_
+        ? exn
+        : exn[1];
+     /*<<callback.ml:27:2>>*/ return  /*<<callback.ml:27:2>>*/ caml_register_named_value
+            (name, slot);
+    /*<<callback.ml:27:32>>*/ }
+   var Stdlib_Callback = [0, register, register_exception];
+   runtime.caml_register_global(1, Stdlib_Callback, "Stdlib__Callback");
+   return;
+   /*<<?>>*/ }
+  (globalThis));
+
+//# unitInfo: Provides: CamlinternalOO
+//# unitInfo: Requires: Assert_failure, Stdlib, Stdlib__Array, Stdlib__List, Stdlib__Map, Stdlib__Obj, Stdlib__Sys
+(function
+  (globalThis){
+   "use strict";
+   var
+    runtime = globalThis.jsoo_runtime,
+    cst_camlinternalOO_ml = "camlinternalOO.ml",
+    caml_check_bound = runtime.caml_check_bound,
+    caml_div = runtime.caml_div,
+    caml_get_public_method = runtime.caml_get_public_method,
+    caml_make_vect = runtime.caml_make_vect,
+    caml_maybe_attach_backtrace = runtime.caml_maybe_attach_backtrace,
+    caml_obj_block = runtime.caml_obj_block,
+    caml_set_oo_id = runtime.caml_set_oo_id,
+    caml_string_compare = runtime.caml_string_compare,
+    caml_wrap_exception = runtime.caml_wrap_exception;
+    /*<<?>>*/ function caml_call1(f, a0){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 1
+            ? f(a0)
+            : runtime.caml_call_gen(f, [a0]);
+   }
+    /*<<?>>*/ function caml_call2(f, a0, a1){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 2
+            ? f(a0, a1)
+            : runtime.caml_call_gen(f, [a0, a1]);
+   }
+    /*<<?>>*/ function caml_call3(f, a0, a1, a2){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 3
+            ? f(a0, a1, a2)
+            : runtime.caml_call_gen(f, [a0, a1, a2]);
+   }
+    /*<<?>>*/ function caml_call5(f, a0, a1, a2, a3, a4){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 5
+            ? f(a0, a1, a2, a3, a4)
+            : runtime.caml_call_gen(f, [a0, a1, a2, a3, a4]);
+   }
+   var
+    global_data = runtime.caml_get_global_data(),
+    Assert_failure = global_data.Assert_failure,
+    Stdlib_Sys = global_data.Stdlib__Sys,
+    Stdlib_Obj = global_data.Stdlib__Obj,
+    Stdlib = global_data.Stdlib,
+    Stdlib_Array = global_data.Stdlib__Array,
+    Stdlib_List = global_data.Stdlib__List,
+    Stdlib_Map = global_data.Stdlib__Map,
+    _g_ = [0, cst_camlinternalOO_ml, 439, 17],
+    _f_ = [0, cst_camlinternalOO_ml, 421, 13],
+    _e_ = [0, cst_camlinternalOO_ml, 418, 13],
+    _d_ = [0, cst_camlinternalOO_ml, 415, 13],
+    _c_ = [0, cst_camlinternalOO_ml, 412, 13],
+    _b_ = [0, cst_camlinternalOO_ml, 409, 13],
+    _a_ = [0, cst_camlinternalOO_ml, 281, 50];
+   function copy(o){
+     /*<<camlinternalOO.ml:25:2>>*/  /*<<camlinternalOO.ml:25:19>>*/ var
+     o$0 =  /*<<camlinternalOO.ml:25:19>>*/ o.slice();
+     /*<<camlinternalOO.ml:26:2>>*/ return  /*<<camlinternalOO.ml:26:2>>*/ caml_set_oo_id
+            (o$0);
+    /*<<camlinternalOO.ml:26:10>>*/ }
+    /*<<camlinternalOO.ml:38:13>>*/ var
+     /*<<camlinternalOO.ml:38:13>>*/ params = [0, 1, 1, 1, 3, 16],
+     /*<<camlinternalOO.ml:38:13>>*/ initial_object_size = 2,
+    dummy_item = 0;
+   function public_method_label(s){
+     /*<<camlinternalOO.ml:71:2>>*/ var
+      /*<<camlinternalOO.ml:71:13>>*/ accu = [0, 0],
+     _aE_ = runtime.caml_ml_string_length(s) - 1 | 0,
+      /*<<camlinternalOO.ml:71:13>>*/ _aD_ = 0;
+    if(_aE_ >= 0){
+     var i = _aD_;
+     for(;;){
+       /*<<camlinternalOO.ml:73:36>>*/  /*<<camlinternalOO.ml:73:36>>*/ var
+       _aF_ =  /*<<camlinternalOO.ml:73:36>>*/ runtime.caml_string_get(s, i);
+      accu[1] = (223 * accu[1] | 0) + _aF_ | 0;
+       /*<<camlinternalOO.ml:72:2>>*/  /*<<camlinternalOO.ml:72:2>>*/ var
+       _aG_ = i + 1 | 0;
+      if(_aE_ === i) break;
+      var i = _aG_;
+     }
+    }
+    accu[1] = accu[1] & 2147483647;
+    var tag = 1073741823 < accu[1] ? accu[1] + 2147483648 | 0 : accu[1];
+     /*<<camlinternalOO.ml:80:2>>*/ return tag;
+    /*<<camlinternalOO.ml:80:11>>*/ }
+    /*<<camlinternalOO.ml:109:2>>*/ var
+    compare = caml_string_compare,
+    Vars = caml_call1(Stdlib_Map[1], [0, compare]),
+    compare$0 = caml_string_compare,
+    Meths = caml_call1(Stdlib_Map[1], [0, compare$0]),
+    compare$1 = runtime.caml_int_compare,
+    Labs = caml_call1(Stdlib_Map[1], [0, compare$1]),
+     /*<<camlinternalOO.ml:109:2>>*/ dummy_table =
+      [0, 0, [0, dummy_item], Meths[1], Labs[1], 0, 0, Vars[1], 0],
+     /*<<camlinternalOO.ml:118:18>>*/ table_count = [0, 0],
+     /*<<camlinternalOO.ml:121:27>>*/ dummy_met =
+       /*<<camlinternalOO.ml:121:27>>*/ caml_obj_block(0, 0);
+   function fit_size(n){
+     /*<<camlinternalOO.ml:126:2>>*/ return 2 < n
+            ? fit_size((n + 1 | 0) / 2 | 0) * 2 | 0
+            : n;
+    /*<<camlinternalOO.ml:127:24>>*/ }
+   function new_table(pub_labels){
+     /*<<camlinternalOO.ml:130:2>>*/ table_count[1]++;
+     /*<<camlinternalOO.ml:132:16>>*/ var
+     len = pub_labels.length - 1,
+      /*<<camlinternalOO.ml:132:16>>*/ methods =
+        /*<<camlinternalOO.ml:132:16>>*/ caml_make_vect
+        ((len * 2 | 0) + 2 | 0, dummy_met);
+     /*<<camlinternalOO.ml:133:2>>*/ caml_check_bound(methods, 0)[1] = len;
+    var
+     _aw_ = Stdlib_Sys[9],
+     _ax_ =
+       ( /*<<camlinternalOO.ml:134:24>>*/ runtime.caml_mul
+        (fit_size(len), _aw_)
+       / 8
+       | 0)
+       - 1
+       | 0;
+     /*<<camlinternalOO.ml:134:2>>*/ caml_check_bound(methods, 1)[2] = _ax_;
+     /*<<camlinternalOO.ml:134:2>>*/ var
+     _az_ = len - 1 | 0,
+      /*<<camlinternalOO.ml:134:2>>*/ _ay_ = 0;
+    if(_az_ >= 0){
+     var i = _ay_;
+     for(;;){
+       /*<<camlinternalOO.ml:135:51>>*/ var
+       _aB_ = (i * 2 | 0) + 3 | 0,
+        /*<<camlinternalOO.ml:135:51>>*/ _aA_ =
+         caml_check_bound(pub_labels, i)[1 + i];
+       /*<<camlinternalOO.ml:135:26>>*/ caml_check_bound(methods, _aB_)
+       [1 + _aB_]
+      = _aA_;
+       /*<<camlinternalOO.ml:135:26>>*/  /*<<camlinternalOO.ml:135:26>>*/ var
+       _aC_ = i + 1 | 0;
+      if(_az_ === i) break;
+      var i = _aC_;
+     }
+    }
+     /*<<camlinternalOO.ml:136:2>>*/ return [0,
+            initial_object_size,
+            methods,
+            Meths[1],
+            Labs[1],
+            0,
+            0,
+            Vars[1],
+            0];
+    /*<<camlinternalOO.ml:143:32>>*/ }
+   function resize(array, new_size){
+     /*<<camlinternalOO.ml:146:2>>*/ var
+     old_size = array[2].length - 1,
+     _au_ = old_size < new_size ? 1 : 0;
+    if(_au_){
+      /*<<camlinternalOO.ml:148:19>>*/  /*<<camlinternalOO.ml:148:19>>*/ var
+      new_buck =
+         /*<<camlinternalOO.ml:148:19>>*/ caml_make_vect(new_size, dummy_met);
+      /*<<camlinternalOO.ml:149:4>>*/  /*<<camlinternalOO.ml:149:4>>*/ caml_call5
+      (Stdlib_Array[8], array[2], 0, new_buck, 0, old_size);
+     array[2] = new_buck;
+     var _av_ = 0;
+    }
+    else
+     var _av_ = _au_;
+    return _av_;
+    /*<<camlinternalOO.ml:151:4>>*/ }
+    /*<<camlinternalOO.ml:159:19>>*/ var
+     /*<<camlinternalOO.ml:159:19>>*/ method_count = [0, 0],
+     /*<<camlinternalOO.ml:160:21>>*/ inst_var_count = [0, 0];
+   function new_method(table){
+     /*<<camlinternalOO.ml:166:2>>*/ var index = table[2].length - 1;
+     /*<<camlinternalOO.ml:167:2>>*/ resize(table, index + 1 | 0);
+     /*<<camlinternalOO.ml:167:2>>*/ return index;
+    /*<<camlinternalOO.ml:168:7>>*/ }
+   function get_method_label(table, name){
+     /*<<camlinternalOO.ml:171:2>>*/ try{
+      /*<<camlinternalOO.ml:172:4>>*/  /*<<camlinternalOO.ml:172:4>>*/ var
+      _as_ =
+         /*<<camlinternalOO.ml:172:4>>*/ caml_call2(Meths[28], name, table[3]);
+      /*<<camlinternalOO.ml:172:4>>*/ return _as_;
+    }
+    catch(_at_){
+     var _ar_ = caml_wrap_exception(_at_);
+     if(_ar_ !== Stdlib[8]) throw caml_maybe_attach_backtrace(_ar_, 0);
+      /*<<camlinternalOO.ml:174:16>>*/  /*<<camlinternalOO.ml:174:16>>*/ var
+      label = new_method(table);
+     table[3] =
+       /*<<camlinternalOO.ml:175:29>>*/ caml_call3
+       (Meths[4], name, label, table[3]);
+     table[4] =
+       /*<<camlinternalOO.ml:176:30>>*/ caml_call3
+       (Labs[4], label, 1, table[4]);
+      /*<<camlinternalOO.ml:177:4>>*/ return label;
+    }
+    /*<<camlinternalOO.ml:177:9>>*/ }
+   function get_method_labels(table, names){
+     /*<<camlinternalOO.ml:180:12>>*/ function _ap_(_aq_){
+      /*<<?>>*/ return get_method_label(table, _aq_);
+    }
+     /*<<camlinternalOO.ml:180:2>>*/ return  /*<<camlinternalOO.ml:180:2>>*/ caml_call2
+            (Stdlib_Array[13], _ap_, names);
+    /*<<camlinternalOO.ml:180:42>>*/ }
+   function set_method(table, label, element){
+     /*<<camlinternalOO.ml:183:2>>*/ method_count[1]++;
+     /*<<camlinternalOO.ml:184:5>>*/ return  /*<<camlinternalOO.ml:184:5>>*/ caml_call2
+             (Labs[28], label, table[4])
+            ? (resize
+               (table, label + 1 | 0),
+              caml_check_bound(table[2], label)[1 + label] = element,
+              0)
+            : (table[6] = [0, [0, label, element], table[6]], 0);
+    /*<<camlinternalOO.ml:187:64>>*/ }
+   function get_method(table, label){
+     /*<<camlinternalOO.ml:190:2>>*/ try{
+      /*<<camlinternalOO.ml:190:6>>*/  /*<<camlinternalOO.ml:190:6>>*/ var
+      _an_ =
+         /*<<camlinternalOO.ml:190:6>>*/ caml_call2
+         (Stdlib_List[46], label, table[6]);
+      /*<<camlinternalOO.ml:190:6>>*/ return _an_;
+    }
+    catch(_ao_){
+     var _am_ = caml_wrap_exception(_ao_);
+     if(_am_ === Stdlib[8])
+       /*<<camlinternalOO.ml:191:20>>*/ return caml_check_bound
+               (table[2], label)
+              [1 + label];
+     throw caml_maybe_attach_backtrace(_am_, 0);
+    }
+    /*<<camlinternalOO.ml:191:41>>*/ }
+   function to_list(arr){
+     /*<<camlinternalOO.ml:194:2>>*/ return 0 === arr
+            ? 0
+            :  /*<<camlinternalOO.ml:194:33>>*/ caml_call1
+              (Stdlib_Array[9], arr);
+    /*<<camlinternalOO.ml:194:50>>*/ }
+   function narrow(table, vars, virt_meths, concr_meths){
+     /*<<camlinternalOO.ml:197:2>>*/ var
+      /*<<camlinternalOO.ml:197:13>>*/ vars$0 = to_list(vars),
+      /*<<camlinternalOO.ml:198:19>>*/ virt_meths$0 = to_list(virt_meths),
+      /*<<camlinternalOO.ml:199:20>>*/ concr_meths$0 = to_list(concr_meths);
+     /*<<camlinternalOO.ml:200:32>>*/ function _X_(_al_){
+      /*<<?>>*/ return get_method_label(table, _al_);
+    }
+     /*<<camlinternalOO.ml:200:23>>*/  /*<<camlinternalOO.ml:200:23>>*/ var
+     virt_meth_labs =
+        /*<<camlinternalOO.ml:200:23>>*/ caml_call2
+        (Stdlib_List[19], _X_, virt_meths$0);
+     /*<<camlinternalOO.ml:201:33>>*/ function _Y_(_ak_){
+      /*<<?>>*/ return get_method_label(table, _ak_);
+    }
+     /*<<camlinternalOO.ml:201:24>>*/  /*<<camlinternalOO.ml:201:24>>*/ var
+     concr_meth_labs =
+        /*<<camlinternalOO.ml:201:24>>*/ caml_call2
+        (Stdlib_List[19], _Y_, concr_meths$0);
+    table[5] =
+     [0,
+      [0, table[3], table[4], table[6], table[7], virt_meth_labs, vars$0],
+      table[5]];
+    var _Z_ = Vars[1], ___ = table[7];
+    function _$_(lab, info, tvars){
+      /*<<camlinternalOO.ml:209:8>>*/ return  /*<<camlinternalOO.ml:209:11>>*/ caml_call2
+              (Stdlib_List[36], lab, vars$0)
+             ?  /*<<camlinternalOO.ml:209:34>>*/ caml_call3
+               (Vars[4], lab, info, tvars)
+             : tvars;
+     /*<<camlinternalOO.ml:209:68>>*/ }
+    table[7] =
+      /*<<camlinternalOO.ml:207:4>>*/ caml_call3(Vars[13], _$_, ___, _Z_);
+     /*<<camlinternalOO.ml:211:16>>*/ var
+      /*<<camlinternalOO.ml:211:16>>*/ by_name = [0, Meths[1]],
+      /*<<camlinternalOO.ml:212:17>>*/ by_label = [0, Labs[1]];
+    function _aa_(met, label){
+      /*<<camlinternalOO.ml:215:7>>*/ by_name[1] =
+       /*<<camlinternalOO.ml:215:18>>*/ caml_call3
+       (Meths[4], met, label, by_name[1]);
+     var _af_ = by_label[1];
+     try{
+       /*<<camlinternalOO.ml:218:17>>*/ var
+        /*<<camlinternalOO.ml:218:17>>*/ _ai_ =
+          /*<<camlinternalOO.ml:218:17>>*/ caml_call2
+          (Labs[28], label, table[4]),
+       _ah_ = _ai_;
+     }
+     catch(_aj_){
+      var _ag_ = caml_wrap_exception(_aj_);
+      if(_ag_ !== Stdlib[8]) throw caml_maybe_attach_backtrace(_ag_, 0);
+      var _ah_ = 1;
+     }
+     by_label[1] =
+       /*<<camlinternalOO.ml:217:10>>*/ caml_call3(Labs[4], label, _ah_, _af_);
+     return 0;
+     /*<<camlinternalOO.ml:219:21>>*/ }
+     /*<<camlinternalOO.ml:213:2>>*/  /*<<camlinternalOO.ml:213:2>>*/ caml_call3
+     (Stdlib_List[27], _aa_, concr_meths$0, concr_meth_labs);
+    function _ab_(met, label){
+      /*<<camlinternalOO.ml:223:7>>*/ by_name[1] =
+       /*<<camlinternalOO.ml:223:18>>*/ caml_call3
+       (Meths[4], met, label, by_name[1]);
+     by_label[1] =
+       /*<<camlinternalOO.ml:224:19>>*/ caml_call3
+       (Labs[4], label, 0, by_label[1]);
+     return 0;
+     /*<<camlinternalOO.ml:224:49>>*/ }
+     /*<<camlinternalOO.ml:221:2>>*/  /*<<camlinternalOO.ml:221:2>>*/ caml_call3
+     (Stdlib_List[27], _ab_, virt_meths$0, virt_meth_labs);
+    table[3] = by_name[1];
+    table[4] = by_label[1];
+     /*<<camlinternalOO.ml:228:2>>*/ var
+      /*<<camlinternalOO.ml:228:2>>*/ _ac_ = 0,
+     _ad_ = table[6];
+    function _ae_(met, hm){
+      /*<<camlinternalOO.ml:230:7>>*/ var lab = met[1];
+      /*<<camlinternalOO.ml:231:13>>*/ return  /*<<camlinternalOO.ml:231:13>>*/ caml_call2
+              (Stdlib_List[36], lab, virt_meth_labs)
+             ? hm
+             : [0, met, hm];
+     /*<<camlinternalOO.ml:231:62>>*/ }
+    table[6] =
+      /*<<camlinternalOO.ml:229:5>>*/ caml_call3
+      (Stdlib_List[26], _ae_, _ad_, _ac_);
+    return 0;
+    /*<<camlinternalOO.ml:233:9>>*/ }
+   function widen(table){
+     /*<<camlinternalOO.ml:236:2>>*/ var
+      /*<<camlinternalOO.ml:237:4>>*/ match =
+        /*<<camlinternalOO.ml:237:4>>*/ caml_call1(Stdlib_List[5], table[5]),
+     vars = match[6],
+     virt_meths = match[5],
+     saved_vars = match[4],
+     saved_hidden_meths = match[3],
+     by_label = match[2],
+     by_name = match[1];
+    table[5] =
+      /*<<camlinternalOO.ml:239:27>>*/ caml_call1(Stdlib_List[6], table[5]);
+    function _T_(s, v){
+      /*<<camlinternalOO.ml:242:19>>*/  /*<<camlinternalOO.ml:242:30>>*/ var
+      _W_ =
+         /*<<camlinternalOO.ml:242:30>>*/ caml_call2(Vars[28], v, table[7]);
+      /*<<camlinternalOO.ml:242:19>>*/ return  /*<<camlinternalOO.ml:242:19>>*/ caml_call3
+             (Vars[4], v, _W_, s);
+     /*<<camlinternalOO.ml:242:56>>*/ }
+    table[7] =
+      /*<<camlinternalOO.ml:241:5>>*/ caml_call3
+      (Stdlib_List[25], _T_, saved_vars, vars);
+    table[3] = by_name;
+    table[4] = by_label;
+    var _U_ = table[6];
+    function _V_(met, hm){
+      /*<<camlinternalOO.ml:248:7>>*/ var lab = met[1];
+      /*<<camlinternalOO.ml:249:13>>*/ return  /*<<camlinternalOO.ml:249:13>>*/ caml_call2
+              (Stdlib_List[36], lab, virt_meths)
+             ? hm
+             : [0, met, hm];
+     /*<<camlinternalOO.ml:249:58>>*/ }
+    table[6] =
+      /*<<camlinternalOO.ml:247:5>>*/ caml_call3
+      (Stdlib_List[26], _V_, _U_, saved_hidden_meths);
+    return 0;
+    /*<<camlinternalOO.ml:251:25>>*/ }
+   function new_variable(table, name){
+     /*<<camlinternalOO.ml:259:2>>*/ try{
+      /*<<camlinternalOO.ml:259:6>>*/  /*<<camlinternalOO.ml:259:6>>*/ var
+      _R_ =
+         /*<<camlinternalOO.ml:259:6>>*/ caml_call2(Vars[28], name, table[7]);
+      /*<<camlinternalOO.ml:259:6>>*/ return _R_;
+    }
+    catch(_S_){
+     var _Q_ = caml_wrap_exception(_S_);
+     if(_Q_ !== Stdlib[8]) throw caml_maybe_attach_backtrace(_Q_, 0);
+     var index = table[1];
+     table[1] = index + 1 | 0;
+      /*<<camlinternalOO.ml:262:7>>*/ if
+      ( /*<<camlinternalOO.ml:262:7>>*/ runtime.caml_string_notequal(name, ""))
+      table[7] =
+        /*<<camlinternalOO.ml:262:37>>*/ caml_call3
+        (Vars[4], name, index, table[7]);
+      /*<<camlinternalOO.ml:263:4>>*/ return index;
+    }
+    /*<<camlinternalOO.ml:263:9>>*/ }
+   function to_array(arr){
+     /*<<camlinternalOO.ml:266:2>>*/ return  /*<<camlinternalOO.ml:266:5>>*/ runtime.caml_equal
+             (arr, 0)
+            ? [0]
+            : arr;
+    /*<<camlinternalOO.ml:266:41>>*/ }
+   function new_methods_variables(table, meths, vals){
+     /*<<camlinternalOO.ml:269:2>>*/ var
+      /*<<camlinternalOO.ml:269:14>>*/ meths$0 = to_array(meths),
+      /*<<camlinternalOO.ml:270:2>>*/ nmeths = meths$0.length - 1,
+     nvals = vals.length - 1,
+      /*<<camlinternalOO.ml:271:12>>*/ res =
+        /*<<camlinternalOO.ml:271:12>>*/ caml_make_vect(nmeths + nvals | 0, 0),
+      /*<<camlinternalOO.ml:272:2>>*/ _I_ = nmeths - 1 | 0,
+      /*<<camlinternalOO.ml:271:12>>*/ _H_ = 0;
+    if(_I_ >= 0){
+     var i$0 = _H_;
+     for(;;){
+       /*<<camlinternalOO.ml:273:15>>*/  /*<<camlinternalOO.ml:273:15>>*/ var
+       _O_ = get_method_label(table, caml_check_bound(meths$0, i$0)[1 + i$0]);
+       /*<<camlinternalOO.ml:273:4>>*/ caml_check_bound(res, i$0)[1 + i$0] = _O_;
+       /*<<camlinternalOO.ml:273:4>>*/  /*<<camlinternalOO.ml:273:4>>*/ var
+       _P_ = i$0 + 1 | 0;
+      if(_I_ === i$0) break;
+      var i$0 = _P_;
+     }
+    }
+     /*<<camlinternalOO.ml:275:2>>*/ var
+     _K_ = nvals - 1 | 0,
+      /*<<camlinternalOO.ml:275:2>>*/ _J_ = 0;
+    if(_K_ >= 0){
+     var i = _J_;
+     for(;;){
+       /*<<camlinternalOO.ml:276:22>>*/ var
+       _M_ = i + nmeths | 0,
+        /*<<camlinternalOO.ml:276:22>>*/ _L_ =
+         new_variable(table, caml_check_bound(vals, i)[1 + i]);
+       /*<<camlinternalOO.ml:276:4>>*/ caml_check_bound(res, _M_)[1 + _M_] = _L_;
+       /*<<camlinternalOO.ml:276:4>>*/  /*<<camlinternalOO.ml:276:4>>*/ var
+       _N_ = i + 1 | 0;
+      if(_K_ === i) break;
+      var i = _N_;
+     }
+    }
+     /*<<camlinternalOO.ml:278:2>>*/ return res;
+    /*<<camlinternalOO.ml:278:5>>*/ }
+   function get_variable(table, name){
+     /*<<camlinternalOO.ml:281:2>>*/ try{
+      /*<<camlinternalOO.ml:281:6>>*/  /*<<camlinternalOO.ml:281:6>>*/ var
+      _F_ =
+         /*<<camlinternalOO.ml:281:6>>*/ caml_call2(Vars[28], name, table[7]);
+      /*<<camlinternalOO.ml:281:6>>*/ return _F_;
+    }
+    catch(_G_){
+     var _E_ = caml_wrap_exception(_G_);
+     if(_E_ === Stdlib[8])
+       /*<<camlinternalOO.ml:281:50>>*/ throw  /*<<camlinternalOO.ml:281:50>>*/ caml_maybe_attach_backtrace
+             ([0, Assert_failure, _a_], 1);
+     throw caml_maybe_attach_backtrace(_E_, 0);
+    }
+    /*<<camlinternalOO.ml:281:62>>*/ }
+   function get_variables(table, names){
+     /*<<camlinternalOO.ml:284:12>>*/ function _C_(_D_){
+      /*<<?>>*/ return get_variable(table, _D_);
+    }
+     /*<<camlinternalOO.ml:284:2>>*/ return  /*<<camlinternalOO.ml:284:2>>*/ caml_call2
+            (Stdlib_Array[13], _C_, names);
+    /*<<camlinternalOO.ml:284:38>>*/ }
+   function add_initializer(table, f){
+     /*<<camlinternalOO.ml:287:2>>*/ table[8] = [0, f, table[8]];
+    return 0;
+    /*<<camlinternalOO.ml:287:45>>*/ }
+   function create_table(public_methods){
+     /*<<camlinternalOO.ml:301:2>>*/ if(0 === public_methods)
+      /*<<camlinternalOO.ml:301:46>>*/ return new_table([0]);
+     /*<<camlinternalOO.ml:303:13>>*/ var
+      /*<<camlinternalOO.ml:303:13>>*/ tags =
+        /*<<camlinternalOO.ml:303:13>>*/ caml_call2
+        (Stdlib_Array[13], public_method_label, public_methods),
+      /*<<camlinternalOO.ml:304:14>>*/ table = new_table(tags);
+    function _B_(i, met){
+      /*<<camlinternalOO.ml:307:6>>*/ var lab = (i * 2 | 0) + 2 | 0;
+     table[3] =
+       /*<<camlinternalOO.ml:308:32>>*/ caml_call3
+       (Meths[4], met, lab, table[3]);
+     table[4] =
+       /*<<camlinternalOO.ml:309:32>>*/ caml_call3(Labs[4], lab, 1, table[4]);
+     return 0;
+     /*<<camlinternalOO.ml:309:72>>*/ }
+     /*<<camlinternalOO.ml:305:2>>*/  /*<<camlinternalOO.ml:305:2>>*/ caml_call2
+     (Stdlib_Array[12], _B_, public_methods);
+     /*<<camlinternalOO.ml:305:2>>*/ return table;
+    /*<<camlinternalOO.ml:311:7>>*/ }
+   function init_class(table){
+     /*<<camlinternalOO.ml:314:2>>*/ inst_var_count[1] =
+     (inst_var_count[1] + table[1] | 0) - 1 | 0;
+    table[8] =
+      /*<<camlinternalOO.ml:315:24>>*/ caml_call1(Stdlib_List[9], table[8]);
+     /*<<camlinternalOO.ml:316:2>>*/  /*<<camlinternalOO.ml:316:2>>*/ var
+     _A_ = Stdlib_Sys[9];
+    return resize
+            (table,
+             3 + caml_div(caml_check_bound(table[2], 1)[2] * 16 | 0, _A_) | 0);
+    /*<<camlinternalOO.ml:316:65>>*/ }
+   function inherits(cla, vals, virt_meths, concr_meths, param, top){
+    var env = param[4], super$0 = param[2];
+     /*<<camlinternalOO.ml:319:2>>*/ narrow
+     (cla, vals, virt_meths, concr_meths);
+    var
+     init =
+       top
+        ?  /*<<camlinternalOO.ml:321:16>>*/ caml_call2(super$0, cla, env)
+        :  /*<<camlinternalOO.ml:321:44>>*/ caml_call1(super$0, cla);
+     /*<<camlinternalOO.ml:322:2>>*/ widen(cla);
+     /*<<camlinternalOO.ml:322:2>>*/ var
+      /*<<camlinternalOO.ml:322:2>>*/ _s_ = 0,
+      /*<<camlinternalOO.ml:328:7>>*/ _t_ = to_array(concr_meths);
+    function _u_(nm){
+      /*<<camlinternalOO.ml:327:18>>*/ return get_method
+             (cla, get_method_label(cla, nm));
+     /*<<camlinternalOO.ml:327:75>>*/ }
+     /*<<camlinternalOO.ml:325:41>>*/ var
+     _v_ =
+       [0,
+         /*<<camlinternalOO.ml:326:5>>*/ caml_call2
+         (Stdlib_Array[13], _u_, _t_),
+        _s_],
+      /*<<camlinternalOO.ml:325:41>>*/ _w_ = to_array(vals);
+     /*<<camlinternalOO.ml:325:22>>*/ function _x_(_z_){
+      /*<<?>>*/ return get_variable(cla, _z_);
+    }
+     /*<<camlinternalOO.ml:324:4>>*/  /*<<camlinternalOO.ml:324:4>>*/ var
+     _y_ =
+       [0,
+        [0, init],
+        [0,
+          /*<<camlinternalOO.ml:325:12>>*/ caml_call2
+          (Stdlib_Array[13], _x_, _w_),
+         _v_]];
+     /*<<camlinternalOO.ml:324:4>>*/ return  /*<<camlinternalOO.ml:324:4>>*/ caml_call1
+            (Stdlib_Array[4], _y_);
+   }
+   function make_class(pub_meths, class_init){
+     /*<<camlinternalOO.ml:331:2>>*/ var
+      /*<<camlinternalOO.ml:331:14>>*/ table = create_table(pub_meths),
+      /*<<camlinternalOO.ml:332:17>>*/ env_init =
+        /*<<camlinternalOO.ml:332:17>>*/ caml_call1(class_init, table);
+     /*<<camlinternalOO.ml:333:2>>*/ init_class(table);
+     /*<<camlinternalOO.ml:334:2>>*/ return [0,
+             /*<<camlinternalOO.ml:334:3>>*/ caml_call1(env_init, 0),
+            class_init,
+            env_init,
+            0];
+    /*<<camlinternalOO.ml:334:59>>*/ }
+   function make_class_store(pub_meths, class_init, init_table){
+     /*<<camlinternalOO.ml:340:2>>*/ var
+      /*<<camlinternalOO.ml:340:14>>*/ table = create_table(pub_meths),
+      /*<<camlinternalOO.ml:341:17>>*/ env_init =
+        /*<<camlinternalOO.ml:341:17>>*/ caml_call1(class_init, table);
+     /*<<camlinternalOO.ml:342:2>>*/ init_class(table);
+    init_table[2] = class_init;
+    init_table[1] = env_init;
+    return 0;
+    /*<<camlinternalOO.ml:344:33>>*/ }
+   function dummy_class(loc){
+    function undef(param){
+      /*<<camlinternalOO.ml:347:23>>*/ throw  /*<<camlinternalOO.ml:347:23>>*/ caml_maybe_attach_backtrace
+            ([0, Stdlib[15], loc], 1);
+     /*<<camlinternalOO.ml:347:61>>*/ }
+     /*<<camlinternalOO.ml:348:2>>*/ return [0, undef, undef, undef, 0];
+    /*<<camlinternalOO.ml:348:45>>*/ }
+   function create_object(table){
+     /*<<camlinternalOO.ml:354:2>>*/  /*<<camlinternalOO.ml:354:12>>*/ var
+     obj =
+        /*<<camlinternalOO.ml:354:12>>*/ caml_obj_block
+        (Stdlib_Obj[10], table[1]);
+     /*<<camlinternalOO.ml:356:2>>*/ obj[1] = table[2];
+     /*<<camlinternalOO.ml:357:10>>*/ return  /*<<camlinternalOO.ml:357:10>>*/ caml_set_oo_id
+            (obj);
+    /*<<camlinternalOO.ml:357:22>>*/ }
+   function create_object_opt(obj_0, table){
+     /*<<camlinternalOO.ml:360:2>>*/ if(obj_0)
+      /*<<camlinternalOO.ml:360:35>>*/ return obj_0;
+     /*<<camlinternalOO.ml:362:14>>*/  /*<<camlinternalOO.ml:362:14>>*/ var
+     obj =
+        /*<<camlinternalOO.ml:362:14>>*/ caml_obj_block
+        (Stdlib_Obj[10], table[1]);
+     /*<<camlinternalOO.ml:364:4>>*/ obj[1] = table[2];
+     /*<<camlinternalOO.ml:365:12>>*/ return  /*<<camlinternalOO.ml:365:12>>*/ caml_set_oo_id
+            (obj);
+    /*<<camlinternalOO.ml:366:5>>*/ }
+   function iter_f(obj, param){
+    var param$0 = param;
+    for(;;){
+     if(! param$0)  /*<<camlinternalOO.ml:370:12>>*/ return 0;
+     var l = param$0[2], f = param$0[1];
+      /*<<camlinternalOO.ml:371:12>>*/  /*<<camlinternalOO.ml:371:12>>*/ caml_call1
+      (f, obj);
+     var param$0 = l;
+    }
+   }
+   function run_initializers(obj, table){
+     /*<<camlinternalOO.ml:374:2>>*/ var
+     inits = table[8],
+     _r_ = 0 !== inits ? 1 : 0;
+    return _r_ ? iter_f(obj, inits) : _r_;
+    /*<<camlinternalOO.ml:376:20>>*/ }
+   function run_initializers_opt(obj_0, obj, table){
+     /*<<camlinternalOO.ml:379:2>>*/ if(obj_0)
+      /*<<camlinternalOO.ml:379:35>>*/ return obj;
+    var inits = table[8];
+    if(0 !== inits)  /*<<camlinternalOO.ml:381:24>>*/ iter_f(obj, inits);
+     /*<<camlinternalOO.ml:381:24>>*/ return obj;
+    /*<<camlinternalOO.ml:383:5>>*/ }
+   function create_object_and_run_initiali(obj_0, table){
+     /*<<camlinternalOO.ml:386:2>>*/ if(obj_0)
+      /*<<camlinternalOO.ml:386:35>>*/ return obj_0;
+     /*<<camlinternalOO.ml:387:14>>*/  /*<<camlinternalOO.ml:387:14>>*/ var
+     obj = create_object(table);
+     /*<<camlinternalOO.ml:388:4>>*/ run_initializers(obj, table);
+     /*<<camlinternalOO.ml:388:4>>*/ return obj;
+    /*<<camlinternalOO.ml:390:5>>*/ }
+   function get_data(param){
+     /*<<camlinternalOO.ml:417:15>>*/ if(param)
+      /*<<camlinternalOO.ml:419:19>>*/ return param[2];
+     /*<<camlinternalOO.ml:418:13>>*/ throw  /*<<camlinternalOO.ml:418:13>>*/ caml_maybe_attach_backtrace
+           ([0, Assert_failure, _e_], 1);
+    /*<<camlinternalOO.ml:419:30>>*/ }
+   function build_path(n, keys, tables){
+     /*<<camlinternalOO.ml:425:2>>*/ var
+      /*<<camlinternalOO.ml:425:17>>*/ res = [0, 0, 0, 0],
+      /*<<camlinternalOO.ml:426:10>>*/ r = [0, res],
+      /*<<camlinternalOO.ml:426:10>>*/ _o_ = 0;
+    if(n >= 0){
+     var i = _o_;
+     for(;;){
+      var _p_ = r[1];
+      r[1] = [0, caml_check_bound(keys, i)[1 + i], _p_, 0];
+       /*<<camlinternalOO.ml:427:2>>*/  /*<<camlinternalOO.ml:427:2>>*/ var
+       _q_ = i + 1 | 0;
+      if(n === i) break;
+      var i = _q_;
+     }
+    }
+    var v = r[1];
+    if(! tables)
+      /*<<camlinternalOO.ml:409:13>>*/ throw  /*<<camlinternalOO.ml:409:13>>*/ caml_maybe_attach_backtrace
+            ([0, Assert_failure, _b_], 1);
+    tables[2] = v;
+     /*<<camlinternalOO.ml:430:2>>*/ return res;
+    /*<<camlinternalOO.ml:431:5>>*/ }
+   function lookup_tables(root, keys){
+     /*<<camlinternalOO.ml:453:2>>*/  /*<<camlinternalOO.ml:453:8>>*/ var
+     root_data = get_data(root);
+    if(! root_data)
+      /*<<camlinternalOO.ml:457:4>>*/ return build_path
+             (keys.length - 1 - 1 | 0, keys, root);
+    var i$1 = keys.length - 1 - 1 | 0, i = i$1, tables$0 = root_data;
+     /*<<camlinternalOO.ml:434:2>>*/ for(;;){
+     if(0 > i)  /*<<camlinternalOO.ml:434:16>>*/ return tables$0;
+      /*<<camlinternalOO.ml:435:12>>*/ var
+       /*<<camlinternalOO.ml:435:12>>*/ key = caml_check_bound(keys, i)[1 + i],
+      tables$1 = tables$0;
+      /*<<camlinternalOO.ml:437:4>>*/ for(;;){
+      if(! tables$1)
+        /*<<camlinternalOO.ml:415:13>>*/ throw  /*<<camlinternalOO.ml:415:13>>*/ caml_maybe_attach_backtrace
+              ([0, Assert_failure, _d_], 1);
+      if(tables$1[1] === key){
+        /*<<camlinternalOO.ml:438:12>>*/  /*<<camlinternalOO.ml:438:12>>*/ var
+        tables_data = get_data(tables$1);
+       if(! tables_data)
+         /*<<camlinternalOO.ml:439:17>>*/ throw  /*<<camlinternalOO.ml:439:17>>*/ caml_maybe_attach_backtrace
+               ([0, Assert_failure, _g_], 1);
+       var i$0 = i - 1 | 0, i = i$0, tables$0 = tables_data;
+       break;
+      }
+      if(! tables$1)
+        /*<<camlinternalOO.ml:421:13>>*/ throw  /*<<camlinternalOO.ml:421:13>>*/ caml_maybe_attach_backtrace
+              ([0, Assert_failure, _f_], 1);
+       /*<<camlinternalOO.ml:422:19>>*/  /*<<camlinternalOO.ml:422:19>>*/ var
+       tables = tables$1[3];
+      if(! tables){
+        /*<<camlinternalOO.ml:446:35>>*/  /*<<camlinternalOO.ml:446:35>>*/ var
+        next = [0, key, 0, 0];
+       if(! tables$1)
+         /*<<camlinternalOO.ml:412:13>>*/ throw  /*<<camlinternalOO.ml:412:13>>*/ caml_maybe_attach_backtrace
+               ([0, Assert_failure, _c_], 1);
+       tables$1[3] = next;
+        /*<<camlinternalOO.ml:447:10>>*/ return build_path
+               (i - 1 | 0, keys, next);
+      }
+      var tables$1 = tables;
+     }
+    }
+    /*<<camlinternalOO.ml:457:48>>*/ }
+   function new_cache(table){
+     /*<<camlinternalOO.ml:509:2>>*/  /*<<camlinternalOO.ml:509:10>>*/ var
+     n = new_method(table);
+    a:
+    {
+     if(0 !== (n % 2 | 0)){
+      var _n_ = Stdlib_Sys[9];
+      if
+       ((2 + caml_div(caml_check_bound(table[2], 1)[2] * 16 | 0, _n_) | 0)
+        >= n){
+       var n$0 = new_method(table);
+       break a;
+      }
+     }
+     var n$0 = n;
+    }
+     /*<<camlinternalOO.ml:514:2>>*/ caml_check_bound(table[2], n$0)[1 + n$0]
+    = 0;
+     /*<<camlinternalOO.ml:514:2>>*/ return n$0;
+    /*<<camlinternalOO.ml:515:3>>*/ }
+   function set_methods(table, methods){
+     /*<<camlinternalOO.ml:600:2>>*/ var
+     len = methods.length - 1,
+      /*<<camlinternalOO.ml:600:44>>*/ i = [0, 0];
+    for(;;){
+     if(i[1] >= len) return 0;
+      /*<<camlinternalOO.ml:602:16>>*/ var
+      _h_ = i[1],
+       /*<<camlinternalOO.ml:602:16>>*/ label =
+        caml_check_bound(methods, _h_)[1 + _h_],
+      next =
+        function(param){
+          /*<<camlinternalOO.ml:545:16>>*/ i[1]++;
+         var _m_ = i[1];
+          /*<<camlinternalOO.ml:545:30>>*/ return caml_check_bound
+                  (methods, _m_)
+                 [1 + _m_];
+         /*<<camlinternalOO.ml:545:38>>*/ },
+       /*<<camlinternalOO.ml:546:8>>*/ clo = next(0);
+     if(typeof clo === "number")
+      switch(clo){
+        case 0:
+          /*<<camlinternalOO.ml:547:28>>*/ var
+           /*<<camlinternalOO.ml:547:28>>*/ x = next(0),
+          clo$0 =
+            function(x){
+               /*<<?>>*/ return function(obj){
+                /*<<camlinternalOO.ml:461:35>>*/ return x; /*<<camlinternalOO.ml:461:36>>*/ };
+             }
+             (x);
+         break;
+        case 1:
+          /*<<camlinternalOO.ml:548:24>>*/ var
+           /*<<camlinternalOO.ml:548:24>>*/ n = next(0),
+          clo$0 =
+            function(n){
+               /*<<?>>*/ return function(obj){
+                /*<<camlinternalOO.ml:462:34>>*/ return obj[1 + n]; /*<<camlinternalOO.ml:462:56>>*/ };
+             }
+             (n);
+         break;
+        case 2:
+          /*<<camlinternalOO.ml:549:24>>*/ var
+           /*<<camlinternalOO.ml:549:24>>*/ e = next(0),
+           /*<<camlinternalOO.ml:549:42>>*/ n$0 = next(0),
+          clo$0 =
+            function(e, n){
+               /*<<?>>*/ return function(obj){
+                /*<<camlinternalOO.ml:465:4>>*/ return obj[1 + e][1 + n]; /*<<camlinternalOO.ml:465:65>>*/ };
+             }
+             (e, n$0);
+         break;
+        case 3:
+          /*<<camlinternalOO.ml:550:24>>*/ var
+           /*<<camlinternalOO.ml:550:24>>*/ n$1 = next(0),
+          clo$0 =
+            function(n){
+               /*<<?>>*/ return function(obj){
+                /*<<camlinternalOO.ml:466:34>>*/ return  /*<<camlinternalOO.ml:466:34>>*/ caml_call1
+                       (obj[1][1 + n], obj); /*<<camlinternalOO.ml:466:48>>*/ };
+             }
+             (n$1);
+         break;
+        case 4:
+          /*<<camlinternalOO.ml:551:24>>*/ var
+           /*<<camlinternalOO.ml:551:24>>*/ n$2 = next(0),
+          clo$0 =
+            function(n){
+               /*<<?>>*/ return function(obj, x){
+                /*<<camlinternalOO.ml:467:36>>*/ obj[1 + n] = x;
+               return 0; /*<<camlinternalOO.ml:467:60>>*/ };
+             }
+             (n$2);
+         break;
+        case 5:
+          /*<<camlinternalOO.ml:552:24>>*/ var
+           /*<<camlinternalOO.ml:552:24>>*/ f = next(0),
+           /*<<camlinternalOO.ml:552:42>>*/ x$0 = next(0),
+          clo$0 =
+            function(f, x){
+               /*<<?>>*/ return function(obj){
+                /*<<camlinternalOO.ml:468:37>>*/ return  /*<<camlinternalOO.ml:468:20>>*/ caml_call1
+                       (f, x); /*<<camlinternalOO.ml:468:40>>*/ };
+             }
+             (f, x$0);
+         break;
+        case 6:
+          /*<<camlinternalOO.ml:553:24>>*/ var
+           /*<<camlinternalOO.ml:553:24>>*/ f$0 = next(0),
+           /*<<camlinternalOO.ml:553:42>>*/ n$3 = next(0),
+          clo$0 =
+            function(f, n){
+               /*<<?>>*/ return function(obj){
+                /*<<camlinternalOO.ml:469:36>>*/ return caml_call1
+                       (f, obj[1 + n]); /*<<camlinternalOO.ml:469:62>>*/ };
+             }
+             (f$0, n$3);
+         break;
+        case 7:
+          /*<<camlinternalOO.ml:555:14>>*/ var
+           /*<<camlinternalOO.ml:555:14>>*/ f$1 = next(0),
+           /*<<camlinternalOO.ml:555:33>>*/ e$0 = next(0),
+           /*<<camlinternalOO.ml:555:51>>*/ n$4 = next(0),
+          clo$0 =
+            function(f, e, n){
+               /*<<?>>*/ return function(obj){
+                /*<<camlinternalOO.ml:472:4>>*/ return caml_call1
+                       (f, obj[1 + e][1 + n]); /*<<camlinternalOO.ml:472:69>>*/ };
+             }
+             (f$1, e$0, n$4);
+         break;
+        case 8:
+          /*<<camlinternalOO.ml:557:24>>*/ var
+           /*<<camlinternalOO.ml:557:24>>*/ f$2 = next(0),
+           /*<<camlinternalOO.ml:557:42>>*/ n$5 = next(0),
+          clo$0 =
+            function(f, n){
+               /*<<?>>*/ return function(obj){
+                /*<<camlinternalOO.ml:473:36>>*/ return  /*<<camlinternalOO.ml:473:38>>*/ caml_call1
+                       (f,
+                         /*<<camlinternalOO.ml:473:38>>*/ caml_call1
+                         (obj[1][1 + n], obj)); /*<<camlinternalOO.ml:473:54>>*/ };
+             }
+             (f$2, n$5);
+         break;
+        case 9:
+          /*<<camlinternalOO.ml:559:14>>*/ var
+           /*<<camlinternalOO.ml:559:14>>*/ f$3 = next(0),
+           /*<<camlinternalOO.ml:559:32>>*/ x$1 = next(0),
+           /*<<camlinternalOO.ml:559:50>>*/ y = next(0),
+          clo$0 =
+            function(f, x, y){
+               /*<<?>>*/ return function(obj){
+                /*<<camlinternalOO.ml:474:45>>*/ return  /*<<camlinternalOO.ml:474:28>>*/ caml_call2
+                       (f, x, y); /*<<camlinternalOO.ml:474:50>>*/ };
+             }
+             (f$3, x$1, y);
+         break;
+        case 10:
+          /*<<camlinternalOO.ml:562:14>>*/ var
+           /*<<camlinternalOO.ml:562:14>>*/ f$4 = next(0),
+           /*<<camlinternalOO.ml:562:32>>*/ x$2 = next(0),
+           /*<<camlinternalOO.ml:562:50>>*/ n$6 = next(0),
+          clo$0 =
+            function(f, x, n){
+               /*<<?>>*/ return function(obj){
+                /*<<camlinternalOO.ml:475:44>>*/ return caml_call2
+                       (f, x, obj[1 + n]); /*<<camlinternalOO.ml:475:72>>*/ };
+             }
+             (f$4, x$2, n$6);
+         break;
+        case 11:
+          /*<<camlinternalOO.ml:565:14>>*/ var
+           /*<<camlinternalOO.ml:565:14>>*/ f$5 = next(0),
+           /*<<camlinternalOO.ml:565:32>>*/ x$3 = next(0),
+           /*<<camlinternalOO.ml:565:50>>*/ e$1 = next(0),
+           /*<<camlinternalOO.ml:565:69>>*/ n$7 = next(0),
+          clo$0 =
+            function(f, x, e, n){
+               /*<<?>>*/ return function(obj){
+                /*<<camlinternalOO.ml:481:4>>*/ return caml_call2
+                       (f, x, obj[1 + e][1 + n]); /*<<camlinternalOO.ml:481:71>>*/ };
+             }
+             (f$5, x$3, e$1, n$7);
+         break;
+        case 12:
+          /*<<camlinternalOO.ml:568:14>>*/ var
+           /*<<camlinternalOO.ml:568:14>>*/ f$6 = next(0),
+           /*<<camlinternalOO.ml:568:32>>*/ x$4 = next(0),
+           /*<<camlinternalOO.ml:568:50>>*/ n$8 = next(0),
+          clo$0 =
+            function(f, x, n){
+               /*<<?>>*/ return function(obj){
+                /*<<camlinternalOO.ml:476:43>>*/ return  /*<<camlinternalOO.ml:476:47>>*/ caml_call2
+                       (f,
+                        x,
+                         /*<<camlinternalOO.ml:476:47>>*/ caml_call1
+                         (obj[1][1 + n], obj)); /*<<camlinternalOO.ml:476:63>>*/ };
+             }
+             (f$6, x$4, n$8);
+         break;
+        case 13:
+          /*<<camlinternalOO.ml:571:14>>*/ var
+           /*<<camlinternalOO.ml:571:14>>*/ f$7 = next(0),
+           /*<<camlinternalOO.ml:571:32>>*/ n$9 = next(0),
+           /*<<camlinternalOO.ml:571:50>>*/ x$5 = next(0),
+          clo$0 =
+            function(f, n, x){
+               /*<<?>>*/ return function(obj){
+                /*<<camlinternalOO.ml:477:42>>*/ return  /*<<camlinternalOO.ml:477:26>>*/ caml_call2
+                       (f, obj[1 + n], x); /*<<camlinternalOO.ml:477:70>>*/ };
+             }
+             (f$7, n$9, x$5);
+         break;
+        case 14:
+          /*<<camlinternalOO.ml:574:14>>*/ var
+           /*<<camlinternalOO.ml:574:14>>*/ f$8 = next(0),
+           /*<<camlinternalOO.ml:574:32>>*/ e$2 = next(0),
+           /*<<camlinternalOO.ml:574:51>>*/ n$10 = next(0),
+           /*<<camlinternalOO.ml:574:69>>*/ x$6 = next(0),
+          clo$0 =
+            function(f, e, n, x){
+               /*<<?>>*/ return function(obj){
+                /*<<camlinternalOO.ml:484:4>>*/ return  /*<<camlinternalOO.ml:483:2>>*/ caml_call2
+                       (f, obj[1 + e][1 + n], x); /*<<camlinternalOO.ml:484:71>>*/ };
+             }
+             (f$8, e$2, n$10, x$6);
+         break;
+        case 15:
+          /*<<camlinternalOO.ml:577:14>>*/ var
+           /*<<camlinternalOO.ml:577:14>>*/ f$9 = next(0),
+           /*<<camlinternalOO.ml:577:32>>*/ n$11 = next(0),
+           /*<<camlinternalOO.ml:577:50>>*/ x$7 = next(0),
+          clo$0 =
+            function(f, n, x){
+               /*<<?>>*/ return function(obj){
+                /*<<camlinternalOO.ml:478:43>>*/ return  /*<<camlinternalOO.ml:478:27>>*/ caml_call2
+                       (f,
+                         /*<<camlinternalOO.ml:478:45>>*/ caml_call1
+                         (obj[1][1 + n], obj),
+                        x); /*<<camlinternalOO.ml:478:63>>*/ };
+             }
+             (f$9, n$11, x$7);
+         break;
+        case 16:
+          /*<<camlinternalOO.ml:580:14>>*/ var
+           /*<<camlinternalOO.ml:580:14>>*/ n$12 = next(0),
+           /*<<camlinternalOO.ml:580:32>>*/ x$8 = next(0),
+          clo$0 =
+            function(n, x){
+               /*<<?>>*/ return function(obj){
+                /*<<camlinternalOO.ml:485:41>>*/ return  /*<<camlinternalOO.ml:485:25>>*/ caml_call2
+                       (obj[1][1 + n], obj, x); /*<<camlinternalOO.ml:485:68>>*/ };
+             }
+             (n$12, x$8);
+         break;
+        case 17:
+          /*<<camlinternalOO.ml:582:14>>*/ var
+           /*<<camlinternalOO.ml:582:14>>*/ n$13 = next(0),
+           /*<<camlinternalOO.ml:582:32>>*/ m = next(0),
+          clo$0 =
+            function(n, m){
+               /*<<?>>*/ return function(obj){
+                /*<<camlinternalOO.ml:487:18>>*/ return caml_call2
+                       (obj[1][1 + n], obj, obj[1 + m]); /*<<camlinternalOO.ml:487:68>>*/ };
+             }
+             (n$13, m);
+         break;
+        case 18:
+          /*<<camlinternalOO.ml:584:14>>*/ var
+           /*<<camlinternalOO.ml:584:14>>*/ n$14 = next(0),
+           /*<<camlinternalOO.ml:584:32>>*/ e$3 = next(0),
+           /*<<camlinternalOO.ml:584:50>>*/ m$0 = next(0),
+          clo$0 =
+            function(n, e, m){
+               /*<<?>>*/ return function(obj){
+                /*<<camlinternalOO.ml:489:18>>*/ return caml_call2
+                       (obj[1][1 + n], obj, obj[1 + e][1 + m]); /*<<camlinternalOO.ml:490:69>>*/ };
+             }
+             (n$14, e$3, m$0);
+         break;
+        case 19:
+          /*<<camlinternalOO.ml:587:14>>*/ var
+           /*<<camlinternalOO.ml:587:14>>*/ n$15 = next(0),
+           /*<<camlinternalOO.ml:587:32>>*/ m$1 = next(0),
+          clo$0 =
+            function(n, m){
+               /*<<?>>*/ return function(obj){
+                /*<<camlinternalOO.ml:492:18>>*/  /*<<camlinternalOO.ml:492:44>>*/ var
+                _k_ =
+                   /*<<camlinternalOO.ml:492:44>>*/ caml_call1
+                   (obj[1][1 + m], obj);
+                /*<<camlinternalOO.ml:492:44>>*/ return  /*<<camlinternalOO.ml:492:44>>*/ caml_call2
+                       (obj[1][1 + n], obj, _k_); /*<<camlinternalOO.ml:492:60>>*/ };
+             }
+             (n$15, m$1);
+         break;
+        case 20:
+          /*<<camlinternalOO.ml:589:14>>*/ var
+           /*<<camlinternalOO.ml:589:14>>*/ m$2 = next(0),
+           /*<<camlinternalOO.ml:589:32>>*/ x$9 = next(0);
+          /*<<camlinternalOO.ml:589:57>>*/ new_cache(table);
+         var
+          clo$0 =
+            function(m, x){
+               /*<<?>>*/ return function(obj){
+                /*<<camlinternalOO.ml:494:18>>*/ return  /*<<camlinternalOO.ml:494:2>>*/ caml_call1
+                       (caml_get_public_method(x, m, 0), x); /*<<camlinternalOO.ml:494:58>>*/ };
+             }
+             (m$2, x$9);
+         break;
+        case 21:
+          /*<<camlinternalOO.ml:591:14>>*/ var
+           /*<<camlinternalOO.ml:591:14>>*/ m$3 = next(0),
+           /*<<camlinternalOO.ml:591:32>>*/ n$16 = next(0);
+          /*<<camlinternalOO.ml:591:56>>*/ new_cache(table);
+         var
+          clo$0 =
+            function(m, n){
+               /*<<?>>*/ return function(obj){
+                /*<<camlinternalOO.ml:497:4>>*/ var _j_ = obj[1 + n];
+               return caml_call1(caml_get_public_method(_j_, m, 0), _j_); /*<<camlinternalOO.ml:498:32>>*/ };
+             }
+             (m$3, n$16);
+         break;
+        case 22:
+          /*<<camlinternalOO.ml:593:14>>*/ var
+           /*<<camlinternalOO.ml:593:14>>*/ m$4 = next(0),
+           /*<<camlinternalOO.ml:593:32>>*/ e$4 = next(0),
+           /*<<camlinternalOO.ml:593:50>>*/ n$17 = next(0);
+          /*<<camlinternalOO.ml:594:21>>*/ new_cache(table);
+         var
+          clo$0 =
+            function(m, e, n){
+               /*<<?>>*/ return function(obj){
+                /*<<camlinternalOO.ml:501:4>>*/ var _i_ = obj[1 + e][1 + n];
+               return caml_call1(caml_get_public_method(_i_, m, 0), _i_); /*<<camlinternalOO.ml:504:34>>*/ };
+             }
+             (m$4, e$4, n$17);
+         break;
+        default:
+          /*<<camlinternalOO.ml:596:14>>*/ var
+           /*<<camlinternalOO.ml:596:14>>*/ m$5 = next(0),
+           /*<<camlinternalOO.ml:596:32>>*/ n$18 = next(0);
+          /*<<camlinternalOO.ml:596:57>>*/ new_cache(table);
+         var
+          clo$0 =
+            function(m, n){
+               /*<<?>>*/ return function(obj){
+                /*<<camlinternalOO.ml:507:4>>*/  /*<<camlinternalOO.ml:507:14>>*/ var
+                _l_ =
+                   /*<<camlinternalOO.ml:507:14>>*/ caml_call1
+                   (obj[1][1 + n], obj);
+                /*<<camlinternalOO.ml:507:14>>*/ return  /*<<camlinternalOO.ml:507:14>>*/ caml_call1
+                       (caml_get_public_method(_l_, m, 0), _l_); /*<<camlinternalOO.ml:507:59>>*/ };
+             }
+             (m$5, n$18);
+      }
+     else
+      var clo$0 = clo;
+      /*<<camlinternalOO.ml:603:4>>*/ set_method(table, label, clo$0);
+     i[1]++;
+    }
+    /*<<camlinternalOO.ml:605:6>>*/ }
+   function stats(param){
+     /*<<camlinternalOO.ml:613:2>>*/ return [0,
+            table_count[1],
+            method_count[1],
+            inst_var_count[1]];
+    /*<<camlinternalOO.ml:614:59>>*/ }
+   var
+    CamlinternalOO =
+      [0,
+       public_method_label,
+       new_method,
+       new_variable,
+       new_methods_variables,
+       get_variable,
+       get_variables,
+       get_method_label,
+       get_method_labels,
+       get_method,
+       set_method,
+       set_methods,
+       narrow,
+       widen,
+       add_initializer,
+       dummy_table,
+       create_table,
+       init_class,
+       inherits,
+       make_class,
+       make_class_store,
+       dummy_class,
+       copy,
+       create_object,
+       create_object_opt,
+       run_initializers,
+       run_initializers_opt,
+       create_object_and_run_initiali,
+       lookup_tables,
+       params,
+       stats];
+   runtime.caml_register_global(17, CamlinternalOO, "CamlinternalOO");
+   return;
+   /*<<?>>*/ }
+  (globalThis));
+
+//# unitInfo: Provides: Stdlib__Oo
+//# unitInfo: Requires: CamlinternalOO
+(function
+  (globalThis){
+   "use strict";
+   var
+    runtime = globalThis.jsoo_runtime,
+    global_data = runtime.caml_get_global_data(),
+    CamlinternalOO = global_data.CamlinternalOO,
+    copy = CamlinternalOO[22],
+    new_method = CamlinternalOO[1],
+    public_method_label = CamlinternalOO[1],
+    Stdlib_Oo = [0, copy, new_method, public_method_label];
+   runtime.caml_register_global(1, Stdlib_Oo, "Stdlib__Oo");
+   return;
+   /*<<?>>*/ }
+  (globalThis));
+
+//# unitInfo: Provides: CamlinternalMod
+//# unitInfo: Requires: Assert_failure, CamlinternalLazy, CamlinternalOO, Stdlib, Stdlib__Obj
+(function
+  (globalThis){
+   "use strict";
+   var
+    runtime = globalThis.jsoo_runtime,
+    cst_camlinternalMod_ml = "camlinternalMod.ml",
+    caml_check_bound = runtime.caml_check_bound,
+    caml_maybe_attach_backtrace = runtime.caml_maybe_attach_backtrace,
+    caml_obj_tag = runtime.caml_obj_tag;
+    /*<<?>>*/ function caml_call1(f, a0){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 1
+            ? f(a0)
+            : runtime.caml_call_gen(f, [a0]);
+   }
+   var
+    global_data = runtime.caml_get_global_data(),
+    Stdlib = global_data.Stdlib,
+    CamlinternalLazy = global_data.CamlinternalLazy,
+    CamlinternalOO = global_data.CamlinternalOO,
+    Assert_failure = global_data.Assert_failure,
+    _a_ = [0, cst_camlinternalMod_ml, 72, 5],
+    _b_ = [0, cst_camlinternalMod_ml, 81, 2],
+    cst_CamlinternalMod_update_mod =
+      "CamlinternalMod.update_mod: not a module",
+    cst_CamlinternalMod_init_mod_n = "CamlinternalMod.init_mod: not a module";
+   function init_mod_block(loc, comps$0){
+     /*<<camlinternalMod.ml:52:2>>*/ var
+     length = comps$0.length - 1,
+      /*<<camlinternalMod.ml:53:13>>*/ modu =
+        /*<<camlinternalMod.ml:53:13>>*/ runtime.caml_obj_block(0, length),
+      /*<<camlinternalMod.ml:54:2>>*/ _h_ = length - 1 | 0,
+      /*<<camlinternalMod.ml:53:13>>*/ _g_ = 0;
+    if(_h_ >= 0){
+     var i = _g_;
+     for(;;){
+       /*<<camlinternalMod.ml:55:30>>*/  /*<<camlinternalMod.ml:55:30>>*/ var
+       shape = caml_check_bound(comps$0, i)[1 + i];
+      if(typeof shape === "number")
+       switch(shape){
+         case 0:
+          var
+           fn$0 =
+             function(i){
+              function fn(x){
+                /*<<camlinternalMod.ml:28:9>>*/  /*<<camlinternalMod.ml:28:38>>*/ var
+                fn$0 = modu[1 + i];
+               if(fn === fn$0)
+                 /*<<camlinternalMod.ml:30:11>>*/ throw  /*<<camlinternalMod.ml:30:11>>*/ caml_maybe_attach_backtrace
+                       ([0, Stdlib[15], loc], 1);
+                /*<<camlinternalMod.ml:32:11>>*/ return  /*<<camlinternalMod.ml:32:11>>*/ caml_call1
+                       (fn$0, x);
+               /*<<camlinternalMod.ml:32:16>>*/ }
+              return fn;
+             },
+           fn = fn$0(i),
+           init = fn;
+          break;
+         case 1:
+          var l = [];
+          runtime.caml_update_dummy
+           (l,
+            [246,
+             function(l, i){
+                /*<<?>>*/ return function(param){
+                 /*<<camlinternalMod.ml:37:28>>*/  /*<<camlinternalMod.ml:37:28>>*/ var
+                 l$0 = modu[1 + i];
+                if(l === l$0)
+                  /*<<camlinternalMod.ml:39:13>>*/ throw  /*<<camlinternalMod.ml:39:13>>*/ caml_maybe_attach_backtrace
+                        ([0, Stdlib[15], loc], 1);
+                var _j_ = caml_obj_tag(l$0);
+                if(250 === _j_) return l$0[1];
+                if(246 !== _j_ && 244 !== _j_)
+                  /*<<camlinternalMod.ml:41:13>>*/ return l$0;
+                 /*<<camlinternalMod.ml:41:13>>*/ return  /*<<camlinternalMod.ml:41:13>>*/ caml_call1
+                        (CamlinternalLazy[2], l$0);};
+              }
+              (l, i)]);
+          var init = l;
+          break;
+         default:
+          var
+           init =
+              /*<<camlinternalMod.ml:44:16>>*/ caml_call1
+              (CamlinternalOO[21], loc);
+       }
+      else if(0 === shape[0])
+       var comps = shape[1], init = init_mod_block(loc, comps);
+      else
+       var v = shape[1], init = v;
+       /*<<camlinternalMod.ml:49:2>>*/ modu[1 + i] = init;
+       /*<<camlinternalMod.ml:55:4>>*/  /*<<camlinternalMod.ml:55:4>>*/ var
+       _i_ = i + 1 | 0;
+      if(_h_ === i) break;
+      var i = _i_;
+     }
+    }
+     /*<<camlinternalMod.ml:57:2>>*/ return modu;
+    /*<<camlinternalMod.ml:57:6>>*/ }
+   function init_mod(loc, shape){
+     /*<<camlinternalMod.ml:60:2>>*/ if
+     (typeof shape !== "number" && 0 === shape[0]){
+     var comps = shape[1];
+      /*<<camlinternalMod.ml:62:5>>*/ return init_mod_block(loc, comps);
+    }
+     /*<<camlinternalMod.ml:63:9>>*/ return  /*<<camlinternalMod.ml:63:9>>*/ caml_call1
+            (Stdlib[2], cst_CamlinternalMod_init_mod_n);
+    /*<<camlinternalMod.ml:63:58>>*/ }
+   function update_mod_block(comps$0, modu, n){
+     /*<<camlinternalMod.ml:81:2>>*/ if
+     (0 ===  /*<<camlinternalMod.ml:81:10>>*/ caml_obj_tag(n)
+      && comps$0.length - 1 <= n.length - 1){
+      /*<<camlinternalMod.ml:82:2>>*/ var
+      _e_ = comps$0.length - 1 - 1 | 0,
+       /*<<camlinternalMod.ml:82:2>>*/ _d_ = 0;
+     if(_e_ >= 0){
+      var i = _d_;
+      for(;;){
+        /*<<camlinternalMod.ml:83:35>>*/ var
+         /*<<camlinternalMod.ml:83:35>>*/ n$0 = n[1 + i],
+         /*<<camlinternalMod.ml:83:25>>*/ shape =
+          caml_check_bound(comps$0, i)[1 + i];
+       a:
+       if(typeof shape === "number"){
+        if(2 === shape){
+         if
+          (0 ===  /*<<camlinternalMod.ml:72:13>>*/ caml_obj_tag(n$0)
+           && 4 === n$0.length - 1){
+           /*<<camlinternalMod.ml:73:14>>*/ var
+            /*<<camlinternalMod.ml:73:14>>*/ cl = modu[1 + i],
+           j = 0;
+          for(;;){
+            /*<<camlinternalMod.ml:75:7>>*/ cl[1 + j] = n$0[1 + j];
+            /*<<camlinternalMod.ml:75:7>>*/  /*<<camlinternalMod.ml:75:7>>*/ var
+            _c_ = j + 1 | 0;
+           if(3 === j) break a;
+           var j = _c_;
+          }
+         }
+          /*<<camlinternalMod.ml:72:5>>*/ throw  /*<<camlinternalMod.ml:72:5>>*/ caml_maybe_attach_backtrace
+                ([0, Assert_failure, _a_], 1);
+        }
+         /*<<camlinternalMod.ml:68:5>>*/ modu[1 + i] = n$0;
+       }
+       else if(0 === shape[0]){
+        var comps = shape[1];
+         /*<<camlinternalMod.ml:78:5>>*/ update_mod_block
+         (comps, modu[1 + i], n$0);
+       }
+        /*<<camlinternalMod.ml:83:4>>*/  /*<<camlinternalMod.ml:83:4>>*/ var
+        _f_ = i + 1 | 0;
+       if(_e_ === i) break;
+       var i = _f_;
+      }
+     }
+     return 0;
+    }
+     /*<<camlinternalMod.ml:81:2>>*/ throw  /*<<camlinternalMod.ml:81:2>>*/ caml_maybe_attach_backtrace
+           ([0, Assert_failure, _b_], 1);
+    /*<<camlinternalMod.ml:84:6>>*/ }
+   function update_mod(shape, o, n){
+     /*<<camlinternalMod.ml:87:2>>*/ if
+     (typeof shape !== "number" && 0 === shape[0]){
+     var comps = shape[1];
+      /*<<camlinternalMod.ml:89:5>>*/ return update_mod_block(comps, o, n);
+    }
+     /*<<camlinternalMod.ml:90:9>>*/ return  /*<<camlinternalMod.ml:90:9>>*/ caml_call1
+            (Stdlib[2], cst_CamlinternalMod_update_mod);
+    /*<<camlinternalMod.ml:90:60>>*/ }
+   var CamlinternalMod = [0, init_mod, update_mod];
+   runtime.caml_register_global(8, CamlinternalMod, "CamlinternalMod");
+   return;
+   /*<<?>>*/ }
+  (globalThis));
+
+//# unitInfo: Provides: Stdlib__Ephemeron
+//# unitInfo: Requires: CamlinternalLazy, Stdlib, Stdlib__Array, Stdlib__Hashtbl, Stdlib__Int, Stdlib__List, Stdlib__Obj, Stdlib__Random, Stdlib__Seq, Stdlib__Sys
+(function
+  (globalThis){
+   "use strict";
+   var
+    runtime = globalThis.jsoo_runtime,
+    caml_check_bound = runtime.caml_check_bound,
+    caml_make_vect = runtime.caml_make_vect,
+    caml_maybe_attach_backtrace = runtime.caml_maybe_attach_backtrace,
+    caml_wrap_exception = runtime.caml_wrap_exception;
+    /*<<?>>*/ function caml_call1(f, a0){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 1
+            ? f(a0)
+            : runtime.caml_call_gen(f, [a0]);
+   }
+    /*<<?>>*/ function caml_call2(f, a0, a1){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 2
+            ? f(a0, a1)
+            : runtime.caml_call_gen(f, [a0, a1]);
+   }
+    /*<<?>>*/ function caml_call3(f, a0, a1, a2){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 3
+            ? f(a0, a1, a2)
+            : runtime.caml_call_gen(f, [a0, a1, a2]);
+   }
+   var
+    global_data = runtime.caml_get_global_data(),
+    Stdlib_List = global_data.Stdlib__List,
+    Stdlib = global_data.Stdlib,
+    Stdlib_Obj = global_data.Stdlib__Obj,
+    Stdlib_Sys = global_data.Stdlib__Sys,
+    Stdlib_Seq = global_data.Stdlib__Seq,
+    Stdlib_Int = global_data.Stdlib__Int,
+    Stdlib_Array = global_data.Stdlib__Array,
+    Stdlib_Hashtbl = global_data.Stdlib__Hashtbl,
+    CamlinternalLazy = global_data.CamlinternalLazy,
+    Stdlib_Random = global_data.Stdlib__Random,
+    _c_ = [0, 0],
+    _b_ = [0, 0],
+    _a_ = [0, 0];
+   function MakeSeeded(H){
+     /*<<ephemeron.ml:105:20>>*/  /*<<ephemeron.ml:105:20>>*/ var
+     prng =
+       [246,
+        function(_aM_){ /*<<?>>*/ return caml_call1(Stdlib_Random[15][2], 0);}];
+    function create(opt, initial_size){
+      /*<<ephemeron.ml:108:6>>*/ if(opt)
+      var sth = opt[1], random = sth;
+     else
+      var
+       random =  /*<<ephemeron.ml:107:26>>*/ caml_call1(Stdlib_Hashtbl[17], 0);
+     var x = 16;
+      /*<<ephemeron.ml:101:6>>*/ for(;;){
+      if(initial_size > x && Stdlib_Sys[13] >= (x * 2 | 0)){var x$0 = x * 2 | 0, x = x$0; continue;}
+       /*<<ephemeron.ml:109:6>>*/ if(random){
+       var _aK_ = runtime.caml_obj_tag(prng);
+       a:
+       if(250 === _aK_)
+        var _aL_ = prng[1];
+       else{
+        if(246 !== _aK_ && 244 !== _aK_){var _aL_ = prng; break a;}
+        var _aL_ = caml_call1(CamlinternalLazy[2], prng);
+       }
+       var
+        seed =
+           /*<<ephemeron.ml:109:32>>*/ caml_call1(Stdlib_Random[15][4], _aL_);
+      }
+      else
+       var seed = 0;
+       /*<<ephemeron.ml:110:6>>*/ return [0,
+              0,
+               /*<<ephemeron.ml:110:56>>*/ caml_make_vect(x, 0),
+              seed,
+              x];
+     }
+     /*<<ephemeron.ml:110:76>>*/ }
+    function clear(h){
+      /*<<ephemeron.ml:113:6>>*/ h[1] = 0;
+      /*<<ephemeron.ml:115:6>>*/ var
+      len = h[2].length - 1,
+       /*<<ephemeron.ml:115:6>>*/ _aI_ = len - 1 | 0,
+      _aH_ = 0;
+     if(_aI_ >= 0){
+      var i = _aH_;
+      for(;;){
+        /*<<ephemeron.ml:116:8>>*/ caml_check_bound(h[2], i)[1 + i] = 0;
+        /*<<ephemeron.ml:116:8>>*/  /*<<ephemeron.ml:116:8>>*/ var
+        _aJ_ = i + 1 | 0;
+       if(_aI_ === i) break;
+       var i = _aJ_;
+      }
+     }
+     return 0;
+     /*<<ephemeron.ml:117:10>>*/ }
+    function reset(h){
+      /*<<ephemeron.ml:120:6>>*/ var len = h[2].length - 1;
+     return len === h[4]
+             ? clear(h)
+             : (h
+                [1]
+               = 0,
+               h[2] =  /*<<ephemeron.ml:125:18>>*/ caml_make_vect(h[4], 0),
+               0);
+     /*<<ephemeron.ml:126:9>>*/ }
+    function copy(h){
+      /*<<ephemeron.ml:128:17>>*/ var
+      _aE_ = h[4],
+      _aF_ = h[3],
+       /*<<ephemeron.ml:128:33>>*/ _aG_ =
+         /*<<ephemeron.ml:128:33>>*/ caml_call1(Stdlib_Array[6], h[2]);
+      /*<<ephemeron.ml:128:17>>*/ return [0, h[1], _aG_, _aF_, _aE_];
+     /*<<ephemeron.ml:128:52>>*/ }
+    function key_index(h, hkey){
+      /*<<ephemeron.ml:131:6>>*/ return hkey & (h[2].length - 1 - 1 | 0);
+     /*<<ephemeron.ml:131:41>>*/ }
+    function clean(h){
+     function do_bucket(param){
+       /*<<ephemeron.ml:134:26>>*/ var param$0 = param;
+       /*<<ephemeron.ml:134:26>>*/ for(;;){
+       if(! param$0)  /*<<ephemeron.ml:136:12>>*/ return 0;
+       var hkey = param$0[1], rest = param$0[3], c = param$0[2];
+        /*<<ephemeron.ml:137:36>>*/ if
+        ( /*<<ephemeron.ml:137:36>>*/ caml_call1(H[6], c)){
+        var rest$0 = param$0[3], c$0 = param$0[2];
+         /*<<ephemeron.ml:141:12>>*/ return [0, hkey, c$0, do_bucket(rest$0)];
+       }
+       h[1] = h[1] - 1 | 0;
+       var param$0 = rest;
+      }
+      /*<<ephemeron.ml:141:41>>*/ }
+     var d = h[2], _aC_ = d.length - 1 - 1 | 0, _aB_ = 0;
+     if(_aC_ >= 0){
+      var i = _aB_;
+      for(;;){
+        /*<<ephemeron.ml:145:8>>*/ d[1 + i] =
+        do_bucket(caml_check_bound(d, i)[1 + i]);
+        /*<<ephemeron.ml:145:8>>*/  /*<<ephemeron.ml:145:8>>*/ var
+        _aD_ = i + 1 | 0;
+       if(_aC_ === i) break;
+       var i = _aD_;
+      }
+     }
+     return 0;
+     /*<<ephemeron.ml:146:10>>*/ }
+    function resize(h){
+      /*<<ephemeron.ml:169:6>>*/ var
+      odata = h[2],
+       /*<<ephemeron.ml:170:6>>*/ osize = odata.length - 1,
+      nsize = osize * 2 | 0;
+      /*<<ephemeron.ml:172:6>>*/ clean(h);
+     var
+      _av_ = nsize < Stdlib_Sys[13] ? 1 : 0,
+      _aw_ = _av_ ? (osize >>> 1 | 0) <= h[1] ? 1 : 0 : _av_;
+     if(_aw_){
+       /*<<ephemeron.ml:174:20>>*/  /*<<ephemeron.ml:174:20>>*/ var
+       ndata =  /*<<ephemeron.ml:174:20>>*/ caml_make_vect(nsize, 0);
+      h[2] = ndata;
+       /*<<ephemeron.ml:170:6>>*/ var
+       insert_bucket =
+         function(param){
+           /*<<ephemeron.ml:176:32>>*/ if(! param)
+            /*<<ephemeron.ml:177:21>>*/ return 0;
+          var rest = param[3], data = param[2], hkey = param[1];
+           /*<<ephemeron.ml:179:14>>*/ insert_bucket(rest);
+           /*<<ephemeron.ml:180:25>>*/  /*<<ephemeron.ml:180:25>>*/ var
+           nidx = key_index(h, hkey);
+           /*<<ephemeron.ml:181:14>>*/ ndata[1 + nidx] =
+           [0, hkey, data, caml_check_bound(ndata, nidx)[1 + nidx]];
+           /*<<ephemeron.ml:181:14>>*/ return 0;
+          /*<<ephemeron.ml:181:60>>*/ },
+        /*<<ephemeron.ml:170:6>>*/ _ay_ = osize - 1 | 0,
+        /*<<ephemeron.ml:182:8>>*/ _ax_ = 0;
+      if(_ay_ >= 0){
+       var i = _ax_;
+       for(;;){
+         /*<<ephemeron.ml:183:10>>*/ insert_bucket
+         (caml_check_bound(odata, i)[1 + i]);
+         /*<<ephemeron.ml:183:10>>*/  /*<<ephemeron.ml:183:10>>*/ var
+         _aA_ = i + 1 | 0;
+        if(_ay_ === i) break;
+        var i = _aA_;
+       }
+      }
+      var _az_ = 0;
+     }
+     else
+      var _az_ = _aw_;
+     return _az_;
+     /*<<ephemeron.ml:185:9>>*/ }
+    function add(h, key, info){
+      /*<<ephemeron.ml:188:6>>*/ var
+       /*<<ephemeron.ml:188:17>>*/ hkey =
+         /*<<ephemeron.ml:188:17>>*/ caml_call2(H[2], h[3], key),
+       /*<<ephemeron.ml:189:14>>*/ i = key_index(h, hkey),
+       /*<<ephemeron.ml:190:22>>*/ container =
+         /*<<ephemeron.ml:190:22>>*/ caml_call2(H[1], key, info),
+       /*<<ephemeron.ml:191:19>>*/ bucket =
+        [0, hkey, container, caml_check_bound(h[2], i)[1 + i]];
+      /*<<ephemeron.ml:192:6>>*/ caml_check_bound(h[2], i)[1 + i] = bucket;
+     h[1] = h[1] + 1 | 0;
+     var _au_ = h[2].length - 1 << 1 < h[1] ? 1 : 0;
+     return _au_ ? resize(h) : _au_;
+     /*<<ephemeron.ml:194:57>>*/ }
+    function remove(h, key){
+      /*<<ephemeron.ml:197:6>>*/  /*<<ephemeron.ml:197:17>>*/ var
+      hkey =  /*<<ephemeron.ml:197:17>>*/ caml_call2(H[2], h[3], key);
+     function remove_bucket(param){
+       /*<<ephemeron.ml:198:30>>*/ var param$0 = param;
+       /*<<ephemeron.ml:198:30>>*/ for(;;){
+       if(! param$0)  /*<<ephemeron.ml:199:19>>*/ return 0;
+       var hk = param$0[1], next = param$0[3], c = param$0[2];
+       if(hkey !== hk){
+        var next$0 = param$0[3], c$0 = param$0[2];
+         /*<<ephemeron.ml:210:29>>*/ return [0,
+                hk,
+                c$0,
+                remove_bucket(next$0)];
+       }
+       switch( /*<<ephemeron.ml:201:24>>*/ caml_call2(H[3], c, key)){
+         case 0:
+          h[1] = h[1] - 1 | 0;  /*<<ephemeron.ml:202:45>>*/ return next;
+         case 1:
+           /*<<ephemeron.ml:203:24>>*/ return [0, hk, c, remove_bucket(next)];
+         default: h[1] = h[1] - 1 | 0; var param$0 = next;
+       }
+      }
+      /*<<ephemeron.ml:210:60>>*/ }
+      /*<<ephemeron.ml:211:14>>*/ var
+       /*<<ephemeron.ml:211:14>>*/ i = key_index(h, hkey),
+       /*<<ephemeron.ml:212:20>>*/ _at_ =
+        remove_bucket(caml_check_bound(h[2], i)[1 + i]);
+      /*<<ephemeron.ml:212:6>>*/ caml_check_bound(h[2], i)[1 + i] = _at_;
+      /*<<ephemeron.ml:212:6>>*/ return 0;
+     /*<<ephemeron.ml:212:44>>*/ }
+    function find(h, key){
+      /*<<ephemeron.ml:239:6>>*/ var
+       /*<<ephemeron.ml:239:17>>*/ hkey =
+         /*<<ephemeron.ml:239:17>>*/ caml_call2(H[2], h[3], key),
+       /*<<ephemeron.ml:241:33>>*/ _as_ = key_index(h, hkey),
+      param = caml_check_bound(h[2], _as_)[1 + _as_];
+     for(;;){
+      if(! param)
+        /*<<ephemeron.ml:220:10>>*/ throw  /*<<ephemeron.ml:220:10>>*/ caml_maybe_attach_backtrace
+              (Stdlib[8], 1);
+      var hk = param[1], rest = param[3], c = param[2];
+      if(hkey === hk)
+       switch( /*<<ephemeron.ml:222:22>>*/ caml_call2(H[3], c, key)){
+         case 0:
+           /*<<ephemeron.ml:224:26>>*/  /*<<ephemeron.ml:224:26>>*/ var
+           match =  /*<<ephemeron.ml:224:26>>*/ caml_call1(H[4], c);
+          if(match){var d = match[1];  /*<<ephemeron.ml:229:26>>*/ return d;}
+          var param = rest;
+          break;
+         case 1:
+          var param = rest; break;
+         default: var param = rest;
+       }
+      else
+       var rest$0 = param[3], param = rest$0;
+     }
+     /*<<ephemeron.ml:241:51>>*/ }
+    function find_opt(h, key){
+      /*<<ephemeron.ml:264:6>>*/ var
+       /*<<ephemeron.ml:264:17>>*/ hkey =
+         /*<<ephemeron.ml:264:17>>*/ caml_call2(H[2], h[3], key),
+       /*<<ephemeron.ml:266:37>>*/ _ar_ = key_index(h, hkey),
+      param = caml_check_bound(h[2], _ar_)[1 + _ar_];
+     for(;;){
+      if(! param)  /*<<ephemeron.ml:245:10>>*/ return 0;
+      var hk = param[1], rest = param[3], c = param[2];
+      if(hkey === hk)
+       switch( /*<<ephemeron.ml:247:22>>*/ caml_call2(H[3], c, key)){
+         case 0:
+           /*<<ephemeron.ml:249:26>>*/  /*<<ephemeron.ml:249:26>>*/ var
+           d =  /*<<ephemeron.ml:249:26>>*/ caml_call1(H[4], c);
+          if(d)  /*<<ephemeron.ml:254:31>>*/ return d;
+          var param = rest;
+          break;
+         case 1:
+          var param = rest; break;
+         default: var param = rest;
+       }
+      else
+       var rest$0 = param[3], param = rest$0;
+     }
+     /*<<ephemeron.ml:266:55>>*/ }
+    function find_all(h, key){
+      /*<<ephemeron.ml:269:6>>*/  /*<<ephemeron.ml:269:17>>*/ var
+      hkey =  /*<<ephemeron.ml:269:17>>*/ caml_call2(H[2], h[3], key);
+     function find_in_bucket(param){
+       /*<<ephemeron.ml:270:31>>*/ var param$0 = param;
+       /*<<ephemeron.ml:270:31>>*/ for(;;){
+       if(! param$0)  /*<<ephemeron.ml:271:17>>*/ return 0;
+       var hk = param$0[1], rest = param$0[3], c = param$0[2];
+       if(hkey === hk)
+        switch( /*<<ephemeron.ml:273:22>>*/ caml_call2(H[3], c, key)){
+          case 0:
+            /*<<ephemeron.ml:274:33>>*/  /*<<ephemeron.ml:274:33>>*/ var
+            match =  /*<<ephemeron.ml:274:33>>*/ caml_call1(H[4], c);
+           if(match){
+            var d = match[1];
+             /*<<ephemeron.ml:277:26>>*/ return [0, d, find_in_bucket(rest)];
+           }
+           var param$0 = rest;
+           break;
+          case 1:
+           var param$0 = rest; break;
+          default: var param$0 = rest;
+        }
+       else
+        var rest$0 = param$0[3], param$0 = rest$0;
+      }
+      /*<<ephemeron.ml:284:29>>*/ }
+      /*<<ephemeron.ml:285:29>>*/  /*<<ephemeron.ml:285:29>>*/ var
+      _aq_ = key_index(h, hkey);
+      /*<<ephemeron.ml:285:21>>*/ return find_in_bucket
+             (caml_check_bound(h[2], _aq_)[1 + _aq_]);
+     /*<<ephemeron.ml:285:46>>*/ }
+    function replace(h, key, info){
+      /*<<ephemeron.ml:289:6>>*/ var
+       /*<<ephemeron.ml:289:17>>*/ hkey =
+         /*<<ephemeron.ml:289:17>>*/ caml_call2(H[2], h[3], key),
+       /*<<ephemeron.ml:299:14>>*/ i = key_index(h, hkey),
+       /*<<ephemeron.ml:300:14>>*/ l = caml_check_bound(h[2], i)[1 + i];
+      /*<<ephemeron.ml:301:6>>*/ try{
+      var param = l;
+       /*<<ephemeron.ml:290:31>>*/ for(;;){
+       if(! param)
+         /*<<ephemeron.ml:291:19>>*/ throw  /*<<ephemeron.ml:291:19>>*/ caml_maybe_attach_backtrace
+               (Stdlib[8], 1);
+       var hk = param[1], next = param[3], c = param[2];
+       if(hkey === hk){
+        if(!  /*<<ephemeron.ml:293:24>>*/ caml_call2(H[3], c, key)){
+          /*<<ephemeron.ml:290:6>>*/  /*<<ephemeron.ml:290:6>>*/ var
+          _am_ =  /*<<ephemeron.ml:290:6>>*/ caml_call3(H[5], c, key, info);
+          /*<<ephemeron.ml:302:8>>*/ return _am_;
+        }
+        var param = next;
+       }
+       else
+        var next$0 = param[3], param = next$0;
+      }
+     }
+     catch(_ap_){
+      var _an_ = caml_wrap_exception(_ap_);
+      if(_an_ !== Stdlib[8]) throw caml_maybe_attach_backtrace(_an_, 0);
+       /*<<ephemeron.ml:304:24>>*/  /*<<ephemeron.ml:304:24>>*/ var
+       container =  /*<<ephemeron.ml:304:24>>*/ caml_call2(H[1], key, info);
+       /*<<ephemeron.ml:305:8>>*/ caml_check_bound(h[2], i)[1 + i] = [0, hkey, container, l];
+      h[1] = h[1] + 1 | 0;
+      var _ao_ = h[2].length - 1 << 1 < h[1] ? 1 : 0;
+      return _ao_ ? resize(h) : _ao_;
+     }
+     /*<<ephemeron.ml:307:59>>*/ }
+    function mem(h, key){
+      /*<<ephemeron.ml:310:6>>*/ var
+       /*<<ephemeron.ml:310:17>>*/ hkey =
+         /*<<ephemeron.ml:310:17>>*/ caml_call2(H[2], h[3], key),
+       /*<<ephemeron.ml:320:28>>*/ _al_ = key_index(h, hkey),
+      param = caml_check_bound(h[2], _al_)[1 + _al_];
+      /*<<ephemeron.ml:311:30>>*/ for(;;){
+      if(! param)  /*<<ephemeron.ml:313:10>>*/ return 0;
+      var hk = param[1], rest = param[3], c = param[2];
+      if(hk === hkey){
+       if(!  /*<<ephemeron.ml:315:22>>*/ caml_call2(H[3], c, key))
+         /*<<ephemeron.ml:316:21>>*/ return 1;
+       var param = rest;
+      }
+      else
+       var rest$0 = param[3], param = rest$0;
+     }
+     /*<<ephemeron.ml:320:45>>*/ }
+    function length(h){
+      /*<<ephemeron.ml:322:19>>*/ return h[1];
+     /*<<ephemeron.ml:322:25>>*/ }
+    function bucket_length(accu, param){
+     var accu$0 = accu, param$0 = param;
+     for(;;){
+      if(! param$0)  /*<<ephemeron.ml:325:17>>*/ return accu$0;
+       /*<<ephemeron.ml:326:28>>*/ var
+       rest = param$0[3],
+        /*<<ephemeron.ml:326:28>>*/ accu$1 = accu$0 + 1 | 0,
+       accu$0 = accu$1,
+       param$0 = rest;
+     }
+    }
+    function stats(h){
+      /*<<ephemeron.ml:329:6>>*/ var _af_ = h[2], _ag_ = 0;
+     function _ah_(m, b){
+       /*<<ephemeron.ml:330:36>>*/  /*<<ephemeron.ml:330:46>>*/ var
+       _ak_ = bucket_length(0, b);
+       /*<<ephemeron.ml:330:46>>*/ return  /*<<ephemeron.ml:330:46>>*/ caml_call2
+              (Stdlib_Int[11], m, _ak_);
+      /*<<ephemeron.ml:330:65>>*/ }
+      /*<<ephemeron.ml:330:8>>*/ var
+       /*<<ephemeron.ml:330:8>>*/ mbl =
+         /*<<ephemeron.ml:330:8>>*/ caml_call3
+         (Stdlib_Array[15], _ah_, _ag_, _af_),
+       /*<<ephemeron.ml:331:18>>*/ histo =
+         /*<<ephemeron.ml:331:18>>*/ caml_make_vect(mbl + 1 | 0, 0),
+       /*<<ephemeron.ml:332:6>>*/ _ai_ = h[2];
+     function _aj_(b){
+       /*<<ephemeron.ml:334:11>>*/  /*<<ephemeron.ml:334:19>>*/ var
+       l = bucket_length(0, b);
+       /*<<ephemeron.ml:335:11>>*/ histo[1 + l] =
+       caml_check_bound(histo, l)[1 + l] + 1 | 0;
+       /*<<ephemeron.ml:335:11>>*/ return 0;
+      /*<<ephemeron.ml:335:37>>*/ }
+      /*<<ephemeron.ml:332:6>>*/  /*<<ephemeron.ml:332:6>>*/ caml_call2
+      (Stdlib_Array[11], _aj_, _ai_);
+      /*<<ephemeron.ml:337:6>>*/ return [0, h[1], h[2].length - 1, mbl, histo];
+     /*<<ephemeron.ml:340:34>>*/ }
+    function bucket_length_alive(accu, param){
+     var accu$0 = accu, param$0 = param;
+     for(;;){
+      if(! param$0)  /*<<ephemeron.ml:343:17>>*/ return accu$0;
+      var rest = param$0[3], c = param$0[2];
+       /*<<ephemeron.ml:344:30>>*/ if
+       ( /*<<ephemeron.ml:344:30>>*/ caml_call1(H[6], c))
+       var accu$1 = accu$0 + 1 | 0, accu$0 = accu$1, param$0 = rest;
+      else
+       var rest$0 = param$0[3], param$0 = rest$0;
+     }
+    }
+    function stats_alive(h){
+      /*<<ephemeron.ml:349:6>>*/ var
+       /*<<ephemeron.ml:349:17>>*/ size = [0, 0],
+       /*<<ephemeron.ml:350:6>>*/ _$_ = h[2],
+      _aa_ = 0;
+     function _ab_(m, b){
+       /*<<ephemeron.ml:352:22>>*/  /*<<ephemeron.ml:352:32>>*/ var
+       _ae_ = bucket_length_alive(0, b);
+       /*<<ephemeron.ml:352:32>>*/ return  /*<<ephemeron.ml:352:32>>*/ caml_call2
+              (Stdlib_Int[11], m, _ae_);
+      /*<<ephemeron.ml:352:57>>*/ }
+      /*<<ephemeron.ml:351:8>>*/ var
+       /*<<ephemeron.ml:351:8>>*/ mbl =
+         /*<<ephemeron.ml:351:8>>*/ caml_call3
+         (Stdlib_Array[15], _ab_, _aa_, _$_),
+       /*<<ephemeron.ml:354:18>>*/ histo =
+         /*<<ephemeron.ml:354:18>>*/ caml_make_vect(mbl + 1 | 0, 0),
+       /*<<ephemeron.ml:355:6>>*/ _ac_ = h[2];
+     function _ad_(b){
+       /*<<ephemeron.ml:357:11>>*/  /*<<ephemeron.ml:357:19>>*/ var
+       l = bucket_length_alive(0, b);
+      size[1] = size[1] + l | 0;
+       /*<<ephemeron.ml:359:11>>*/ histo[1 + l] =
+       caml_check_bound(histo, l)[1 + l] + 1 | 0;
+       /*<<ephemeron.ml:359:11>>*/ return 0;
+      /*<<ephemeron.ml:359:37>>*/ }
+      /*<<ephemeron.ml:355:6>>*/  /*<<ephemeron.ml:355:6>>*/ caml_call2
+      (Stdlib_Array[11], _ad_, _ac_);
+      /*<<ephemeron.ml:361:6>>*/ return [0,
+             size[1],
+             h[2].length - 1,
+             mbl,
+             histo];
+     /*<<ephemeron.ml:364:34>>*/ }
+    function add_seq(tbl, i){
+     function ___(param){
+       /*<<ephemeron.ml:367:15>>*/ var v = param[2], k = param[1];
+       /*<<ephemeron.ml:367:29>>*/ return add(tbl, k, v);
+      /*<<ephemeron.ml:367:41>>*/ }
+      /*<<ephemeron.ml:367:6>>*/ return  /*<<ephemeron.ml:367:6>>*/ caml_call2
+             (Stdlib_Seq[4], ___, i);
+     /*<<ephemeron.ml:367:43>>*/ }
+    function replace_seq(tbl, i){
+     function _Z_(param){
+       /*<<ephemeron.ml:370:15>>*/ var v = param[2], k = param[1];
+       /*<<ephemeron.ml:370:29>>*/ return replace(tbl, k, v);
+      /*<<ephemeron.ml:370:45>>*/ }
+      /*<<ephemeron.ml:370:6>>*/ return  /*<<ephemeron.ml:370:6>>*/ caml_call2
+             (Stdlib_Seq[4], _Z_, i);
+     /*<<ephemeron.ml:370:47>>*/ }
+    function of_seq(i){
+      /*<<ephemeron.ml:373:6>>*/  /*<<ephemeron.ml:373:16>>*/ var
+      tbl = create(0, 16);
+      /*<<ephemeron.ml:374:6>>*/ replace_seq(tbl, i);
+      /*<<ephemeron.ml:374:6>>*/ return tbl;
+     /*<<ephemeron.ml:375:9>>*/ }
+     /*<<ephemeron.ml:82:4>>*/ return [0,
+            create,
+            clear,
+            reset,
+            copy,
+            add,
+            remove,
+            find,
+            find_opt,
+            find_all,
+            replace,
+            mem,
+            length,
+            stats,
+            add_seq,
+            replace_seq,
+            of_seq,
+            clean,
+            stats_alive];
+   }
+   function create(param){
+     /*<<ephemeron.ml:394:30>>*/ return  /*<<ephemeron.ml:394:30>>*/ caml_call1
+            (Stdlib_Obj[24][1], 1);
+    /*<<ephemeron.ml:394:45>>*/ }
+   function get_key(t){
+     /*<<ephemeron.ml:396:42>>*/ return  /*<<ephemeron.ml:396:50>>*/ caml_call2
+            (Stdlib_Obj[24][3], t, 0);
+    /*<<ephemeron.ml:396:70>>*/ }
+   function set_key(t, k){
+     /*<<ephemeron.ml:397:44>>*/ return  /*<<ephemeron.ml:397:44>>*/ caml_call3
+            (Stdlib_Obj[24][5], t, 0, k);
+    /*<<ephemeron.ml:397:75>>*/ }
+   function check_key(t){
+     /*<<ephemeron.ml:398:39>>*/ return  /*<<ephemeron.ml:398:39>>*/ caml_call2
+            (Stdlib_Obj[24][7], t, 0);
+    /*<<ephemeron.ml:398:59>>*/ }
+   function get_data(t){
+     /*<<ephemeron.ml:400:43>>*/ return  /*<<ephemeron.ml:400:51>>*/ caml_call1
+            (Stdlib_Obj[24][9], t);
+    /*<<ephemeron.ml:400:70>>*/ }
+   function set_data(t, d){
+     /*<<ephemeron.ml:401:45>>*/ return  /*<<ephemeron.ml:401:45>>*/ caml_call2
+            (Stdlib_Obj[24][11], t, d);
+    /*<<ephemeron.ml:401:75>>*/ }
+   function make(key, data){
+     /*<<ephemeron.ml:405:4>>*/  /*<<ephemeron.ml:405:14>>*/ var
+     eph = create(0);
+     /*<<ephemeron.ml:406:4>>*/ set_data(eph, data);
+     /*<<ephemeron.ml:407:4>>*/ set_key(eph, key);
+     /*<<ephemeron.ml:407:4>>*/ return eph;
+    /*<<ephemeron.ml:408:7>>*/ }
+   function query(eph, key){
+     /*<<ephemeron.ml:411:4>>*/  /*<<ephemeron.ml:411:10>>*/ var
+     match = get_key(eph);
+    if(! match)  /*<<ephemeron.ml:412:14>>*/ return 0;
+    var k = match[1];
+    return k === key ? get_data(eph) : 0;
+    /*<<ephemeron.ml:414:20>>*/ }
+   function MakeSeeded$0(H){
+    function create$0(k, d){
+      /*<<ephemeron.ml:421:8>>*/  /*<<ephemeron.ml:421:16>>*/ var
+      c = create(0);
+      /*<<ephemeron.ml:422:8>>*/ set_data(c, d);
+      /*<<ephemeron.ml:423:8>>*/ set_key(c, k);
+      /*<<ephemeron.ml:423:8>>*/ return c;
+     /*<<ephemeron.ml:424:9>>*/ }
+    var seeded_hash = H[2];
+    function equal(c, k){
+      /*<<ephemeron.ml:429:8>>*/  /*<<ephemeron.ml:429:14>>*/ var
+      match = get_key(c);
+     if(! match)  /*<<ephemeron.ml:430:18>>*/ return 2;
+     var k$0 = match[1];
+      /*<<ephemeron.ml:432:15>>*/ return  /*<<ephemeron.ml:432:15>>*/ caml_call2
+              (H[1], k, k$0)
+             ? 0
+             : 1;
+     /*<<ephemeron.ml:432:76>>*/ }
+    function set_key_data(c, k, d){
+      /*<<ephemeron.ml:435:8>>*/  /*<<ephemeron.ml:402:40>>*/ caml_call1
+      (Stdlib_Obj[24][12], c);
+      /*<<ephemeron.ml:436:8>>*/ set_key(c, k);
+      /*<<ephemeron.ml:436:8>>*/ return set_data(c, d);
+     /*<<ephemeron.ml:437:20>>*/ }
+     /*<<ephemeron.ml:417:28>>*/ return MakeSeeded
+            ([0,
+              create$0,
+              seeded_hash,
+              equal,
+              get_data,
+              set_key_data,
+              check_key]);
+   }
+   function Make(H){
+    var equal = H[1];
+    function seeded_hash(seed, x){
+      /*<<ephemeron.ml:446:41>>*/ return  /*<<ephemeron.ml:446:41>>*/ caml_call1
+             (H[2], x);
+     /*<<ephemeron.ml:446:49>>*/ }
+    var
+     include = MakeSeeded$0([0, equal, seeded_hash]),
+     clear = include[2],
+     reset = include[3],
+     copy = include[4],
+     add = include[5],
+     remove = include[6],
+     find = include[7],
+     find_opt = include[8],
+     find_all = include[9],
+     replace = include[10],
+     mem = include[11],
+     length = include[12],
+     stats = include[13],
+     add_seq = include[14],
+     replace_seq = include[15],
+     clean = include[17],
+     stats_alive = include[18],
+     _Y_ = include[1];
+    function create(sz){
+      /*<<ephemeron.ml:448:20>>*/ return  /*<<ephemeron.ml:448:20>>*/ caml_call2
+             (_Y_, _a_, sz);
+     /*<<ephemeron.ml:448:43>>*/ }
+    function of_seq(i){
+      /*<<ephemeron.ml:450:6>>*/  /*<<ephemeron.ml:450:16>>*/ var
+      tbl = create(16);
+      /*<<ephemeron.ml:451:6>>*/  /*<<ephemeron.ml:451:6>>*/ caml_call2
+      (replace_seq, tbl, i);
+      /*<<ephemeron.ml:451:6>>*/ return tbl;
+     /*<<ephemeron.ml:452:9>>*/ }
+     /*<<ephemeron.ml:442:2>>*/ return [0,
+            create,
+            clear,
+            reset,
+            copy,
+            add,
+            remove,
+            find,
+            find_opt,
+            find_all,
+            replace,
+            mem,
+            length,
+            stats,
+            add_seq,
+            replace_seq,
+            of_seq,
+            clean,
+            stats_alive];
+   }
+   function make$0(param){
+     /*<<ephemeron.ml:459:18>>*/ return [0, 0];
+    /*<<ephemeron.ml:459:24>>*/ }
+   function add(b, k, d){
+     /*<<ephemeron.ml:460:20>>*/ var _X_ = b[1];
+    b[1] = [0, make(k, d), _X_];
+    return 0;
+    /*<<ephemeron.ml:460:42>>*/ }
+   function test_key(k, e){
+     /*<<ephemeron.ml:463:6>>*/  /*<<ephemeron.ml:463:12>>*/ var
+     match = get_key(e);
+    if(match){
+     var x = match[1];
+     if(x === k)  /*<<ephemeron.ml:464:30>>*/ return 1;
+    }
+     /*<<ephemeron.ml:465:13>>*/ return 0;
+    /*<<ephemeron.ml:465:18>>*/ }
+   function remove(b, k){
+     /*<<ephemeron.ml:468:6>>*/ var l$0 = b[1], l = l$0, acc = 0;
+     /*<<ephemeron.ml:469:8>>*/ for(;;){
+     if(! l)  /*<<ephemeron.ml:470:16>>*/ return 0;
+     var h = l[1], t = l[2];
+      /*<<ephemeron.ml:471:22>>*/ if(test_key(k, h)){
+      b[1] =  /*<<ephemeron.ml:471:43>>*/ caml_call2(Stdlib_List[12], acc, t);
+      return 0;
+     }
+      /*<<ephemeron.ml:472:27>>*/ var
+      t$0 = l[2],
+       /*<<ephemeron.ml:472:27>>*/ acc$0 = [0, h, acc],
+      l = t$0,
+      acc = acc$0;
+    }
+    /*<<ephemeron.ml:474:16>>*/ }
+   function find(b, k){
+     /*<<ephemeron.ml:477:6>>*/ var _U_ = b[1];
+     /*<<ephemeron.ml:477:26>>*/ function _V_(_W_){
+      /*<<?>>*/ return test_key(k, _W_);
+    }
+     /*<<ephemeron.ml:477:12>>*/  /*<<ephemeron.ml:477:12>>*/ var
+     match =
+        /*<<ephemeron.ml:477:12>>*/ caml_call2(Stdlib_List[39], _V_, _U_);
+    if(! match)  /*<<ephemeron.ml:479:16>>*/ return 0;
+    var e = match[1];
+     /*<<ephemeron.ml:478:18>>*/ return get_data(e);
+    /*<<ephemeron.ml:479:20>>*/ }
+   function length(b){
+     /*<<ephemeron.ml:481:19>>*/ return caml_call1(Stdlib_List[1], b[1]);
+    /*<<ephemeron.ml:481:33>>*/ }
+   function clear(b){
+     /*<<ephemeron.ml:482:18>>*/ b[1] = 0;
+    return 0;
+    /*<<ephemeron.ml:482:25>>*/ }
+   function create$0(param){
+     /*<<ephemeron.ml:491:35>>*/ return  /*<<ephemeron.ml:491:35>>*/ caml_call1
+            (Stdlib_Obj[24][1], 2);
+    /*<<ephemeron.ml:491:50>>*/ }
+   function get_key1(t){
+     /*<<ephemeron.ml:493:49>>*/ return  /*<<ephemeron.ml:493:57>>*/ caml_call2
+            (Stdlib_Obj[24][3], t, 0);
+    /*<<ephemeron.ml:493:77>>*/ }
+   function set_key1(t, k){
+     /*<<ephemeron.ml:495:4>>*/ return  /*<<ephemeron.ml:495:4>>*/ caml_call3
+            (Stdlib_Obj[24][5], t, 0, k);
+    /*<<ephemeron.ml:495:35>>*/ }
+   function get_key2(t){
+     /*<<ephemeron.ml:498:49>>*/ return  /*<<ephemeron.ml:498:57>>*/ caml_call2
+            (Stdlib_Obj[24][3], t, 1);
+    /*<<ephemeron.ml:498:77>>*/ }
+   function set_key2(t, k){
+     /*<<ephemeron.ml:500:4>>*/ return  /*<<ephemeron.ml:500:4>>*/ caml_call3
+            (Stdlib_Obj[24][5], t, 1, k);
+    /*<<ephemeron.ml:500:35>>*/ }
+   function get_data$0(t){
+     /*<<ephemeron.ml:503:48>>*/ return  /*<<ephemeron.ml:503:56>>*/ caml_call1
+            (Stdlib_Obj[24][9], t);
+    /*<<ephemeron.ml:503:75>>*/ }
+   function set_data$0(t, d){
+     /*<<ephemeron.ml:505:4>>*/ return  /*<<ephemeron.ml:505:4>>*/ caml_call2
+            (Stdlib_Obj[24][11], t, d);
+    /*<<ephemeron.ml:505:34>>*/ }
+   function make$1(key1, key2, data){
+     /*<<ephemeron.ml:509:4>>*/  /*<<ephemeron.ml:509:14>>*/ var
+     eph = create$0(0);
+     /*<<ephemeron.ml:510:4>>*/ set_data$0(eph, data);
+     /*<<ephemeron.ml:511:4>>*/ set_key1(eph, key1);
+     /*<<ephemeron.ml:512:4>>*/ set_key2(eph, key2);
+     /*<<ephemeron.ml:514:4>>*/ return eph;
+    /*<<ephemeron.ml:514:7>>*/ }
+   function query$0(eph, key1, key2){
+     /*<<ephemeron.ml:517:4>>*/  /*<<ephemeron.ml:517:10>>*/ var
+     match = get_key1(eph);
+    if(! match)  /*<<ephemeron.ml:518:14>>*/ return 0;
+    var k = match[1];
+    if(k !== key1)  /*<<ephemeron.ml:525:16>>*/ return 0;
+     /*<<ephemeron.ml:520:20>>*/  /*<<ephemeron.ml:520:20>>*/ var
+     match$0 = get_key2(eph);
+    if(! match$0)  /*<<ephemeron.ml:521:18>>*/ return 0;
+    var k$0 = match$0[1];
+    return k$0 === key2 ? get_data$0(eph) : 0;
+    /*<<ephemeron.ml:525:20>>*/ }
+   function MakeSeeded$1(H1, H2){
+    function create(param, d){
+      /*<<ephemeron.ml:534:16>>*/ var
+      k2 = param[2],
+      k1 = param[1],
+       /*<<ephemeron.ml:534:16>>*/ c = create$0(0);
+      /*<<ephemeron.ml:535:8>>*/ set_data$0(c, d);
+      /*<<ephemeron.ml:536:8>>*/ set_key1(c, k1);
+      /*<<ephemeron.ml:536:23>>*/ set_key2(c, k2);
+      /*<<ephemeron.ml:536:23>>*/ return c;
+    }
+    function seeded_hash(seed, param){
+      /*<<ephemeron.ml:539:33>>*/ var
+      k2 = param[2],
+      k1 = param[1],
+       /*<<ephemeron.ml:539:33>>*/ _T_ =
+         /*<<ephemeron.ml:539:33>>*/ caml_call2(H2[2], seed, k2) * 65599 | 0;
+      /*<<ephemeron.ml:539:8>>*/ return  /*<<ephemeron.ml:539:8>>*/ caml_call2
+             (H1[2], seed, k1)
+            + _T_
+            | 0;
+    }
+    function equal(c, param){
+      /*<<ephemeron.ml:541:14>>*/ var
+      k2 = param[2],
+      k1 = param[1],
+       /*<<ephemeron.ml:541:14>>*/ match = get_key1(c),
+       /*<<ephemeron.ml:541:26>>*/ match$0 = get_key2(c);
+     if(match && match$0){
+      var k2$0 = match$0[1], k1$0 = match[1];
+       /*<<ephemeron.ml:544:34>>*/ if
+       ( /*<<ephemeron.ml:544:15>>*/ caml_call2(H1[1], k1, k1$0)
+        &&  /*<<ephemeron.ml:544:34>>*/ caml_call2(H2[1], k2, k2$0))
+        /*<<ephemeron.ml:545:17>>*/ return 0;
+       /*<<ephemeron.ml:545:41>>*/ return 1;
+     }
+      /*<<ephemeron.ml:542:32>>*/ return 2;
+    }
+    function set_key_data(c, param, d){
+     var k2 = param[2], k1 = param[1];
+      /*<<ephemeron.ml:506:45>>*/  /*<<ephemeron.ml:506:45>>*/ caml_call1
+      (Stdlib_Obj[24][12], c);
+      /*<<ephemeron.ml:549:8>>*/ set_key1(c, k1);
+      /*<<ephemeron.ml:549:23>>*/ set_key2(c, k2);
+      /*<<ephemeron.ml:549:23>>*/ return set_data$0(c, d);
+    }
+    function check_key(c){
+      /*<<ephemeron.ml:551:24>>*/  /*<<ephemeron.ml:496:45>>*/ var
+      _S_ =  /*<<ephemeron.ml:496:45>>*/ caml_call2(Stdlib_Obj[24][7], c, 0);
+      /*<<ephemeron.ml:551:24>>*/ return _S_
+             ?  /*<<ephemeron.ml:501:45>>*/ caml_call2
+               (Stdlib_Obj[24][7], c, 1)
+             : _S_;
+     /*<<ephemeron.ml:551:52>>*/ }
+     /*<<ephemeron.ml:530:28>>*/ return MakeSeeded
+            ([0,
+              create,
+              seeded_hash,
+              equal,
+              get_data$0,
+              set_key_data,
+              check_key]);
+   }
+   function Make$0(H1, H2){
+    var equal = H2[1];
+    function seeded_hash(seed, x){
+      /*<<ephemeron.ml:566:43>>*/ return  /*<<ephemeron.ml:566:43>>*/ caml_call1
+             (H2[2], x);
+     /*<<ephemeron.ml:566:52>>*/ }
+     /*<<ephemeron.ml:563:9>>*/ var
+     equal$0 = H1[1],
+      /*<<ephemeron.ml:563:9>>*/ _Q_ = [0, equal, seeded_hash];
+    function seeded_hash$0(seed, x){
+      /*<<ephemeron.ml:561:43>>*/ return  /*<<ephemeron.ml:561:43>>*/ caml_call1
+             (H1[2], x);
+     /*<<ephemeron.ml:561:52>>*/ }
+    var
+     include = MakeSeeded$1([0, equal$0, seeded_hash$0], _Q_),
+     clear = include[2],
+     reset = include[3],
+     copy = include[4],
+     add = include[5],
+     remove = include[6],
+     find = include[7],
+     find_opt = include[8],
+     find_all = include[9],
+     replace = include[10],
+     mem = include[11],
+     length = include[12],
+     stats = include[13],
+     add_seq = include[14],
+     replace_seq = include[15],
+     clean = include[17],
+     stats_alive = include[18],
+     _R_ = include[1];
+    function create(sz){
+      /*<<ephemeron.ml:568:20>>*/ return  /*<<ephemeron.ml:568:20>>*/ caml_call2
+             (_R_, _b_, sz);
+     /*<<ephemeron.ml:568:43>>*/ }
+    function of_seq(i){
+      /*<<ephemeron.ml:570:6>>*/  /*<<ephemeron.ml:570:16>>*/ var
+      tbl = create(16);
+      /*<<ephemeron.ml:571:6>>*/  /*<<ephemeron.ml:571:6>>*/ caml_call2
+      (replace_seq, tbl, i);
+      /*<<ephemeron.ml:571:6>>*/ return tbl;
+     /*<<ephemeron.ml:572:9>>*/ }
+     /*<<ephemeron.ml:556:2>>*/ return [0,
+            create,
+            clear,
+            reset,
+            copy,
+            add,
+            remove,
+            find,
+            find_opt,
+            find_all,
+            replace,
+            mem,
+            length,
+            stats,
+            add_seq,
+            replace_seq,
+            of_seq,
+            clean,
+            stats_alive];
+   }
+   function make$2(param){
+     /*<<ephemeron.ml:579:18>>*/ return [0, 0];
+    /*<<ephemeron.ml:579:24>>*/ }
+   function add$0(b, k1, k2, d){
+     /*<<ephemeron.ml:580:24>>*/ var _P_ = b[1];
+    b[1] = [0, make$1(k1, k2, d), _P_];
+    return 0;
+    /*<<ephemeron.ml:580:50>>*/ }
+   function test_keys(k1, k2, e){
+     /*<<ephemeron.ml:583:6>>*/ var
+      /*<<ephemeron.ml:583:12>>*/ match = get_key1(e),
+      /*<<ephemeron.ml:583:24>>*/ match$0 = get_key2(e);
+    if(match && match$0){
+     var x2 = match$0[1], x1 = match[1];
+     if(x1 === k1 && x2 === k2)  /*<<ephemeron.ml:584:54>>*/ return 1;
+    }
+     /*<<ephemeron.ml:585:13>>*/ return 0;
+    /*<<ephemeron.ml:585:18>>*/ }
+   function remove$0(b, k1, k2){
+     /*<<ephemeron.ml:588:6>>*/ var l$0 = b[1], l = l$0, acc = 0;
+     /*<<ephemeron.ml:589:8>>*/ for(;;){
+     if(! l)  /*<<ephemeron.ml:590:16>>*/ return 0;
+     var h = l[1], t = l[2];
+      /*<<ephemeron.ml:591:22>>*/ if(test_keys(k1, k2, h)){
+      b[1] =  /*<<ephemeron.ml:591:48>>*/ caml_call2(Stdlib_List[12], acc, t);
+      return 0;
+     }
+      /*<<ephemeron.ml:592:27>>*/ var
+      t$0 = l[2],
+       /*<<ephemeron.ml:592:27>>*/ acc$0 = [0, h, acc],
+      l = t$0,
+      acc = acc$0;
+    }
+    /*<<ephemeron.ml:594:16>>*/ }
+   function find$0(b, k1, k2){
+     /*<<ephemeron.ml:597:6>>*/ var _M_ = b[1];
+     /*<<ephemeron.ml:597:26>>*/ function _N_(_O_){
+      /*<<?>>*/ return test_keys(k1, k2, _O_);
+    }
+     /*<<ephemeron.ml:597:12>>*/  /*<<ephemeron.ml:597:12>>*/ var
+     match =
+        /*<<ephemeron.ml:597:12>>*/ caml_call2(Stdlib_List[39], _N_, _M_);
+    if(! match)  /*<<ephemeron.ml:599:16>>*/ return 0;
+    var e = match[1];
+     /*<<ephemeron.ml:598:18>>*/ return get_data$0(e);
+    /*<<ephemeron.ml:599:20>>*/ }
+   function length$0(b){
+     /*<<ephemeron.ml:601:19>>*/ return caml_call1(Stdlib_List[1], b[1]);
+    /*<<ephemeron.ml:601:33>>*/ }
+   function clear$0(b){
+     /*<<ephemeron.ml:602:18>>*/ b[1] = 0;
+    return 0;
+    /*<<ephemeron.ml:602:25>>*/ }
+   function create$1(n){
+     /*<<ephemeron.ml:611:29>>*/ return  /*<<ephemeron.ml:611:29>>*/ caml_call1
+            (Stdlib_Obj[24][1], n);
+    /*<<ephemeron.ml:611:44>>*/ }
+   function length$1(k){
+     /*<<ephemeron.ml:612:35>>*/ return  /*<<ephemeron.ml:612:35>>*/ caml_call1
+            (Stdlib_Obj[24][2], k);
+    /*<<ephemeron.ml:612:50>>*/ }
+   function get_key$0(t, n){
+     /*<<ephemeron.ml:614:50>>*/ return  /*<<ephemeron.ml:614:58>>*/ caml_call2
+            (Stdlib_Obj[24][3], t, n);
+    /*<<ephemeron.ml:614:78>>*/ }
+   function set_key$0(t, n, k){
+     /*<<ephemeron.ml:616:4>>*/ return  /*<<ephemeron.ml:616:4>>*/ caml_call3
+            (Stdlib_Obj[24][5], t, n, k);
+    /*<<ephemeron.ml:616:35>>*/ }
+   function get_data$1(t){
+     /*<<ephemeron.ml:619:43>>*/ return  /*<<ephemeron.ml:619:51>>*/ caml_call1
+            (Stdlib_Obj[24][9], t);
+    /*<<ephemeron.ml:619:70>>*/ }
+   function set_data$1(t, d){
+     /*<<ephemeron.ml:620:45>>*/ return  /*<<ephemeron.ml:620:45>>*/ caml_call2
+            (Stdlib_Obj[24][11], t, d);
+    /*<<ephemeron.ml:620:75>>*/ }
+   function make$3(keys, data){
+     /*<<ephemeron.ml:624:4>>*/ var
+     l = keys.length - 1,
+      /*<<ephemeron.ml:625:14>>*/ eph = create$1(l);
+     /*<<ephemeron.ml:626:4>>*/ set_data$1(eph, data);
+     /*<<ephemeron.ml:626:4>>*/ var
+     _K_ = l - 1 | 0,
+      /*<<ephemeron.ml:626:4>>*/ _J_ = 0;
+    if(_K_ >= 0){
+     var i = _J_;
+     for(;;){
+       /*<<ephemeron.ml:627:26>>*/ set_key$0
+       (eph, i, caml_check_bound(keys, i)[1 + i]);
+       /*<<ephemeron.ml:627:26>>*/  /*<<ephemeron.ml:627:26>>*/ var
+       _L_ = i + 1 | 0;
+      if(_K_ === i) break;
+      var i = _L_;
+     }
+    }
+     /*<<ephemeron.ml:628:4>>*/ return eph;
+    /*<<ephemeron.ml:628:7>>*/ }
+   function query$1(eph, keys){
+     /*<<ephemeron.ml:631:4>>*/  /*<<ephemeron.ml:631:12>>*/ var
+     l = length$1(eph);
+     /*<<ephemeron.ml:632:4>>*/ try{
+     if(l !== keys.length - 1)
+       /*<<ephemeron.ml:633:37>>*/ throw  /*<<ephemeron.ml:633:37>>*/ caml_maybe_attach_backtrace
+             (Stdlib[3], 1);
+      /*<<ephemeron.ml:631:12>>*/ var
+       /*<<ephemeron.ml:631:12>>*/ _F_ = l - 1 | 0,
+       /*<<ephemeron.ml:634:6>>*/ _E_ = 0;
+     if(_F_ >= 0){
+      var i = _E_;
+      for(;;){
+        /*<<ephemeron.ml:635:14>>*/  /*<<ephemeron.ml:635:14>>*/ var
+        match = get_key$0(eph, i);
+       if(! match)
+         /*<<ephemeron.ml:636:18>>*/ throw  /*<<ephemeron.ml:636:18>>*/ caml_maybe_attach_backtrace
+               (Stdlib[3], 1);
+       var k = match[1];
+       if(k !== caml_check_bound(keys, i)[1 + i])
+         /*<<ephemeron.ml:638:20>>*/ throw  /*<<ephemeron.ml:638:20>>*/ caml_maybe_attach_backtrace
+               (Stdlib[3], 1);
+        /*<<ephemeron.ml:634:6>>*/  /*<<ephemeron.ml:634:6>>*/ var
+        _H_ = i + 1 | 0;
+       if(_F_ === i) break;
+       var i = _H_;
+      }
+     }
+      /*<<ephemeron.ml:640:6>>*/  /*<<ephemeron.ml:640:6>>*/ var
+      _G_ = get_data$1(eph);
+      /*<<ephemeron.ml:640:6>>*/ return _G_;
+    }
+    catch(_I_){
+     var _D_ = caml_wrap_exception(_I_);
+     if(_D_ === Stdlib[3])  /*<<ephemeron.ml:641:17>>*/ return 0;
+     throw caml_maybe_attach_backtrace(_D_, 0);
+    }
+    /*<<ephemeron.ml:641:21>>*/ }
+   function MakeSeeded$2(H){
+    function create(k, d){
+      /*<<ephemeron.ml:648:8>>*/  /*<<ephemeron.ml:648:16>>*/ var
+      c = create$1(k.length - 1);
+      /*<<ephemeron.ml:649:8>>*/ set_data$1(c, d);
+      /*<<ephemeron.ml:649:8>>*/ var
+      _B_ = k.length - 1 - 1 | 0,
+       /*<<ephemeron.ml:649:8>>*/ _A_ = 0;
+     if(_B_ >= 0){
+      var i = _A_;
+      for(;;){
+        /*<<ephemeron.ml:651:10>>*/ set_key$0
+        (c, i, caml_check_bound(k, i)[1 + i]);
+        /*<<ephemeron.ml:651:10>>*/  /*<<ephemeron.ml:651:10>>*/ var
+        _C_ = i + 1 | 0;
+       if(_B_ === i) break;
+       var i = _C_;
+      }
+     }
+      /*<<ephemeron.ml:653:8>>*/ return c;
+     /*<<ephemeron.ml:653:9>>*/ }
+    function seeded_hash(seed, k){
+      /*<<ephemeron.ml:655:8>>*/ var
+       /*<<ephemeron.ml:655:16>>*/ h = [0, 0],
+      _w_ = k.length - 1 - 1 | 0,
+       /*<<ephemeron.ml:655:16>>*/ _v_ = 0;
+     if(_w_ >= 0){
+      var i = _v_;
+      for(;;){
+        /*<<ephemeron.ml:657:34>>*/ var
+        _x_ = h[1],
+         /*<<ephemeron.ml:657:34>>*/ _y_ = caml_check_bound(k, i)[1 + i];
+       h[1] =
+        ( /*<<ephemeron.ml:657:15>>*/ caml_call2(H[2], seed, _y_) * 65599 | 0)
+        + _x_
+        | 0;
+        /*<<ephemeron.ml:656:8>>*/  /*<<ephemeron.ml:656:8>>*/ var
+        _z_ = i + 1 | 0;
+       if(_w_ === i) break;
+       var i = _z_;
+      }
+     }
+     return h[1];
+     /*<<ephemeron.ml:659:10>>*/ }
+    function equal(c, k){
+      /*<<ephemeron.ml:661:8>>*/ var
+      len = k.length - 1,
+       /*<<ephemeron.ml:662:19>>*/ len$0 = length$1(c);
+     if(len !== len$0)  /*<<ephemeron.ml:663:28>>*/ return 1;
+      /*<<ephemeron.ml:675:10>>*/ var
+       /*<<ephemeron.ml:675:10>>*/ i$1 = len - 1 | 0,
+      i = i$1;
+      /*<<ephemeron.ml:666:12>>*/ for(;;){
+      if(0 > i)  /*<<ephemeron.ml:666:26>>*/ return 0;
+       /*<<ephemeron.ml:668:20>>*/  /*<<ephemeron.ml:668:20>>*/ var
+       match = get_key$0(c, i);
+      if(! match)  /*<<ephemeron.ml:669:24>>*/ return 2;
+       /*<<ephemeron.ml:671:29>>*/ var
+       ki = match[1],
+        /*<<ephemeron.ml:671:29>>*/ _u_ = caml_check_bound(k, i)[1 + i];
+       /*<<ephemeron.ml:671:21>>*/ if
+       (!  /*<<ephemeron.ml:671:21>>*/ caml_call2(H[1], _u_, ki))
+        /*<<ephemeron.ml:673:23>>*/ return 1;
+       /*<<ephemeron.ml:672:23>>*/ var
+        /*<<ephemeron.ml:672:23>>*/ i$0 = i - 1 | 0,
+       i = i$0;
+     }
+     /*<<ephemeron.ml:675:33>>*/ }
+    function set_key_data(c, k, d){
+      /*<<ephemeron.ml:678:8>>*/  /*<<ephemeron.ml:621:40>>*/ caml_call1
+      (Stdlib_Obj[24][12], c);
+      /*<<ephemeron.ml:678:8>>*/ var
+      _s_ = k.length - 1 - 1 | 0,
+       /*<<ephemeron.ml:678:8>>*/ _r_ = 0;
+     if(_s_ >= 0){
+      var i = _r_;
+      for(;;){
+        /*<<ephemeron.ml:680:10>>*/ set_key$0
+        (c, i, caml_check_bound(k, i)[1 + i]);
+        /*<<ephemeron.ml:680:10>>*/  /*<<ephemeron.ml:680:10>>*/ var
+        _t_ = i + 1 | 0;
+       if(_s_ === i) break;
+       var i = _t_;
+      }
+     }
+      /*<<ephemeron.ml:682:8>>*/ return set_data$1(c, d);
+     /*<<ephemeron.ml:682:20>>*/ }
+    function check_key(c){
+      /*<<ephemeron.ml:684:8>>*/ var
+       /*<<ephemeron.ml:686:17>>*/ i$1 = length$1(c) - 1 | 0,
+      i = i$1;
+      /*<<ephemeron.ml:685:10>>*/ for(;;){
+      var _p_ = i < 0 ? 1 : 0;
+      if(_p_)
+       var _q_ = _p_;
+      else{
+        /*<<ephemeron.ml:617:47>>*/  /*<<ephemeron.ml:617:47>>*/ var
+        _o_ =  /*<<ephemeron.ml:617:47>>*/ caml_call2(Stdlib_Obj[24][7], c, i);
+        /*<<ephemeron.ml:685:20>>*/ if(_o_){
+        var i$0 = i - 1 | 0, i = i$0;
+        continue;
+       }
+       var _q_ = _o_;
+      }
+      return _q_;
+     }
+     /*<<ephemeron.ml:686:30>>*/ }
+     /*<<ephemeron.ml:644:28>>*/ return MakeSeeded
+            ([0,
+              create,
+              seeded_hash,
+              equal,
+              get_data$1,
+              set_key_data,
+              check_key]);
+   }
+   function Make$1(H){
+    var equal = H[1];
+    function seeded_hash(seed, x){
+      /*<<ephemeron.ml:694:41>>*/ return  /*<<ephemeron.ml:694:41>>*/ caml_call1
+             (H[2], x);
+     /*<<ephemeron.ml:694:49>>*/ }
+    var
+     include = MakeSeeded$2([0, equal, seeded_hash]),
+     clear = include[2],
+     reset = include[3],
+     copy = include[4],
+     add = include[5],
+     remove = include[6],
+     find = include[7],
+     find_opt = include[8],
+     find_all = include[9],
+     replace = include[10],
+     mem = include[11],
+     length = include[12],
+     stats = include[13],
+     add_seq = include[14],
+     replace_seq = include[15],
+     clean = include[17],
+     stats_alive = include[18],
+     _n_ = include[1];
+    function create(sz){
+      /*<<ephemeron.ml:696:20>>*/ return  /*<<ephemeron.ml:696:20>>*/ caml_call2
+             (_n_, _c_, sz);
+     /*<<ephemeron.ml:696:43>>*/ }
+    function of_seq(i){
+      /*<<ephemeron.ml:698:6>>*/  /*<<ephemeron.ml:698:16>>*/ var
+      tbl = create(16);
+      /*<<ephemeron.ml:699:6>>*/  /*<<ephemeron.ml:699:6>>*/ caml_call2
+      (replace_seq, tbl, i);
+      /*<<ephemeron.ml:699:6>>*/ return tbl;
+     /*<<ephemeron.ml:700:9>>*/ }
+     /*<<ephemeron.ml:690:2>>*/ return [0,
+            create,
+            clear,
+            reset,
+            copy,
+            add,
+            remove,
+            find,
+            find_opt,
+            find_all,
+            replace,
+            mem,
+            length,
+            stats,
+            add_seq,
+            replace_seq,
+            of_seq,
+            clean,
+            stats_alive];
+   }
+   function make$4(param){
+     /*<<ephemeron.ml:707:18>>*/ return [0, 0];
+    /*<<ephemeron.ml:707:24>>*/ }
+   function add$1(b, k, d){
+     /*<<ephemeron.ml:708:20>>*/ var _m_ = b[1];
+    b[1] = [0, make$3(k, d), _m_];
+    return 0;
+    /*<<ephemeron.ml:708:42>>*/ }
+   function test_keys$0(k, e){
+     /*<<ephemeron.ml:711:6>>*/ try{
+     if(length$1(e) !== k.length - 1)
+       /*<<ephemeron.ml:712:43>>*/ throw  /*<<ephemeron.ml:712:43>>*/ caml_maybe_attach_backtrace
+             (Stdlib[3], 1);
+      /*<<ephemeron.ml:713:8>>*/ var
+      _i_ = k.length - 1 - 1 | 0,
+       /*<<ephemeron.ml:713:8>>*/ _h_ = 0;
+     if(_i_ >= 0){
+      var i = _h_;
+      for(;;){
+        /*<<ephemeron.ml:714:16>>*/  /*<<ephemeron.ml:714:16>>*/ var
+        match = get_key$0(e, i);
+       if(match){
+        var x = match[1];
+        if(x === caml_check_bound(k, i)[1 + i]){
+          /*<<ephemeron.ml:713:8>>*/  /*<<ephemeron.ml:713:8>>*/ var
+          _k_ = i + 1 | 0;
+         if(_i_ === i) break;
+         var i = _k_;
+         continue;
+        }
+       }
+        /*<<ephemeron.ml:716:17>>*/ throw  /*<<ephemeron.ml:716:17>>*/ caml_maybe_attach_backtrace
+              (Stdlib[3], 1);
+      }
+     }
+      /*<<ephemeron.ml:718:8>>*/  /*<<ephemeron.ml:718:8>>*/ var _j_ = 1;
+      /*<<ephemeron.ml:718:8>>*/ return _j_;
+    }
+    catch(_l_){
+     var _g_ = caml_wrap_exception(_l_);
+     if(_g_ === Stdlib[3])  /*<<ephemeron.ml:719:19>>*/ return 0;
+     throw caml_maybe_attach_backtrace(_g_, 0);
+    }
+    /*<<ephemeron.ml:719:24>>*/ }
+   function remove$1(b, k){
+     /*<<ephemeron.ml:722:6>>*/ var l$0 = b[1], l = l$0, acc = 0;
+     /*<<ephemeron.ml:723:8>>*/ for(;;){
+     if(! l)  /*<<ephemeron.ml:724:16>>*/ return 0;
+     var h = l[1], t = l[2];
+      /*<<ephemeron.ml:725:22>>*/ if(test_keys$0(k, h)){
+      b[1] =  /*<<ephemeron.ml:725:44>>*/ caml_call2(Stdlib_List[12], acc, t);
+      return 0;
+     }
+      /*<<ephemeron.ml:726:27>>*/ var
+      t$0 = l[2],
+       /*<<ephemeron.ml:726:27>>*/ acc$0 = [0, h, acc],
+      l = t$0,
+      acc = acc$0;
+    }
+    /*<<ephemeron.ml:728:16>>*/ }
+   function find$1(b, k){
+     /*<<ephemeron.ml:731:6>>*/ var _d_ = b[1];
+     /*<<ephemeron.ml:731:26>>*/ function _e_(_f_){
+      /*<<?>>*/ return test_keys$0(k, _f_);
+    }
+     /*<<ephemeron.ml:731:12>>*/  /*<<ephemeron.ml:731:12>>*/ var
+     match =
+        /*<<ephemeron.ml:731:12>>*/ caml_call2(Stdlib_List[39], _e_, _d_);
+    if(! match)  /*<<ephemeron.ml:733:16>>*/ return 0;
+    var e = match[1];
+     /*<<ephemeron.ml:732:18>>*/ return get_data$1(e);
+    /*<<ephemeron.ml:733:20>>*/ }
+   function length$2(b){
+     /*<<ephemeron.ml:735:19>>*/ return caml_call1(Stdlib_List[1], b[1]);
+    /*<<ephemeron.ml:735:33>>*/ }
+   function clear$1(b){
+     /*<<ephemeron.ml:736:18>>*/ b[1] = 0;
+    return 0;
+    /*<<ephemeron.ml:736:25>>*/ }
+   var
+    Stdlib_Ephemeron =
+      [0,
+       [0,
+        make,
+        query,
+        Make,
+        MakeSeeded$0,
+        [0, make$0, add, remove, find, length, clear]],
+       [0,
+        make$1,
+        query$0,
+        Make$0,
+        MakeSeeded$1,
+        [0, make$2, add$0, remove$0, find$0, length$0, clear$0]],
+       [0,
+        make$3,
+        query$1,
+        Make$1,
+        MakeSeeded$2,
+        [0, make$4, add$1, remove$1, find$1, length$2, clear$1]]];
+   runtime.caml_register_global(13, Stdlib_Ephemeron, "Stdlib__Ephemeron");
+   return;
+   /*<<?>>*/ }
+  (globalThis));
+
+//# unitInfo: Provides: Stdlib__Filename
+//# unitInfo: Requires: Stdlib, Stdlib__Buffer, Stdlib__Domain, Stdlib__List, Stdlib__Printf, Stdlib__Random, Stdlib__String, Stdlib__Sys
+(function
+  (globalThis){
+   "use strict";
+   var
+    runtime = globalThis.jsoo_runtime,
+    cst$19 = "",
+    cst$23 = " ",
+    cst_2$1 = " 2>",
+    cst_2_1$1 = " 2>&1",
+    cst$22 = " <",
+    cst$21 = " >",
+    cst$20 = '"',
+    cst$24 = ".",
+    cst$25 = "..",
+    cst$28 = "../",
+    cst$27 = "./",
+    cst$26 = "/",
+    cst_dev_null = "/dev/null",
+    caml_equal = runtime.caml_equal,
+    caml_maybe_attach_backtrace = runtime.caml_maybe_attach_backtrace,
+    caml_ml_string_length = runtime.caml_ml_string_length,
+    caml_string_equal = runtime.caml_string_equal,
+    caml_string_get = runtime.caml_string_get,
+    caml_string_notequal = runtime.caml_string_notequal,
+    caml_sys_getenv = runtime.caml_sys_getenv,
+    caml_trampoline = runtime.caml_trampoline,
+    caml_trampoline_return = runtime.caml_trampoline_return,
+    caml_wrap_exception = runtime.caml_wrap_exception;
+    /*<<?>>*/ function caml_call1(f, a0){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 1
+            ? f(a0)
+            : runtime.caml_call_gen(f, [a0]);
+   }
+    /*<<?>>*/ function caml_call2(f, a0, a1){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 2
+            ? f(a0, a1)
+            : runtime.caml_call_gen(f, [a0, a1]);
+   }
+    /*<<?>>*/ function caml_call3(f, a0, a1, a2){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 3
+            ? f(a0, a1, a2)
+            : runtime.caml_call_gen(f, [a0, a1, a2]);
+   }
+    /*<<?>>*/ function caml_call4(f, a0, a1, a2, a3){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 4
+            ? f(a0, a1, a2, a3)
+            : runtime.caml_call_gen(f, [a0, a1, a2, a3]);
+   }
+   var
+    global_data = runtime.caml_get_global_data(),
+    cst$18 = cst$19,
+    cst$17 = cst$19,
+    cst$16 = cst$19,
+    cst$8 = cst$21,
+    cst$15 = cst$19,
+    cst$9 = cst$22,
+    cst$14 = cst$19,
+    cst$10 = cst$23,
+    cst$11 = cst$23,
+    cst$12 = cst$20,
+    cst$13 = cst$19,
+    cst$6 = cst$20,
+    cst$7 = cst$20,
+    cst$4 = cst$19,
+    cst = cst$21,
+    cst$3 = cst$19,
+    cst$0 = cst$22,
+    cst$2 = cst$19,
+    cst$1 = cst$23,
+    null$0 = cst_dev_null,
+    current_dir_name = cst$24,
+    parent_dir_name = cst$25,
+    dir_sep = cst$26,
+    quotequote = "'\\''",
+    null$1 = "NUL",
+    current_dir_name$0 = cst$24,
+    parent_dir_name$0 = cst$25,
+    dir_sep$0 = "\\",
+    cst$5 = cst$24,
+    null$2 = cst_dev_null,
+    current_dir_name$1 = cst$24,
+    parent_dir_name$1 = cst$25,
+    dir_sep$1 = cst$26,
+    Stdlib = global_data.Stdlib,
+    Stdlib_Domain = global_data.Stdlib__Domain,
+    Stdlib_Random = global_data.Stdlib__Random,
+    Stdlib_Printf = global_data.Stdlib__Printf,
+    Stdlib_String = global_data.Stdlib__String,
+    Stdlib_List = global_data.Stdlib__List,
+    Stdlib_Buffer = global_data.Stdlib__Buffer,
+    Stdlib_Sys = global_data.Stdlib__Sys,
+    _i_ = [0, 7, 0],
+    _h_ = [0, 1, [0, 3, [0, 5, 0]]],
+    _e_ = [0, [2, 0, [4, 6, [0, 2, 6], 0, [2, 0, 0]]], "%s%06x%s"],
+    cst_Filename_chop_extension = "Filename.chop_extension",
+    cst_Filename_chop_suffix = "Filename.chop_suffix",
+    _c_ = [0, cst$20, 0],
+    cst_2_1$0 = cst_2_1$1,
+    cst_2$0 = cst_2$1,
+    cst_Filename_quote_command_bad = "Filename.quote_command: bad file name ",
+    cst_2_1 = cst_2_1$1,
+    cst_2 = cst_2$1,
+    cst_tmp = "/tmp";
+   function generic_basename(is_dir_sep, current_dir_name, name){
+     /*<<filename.ml:37:2>>*/ if
+     ( /*<<filename.ml:46:5>>*/ caml_string_equal(name, cst$19))
+      /*<<filename.ml:47:7>>*/ return current_dir_name;
+    var n$3 = caml_ml_string_length(name) - 1 | 0, n = n$3;
+     /*<<filename.ml:38:4>>*/ for(;;){
+     if(0 > n)
+       /*<<filename.ml:38:18>>*/ return  /*<<filename.ml:38:18>>*/ caml_call3
+              (Stdlib_String[15], name, 0, 1);
+      /*<<filename.ml:39:12>>*/ if
+      ( /*<<filename.ml:39:12>>*/ caml_call2(is_dir_sep, name, n))
+       /*<<filename.ml:39:35>>*/ var
+        /*<<filename.ml:39:35>>*/ n$0 = n - 1 | 0,
+       n = n$0;
+     else{
+       /*<<filename.ml:40:9>>*/ var
+        /*<<filename.ml:40:9>>*/ p = n + 1 | 0,
+       n$1 = n;
+       /*<<filename.ml:42:4>>*/ for(;;){
+       if(0 > n$1)
+         /*<<filename.ml:42:18>>*/ return  /*<<filename.ml:42:18>>*/ caml_call3
+                (Stdlib_String[15], name, 0, p);
+        /*<<filename.ml:43:12>>*/ if
+        ( /*<<filename.ml:43:12>>*/ caml_call2(is_dir_sep, name, n$1))
+         /*<<filename.ml:37:2>>*/ return  /*<<filename.ml:37:2>>*/ caml_call3
+                (Stdlib_String[15], name, n$1 + 1 | 0, (p - n$1 | 0) - 1 | 0);
+       var n$2 = n$1 - 1 | 0, n$1 = n$2;
+      }
+     }
+    }
+    /*<<filename.ml:48:40>>*/ }
+   function generic_dirname(is_dir_sep, current_dir_name, name){
+     /*<<filename.ml:55:2>>*/ if
+     ( /*<<filename.ml:68:5>>*/ caml_string_equal(name, cst$19))
+      /*<<filename.ml:69:7>>*/ return current_dir_name;
+    var n$5 = caml_ml_string_length(name) - 1 | 0, n = n$5;
+     /*<<filename.ml:56:4>>*/ for(;;){
+     if(0 > n)
+       /*<<filename.ml:56:18>>*/ return  /*<<filename.ml:56:18>>*/ caml_call3
+              (Stdlib_String[15], name, 0, 1);
+      /*<<filename.ml:57:12>>*/ if
+      ( /*<<filename.ml:57:12>>*/ caml_call2(is_dir_sep, name, n))
+       /*<<filename.ml:57:35>>*/ var
+        /*<<filename.ml:57:35>>*/ n$0 = n - 1 | 0,
+       n = n$0;
+     else{
+      var n$1 = n;
+       /*<<filename.ml:60:4>>*/ for(;;){
+       if(0 > n$1) return current_dir_name;
+        /*<<filename.ml:61:12>>*/ if
+        ( /*<<filename.ml:61:12>>*/ caml_call2(is_dir_sep, name, n$1)){
+        var n$3 = n$1;
+         /*<<filename.ml:64:4>>*/ for(;;){
+         if(0 > n$3)
+           /*<<filename.ml:64:18>>*/ return  /*<<filename.ml:64:18>>*/ caml_call3
+                  (Stdlib_String[15], name, 0, 1);
+          /*<<filename.ml:65:12>>*/ if
+          (!  /*<<filename.ml:65:12>>*/ caml_call2(is_dir_sep, name, n$3))
+           /*<<filename.ml:66:9>>*/ return  /*<<filename.ml:66:9>>*/ caml_call3
+                  (Stdlib_String[15], name, 0, n$3 + 1 | 0);
+          /*<<filename.ml:65:35>>*/ var
+           /*<<filename.ml:65:35>>*/ n$4 = n$3 - 1 | 0,
+          n$3 = n$4;
+        }
+       }
+       else
+         /*<<filename.ml:62:9>>*/ var
+          /*<<filename.ml:62:9>>*/ n$2 = n$1 - 1 | 0,
+         n$1 = n$2;
+      }
+     }
+    }
+    /*<<filename.ml:70:44>>*/ }
+   function is_dir_sep(s, i){
+     /*<<filename.ml:96:23>>*/ return 47
+            ===  /*<<filename.ml:96:23>>*/ caml_string_get(s, i)
+            ? 1
+            : 0;
+    /*<<filename.ml:96:34>>*/ }
+   function is_relative(n){
+     /*<<filename.ml:97:22>>*/ var
+     _aK_ = caml_ml_string_length(n) < 1 ? 1 : 0,
+     _aL_ =
+       _aK_
+       || (47 !==  /*<<filename.ml:97:45>>*/ caml_string_get(n, 0) ? 1 : 0);
+    return _aL_;
+    /*<<filename.ml:97:57>>*/ }
+   function is_implicit(n){
+     /*<<filename.ml:99:4>>*/  /*<<filename.ml:99:4>>*/ var
+     _aF_ = is_relative(n);
+     /*<<filename.ml:99:4>>*/ if(_aF_){
+     var
+      _aG_ = caml_ml_string_length(n) < 2 ? 1 : 0,
+      _aH_ =
+        _aG_
+        ||
+          /*<<filename.ml:100:31>>*/ caml_string_notequal
+          ( /*<<filename.ml:100:31>>*/ caml_call3(Stdlib_String[15], n, 0, 2),
+           cst$27);
+      /*<<filename.ml:100:31>>*/ if(_aH_)
+      var
+       _aI_ = caml_ml_string_length(n) < 3 ? 1 : 0,
+       _aJ_ =
+         _aI_
+         ||
+           /*<<filename.ml:101:31>>*/ caml_string_notequal
+           ( /*<<filename.ml:101:31>>*/ caml_call3(Stdlib_String[15], n, 0, 3),
+            cst$28);
+     else
+      var _aJ_ = _aH_;
+    }
+    else
+     var _aJ_ = _aF_;
+     /*<<filename.ml:101:31>>*/ return _aJ_;
+    /*<<filename.ml:101:57>>*/ }
+   function check_suffix(name, suff){
+     /*<<filename.ml:103:4>>*/ return  /*<<filename.ml:103:4>>*/ caml_call2
+            (Stdlib_String[11], suff, name);
+    /*<<filename.ml:103:38>>*/ }
+   function chop_suffix_opt(suffix, filename){
+     /*<<filename.ml:106:4>>*/ var
+     len_s = caml_ml_string_length(suffix),
+     len_f = caml_ml_string_length(filename);
+    if(len_s > len_f)  /*<<filename.ml:114:6>>*/ return 0;
+     /*<<filename.ml:108:14>>*/  /*<<filename.ml:108:14>>*/ var
+     r =
+        /*<<filename.ml:108:14>>*/ caml_call3
+        (Stdlib_String[15], filename, len_f - len_s | 0, len_s);
+     /*<<filename.ml:109:9>>*/ return  /*<<filename.ml:109:9>>*/ caml_string_equal
+             (r, suffix)
+            ? [0,
+               /*<<filename.ml:110:13>>*/ caml_call3
+               (Stdlib_String[15], filename, 0, len_f - len_s | 0)]
+            : 0;
+    /*<<filename.ml:114:10>>*/ }
+   try{
+     /*<<filename.ml:117:8>>*/ var
+      /*<<filename.ml:117:8>>*/ _k_ =
+        /*<<filename.ml:117:8>>*/ caml_sys_getenv("TMPDIR"),
+     temp_dir_name = _k_;
+   }
+   catch(_aE_){
+    var _a_ = caml_wrap_exception(_aE_);
+    if(_a_ !== Stdlib[8]) throw caml_maybe_attach_backtrace(_a_, 0);
+    var temp_dir_name = cst_tmp;
+   }
+    /*<<filename.ml:118:14>>*/ function quote(s){
+     /*<<filename.ml:18:10>>*/ var
+     l = caml_ml_string_length(s),
+      /*<<filename.ml:18:10>>*/ b =
+        /*<<filename.ml:18:10>>*/ caml_call1(Stdlib_Buffer[1], l + 20 | 0);
+     /*<<filename.ml:19:2>>*/  /*<<filename.ml:19:2>>*/ caml_call2
+     (Stdlib_Buffer[12], b, 39);
+     /*<<filename.ml:19:2>>*/ var
+     _aB_ = l - 1 | 0,
+      /*<<filename.ml:19:2>>*/ _aA_ = 0;
+    if(_aB_ >= 0){
+     var i = _aA_;
+     for(;;){
+       /*<<filename.ml:21:7>>*/ if
+       (39 ===  /*<<filename.ml:21:7>>*/ caml_string_get(s, i))
+        /*<<filename.ml:22:9>>*/  /*<<filename.ml:22:9>>*/ caml_call2
+        (Stdlib_Buffer[16], b, quotequote);
+      else{
+        /*<<filename.ml:23:28>>*/  /*<<filename.ml:23:28>>*/ var
+        _aD_ =  /*<<filename.ml:23:28>>*/ caml_string_get(s, i);
+        /*<<filename.ml:23:9>>*/  /*<<filename.ml:23:9>>*/ caml_call2
+        (Stdlib_Buffer[12], b, _aD_);
+      }
+       /*<<filename.ml:23:9>>*/  /*<<filename.ml:23:9>>*/ var
+       _aC_ = i + 1 | 0;
+      if(_aB_ === i) break;
+      var i = _aC_;
+     }
+    }
+     /*<<filename.ml:25:2>>*/  /*<<filename.ml:25:2>>*/ caml_call2
+     (Stdlib_Buffer[12], b, 39);
+     /*<<filename.ml:25:2>>*/ return  /*<<filename.ml:25:2>>*/ caml_call1
+            (Stdlib_Buffer[2], b);
+   }
+   function quote_command(cmd, stdin, stdout, stderr, args){
+     /*<<filename.ml:120:4>>*/ if(stderr){
+     var f = stderr[1];
+      /*<<filename.ml:123:51>>*/ if
+      ( /*<<filename.ml:123:51>>*/ caml_equal(stderr, stdout))
+      var _ap_ = cst_2_1;
+     else
+       /*<<filename.ml:125:61>>*/ var
+        /*<<filename.ml:125:61>>*/ _az_ = quote(f),
+       _ap_ =  /*<<filename.ml:125:53>>*/ caml_call2(Stdlib[28], cst_2, _az_);
+     var _aq_ = _ap_;
+    }
+    else
+     var _aq_ = cst$4;
+    if(stdout)
+      /*<<filename.ml:122:55>>*/ var
+      f$0 = stdout[1],
+       /*<<filename.ml:122:55>>*/ _ar_ = quote(f$0),
+      _as_ =  /*<<filename.ml:122:48>>*/ caml_call2(Stdlib[28], cst, _ar_);
+    else
+     var _as_ = cst$3;
+     /*<<filename.ml:122:6>>*/  /*<<filename.ml:122:6>>*/ var
+     _at_ =  /*<<filename.ml:122:6>>*/ caml_call2(Stdlib[28], _as_, _aq_);
+    if(stdin)
+      /*<<filename.ml:121:55>>*/ var
+      f$1 = stdin[1],
+       /*<<filename.ml:121:55>>*/ _au_ = quote(f$1),
+      _av_ =  /*<<filename.ml:121:48>>*/ caml_call2(Stdlib[28], cst$0, _au_);
+    else
+     var _av_ = cst$2;
+     /*<<filename.ml:121:6>>*/ var
+      /*<<filename.ml:121:6>>*/ _aw_ =
+        /*<<filename.ml:121:6>>*/ caml_call2(Stdlib[28], _av_, _at_),
+      /*<<filename.ml:120:22>>*/ _ax_ =
+        /*<<filename.ml:120:22>>*/ caml_call2
+        (Stdlib_List[19], quote, [0, cmd, args]),
+      /*<<filename.ml:120:4>>*/ _ay_ =
+        /*<<filename.ml:120:4>>*/ caml_call2(Stdlib_String[6], cst$1, _ax_);
+     /*<<filename.ml:121:6>>*/ return  /*<<filename.ml:121:6>>*/ caml_call2
+            (Stdlib[28], _ay_, _aw_);
+    /*<<filename.ml:125:69>>*/ }
+    /*<<filename.ml:126:17>>*/ function basename(_ao_){
+     /*<<?>>*/ return generic_basename(is_dir_sep, current_dir_name, _ao_);
+   }
+    /*<<filename.ml:127:16>>*/ function dirname(_an_){
+     /*<<?>>*/ return generic_dirname(is_dir_sep, current_dir_name, _an_);
+   }
+    /*<<filename.ml:91:24>>*/  /*<<filename.ml:91:24>>*/ var
+    Unix =
+      [0,
+       null$0,
+       current_dir_name,
+       parent_dir_name,
+       dir_sep,
+       is_dir_sep,
+       is_relative,
+       is_implicit,
+       check_suffix,
+       chop_suffix_opt,
+       temp_dir_name,
+       quote,
+       quote_command,
+       basename,
+       dirname];
+   function is_dir_sep$0(s, i){
+     /*<<filename.ml:135:23>>*/ var
+      /*<<filename.ml:135:31>>*/ c =
+        /*<<filename.ml:135:31>>*/ caml_string_get(s, i),
+     _ak_ = 47 === c ? 1 : 0;
+    if(_ak_)
+     var _al_ = _ak_;
+    else
+     var _am_ = 92 === c ? 1 : 0, _al_ = _am_ || (58 === c ? 1 : 0);
+    return _al_;
+    /*<<filename.ml:135:70>>*/ }
+   function is_relative$0(n){
+     /*<<filename.ml:137:4>>*/ var
+     _ae_ = caml_ml_string_length(n) < 1 ? 1 : 0,
+     _af_ =
+       _ae_
+       || (47 !==  /*<<filename.ml:137:28>>*/ caml_string_get(n, 0) ? 1 : 0);
+    if(_af_){
+     var
+      _ag_ = caml_ml_string_length(n) < 1 ? 1 : 0,
+      _ah_ =
+        _ag_
+        || (92 !==  /*<<filename.ml:138:31>>*/ caml_string_get(n, 0) ? 1 : 0);
+     if(_ah_)
+      var
+       _ai_ = caml_ml_string_length(n) < 2 ? 1 : 0,
+       _aj_ =
+         _ai_
+         || (58 !==  /*<<filename.ml:139:31>>*/ caml_string_get(n, 1) ? 1 : 0);
+     else
+      var _aj_ = _ah_;
+    }
+    else
+     var _aj_ = _af_;
+    return _aj_;
+    /*<<filename.ml:139:44>>*/ }
+   function is_implicit$0(n){
+     /*<<filename.ml:141:4>>*/  /*<<filename.ml:141:4>>*/ var
+     _X_ = is_relative$0(n);
+     /*<<filename.ml:141:4>>*/ if(_X_){
+     var
+      _Y_ = caml_ml_string_length(n) < 2 ? 1 : 0,
+      _Z_ =
+        _Y_
+        ||
+          /*<<filename.ml:142:31>>*/ caml_string_notequal
+          ( /*<<filename.ml:142:31>>*/ caml_call3(Stdlib_String[15], n, 0, 2),
+           cst$27);
+      /*<<filename.ml:142:31>>*/ if(_Z_){
+      var
+       ___ = caml_ml_string_length(n) < 2 ? 1 : 0,
+       _$_ =
+         ___
+         ||
+           /*<<filename.ml:143:31>>*/ caml_string_notequal
+           ( /*<<filename.ml:143:31>>*/ caml_call3(Stdlib_String[15], n, 0, 2),
+            ".\\");
+       /*<<filename.ml:143:31>>*/ if(_$_){
+       var
+        _aa_ = caml_ml_string_length(n) < 3 ? 1 : 0,
+        _ab_ =
+          _aa_
+          ||
+            /*<<filename.ml:144:31>>*/ caml_string_notequal
+            ( /*<<filename.ml:144:31>>*/ caml_call3
+              (Stdlib_String[15], n, 0, 3),
+             cst$28);
+        /*<<filename.ml:144:31>>*/ if(_ab_)
+        var
+         _ac_ = caml_ml_string_length(n) < 3 ? 1 : 0,
+         _ad_ =
+           _ac_
+           ||
+             /*<<filename.ml:145:31>>*/ caml_string_notequal
+             ( /*<<filename.ml:145:31>>*/ caml_call3
+               (Stdlib_String[15], n, 0, 3),
+              "..\\");
+       else
+        var _ad_ = _ab_;
+      }
+      else
+       var _ad_ = _$_;
+     }
+     else
+      var _ad_ = _Z_;
+    }
+    else
+     var _ad_ = _X_;
+     /*<<filename.ml:145:31>>*/ return _ad_;
+    /*<<filename.ml:145:58>>*/ }
+   function check_suffix$0(name, suff){
+     /*<<filename.ml:147:3>>*/ var
+     _U_ = caml_ml_string_length(suff) <= caml_ml_string_length(name) ? 1 : 0;
+    if(_U_)
+      /*<<filename.ml:148:12>>*/ var
+       /*<<filename.ml:148:12>>*/ s =
+         /*<<filename.ml:148:12>>*/ caml_call3
+         (Stdlib_String[15],
+          name,
+          caml_ml_string_length(name) - caml_ml_string_length(suff) | 0,
+          caml_ml_string_length(suff)),
+       /*<<filename.ml:150:31>>*/ _V_ =
+         /*<<filename.ml:150:31>>*/ caml_call1(Stdlib_String[26], suff),
+      _W_ =
+         /*<<filename.ml:150:4>>*/ caml_string_equal
+         ( /*<<filename.ml:150:4>>*/ caml_call1(Stdlib_String[26], s), _V_);
+    else
+     var _W_ = _U_;
+     /*<<filename.ml:150:4>>*/ return _W_;
+    /*<<filename.ml:150:59>>*/ }
+   function chop_suffix_opt$0(suffix, filename){
+     /*<<filename.ml:153:4>>*/ var
+     len_s = caml_ml_string_length(suffix),
+     len_f = caml_ml_string_length(filename);
+    if(len_s > len_f)  /*<<filename.ml:161:6>>*/ return 0;
+     /*<<filename.ml:155:14>>*/ var
+      /*<<filename.ml:155:14>>*/ r =
+        /*<<filename.ml:155:14>>*/ caml_call3
+        (Stdlib_String[15], filename, len_f - len_s | 0, len_s),
+      /*<<filename.ml:156:36>>*/ _T_ =
+        /*<<filename.ml:156:36>>*/ caml_call1(Stdlib_String[26], suffix);
+     /*<<filename.ml:156:9>>*/ return  /*<<filename.ml:156:9>>*/ caml_string_equal
+             ( /*<<filename.ml:156:9>>*/ caml_call1(Stdlib_String[26], r),
+              _T_)
+            ? [0,
+               /*<<filename.ml:157:13>>*/ caml_call3
+               (Stdlib_String[15], filename, 0, len_f - len_s | 0)]
+            : 0;
+    /*<<filename.ml:161:10>>*/ }
+   try{
+     /*<<filename.ml:165:8>>*/ var
+      /*<<filename.ml:165:8>>*/ _j_ =
+        /*<<filename.ml:165:8>>*/ caml_sys_getenv("TEMP"),
+     temp_dir_name$0 = _j_;
+   }
+   catch(_S_){
+    var _b_ = caml_wrap_exception(_S_);
+    if(_b_ !== Stdlib[8]) throw caml_maybe_attach_backtrace(_b_, 0);
+    var temp_dir_name$0 = cst$5;
+   }
+   function quote$0(s){
+     /*<<filename.ml:167:4>>*/ var
+     l = caml_ml_string_length(s),
+      /*<<filename.ml:168:12>>*/ b =
+        /*<<filename.ml:168:12>>*/ caml_call1(Stdlib_Buffer[1], l + 20 | 0);
+     /*<<filename.ml:169:4>>*/  /*<<filename.ml:169:4>>*/ caml_call2
+     (Stdlib_Buffer[12], b, 34);
+    function add_bs(n){
+      /*<<filename.ml:186:19>>*/  /*<<filename.ml:186:19>>*/ var _Q_ = 1;
+     if(n >= 1){
+      var j = _Q_;
+      for(;;){
+        /*<<filename.ml:186:38>>*/  /*<<filename.ml:186:38>>*/ caml_call2
+        (Stdlib_Buffer[12], b, 92);
+        /*<<filename.ml:186:38>>*/  /*<<filename.ml:186:38>>*/ var
+        _R_ = j + 1 | 0;
+       if(n === j) break;
+       var j = _R_;
+      }
+     }
+     return 0;
+     /*<<filename.ml:186:66>>*/ }
+    function loop$0(counter, i){
+      /*<<filename.ml:171:6>>*/ var i$0 = i;
+      /*<<filename.ml:171:6>>*/ for(;;){
+      if(i$0 === l)
+        /*<<filename.ml:171:20>>*/ return  /*<<filename.ml:171:20>>*/ caml_call2
+               (Stdlib_Buffer[12], b, 34);
+       /*<<filename.ml:172:12>>*/  /*<<filename.ml:172:12>>*/ var
+       c =  /*<<filename.ml:172:12>>*/ caml_string_get(s, i$0);
+      if(34 === c){
+       var _O_ = 0;
+        /*<<filename.ml:173:16>>*/ if(counter >= 50)
+         /*<<filename.ml:173:16>>*/ return  /*<<filename.ml:173:16>>*/ caml_trampoline_return
+                (loop_bs, [0, _O_, i$0]);
+       var counter$1 = counter + 1 | 0;
+        /*<<filename.ml:173:16>>*/ return loop_bs(counter$1, _O_, i$0);
+      }
+      if(92 === c){
+       var _P_ = 0;
+        /*<<filename.ml:174:16>>*/ if(counter >= 50)
+         /*<<filename.ml:174:16>>*/ return  /*<<filename.ml:174:16>>*/ caml_trampoline_return
+                (loop_bs, [0, _P_, i$0]);
+       var counter$0 = counter + 1 | 0;
+        /*<<filename.ml:174:16>>*/ return loop_bs(counter$0, _P_, i$0);
+      }
+       /*<<filename.ml:175:16>>*/  /*<<filename.ml:175:16>>*/ caml_call2
+       (Stdlib_Buffer[12], b, c);
+       /*<<filename.ml:175:16>>*/ var
+        /*<<filename.ml:175:16>>*/ i$1 = i$0 + 1 | 0,
+       i$0 = i$1;
+     }
+     /*<<filename.ml:175:48>>*/ }
+    function loop_bs(counter, n, i){
+      /*<<filename.ml:177:6>>*/ var n$0 = n, i$0 = i;
+      /*<<filename.ml:177:6>>*/ for(;;){
+      if(i$0 === l){
+        /*<<filename.ml:178:8>>*/  /*<<filename.ml:178:8>>*/ caml_call2
+        (Stdlib_Buffer[12], b, 34);
+        /*<<filename.ml:178:8>>*/ return add_bs(n$0);
+      }
+       /*<<filename.ml:181:14>>*/  /*<<filename.ml:181:14>>*/ var
+       match =  /*<<filename.ml:181:14>>*/ caml_string_get(s, i$0);
+      if(34 === match){
+        /*<<filename.ml:182:18>>*/ add_bs((2 * n$0 | 0) + 1 | 0);
+        /*<<filename.ml:182:34>>*/  /*<<filename.ml:182:34>>*/ caml_call2
+        (Stdlib_Buffer[12], b, 34);
+        /*<<filename.ml:182:34>>*/  /*<<filename.ml:182:34>>*/ var
+        _N_ = i$0 + 1 | 0;
+        /*<<filename.ml:182:34>>*/ if(counter >= 50)
+         /*<<filename.ml:182:34>>*/ return  /*<<filename.ml:182:34>>*/ caml_trampoline_return
+                (loop$0, [0, _N_]);
+       var counter$1 = counter + 1 | 0;
+        /*<<filename.ml:182:34>>*/ return loop$0(counter$1, _N_);
+      }
+      if(92 !== match){
+        /*<<filename.ml:184:18>>*/ add_bs(n$0);
+        /*<<filename.ml:184:18>>*/ if(counter >= 50)
+         /*<<filename.ml:184:18>>*/ return  /*<<filename.ml:184:18>>*/ caml_trampoline_return
+                (loop$0, [0, i$0]);
+       var counter$0 = counter + 1 | 0;
+        /*<<filename.ml:184:18>>*/ return loop$0(counter$0, i$0);
+      }
+       /*<<filename.ml:183:18>>*/ var
+        /*<<filename.ml:183:18>>*/ i$1 = i$0 + 1 | 0,
+       n$1 = n$0 + 1 | 0,
+       n$0 = n$1,
+       i$0 = i$1;
+     }
+     /*<<filename.ml:185:9>>*/ }
+    function loop(i){ /*<<?>>*/ return caml_trampoline(loop$0(0, i));}
+     /*<<filename.ml:188:4>>*/ loop(0);
+     /*<<filename.ml:188:4>>*/ return  /*<<filename.ml:188:4>>*/ caml_call1
+            (Stdlib_Buffer[2], b);
+    /*<<filename.ml:189:21>>*/ }
+   function quote_cmd_filename(f){
+     /*<<filename.ml:222:4>>*/ if
+     (!
+       /*<<filename.ml:222:7>>*/ caml_call2(Stdlib_String[14], f, 34)
+      && !  /*<<filename.ml:222:33>>*/ caml_call2(Stdlib_String[14], f, 37)){
+      /*<<filename.ml:224:12>>*/ if
+      (!  /*<<filename.ml:224:12>>*/ caml_call2(Stdlib_String[14], f, 32))
+       /*<<filename.ml:227:6>>*/ return f;
+      /*<<filename.ml:225:13>>*/  /*<<filename.ml:225:13>>*/ var
+      _M_ =  /*<<filename.ml:225:13>>*/ caml_call2(Stdlib[28], f, cst$6);
+      /*<<filename.ml:225:13>>*/ return  /*<<filename.ml:225:13>>*/ caml_call2
+             (Stdlib[28], cst$7, _M_);
+    }
+     /*<<filename.ml:223:15>>*/  /*<<filename.ml:223:15>>*/ var
+     _L_ =
+        /*<<filename.ml:223:15>>*/ caml_call2
+        (Stdlib[28], cst_Filename_quote_command_bad, f);
+     /*<<filename.ml:223:15>>*/ return  /*<<filename.ml:223:15>>*/ caml_call1
+            (Stdlib[2], _L_);
+    /*<<filename.ml:227:7>>*/ }
+   function quote_command$0(cmd, stdin, stdout, stderr, args){
+     /*<<filename.ml:232:4>>*/ if(stderr){
+     var f = stderr[1];
+      /*<<filename.ml:240:43>>*/ if
+      ( /*<<filename.ml:240:43>>*/ caml_equal(stderr, stdout))
+      var _x_ = cst_2_1$0;
+     else
+       /*<<filename.ml:242:53>>*/ var
+        /*<<filename.ml:242:53>>*/ _J_ = quote_cmd_filename(f),
+       _x_ =  /*<<filename.ml:242:45>>*/ caml_call2(Stdlib[28], cst_2$0, _J_);
+     var _y_ = _x_;
+    }
+    else
+     var _y_ = cst$16;
+    var _z_ = [0, _y_, _c_];
+    if(stdout)
+      /*<<filename.ml:238:55>>*/ var
+      f$0 = stdout[1],
+       /*<<filename.ml:238:55>>*/ _A_ = quote_cmd_filename(f$0),
+      _B_ =  /*<<filename.ml:238:48>>*/ caml_call2(Stdlib[28], cst$8, _A_);
+    else
+     var _B_ = cst$15;
+    var _C_ = [0, _B_, _z_];
+    if(stdin)
+      /*<<filename.ml:237:55>>*/ var
+      f$1 = stdin[1],
+       /*<<filename.ml:237:55>>*/ _D_ = quote_cmd_filename(f$1),
+      _E_ =  /*<<filename.ml:237:48>>*/ caml_call2(Stdlib[28], cst$9, _D_);
+    else
+     var _E_ = cst$14;
+     /*<<filename.ml:236:35>>*/ var
+      /*<<filename.ml:236:35>>*/ _G_ =
+        /*<<filename.ml:236:35>>*/ caml_call2(Stdlib_List[19], quote$0, args),
+      /*<<filename.ml:236:16>>*/ s =
+        /*<<filename.ml:236:16>>*/ caml_call2(Stdlib_String[6], cst$10, _G_),
+      /*<<filename.ml:211:12>>*/ b =
+        /*<<filename.ml:211:12>>*/ caml_call1
+        (Stdlib_Buffer[1], caml_ml_string_length(s) + 20 | 0),
+     _F_ = [0, _E_, _C_];
+    function _w_(c){
+      /*<<filename.ml:214:8>>*/ a:
+     {
+      if(62 <= c){
+       var _K_ = c - 63 | 0;
+       if(60 < _K_ >>> 0){if(62 <= _K_) break a;} else if(31 !== _K_) break a;
+      }
+      else
+       if(42 <= c){
+        if(60 !== c) break a;
+       }
+       else{
+        if(33 > c) break a;
+        switch(c - 33 | 0){case 2:case 3:case 6: break a;
+        }
+       }
+       /*<<filename.ml:216:12>>*/  /*<<filename.ml:216:12>>*/ caml_call2
+       (Stdlib_Buffer[12], b, 94);
+       /*<<filename.ml:216:12>>*/ return  /*<<filename.ml:216:12>>*/ caml_call2
+              (Stdlib_Buffer[12], b, c);
+     }
+      /*<<filename.ml:218:12>>*/ return  /*<<filename.ml:218:12>>*/ caml_call2
+             (Stdlib_Buffer[12], b, c);
+     /*<<filename.ml:218:31>>*/ }
+     /*<<filename.ml:212:4>>*/  /*<<filename.ml:212:4>>*/ caml_call2
+     (Stdlib_String[29], _w_, s);
+     /*<<filename.ml:232:21>>*/ var
+     _H_ =
+       [0,
+        cst$11,
+        [0,  /*<<filename.ml:212:4>>*/ caml_call1(Stdlib_Buffer[2], b), _F_]],
+      /*<<filename.ml:232:21>>*/ _I_ =
+       [0, cst$12, [0, quote_cmd_filename(cmd), _H_]];
+     /*<<filename.ml:232:21>>*/ return  /*<<filename.ml:232:21>>*/ caml_call2
+            (Stdlib_String[6], cst$13, _I_);
+    /*<<filename.ml:244:5>>*/ }
+   function drive_and_path(s){
+     /*<<filename.ml:252:4>>*/ var
+     _s_ = 2 <=  /*<<filename.ml:250:4>>*/ caml_ml_string_length(s) ? 1 : 0;
+    if(_s_){
+      /*<<filename.ml:250:38>>*/  /*<<filename.ml:250:38>>*/ var
+      param =  /*<<filename.ml:250:38>>*/ caml_string_get(s, 0);
+     a:
+     {
+      b:
+      {
+       if(91 <= param){
+        if(25 < param - 97 >>> 0) break b;
+       }
+       else if(65 > param) break b;
+       var _t_ = 1;
+       break a;
+      }
+      var _t_ = 0;
+     }
+      /*<<filename.ml:250:28>>*/  /*<<filename.ml:250:28>>*/ var
+      _u_ =
+        _t_
+         ? 58 ===  /*<<filename.ml:250:47>>*/ caml_string_get(s, 1) ? 1 : 0
+         : _t_;
+    }
+    else
+     var _u_ = _s_;
+     /*<<filename.ml:252:7>>*/ if(! _u_)
+      /*<<filename.ml:254:9>>*/ return [0, cst$17, s];
+     /*<<filename.ml:253:28>>*/  /*<<filename.ml:253:28>>*/ var
+     _v_ =
+        /*<<filename.ml:253:28>>*/ caml_call3
+        (Stdlib_String[15], s, 2, caml_ml_string_length(s) - 2 | 0);
+     /*<<filename.ml:253:9>>*/ return [0,
+             /*<<filename.ml:253:10>>*/ caml_call3(Stdlib_String[15], s, 0, 2),
+            _v_];
+    /*<<filename.ml:254:16>>*/ }
+   function dirname$0(s){
+     /*<<filename.ml:256:4>>*/ var
+      /*<<filename.ml:256:24>>*/ match = drive_and_path(s),
+     path = match[2],
+     drive = match[1],
+      /*<<filename.ml:257:14>>*/ dir =
+       generic_dirname(is_dir_sep$0, current_dir_name$0, path);
+     /*<<filename.ml:258:4>>*/ return  /*<<filename.ml:258:4>>*/ caml_call2
+            (Stdlib[28], drive, dir);
+    /*<<filename.ml:258:15>>*/ }
+   function basename$0(s){
+     /*<<filename.ml:260:4>>*/ var path = drive_and_path(s)[2];
+     /*<<filename.ml:261:4>>*/ return generic_basename
+            (is_dir_sep$0, current_dir_name$0, path);
+    /*<<filename.ml:261:53>>*/ }
+    /*<<filename.ml:130:25>>*/  /*<<filename.ml:130:25>>*/ var
+    Win32 =
+      [0,
+       null$1,
+       current_dir_name$0,
+       parent_dir_name$0,
+       dir_sep$0,
+       is_dir_sep$0,
+       is_relative$0,
+       is_implicit$0,
+       check_suffix$0,
+       chop_suffix_opt$0,
+       temp_dir_name$0,
+       quote$0,
+       quote_command$0,
+       basename$0,
+       dirname$0];
+    /*<<filename.ml:277:17>>*/ function basename$1(_r_){
+     /*<<?>>*/ return generic_basename(is_dir_sep$0, current_dir_name$1, _r_);
+   }
+    /*<<filename.ml:278:16>>*/ function dirname$1(_q_){
+     /*<<?>>*/ return generic_dirname(is_dir_sep$0, current_dir_name$1, _q_);
+   }
+    /*<<filename.ml:264:26>>*/ var
+     /*<<filename.ml:264:26>>*/ Cygwin =
+      [0,
+       null$2,
+       current_dir_name$1,
+       parent_dir_name$1,
+       dir_sep$1,
+       is_dir_sep$0,
+       is_relative$0,
+       is_implicit$0,
+       check_suffix$0,
+       chop_suffix_opt$0,
+       temp_dir_name,
+       quote,
+       quote_command,
+       basename$1,
+       dirname$1],
+    _d_ = Stdlib_Sys[4],
+    Sysdeps =
+      caml_string_notequal(_d_, "Cygwin")
+       ? caml_string_notequal(_d_, "Win32") ? Unix : Win32
+       : Cygwin,
+    null$3 = Sysdeps[1],
+    current_dir_name$2 = Sysdeps[2],
+    parent_dir_name$2 = Sysdeps[3],
+    dir_sep$2 = Sysdeps[4],
+    is_dir_sep$1 = Sysdeps[5],
+    is_relative$1 = Sysdeps[6],
+    is_implicit$1 = Sysdeps[7],
+    check_suffix$1 = Sysdeps[8],
+    chop_suffix_opt$1 = Sysdeps[9],
+    temp_dir_name$1 = Sysdeps[10],
+    quote$1 = Sysdeps[11],
+    quote_command$1 = Sysdeps[12],
+    basename$2 = Sysdeps[13],
+    dirname$2 = Sysdeps[14];
+   function concat(dirname, filename){
+     /*<<filename.ml:290:2>>*/ var l = caml_ml_string_length(dirname);
+     /*<<filename.ml:291:14>>*/ if
+     (0 !== l && ! is_dir_sep$1(dirname, l - 1 | 0)){
+      /*<<filename.ml:293:17>>*/  /*<<filename.ml:293:17>>*/ var
+      _p_ =
+         /*<<filename.ml:293:17>>*/ caml_call2
+         (Stdlib[28], dir_sep$2, filename);
+      /*<<filename.ml:293:17>>*/ return  /*<<filename.ml:293:17>>*/ caml_call2
+             (Stdlib[28], dirname, _p_);
+    }
+     /*<<filename.ml:292:7>>*/ return  /*<<filename.ml:292:7>>*/ caml_call2
+            (Stdlib[28], dirname, filename);
+    /*<<filename.ml:293:35>>*/ }
+   function chop_suffix(name, suff){
+     /*<<filename.ml:296:2>>*/ return check_suffix$1(name, suff)
+            ? caml_call3
+              (Stdlib_String[15],
+               name,
+               0,
+               caml_ml_string_length(name) - caml_ml_string_length(suff) | 0)
+            :  /*<<filename.ml:298:7>>*/ caml_call1
+              (Stdlib[1], cst_Filename_chop_suffix);
+    /*<<filename.ml:298:41>>*/ }
+   function extension_len(name){
+     /*<<filename.ml:301:2>>*/ var
+     i$3 = caml_ml_string_length(name) - 1 | 0,
+     i0 = i$3;
+     /*<<filename.ml:307:4>>*/ for(;;){
+      /*<<filename.ml:307:16>>*/ if(0 <= i0 && ! is_dir_sep$1(name, i0)){
+       /*<<filename.ml:308:12>>*/ if
+       (46 !==  /*<<filename.ml:308:12>>*/ caml_string_get(name, i0)){
+        /*<<filename.ml:309:9>>*/ var
+         /*<<filename.ml:309:9>>*/ i$2 = i0 - 1 | 0,
+        i0 = i$2;
+       continue;
+      }
+       /*<<filename.ml:308:32>>*/ var
+        /*<<filename.ml:308:32>>*/ i$1 = i0 - 1 | 0,
+       i = i$1;
+       /*<<filename.ml:302:4>>*/ for(;;){
+        /*<<filename.ml:302:16>>*/ if(0 <= i && ! is_dir_sep$1(name, i)){
+         /*<<filename.ml:303:12>>*/ if
+         (46 !==  /*<<filename.ml:303:12>>*/ caml_string_get(name, i))
+         return caml_ml_string_length(name) - i0 | 0;
+         /*<<filename.ml:303:32>>*/ var
+          /*<<filename.ml:303:32>>*/ i$0 = i - 1 | 0,
+         i = i$0;
+        continue;
+       }
+        /*<<filename.ml:302:39>>*/ return 0;
+      }
+     }
+      /*<<filename.ml:307:39>>*/ return 0;
+    }
+    /*<<filename.ml:311:37>>*/ }
+   function extension(name){
+     /*<<filename.ml:314:2>>*/  /*<<filename.ml:314:10>>*/ var
+     l = extension_len(name);
+     /*<<filename.ml:315:2>>*/ return 0 === l
+            ? cst$18
+            :  /*<<filename.ml:315:24>>*/ caml_call3
+              (Stdlib_String[15],
+               name,
+               caml_ml_string_length(name) - l | 0,
+               l);
+    /*<<filename.ml:315:66>>*/ }
+   function chop_extension(name){
+     /*<<filename.ml:318:2>>*/  /*<<filename.ml:318:10>>*/ var
+     l = extension_len(name);
+     /*<<filename.ml:319:2>>*/ return 0 === l
+            ?  /*<<filename.ml:319:16>>*/ caml_call1
+              (Stdlib[1], cst_Filename_chop_extension)
+            : caml_call3
+              (Stdlib_String[15],
+               name,
+               0,
+               caml_ml_string_length(name) - l | 0);
+    /*<<filename.ml:320:49>>*/ }
+   function remove_extension(name){
+     /*<<filename.ml:323:2>>*/  /*<<filename.ml:323:10>>*/ var
+     l = extension_len(name);
+     /*<<filename.ml:324:2>>*/ return 0 === l
+            ? name
+            : caml_call3
+              (Stdlib_String[15],
+               name,
+               0,
+               caml_ml_string_length(name) - l | 0);
+    /*<<filename.ml:324:68>>*/ }
+    /*<<filename.ml:330:2>>*/  /*<<filename.ml:330:2>>*/ var
+    prng_key =
+       /*<<filename.ml:330:2>>*/ caml_call2
+       (Stdlib_Domain[10][1], 0, Stdlib_Random[15][2]);
+   function temp_file_name(temp_dir, prefix, suffix){
+     /*<<filename.ml:333:2>>*/ var
+      /*<<filename.ml:333:21>>*/ random_state =
+        /*<<filename.ml:333:21>>*/ caml_call1(Stdlib_Domain[10][2], prng_key),
+      /*<<filename.ml:334:12>>*/ rnd =
+        /*<<filename.ml:334:12>>*/ caml_call1
+        (Stdlib_Random[15][4], random_state)
+       & 16777215;
+     /*<<filename.ml:335:18>>*/ return concat
+            (temp_dir,
+              /*<<filename.ml:335:18>>*/ caml_call4
+              (Stdlib_Printf[4], _e_, prefix, rnd, suffix));
+    /*<<filename.ml:335:63>>*/ }
+   function _f_(param){
+     /*<<filename.ml:338:58>>*/ return temp_dir_name$1;
+    /*<<filename.ml:338:71>>*/ }
+    /*<<filename.ml:338:40>>*/ var
+     /*<<filename.ml:338:40>>*/ _g_ =
+      [0, function(_o_){ /*<<?>>*/ return _o_;}],
+     /*<<filename.ml:338:2>>*/ current_temp_dir_name =
+       /*<<filename.ml:338:2>>*/ caml_call2(Stdlib_Domain[10][1], _g_, _f_);
+   function set_temp_dir_name(s){
+     /*<<filename.ml:340:26>>*/ return  /*<<filename.ml:340:26>>*/ caml_call2
+            (Stdlib_Domain[10][3], current_temp_dir_name, s);
+    /*<<filename.ml:340:64>>*/ }
+   function get_temp_dir_name(param){
+     /*<<filename.ml:341:27>>*/ return caml_call1
+            (Stdlib_Domain[10][2], current_temp_dir_name);
+    /*<<filename.ml:341:63>>*/ }
+   function temp_file(opt, prefix, suffix){
+     /*<<filename.ml:344:2>>*/ if(opt)
+     var sth = opt[1], temp_dir = sth;
+    else
+     var
+      temp_dir =
+         /*<<filename.ml:343:27>>*/ caml_call1
+         (Stdlib_Domain[10][2], current_temp_dir_name);
+    var counter = 0;
+     /*<<filename.ml:345:4>>*/ for(;;){
+      /*<<filename.ml:345:15>>*/  /*<<filename.ml:345:15>>*/ var
+      name = temp_file_name(temp_dir, prefix, suffix);
+      /*<<filename.ml:346:4>>*/ try{
+       /*<<filename.ml:347:6>>*/  /*<<filename.ml:347:6>>*/ runtime.caml_sys_close
+       ( /*<<filename.ml:347:16>>*/ runtime.caml_sys_open(name, _h_, 384));
+       /*<<filename.ml:347:6>>*/ return name;
+     }
+     catch(e$0){
+      var e = caml_wrap_exception(e$0);
+      if(e[1] !== Stdlib[11]) throw caml_maybe_attach_backtrace(e, 0);
+      if(1000 <= counter)
+        /*<<filename.ml:350:30>>*/ throw  /*<<filename.ml:350:30>>*/ caml_maybe_attach_backtrace
+              (e, 0);
+       /*<<filename.ml:350:43>>*/ var
+        /*<<filename.ml:350:43>>*/ counter$0 = counter + 1 | 0,
+       counter = counter$0;
+     }
+    }
+    /*<<filename.ml:351:15>>*/ }
+   function open_temp_file(opt, _m_, _l_, prefix, suffix){
+     /*<<filename.ml:356:2>>*/ if(opt)
+     var sth = opt[1], mode = sth;
+    else
+     var mode = _i_;
+     /*<<filename.ml:356:2>>*/ if(_m_)
+     var sth$0 = _m_[1], perms = sth$0;
+    else
+     var perms = 384;
+     /*<<filename.ml:356:2>>*/ if(_l_)
+     var sth$1 = _l_[1], temp_dir = sth$1;
+    else
+     var
+      temp_dir =
+         /*<<filename.ml:354:17>>*/ caml_call1
+         (Stdlib_Domain[10][2], current_temp_dir_name);
+    var counter = 0;
+     /*<<filename.ml:357:4>>*/ for(;;){
+      /*<<filename.ml:357:15>>*/  /*<<filename.ml:357:15>>*/ var
+      name = temp_file_name(temp_dir, prefix, suffix);
+      /*<<filename.ml:358:4>>*/ try{
+       /*<<filename.ml:359:6>>*/  /*<<filename.ml:359:6>>*/ var
+       _n_ =
+         [0,
+          name,
+           /*<<filename.ml:360:7>>*/ caml_call3
+           (Stdlib[62], [0, 1, [0, 3, [0, 5, mode]]], perms, name)];
+       /*<<filename.ml:359:6>>*/ return _n_;
+     }
+     catch(e$0){
+      var e = caml_wrap_exception(e$0);
+      if(e[1] !== Stdlib[11]) throw caml_maybe_attach_backtrace(e, 0);
+      if(1000 <= counter)
+        /*<<filename.ml:362:30>>*/ throw  /*<<filename.ml:362:30>>*/ caml_maybe_attach_backtrace
+              (e, 0);
+       /*<<filename.ml:362:43>>*/ var
+        /*<<filename.ml:362:43>>*/ counter$0 = counter + 1 | 0,
+       counter = counter$0;
+     }
+    }
+    /*<<filename.ml:363:15>>*/ }
+   var
+    Stdlib_Filename =
+      [0,
+       current_dir_name$2,
+       parent_dir_name$2,
+       dir_sep$2,
+       concat,
+       is_relative$1,
+       is_implicit$1,
+       check_suffix$1,
+       chop_suffix,
+       chop_suffix_opt$1,
+       extension,
+       remove_extension,
+       chop_extension,
+       basename$2,
+       dirname$2,
+       null$3,
+       temp_file,
+       open_temp_file,
+       get_temp_dir_name,
+       set_temp_dir_name,
+       quote$1,
+       quote_command$1];
+   runtime.caml_register_global(65, Stdlib_Filename, "Stdlib__Filename");
+   return;
+   /*<<?>>*/ }
+  (globalThis));
+
+//# unitInfo: Provides: Stdlib__Complex
+//# unitInfo: Requires: Stdlib, Stdlib__Float
+(function
+  (globalThis){
+   "use strict";
+   var
+    runtime = globalThis.jsoo_runtime,
+    zero = [254, 0., 0.],
+    one = [254, 1., 0.],
+    i = [254, 0., 1.],
+    _a_ = [254, 0., 0.];
+   function add(x, y){
+     /*<<complex.ml:24:14>>*/ return [254, x[1] + y[1], x[2] + y[2]];
+    /*<<complex.ml:24:54>>*/ }
+   function sub(x, y){
+     /*<<complex.ml:26:14>>*/ return [254, x[1] - y[1], x[2] - y[2]];
+    /*<<complex.ml:26:54>>*/ }
+   function neg(x){
+     /*<<complex.ml:28:12>>*/ return [254, - x[1], - x[2]];
+    /*<<complex.ml:28:42>>*/ }
+   function conj(x){
+     /*<<complex.ml:30:13>>*/ return [254, x[1], - x[2]];
+    /*<<complex.ml:30:40>>*/ }
+   function mul(x, y){
+     /*<<complex.ml:32:14>>*/ return [254,
+            x[1] * y[1] - x[2] * y[2],
+            x[1] * y[2] + x[2] * y[1]];
+    /*<<complex.ml:33:51>>*/ }
+   function div(x, y){
+     /*<<complex.ml:36:2>>*/ if
+     ( /*<<complex.ml:36:23>>*/ Math.abs(y[2])
+      <=  /*<<complex.ml:36:5>>*/ Math.abs(y[1])){
+      /*<<complex.ml:37:12>>*/ var
+       /*<<complex.ml:37:12>>*/ r = y[2] / y[1],
+       /*<<complex.ml:38:12>>*/ d = y[1] + r * y[2];
+      /*<<complex.ml:39:4>>*/ return [254,
+             (x[1] + r * x[2]) / d,
+             (x[2] - r * x[1]) / d];
+    }
+     /*<<complex.ml:42:12>>*/ var
+      /*<<complex.ml:42:12>>*/ r$0 = y[1] / y[2],
+      /*<<complex.ml:43:12>>*/ d$0 = y[2] + r$0 * y[1];
+     /*<<complex.ml:44:4>>*/ return [254,
+            (r$0 * x[1] + x[2]) / d$0,
+            (r$0 * x[2] - x[1]) / d$0];
+    /*<<complex.ml:45:37>>*/ }
+   function inv(x){
+     /*<<complex.ml:47:12>>*/ return div(one, x);
+    /*<<complex.ml:47:21>>*/ }
+   function norm2(x){
+     /*<<complex.ml:49:14>>*/ return x[1] * x[1] + x[2] * x[2];
+    /*<<complex.ml:49:42>>*/ }
+   function norm(x){
+     /*<<complex.ml:51:13>>*/ return  /*<<complex.ml:51:13>>*/ runtime.caml_hypot_float
+            (x[1], x[2]);
+    /*<<complex.ml:51:34>>*/ }
+   function arg(x){
+     /*<<complex.ml:53:12>>*/ return  /*<<complex.ml:53:12>>*/ Math.atan2
+            (x[2], x[1]);
+    /*<<complex.ml:53:27>>*/ }
+   function polar(n, a){
+     /*<<complex.ml:55:16>>*/ return [254,
+             /*<<complex.ml:55:23>>*/ Math.cos(a) * n,
+             /*<<complex.ml:55:40>>*/ Math.sin(a) * n];
+    /*<<complex.ml:55:52>>*/ }
+   function sqrt(x){
+     /*<<complex.ml:58:2>>*/ if(x[1] == 0. && x[2] == 0.)
+      /*<<complex.ml:58:35>>*/ return _a_;
+     /*<<complex.ml:60:12>>*/ var
+      /*<<complex.ml:60:12>>*/ r =  /*<<complex.ml:60:12>>*/ Math.abs(x[1]),
+      /*<<complex.ml:60:35>>*/ i =  /*<<complex.ml:60:35>>*/ Math.abs(x[2]);
+    if(i <= r)
+      /*<<complex.ml:63:16>>*/ var
+       /*<<complex.ml:63:16>>*/ q = i / r,
+      w =
+         /*<<complex.ml:64:8>>*/ Math.sqrt(r)
+        *
+          /*<<complex.ml:64:19>>*/ Math.sqrt
+          (0.5 * (1. +  /*<<complex.ml:64:39>>*/ Math.sqrt(1. + q * q)));
+    else
+      /*<<complex.ml:66:16>>*/ var
+       /*<<complex.ml:66:16>>*/ q$0 = r / i,
+      w =
+         /*<<complex.ml:67:8>>*/ Math.sqrt(i)
+        *
+          /*<<complex.ml:67:19>>*/ Math.sqrt
+          (0.5 * (q$0 +  /*<<complex.ml:67:37>>*/ Math.sqrt(1. + q$0 * q$0)));
+    if(0. <= x[1])  /*<<complex.ml:70:9>>*/ return [254, w, 0.5 * x[2] / w];
+    var w$0 = 0. <= x[2] ? w : - w;
+     /*<<complex.ml:71:9>>*/ return [254, 0.5 * i / w, w$0];
+    /*<<complex.ml:72:5>>*/ }
+   function exp(x){
+     /*<<complex.ml:75:2>>*/  /*<<complex.ml:75:10>>*/ var
+     e =  /*<<complex.ml:75:10>>*/ Math.exp(x[1]);
+     /*<<complex.ml:75:22>>*/ return [254,
+            e *  /*<<complex.ml:75:34>>*/ Math.cos(x[2]),
+            e *  /*<<complex.ml:75:54>>*/ Math.sin(x[2])];
+    /*<<complex.ml:75:64>>*/ }
+   function log(x){
+     /*<<complex.ml:77:12>>*/  /*<<complex.ml:77:38>>*/ var
+     _b_ =  /*<<complex.ml:77:38>>*/ Math.atan2(x[2], x[1]);
+     /*<<complex.ml:77:12>>*/ return [254,
+             /*<<complex.ml:77:19>>*/ Math.log(norm(x)),
+            _b_];
+    /*<<complex.ml:77:55>>*/ }
+   function pow(x, y){
+     /*<<complex.ml:79:14>>*/ return exp(mul(y, log(x)));
+    /*<<complex.ml:79:33>>*/ }
+   var
+    Stdlib_Complex =
+      [0,
+       zero,
+       one,
+       i,
+       neg,
+       conj,
+       add,
+       sub,
+       mul,
+       inv,
+       div,
+       sqrt,
+       norm2,
+       norm,
+       arg,
+       polar,
+       exp,
+       log,
+       pow];
+   runtime.caml_register_global(15, Stdlib_Complex, "Stdlib__Complex");
+   return;
+   /*<<?>>*/ }
+  (globalThis));
+
+//# unitInfo: Provides: Stdlib__ArrayLabels
+//# unitInfo: Requires: Stdlib__Array
+(function
+  (globalThis){
+   "use strict";
+   var
+    runtime = globalThis.jsoo_runtime,
+    global_data = runtime.caml_get_global_data(),
+    Stdlib_Array = global_data.Stdlib__Array,
+    init = Stdlib_Array[1],
+    make_matrix = Stdlib_Array[2],
+    append = Stdlib_Array[3],
+    concat = Stdlib_Array[4],
+    sub = Stdlib_Array[5],
+    copy = Stdlib_Array[6],
+    fill = Stdlib_Array[7],
+    blit = Stdlib_Array[8],
+    to_list = Stdlib_Array[9],
+    of_list = Stdlib_Array[10],
+    iter = Stdlib_Array[11],
+    iteri = Stdlib_Array[12],
+    map = Stdlib_Array[13],
+    mapi = Stdlib_Array[14],
+    fold_left = Stdlib_Array[15],
+    fold_left_map = Stdlib_Array[16],
+    fold_right = Stdlib_Array[17],
+    iter2 = Stdlib_Array[18],
+    map2 = Stdlib_Array[19],
+    for_all = Stdlib_Array[20],
+    exists = Stdlib_Array[21],
+    for_all2 = Stdlib_Array[22],
+    exists2 = Stdlib_Array[23],
+    mem = Stdlib_Array[24],
+    memq = Stdlib_Array[25],
+    find_opt = Stdlib_Array[26],
+    find_map = Stdlib_Array[27],
+    split = Stdlib_Array[28],
+    combine = Stdlib_Array[29],
+    sort = Stdlib_Array[30],
+    stable_sort = Stdlib_Array[31],
+    fast_sort = Stdlib_Array[32],
+    to_seq = Stdlib_Array[33],
+    to_seqi = Stdlib_Array[34],
+    of_seq = Stdlib_Array[35],
+    Floatarray = Stdlib_Array[36],
+    Stdlib_ArrayLabels =
+      [0,
+       init,
+       make_matrix,
+       append,
+       concat,
+       sub,
+       copy,
+       fill,
+       blit,
+       to_list,
+       of_list,
+       iter,
+       iteri,
+       map,
+       mapi,
+       fold_left,
+       fold_left_map,
+       fold_right,
+       iter2,
+       map2,
+       for_all,
+       exists,
+       for_all2,
+       exists2,
+       mem,
+       memq,
+       find_opt,
+       find_map,
+       split,
+       combine,
+       sort,
+       stable_sort,
+       fast_sort,
+       to_seq,
+       to_seqi,
+       of_seq,
+       Floatarray];
+   runtime.caml_register_global(1, Stdlib_ArrayLabels, "Stdlib__ArrayLabels");
+   return;
+   /*<<?>>*/ }
+  (globalThis));
+
+//# unitInfo: Provides: Stdlib__ListLabels
+//# unitInfo: Requires: Stdlib__List
+(function
+  (globalThis){
+   "use strict";
+   var
+    runtime = globalThis.jsoo_runtime,
+    global_data = runtime.caml_get_global_data(),
+    Stdlib_List = global_data.Stdlib__List,
+    length = Stdlib_List[1],
+    compare_lengths = Stdlib_List[2],
+    compare_length_with = Stdlib_List[3],
+    cons = Stdlib_List[4],
+    hd = Stdlib_List[5],
+    tl = Stdlib_List[6],
+    nth = Stdlib_List[7],
+    nth_opt = Stdlib_List[8],
+    rev = Stdlib_List[9],
+    init = Stdlib_List[10],
+    append = Stdlib_List[11],
+    rev_append = Stdlib_List[12],
+    concat = Stdlib_List[13],
+    flatten = Stdlib_List[14],
+    equal = Stdlib_List[15],
+    compare = Stdlib_List[16],
+    iter = Stdlib_List[17],
+    iteri = Stdlib_List[18],
+    map = Stdlib_List[19],
+    mapi = Stdlib_List[20],
+    rev_map = Stdlib_List[21],
+    filter_map = Stdlib_List[22],
+    concat_map = Stdlib_List[23],
+    fold_left_map = Stdlib_List[24],
+    fold_left = Stdlib_List[25],
+    fold_right = Stdlib_List[26],
+    iter2 = Stdlib_List[27],
+    map2 = Stdlib_List[28],
+    rev_map2 = Stdlib_List[29],
+    fold_left2 = Stdlib_List[30],
+    fold_right2 = Stdlib_List[31],
+    for_all = Stdlib_List[32],
+    exists = Stdlib_List[33],
+    for_all2 = Stdlib_List[34],
+    exists2 = Stdlib_List[35],
+    mem = Stdlib_List[36],
+    memq = Stdlib_List[37],
+    find = Stdlib_List[38],
+    find_opt = Stdlib_List[39],
+    find_map = Stdlib_List[40],
+    filter = Stdlib_List[41],
+    find_all = Stdlib_List[42],
+    filteri = Stdlib_List[43],
+    partition = Stdlib_List[44],
+    partition_map = Stdlib_List[45],
+    assoc = Stdlib_List[46],
+    assoc_opt = Stdlib_List[47],
+    assq = Stdlib_List[48],
+    assq_opt = Stdlib_List[49],
+    mem_assoc = Stdlib_List[50],
+    mem_assq = Stdlib_List[51],
+    remove_assoc = Stdlib_List[52],
+    remove_assq = Stdlib_List[53],
+    split = Stdlib_List[54],
+    combine = Stdlib_List[55],
+    sort = Stdlib_List[56],
+    stable_sort = Stdlib_List[57],
+    fast_sort = Stdlib_List[58],
+    sort_uniq = Stdlib_List[59],
+    merge = Stdlib_List[60],
+    to_seq = Stdlib_List[61],
+    of_seq = Stdlib_List[62],
+    Stdlib_ListLabels =
+      [0,
+       length,
+       compare_lengths,
+       compare_length_with,
+       cons,
+       hd,
+       tl,
+       nth,
+       nth_opt,
+       rev,
+       init,
+       append,
+       rev_append,
+       concat,
+       flatten,
+       equal,
+       compare,
+       iter,
+       iteri,
+       map,
+       mapi,
+       rev_map,
+       filter_map,
+       concat_map,
+       fold_left_map,
+       fold_left,
+       fold_right,
+       iter2,
+       map2,
+       rev_map2,
+       fold_left2,
+       fold_right2,
+       for_all,
+       exists,
+       for_all2,
+       exists2,
+       mem,
+       memq,
+       find,
+       find_opt,
+       find_map,
+       filter,
+       find_all,
+       filteri,
+       partition,
+       partition_map,
+       assoc,
+       assoc_opt,
+       assq,
+       assq_opt,
+       mem_assoc,
+       mem_assq,
+       remove_assoc,
+       remove_assq,
+       split,
+       combine,
+       sort,
+       stable_sort,
+       fast_sort,
+       sort_uniq,
+       merge,
+       to_seq,
+       of_seq];
+   runtime.caml_register_global(1, Stdlib_ListLabels, "Stdlib__ListLabels");
+   return;
+   /*<<?>>*/ }
+  (globalThis));
+
+//# unitInfo: Provides: Stdlib__BytesLabels
+//# unitInfo: Requires: Stdlib__Bytes
+(function
+  (globalThis){
+   "use strict";
+   var
+    runtime = globalThis.jsoo_runtime,
+    global_data = runtime.caml_get_global_data(),
+    Stdlib_Bytes = global_data.Stdlib__Bytes,
+    make = Stdlib_Bytes[1],
+    init = Stdlib_Bytes[2],
+    empty = Stdlib_Bytes[3],
+    copy = Stdlib_Bytes[4],
+    of_string = Stdlib_Bytes[5],
+    to_string = Stdlib_Bytes[6],
+    sub = Stdlib_Bytes[7],
+    sub_string = Stdlib_Bytes[8],
+    extend = Stdlib_Bytes[9],
+    fill = Stdlib_Bytes[10],
+    blit = Stdlib_Bytes[11],
+    blit_string = Stdlib_Bytes[12],
+    concat = Stdlib_Bytes[13],
+    cat = Stdlib_Bytes[14],
+    iter = Stdlib_Bytes[15],
+    iteri = Stdlib_Bytes[16],
+    map = Stdlib_Bytes[17],
+    mapi = Stdlib_Bytes[18],
+    fold_left = Stdlib_Bytes[19],
+    fold_right = Stdlib_Bytes[20],
+    for_all = Stdlib_Bytes[21],
+    exists = Stdlib_Bytes[22],
+    trim = Stdlib_Bytes[23],
+    escaped = Stdlib_Bytes[24],
+    index = Stdlib_Bytes[25],
+    index_opt = Stdlib_Bytes[26],
+    rindex = Stdlib_Bytes[27],
+    rindex_opt = Stdlib_Bytes[28],
+    index_from = Stdlib_Bytes[29],
+    index_from_opt = Stdlib_Bytes[30],
+    rindex_from = Stdlib_Bytes[31],
+    rindex_from_opt = Stdlib_Bytes[32],
+    contains = Stdlib_Bytes[33],
+    contains_from = Stdlib_Bytes[34],
+    rcontains_from = Stdlib_Bytes[35],
+    uppercase_ascii = Stdlib_Bytes[36],
+    lowercase_ascii = Stdlib_Bytes[37],
+    capitalize_ascii = Stdlib_Bytes[38],
+    uncapitalize_ascii = Stdlib_Bytes[39],
+    compare = Stdlib_Bytes[40],
+    equal = Stdlib_Bytes[41],
+    starts_with = Stdlib_Bytes[42],
+    ends_with = Stdlib_Bytes[43],
+    unsafe_to_string = Stdlib_Bytes[44],
+    unsafe_of_string = Stdlib_Bytes[45],
+    split_on_char = Stdlib_Bytes[46],
+    to_seq = Stdlib_Bytes[47],
+    to_seqi = Stdlib_Bytes[48],
+    of_seq = Stdlib_Bytes[49],
+    get_utf_8_uchar = Stdlib_Bytes[50],
+    set_utf_8_uchar = Stdlib_Bytes[51],
+    is_valid_utf_8 = Stdlib_Bytes[52],
+    get_utf_16be_uchar = Stdlib_Bytes[53],
+    set_utf_16be_uchar = Stdlib_Bytes[54],
+    is_valid_utf_16be = Stdlib_Bytes[55],
+    get_utf_16le_uchar = Stdlib_Bytes[56],
+    set_utf_16le_uchar = Stdlib_Bytes[57],
+    is_valid_utf_16le = Stdlib_Bytes[58],
+    get_uint8 = Stdlib_Bytes[59],
+    get_int8 = Stdlib_Bytes[60],
+    get_uint16_ne = Stdlib_Bytes[61],
+    get_uint16_be = Stdlib_Bytes[62],
+    get_uint16_le = Stdlib_Bytes[63],
+    get_int16_ne = Stdlib_Bytes[64],
+    get_int16_be = Stdlib_Bytes[65],
+    get_int16_le = Stdlib_Bytes[66],
+    get_int32_ne = Stdlib_Bytes[67],
+    get_int32_be = Stdlib_Bytes[68],
+    get_int32_le = Stdlib_Bytes[69],
+    get_int64_ne = Stdlib_Bytes[70],
+    get_int64_be = Stdlib_Bytes[71],
+    get_int64_le = Stdlib_Bytes[72],
+    set_uint8 = Stdlib_Bytes[73],
+    set_int8 = Stdlib_Bytes[74],
+    set_uint16_ne = Stdlib_Bytes[75],
+    set_uint16_be = Stdlib_Bytes[76],
+    set_uint16_le = Stdlib_Bytes[77],
+    set_int16_ne = Stdlib_Bytes[78],
+    set_int16_be = Stdlib_Bytes[79],
+    set_int16_le = Stdlib_Bytes[80],
+    set_int32_ne = Stdlib_Bytes[81],
+    set_int32_be = Stdlib_Bytes[82],
+    set_int32_le = Stdlib_Bytes[83],
+    set_int64_ne = Stdlib_Bytes[84],
+    set_int64_be = Stdlib_Bytes[85],
+    set_int64_le = Stdlib_Bytes[86],
+    unsafe_escape = Stdlib_Bytes[87],
+    Stdlib_BytesLabels =
+      [0,
+       make,
+       init,
+       empty,
+       copy,
+       of_string,
+       to_string,
+       sub,
+       sub_string,
+       extend,
+       fill,
+       blit,
+       blit_string,
+       concat,
+       cat,
+       iter,
+       iteri,
+       map,
+       mapi,
+       fold_left,
+       fold_right,
+       for_all,
+       exists,
+       trim,
+       escaped,
+       index,
+       index_opt,
+       rindex,
+       rindex_opt,
+       index_from,
+       index_from_opt,
+       rindex_from,
+       rindex_from_opt,
+       contains,
+       contains_from,
+       rcontains_from,
+       uppercase_ascii,
+       lowercase_ascii,
+       capitalize_ascii,
+       uncapitalize_ascii,
+       compare,
+       equal,
+       starts_with,
+       ends_with,
+       unsafe_to_string,
+       unsafe_of_string,
+       split_on_char,
+       to_seq,
+       to_seqi,
+       of_seq,
+       get_utf_8_uchar,
+       set_utf_8_uchar,
+       is_valid_utf_8,
+       get_utf_16be_uchar,
+       set_utf_16be_uchar,
+       is_valid_utf_16be,
+       get_utf_16le_uchar,
+       set_utf_16le_uchar,
+       is_valid_utf_16le,
+       get_uint8,
+       get_int8,
+       get_uint16_ne,
+       get_uint16_be,
+       get_uint16_le,
+       get_int16_ne,
+       get_int16_be,
+       get_int16_le,
+       get_int32_ne,
+       get_int32_be,
+       get_int32_le,
+       get_int64_ne,
+       get_int64_be,
+       get_int64_le,
+       set_uint8,
+       set_int8,
+       set_uint16_ne,
+       set_uint16_be,
+       set_uint16_le,
+       set_int16_ne,
+       set_int16_be,
+       set_int16_le,
+       set_int32_ne,
+       set_int32_be,
+       set_int32_le,
+       set_int64_ne,
+       set_int64_be,
+       set_int64_le,
+       unsafe_escape];
+   runtime.caml_register_global(1, Stdlib_BytesLabels, "Stdlib__BytesLabels");
+   return;
+   /*<<?>>*/ }
+  (globalThis));
+
+//# unitInfo: Provides: Stdlib__StringLabels
+//# unitInfo: Requires: Stdlib__String
+(function
+  (globalThis){
+   "use strict";
+   var
+    runtime = globalThis.jsoo_runtime,
+    global_data = runtime.caml_get_global_data(),
+    Stdlib_String = global_data.Stdlib__String,
+    make = Stdlib_String[1],
+    init = Stdlib_String[2],
+    empty = Stdlib_String[3],
+    of_bytes = Stdlib_String[4],
+    to_bytes = Stdlib_String[5],
+    concat = Stdlib_String[6],
+    cat = Stdlib_String[7],
+    equal = Stdlib_String[8],
+    compare = Stdlib_String[9],
+    starts_with = Stdlib_String[10],
+    ends_with = Stdlib_String[11],
+    contains_from = Stdlib_String[12],
+    rcontains_from = Stdlib_String[13],
+    contains = Stdlib_String[14],
+    sub = Stdlib_String[15],
+    split_on_char = Stdlib_String[16],
+    map = Stdlib_String[17],
+    mapi = Stdlib_String[18],
+    fold_left = Stdlib_String[19],
+    fold_right = Stdlib_String[20],
+    for_all = Stdlib_String[21],
+    exists = Stdlib_String[22],
+    trim = Stdlib_String[23],
+    escaped = Stdlib_String[24],
+    uppercase_ascii = Stdlib_String[25],
+    lowercase_ascii = Stdlib_String[26],
+    capitalize_ascii = Stdlib_String[27],
+    uncapitalize_ascii = Stdlib_String[28],
+    iter = Stdlib_String[29],
+    iteri = Stdlib_String[30],
+    index_from = Stdlib_String[31],
+    index_from_opt = Stdlib_String[32],
+    rindex_from = Stdlib_String[33],
+    rindex_from_opt = Stdlib_String[34],
+    index = Stdlib_String[35],
+    index_opt = Stdlib_String[36],
+    rindex = Stdlib_String[37],
+    rindex_opt = Stdlib_String[38],
+    to_seq = Stdlib_String[39],
+    to_seqi = Stdlib_String[40],
+    of_seq = Stdlib_String[41],
+    get_utf_8_uchar = Stdlib_String[42],
+    is_valid_utf_8 = Stdlib_String[43],
+    get_utf_16be_uchar = Stdlib_String[44],
+    is_valid_utf_16be = Stdlib_String[45],
+    get_utf_16le_uchar = Stdlib_String[46],
+    is_valid_utf_16le = Stdlib_String[47],
+    blit = Stdlib_String[48],
+    get_uint8 = Stdlib_String[49],
+    get_int8 = Stdlib_String[50],
+    get_uint16_ne = Stdlib_String[51],
+    get_uint16_be = Stdlib_String[52],
+    get_uint16_le = Stdlib_String[53],
+    get_int16_ne = Stdlib_String[54],
+    get_int16_be = Stdlib_String[55],
+    get_int16_le = Stdlib_String[56],
+    get_int32_ne = Stdlib_String[57],
+    hash = Stdlib_String[58],
+    seeded_hash = Stdlib_String[59],
+    get_int32_be = Stdlib_String[60],
+    get_int32_le = Stdlib_String[61],
+    get_int64_ne = Stdlib_String[62],
+    get_int64_be = Stdlib_String[63],
+    get_int64_le = Stdlib_String[64],
+    Stdlib_StringLabels =
+      [0,
+       make,
+       init,
+       empty,
+       of_bytes,
+       to_bytes,
+       concat,
+       cat,
+       equal,
+       compare,
+       starts_with,
+       ends_with,
+       contains_from,
+       rcontains_from,
+       contains,
+       sub,
+       split_on_char,
+       map,
+       mapi,
+       fold_left,
+       fold_right,
+       for_all,
+       exists,
+       trim,
+       escaped,
+       uppercase_ascii,
+       lowercase_ascii,
+       capitalize_ascii,
+       uncapitalize_ascii,
+       iter,
+       iteri,
+       index_from,
+       index_from_opt,
+       rindex_from,
+       rindex_from_opt,
+       index,
+       index_opt,
+       rindex,
+       rindex_opt,
+       to_seq,
+       to_seqi,
+       of_seq,
+       get_utf_8_uchar,
+       is_valid_utf_8,
+       get_utf_16be_uchar,
+       is_valid_utf_16be,
+       get_utf_16le_uchar,
+       is_valid_utf_16le,
+       blit,
+       get_uint8,
+       get_int8,
+       get_uint16_ne,
+       get_uint16_be,
+       get_uint16_le,
+       get_int16_ne,
+       get_int16_be,
+       get_int16_le,
+       get_int32_ne,
+       hash,
+       seeded_hash,
+       get_int32_be,
+       get_int32_le,
+       get_int64_ne,
+       get_int64_be,
+       get_int64_le];
+   runtime.caml_register_global
+    (1, Stdlib_StringLabels, "Stdlib__StringLabels");
+   return;
+   /*<<?>>*/ }
+  (globalThis));
+
+//# unitInfo: Provides: Stdlib__MoreLabels
+//# unitInfo: Requires: Stdlib__Hashtbl, Stdlib__Map, Stdlib__Set
+(function
+  (globalThis){
+   "use strict";
+   var
+    runtime = globalThis.jsoo_runtime,
+    global_data = runtime.caml_get_global_data(),
+    Stdlib_Set = global_data.Stdlib__Set,
+    Stdlib_Map = global_data.Stdlib__Map,
+    Stdlib_Hashtbl = global_data.Stdlib__Hashtbl,
+    Stdlib_MoreLabels = [0, Stdlib_Hashtbl, Stdlib_Map, Stdlib_Set];
+   runtime.caml_register_global(3, Stdlib_MoreLabels, "Stdlib__MoreLabels");
+   return;
+   /*<<?>>*/ }
+  (globalThis));
+
+//# unitInfo: Provides: Stdlib__StdLabels
+(function(globalThis){
+   "use strict";
+   var runtime = globalThis.jsoo_runtime, Stdlib_StdLabels = [0];
+   runtime.caml_register_global(0, Stdlib_StdLabels, "Stdlib__StdLabels");
+   return;
+   /*<<?>>*/ }
+  (globalThis));
+
+//# unitInfo: Provides: Stdlib__In_channel
+//# unitInfo: Requires: Stdlib, Stdlib__Bytes, Stdlib__Fun, Stdlib__Sys
+(function
+  (globalThis){
+   "use strict";
+   var
+    runtime = globalThis.jsoo_runtime,
+    caml_create_bytes = runtime.caml_create_bytes,
+    caml_maybe_attach_backtrace = runtime.caml_maybe_attach_backtrace,
+    caml_ml_bytes_length = runtime.caml_ml_bytes_length,
+    caml_wrap_exception = runtime.caml_wrap_exception;
+    /*<<?>>*/ function caml_call1(f, a0){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 1
+            ? f(a0)
+            : runtime.caml_call_gen(f, [a0]);
+   }
+    /*<<?>>*/ function caml_call2(f, a0, a1){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 2
+            ? f(a0, a1)
+            : runtime.caml_call_gen(f, [a0, a1]);
+   }
+    /*<<?>>*/ function caml_call3(f, a0, a1, a2){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 3
+            ? f(a0, a1, a2)
+            : runtime.caml_call_gen(f, [a0, a1, a2]);
+   }
+    /*<<?>>*/ function caml_call4(f, a0, a1, a2, a3){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 4
+            ? f(a0, a1, a2, a3)
+            : runtime.caml_call_gen(f, [a0, a1, a2, a3]);
+   }
+    /*<<?>>*/ function caml_call5(f, a0, a1, a2, a3, a4){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 5
+            ? f(a0, a1, a2, a3, a4)
+            : runtime.caml_call_gen(f, [a0, a1, a2, a3, a4]);
+   }
+   var
+    global_data = runtime.caml_get_global_data(),
+    Stdlib_Bytes = global_data.Stdlib__Bytes,
+    Stdlib = global_data.Stdlib,
+    Stdlib_Sys = global_data.Stdlib__Sys,
+    Stdlib_Fun = global_data.Stdlib__Fun,
+    stdin = Stdlib[38],
+    open_bin = Stdlib[80],
+    open_text = Stdlib[79],
+    open_gen = Stdlib[81],
+    cst_In_channel_input_all_chann =
+      "In_channel.input_all: channel content is larger than maximum string length",
+    _a_ = [0, 0];
+   function with_open(openfun, s, f){
+     /*<<in_channel.ml:35:2>>*/  /*<<in_channel.ml:35:11>>*/ var
+     ic =  /*<<in_channel.ml:35:11>>*/ caml_call1(openfun, s);
+    function _r_(param){
+      /*<<in_channel.ml:37:15>>*/ return  /*<<in_channel.ml:36:2>>*/ caml_call1
+             (f, ic);
+     /*<<in_channel.ml:37:19>>*/ }
+    function _s_(param){
+      /*<<in_channel.ml:36:34>>*/ return  /*<<in_channel.ml:37:4>>*/ caml_call1
+             (Stdlib[94], ic);
+     /*<<in_channel.ml:36:58>>*/ }
+     /*<<in_channel.ml:37:4>>*/ return  /*<<in_channel.ml:37:4>>*/ caml_call2
+            (Stdlib_Fun[4], _s_, _r_);
+    /*<<in_channel.ml:37:20>>*/ }
+   function with_open_bin(s, f){
+     /*<<in_channel.ml:40:2>>*/ return with_open(Stdlib[80], s, f);
+    /*<<in_channel.ml:40:34>>*/ }
+   function with_open_text(s, f){
+     /*<<in_channel.ml:43:2>>*/ return with_open(Stdlib[79], s, f);
+    /*<<in_channel.ml:43:30>>*/ }
+   function with_open_gen(flags, perm, s, f){
+     /*<<in_channel.ml:46:2>>*/ return with_open
+            ( /*<<in_channel.ml:46:12>>*/ caml_call2(Stdlib[81], flags, perm),
+             s,
+             f);
+    /*<<in_channel.ml:46:47>>*/ }
+   var
+    seek = Stdlib[96][4],
+    pos = Stdlib[96][5],
+    length = Stdlib[96][6],
+    close = Stdlib[93],
+    close_noerr = Stdlib[94];
+   function input_char(ic){
+     /*<<in_channel.ml:55:2>>*/ try{
+      /*<<in_channel.ml:55:8>>*/  /*<<in_channel.ml:55:8>>*/ var
+      c =  /*<<in_channel.ml:55:8>>*/ caml_call1(Stdlib[82], ic);
+    }
+    catch(_q_){
+     var _p_ = caml_wrap_exception(_q_);
+     if(_p_ === Stdlib[12])  /*<<in_channel.ml:57:29>>*/ return 0;
+     throw caml_maybe_attach_backtrace(_p_, 0);
+    }
+     /*<<in_channel.ml:56:9>>*/ return [0, c];
+    /*<<in_channel.ml:57:33>>*/ }
+   function input_byte(ic){
+     /*<<in_channel.ml:60:2>>*/ try{
+      /*<<in_channel.ml:60:8>>*/  /*<<in_channel.ml:60:8>>*/ var
+      n =  /*<<in_channel.ml:60:8>>*/ caml_call1(Stdlib[87], ic);
+    }
+    catch(_o_){
+     var _n_ = caml_wrap_exception(_o_);
+     if(_n_ === Stdlib[12])  /*<<in_channel.ml:62:29>>*/ return 0;
+     throw caml_maybe_attach_backtrace(_n_, 0);
+    }
+     /*<<in_channel.ml:61:9>>*/ return [0, n];
+    /*<<in_channel.ml:62:33>>*/ }
+   function input_line(ic){
+     /*<<in_channel.ml:65:2>>*/ try{
+      /*<<in_channel.ml:65:8>>*/  /*<<in_channel.ml:65:8>>*/ var
+      s =  /*<<in_channel.ml:65:8>>*/ caml_call1(Stdlib[83], ic);
+    }
+    catch(_m_){
+     var _l_ = caml_wrap_exception(_m_);
+     if(_l_ === Stdlib[12])  /*<<in_channel.ml:67:29>>*/ return 0;
+     throw caml_maybe_attach_backtrace(_l_, 0);
+    }
+     /*<<in_channel.ml:66:9>>*/ return [0, s];
+    /*<<in_channel.ml:67:33>>*/ }
+   var input = Stdlib[84];
+   function really_input(ic, buf, pos, len){
+     /*<<in_channel.ml:72:2>>*/ try{
+      /*<<in_channel.ml:72:8>>*/  /*<<in_channel.ml:72:8>>*/ caml_call4
+      (Stdlib[85], ic, buf, pos, len);
+      /*<<in_channel.ml:73:10>>*/ return _a_;
+    }
+    catch(_k_){
+     var _j_ = caml_wrap_exception(_k_);
+     if(_j_ === Stdlib[12])  /*<<in_channel.ml:74:29>>*/ return 0;
+     throw caml_maybe_attach_backtrace(_j_, 0);
+    }
+    /*<<in_channel.ml:74:33>>*/ }
+   function really_input_string(ic, len){
+     /*<<in_channel.ml:77:2>>*/ try{
+      /*<<in_channel.ml:77:8>>*/  /*<<in_channel.ml:77:8>>*/ var
+      s =  /*<<in_channel.ml:77:8>>*/ caml_call2(Stdlib[86], ic, len);
+    }
+    catch(_i_){
+     var _h_ = caml_wrap_exception(_i_);
+     if(_h_ === Stdlib[12])  /*<<in_channel.ml:79:29>>*/ return 0;
+     throw caml_maybe_attach_backtrace(_h_, 0);
+    }
+     /*<<in_channel.ml:78:9>>*/ return [0, s];
+    /*<<in_channel.ml:79:33>>*/ }
+   function read_upto(ic, buf, ofs, len){
+     /*<<in_channel.ml:84:2>>*/ var ofs$0 = ofs, len$0 = len;
+     /*<<in_channel.ml:85:4>>*/ for(;;){
+     if(0 !== len$0){
+       /*<<in_channel.ml:87:14>>*/  /*<<in_channel.ml:87:14>>*/ var
+       r =
+          /*<<in_channel.ml:87:14>>*/ caml_call4
+          (Stdlib[84], ic, buf, ofs$0, len$0);
+       /*<<in_channel.ml:88:6>>*/ if(0 !== r){
+       var
+        len$1 = len$0 - r | 0,
+        ofs$1 = ofs$0 + r | 0,
+        ofs$0 = ofs$1,
+        len$0 = len$1;
+       continue;
+      }
+     }
+      /*<<in_channel.ml:94:2>>*/ return ofs$0 - ofs | 0;
+    }
+    /*<<in_channel.ml:94:20>>*/ }
+   function ensure(buf, ofs, n){
+     /*<<in_channel.ml:109:2>>*/ var len = caml_ml_bytes_length(buf);
+    if((ofs + n | 0) <= len)  /*<<in_channel.ml:110:25>>*/ return buf;
+     /*<<in_channel.ml:112:18>>*/  /*<<in_channel.ml:112:18>>*/ var
+     new_len = [0, len];
+    for(;;){
+     if(new_len[1] >= (ofs + n | 0)){
+       /*<<in_channel.ml:126:18>>*/ var
+       new_len$0 = new_len[1],
+       new_len$1 =
+         new_len$0 <= Stdlib_Sys[12]
+          ? new_len$0
+          : ofs
+            < Stdlib_Sys[12]
+            ? Stdlib_Sys[12]
+            :  /*<<in_channel.ml:123:8>>*/ caml_call1
+              (Stdlib[2], cst_In_channel_input_all_chann),
+        /*<<in_channel.ml:126:18>>*/ new_buf =
+          /*<<in_channel.ml:126:18>>*/ caml_create_bytes(new_len$1);
+       /*<<in_channel.ml:127:4>>*/  /*<<in_channel.ml:127:4>>*/ caml_call5
+       (Stdlib_Bytes[11], buf, 0, new_buf, 0, ofs);
+       /*<<in_channel.ml:127:4>>*/ return new_buf;
+     }
+     new_len[1] = (2 * new_len[1] | 0) + 1 | 0;
+    }
+    /*<<in_channel.ml:129:5>>*/ }
+   function input_all(ic){
+     /*<<in_channel.ml:132:2>>*/  /*<<in_channel.ml:132:2>>*/ var
+     chunk_size = 65536;
+     /*<<in_channel.ml:133:2>>*/ try{
+      /*<<in_channel.ml:135:36>>*/ var
+       /*<<in_channel.ml:135:36>>*/ _d_ =
+         /*<<in_channel.ml:135:36>>*/ caml_call1(Stdlib[91], ic),
+       /*<<in_channel.ml:135:6>>*/ _e_ =
+         /*<<in_channel.ml:135:6>>*/ caml_call1(Stdlib[92], ic) - _d_ | 0,
+      initial_size = _e_;
+    }
+    catch(_g_){
+     var _b_ = caml_wrap_exception(_g_);
+     if(_b_[1] !== Stdlib[11]) throw caml_maybe_attach_backtrace(_b_, 0);
+     var initial_size = -1;
+    }
+     /*<<in_channel.ml:139:2>>*/ var
+      /*<<in_channel.ml:139:2>>*/ initial_size$0 =
+       0 <= initial_size ? initial_size : chunk_size,
+     initial_size$1 =
+       initial_size$0 <= Stdlib_Sys[12] ? initial_size$0 : Stdlib_Sys[12],
+      /*<<in_channel.ml:146:12>>*/ buf =
+        /*<<in_channel.ml:146:12>>*/ caml_create_bytes(initial_size$1),
+      /*<<in_channel.ml:147:14>>*/ nread =
+       read_upto(ic, buf, 0, initial_size$1);
+    if(nread < initial_size$1)
+      /*<<in_channel.ml:149:4>>*/ return  /*<<in_channel.ml:149:4>>*/ caml_call3
+             (Stdlib_Bytes[8], buf, 0, nread);
+     /*<<in_channel.ml:150:7>>*/ try{
+      /*<<in_channel.ml:151:10>>*/  /*<<in_channel.ml:151:10>>*/ var
+      c =  /*<<in_channel.ml:151:10>>*/ caml_call1(Stdlib[82], ic);
+    }
+    catch(_f_){
+     var _c_ = caml_wrap_exception(_f_);
+     if(_c_ === Stdlib[12])
+       /*<<in_channel.ml:154:8>>*/ return  /*<<in_channel.ml:154:8>>*/ caml_call1
+              (Stdlib_Bytes[44], buf);
+     throw caml_maybe_attach_backtrace(_c_, 0);
+    }
+     /*<<in_channel.ml:168:18>>*/  /*<<in_channel.ml:168:18>>*/ var
+     buf$2 = ensure(buf, nread, 65537);
+     /*<<in_channel.ml:169:8>>*/  /*<<in_channel.ml:169:8>>*/ runtime.caml_bytes_set
+     (buf$2, nread, c);
+     /*<<in_channel.ml:169:8>>*/ var
+      /*<<in_channel.ml:169:8>>*/ ofs$1 = nread + 1 | 0,
+     buf$0 = buf$2,
+     ofs = ofs$1;
+     /*<<in_channel.ml:158:10>>*/ for(;;){
+      /*<<in_channel.ml:158:20>>*/ var
+       /*<<in_channel.ml:158:20>>*/ buf$1 = ensure(buf$0, ofs, chunk_size),
+      rem = caml_ml_bytes_length(buf$1) - ofs | 0,
+       /*<<in_channel.ml:162:18>>*/ r = read_upto(ic, buf$1, ofs, rem);
+     if(r < rem)
+       /*<<in_channel.ml:158:20>>*/ return  /*<<in_channel.ml:158:20>>*/ caml_call3
+              (Stdlib_Bytes[8], buf$1, 0, ofs + r | 0);
+     var ofs$0 = ofs + rem | 0, buf$0 = buf$1, ofs = ofs$0;
+    }
+    /*<<in_channel.ml:171:5>>*/ }
+   var
+    set_binary_mode = Stdlib[95],
+    Stdlib_In_channel =
+      [0,
+       stdin,
+       open_bin,
+       open_text,
+       open_gen,
+       with_open_bin,
+       with_open_text,
+       with_open_gen,
+       seek,
+       pos,
+       length,
+       close,
+       close_noerr,
+       input_char,
+       input_byte,
+       input_line,
+       input,
+       really_input,
+       really_input_string,
+       input_all,
+       set_binary_mode];
+   runtime.caml_register_global(6, Stdlib_In_channel, "Stdlib__In_channel");
+   return;
+   /*<<?>>*/ }
+  (globalThis));
+
+//# unitInfo: Provides: Stdlib__Out_channel
+//# unitInfo: Requires: Stdlib, Stdlib__Fun
+(function
+  (globalThis){
+   "use strict";
+   var runtime = globalThis.jsoo_runtime;
+    /*<<?>>*/ function caml_call1(f, a0){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 1
+            ? f(a0)
+            : runtime.caml_call_gen(f, [a0]);
+   }
+    /*<<?>>*/ function caml_call2(f, a0, a1){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 2
+            ? f(a0, a1)
+            : runtime.caml_call_gen(f, [a0, a1]);
+   }
+   var
+    global_data = runtime.caml_get_global_data(),
+    Stdlib = global_data.Stdlib,
+    Stdlib_Fun = global_data.Stdlib__Fun,
+    stdout = Stdlib[39],
+    stderr = Stdlib[40],
+    open_bin = Stdlib[61],
+    open_text = Stdlib[60],
+    open_gen = Stdlib[62];
+   function with_open(openfun, s, f){
+     /*<<out_channel.ml:36:2>>*/  /*<<out_channel.ml:36:11>>*/ var
+     oc =  /*<<out_channel.ml:36:11>>*/ caml_call1(openfun, s);
+    function _a_(param){
+      /*<<out_channel.ml:38:15>>*/ return  /*<<out_channel.ml:37:2>>*/ caml_call1
+             (f, oc);
+     /*<<out_channel.ml:38:19>>*/ }
+    function _b_(param){
+      /*<<out_channel.ml:37:34>>*/ return  /*<<out_channel.ml:38:4>>*/ caml_call1
+             (Stdlib[77], oc);
+     /*<<out_channel.ml:37:59>>*/ }
+     /*<<out_channel.ml:38:4>>*/ return  /*<<out_channel.ml:38:4>>*/ caml_call2
+            (Stdlib_Fun[4], _b_, _a_);
+    /*<<out_channel.ml:38:20>>*/ }
+   function with_open_bin(s, f){
+     /*<<out_channel.ml:41:2>>*/ return with_open(Stdlib[61], s, f);
+    /*<<out_channel.ml:41:35>>*/ }
+   function with_open_text(s, f){
+     /*<<out_channel.ml:44:2>>*/ return with_open(Stdlib[60], s, f);
+    /*<<out_channel.ml:44:31>>*/ }
+   function with_open_gen(flags, perm, s, f){
+     /*<<out_channel.ml:47:2>>*/ return with_open
+            ( /*<<out_channel.ml:47:12>>*/ caml_call2(Stdlib[62], flags, perm),
+             s,
+             f);
+    /*<<out_channel.ml:47:48>>*/ }
+   var
+    seek = Stdlib[96][1],
+    pos = Stdlib[96][2],
+    length = Stdlib[96][3],
+    close = Stdlib[76],
+    close_noerr = Stdlib[77],
+    flush = Stdlib[63],
+    flush_all = Stdlib[64],
+    output_char = Stdlib[65],
+    output_byte = Stdlib[70],
+    output_string = Stdlib[66],
+    output_bytes = Stdlib[67],
+    output = Stdlib[68],
+    output_substring = Stdlib[69],
+    set_binary_mode = Stdlib[78],
+    Stdlib_Out_channel =
+      [0,
+       stdout,
+       stderr,
+       open_bin,
+       open_text,
+       open_gen,
+       with_open_bin,
+       with_open_text,
+       with_open_gen,
+       seek,
+       pos,
+       length,
+       close,
+       close_noerr,
+       flush,
+       flush_all,
+       output_char,
+       output_byte,
+       output_string,
+       output_bytes,
+       output,
+       output_substring,
+       set_binary_mode,
+       runtime.caml_ml_set_buffered,
+       runtime.caml_ml_is_buffered];
+   runtime.caml_register_global(2, Stdlib_Out_channel, "Stdlib__Out_channel");
+   return;
+   /*<<?>>*/ }
+  (globalThis));
+
+//# unitInfo: Provides: Stdlib__Effect
+//# unitInfo: Requires: Stdlib, Stdlib__Callback, Stdlib__Printexc, Stdlib__Printf
+//# unitInfo: Effects_without_cps: true
+(function
+  (globalThis){
+   "use strict";
+   var
+    runtime = globalThis.jsoo_runtime,
+    caml_alloc_stack = runtime.caml_alloc_stack,
+    caml_continuation_use_noexc = runtime.caml_continuation_use_noexc,
+    caml_fresh_oo_id = runtime.caml_fresh_oo_id,
+    caml_maybe_attach_backtrace = runtime.caml_maybe_attach_backtrace,
+    caml_restore_raw_backtrace = runtime.caml_restore_raw_backtrace,
+    caml_wrap_exception = runtime.caml_wrap_exception,
+    jsoo_effect_not_supported = runtime.jsoo_effect_not_supported;
+    /*<<?>>*/ function caml_call1(f, a0){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 1
+            ? f(a0)
+            : runtime.caml_call_gen(f, [a0]);
+   }
+    /*<<?>>*/ function caml_call2(f, a0, a1){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 2
+            ? f(a0, a1)
+            : runtime.caml_call_gen(f, [a0, a1]);
+   }
+    /*<<effect.ml:18:12>>*/ var
+    global_data = runtime.caml_get_global_data(),
+    Stdlib = global_data.Stdlib,
+    Stdlib_Printexc = global_data.Stdlib__Printexc,
+    Stdlib_Printf = global_data.Stdlib__Printf,
+    Stdlib_Callback = global_data.Stdlib__Callback,
+     /*<<effect.ml:18:12>>*/ Unhandled =
+      [248, "Stdlib.Effect.Unhandled", caml_fresh_oo_id(0)],
+     /*<<effect.ml:19:0>>*/ Continuation_already_resumed =
+      [248, "Stdlib.Effect.Continuation_already_resumed", caml_fresh_oo_id(0)],
+    cst_impossible = "impossible",
+    cst_Initial_setup = "Initial_setup__",
+    cst_E = "E",
+    _a_ =
+      [0,
+       [11, "Stdlib.Effect.Unhandled(", [2, 0, [12, 41, 0]]],
+       "Stdlib.Effect.Unhandled(%s)"],
+    cst_Stdlib_Effect_Should_not_s = "Stdlib.Effect.Should_not_see_this__",
+    cst_Effect_Unhandled = "Effect.Unhandled",
+    cst_Effect_Continuation_alread = "Effect.Continuation_already_resumed";
+   function printer(param){
+     /*<<effect.ml:22:16>>*/ if(param[1] !== Unhandled)
+      /*<<effect.ml:28:11>>*/ return 0;
+     /*<<effect.ml:25:12>>*/ var
+     x = param[2],
+      /*<<effect.ml:25:12>>*/ _j_ =
+        /*<<effect.ml:25:12>>*/ caml_call1(Stdlib_Printexc[26], x),
+      /*<<effect.ml:24:18>>*/ msg =
+        /*<<effect.ml:24:18>>*/ caml_call2(Stdlib_Printf[4], _a_, _j_);
+     /*<<effect.ml:27:8>>*/ return [0, msg];
+    /*<<effect.ml:28:15>>*/ }
+    /*<<effect.ml:30:2>>*/  /*<<effect.ml:30:2>>*/ caml_call1
+    (Stdlib_Printexc[9], printer);
+    /*<<effect.ml:33:12>>*/  /*<<effect.ml:33:12>>*/ var
+    Should_not_see_this =
+      [248, cst_Stdlib_Effect_Should_not_s, caml_fresh_oo_id(0)];
+    /*<<effect.ml:34:8>>*/  /*<<effect.ml:34:8>>*/ caml_call2
+    (Stdlib_Callback[2],
+     cst_Effect_Unhandled,
+     [0, Unhandled, Should_not_see_this]);
+    /*<<effect.ml:36:8>>*/  /*<<effect.ml:36:8>>*/ caml_call2
+    (Stdlib_Callback[2],
+     cst_Effect_Continuation_alread,
+     Continuation_already_resumed);
+    /*<<effect.ml:36:8>>*/ function continue$0(k, v){
+    function _h_(x){
+      /*<<effect.ml:57:58>>*/ return x;
+     /*<<effect.ml:57:59>>*/ }
+     /*<<effect.ml:57:28>>*/  /*<<effect.ml:57:28>>*/ var
+     _i_ =  /*<<effect.ml:57:28>>*/ caml_continuation_use_noexc(k);
+     /*<<effect.ml:57:28>>*/ return  /*<<effect.ml:57:28>>*/ jsoo_effect_not_supported
+            ();
+    /*<<effect.ml:57:62>>*/ }
+   function discontinue(k, e){
+    function _f_(e){
+      /*<<effect.ml:59:61>>*/ throw  /*<<effect.ml:59:61>>*/ caml_maybe_attach_backtrace
+            (e, 1);
+     /*<<effect.ml:59:68>>*/ }
+     /*<<effect.ml:59:31>>*/  /*<<effect.ml:59:31>>*/ var
+     _g_ =  /*<<effect.ml:59:31>>*/ caml_continuation_use_noexc(k);
+     /*<<effect.ml:59:31>>*/ return  /*<<effect.ml:59:31>>*/ jsoo_effect_not_supported
+            ();
+    /*<<effect.ml:59:71>>*/ }
+   function discontinue_with_backtrace(k, e, bt){
+    function _d_(e){
+      /*<<effect.ml:62:4>>*/ caml_restore_raw_backtrace(e, bt);
+      /*<<effect.ml:62:4>>*/ throw  /*<<effect.ml:62:4>>*/ caml_maybe_attach_backtrace
+            (e, 0);
+     /*<<effect.ml:62:38>>*/ }
+     /*<<effect.ml:61:49>>*/  /*<<effect.ml:61:49>>*/ var
+     _e_ =  /*<<effect.ml:61:49>>*/ caml_continuation_use_noexc(k);
+     /*<<effect.ml:61:49>>*/ return  /*<<effect.ml:61:49>>*/ jsoo_effect_not_supported
+            ();
+    /*<<effect.ml:62:41>>*/ }
+   function match_with(comp, arg, handler){
+    function effc(eff, k, last_fiber){
+      /*<<effect.ml:74:6>>*/  /*<<effect.ml:74:12>>*/ var
+      match =  /*<<effect.ml:74:12>>*/ caml_call1(handler[3], eff);
+     if(! match)
+       /*<<effect.ml:76:16>>*/ return  /*<<effect.ml:76:16>>*/ jsoo_effect_not_supported
+              ();
+     var f = match[1];
+      /*<<effect.ml:75:18>>*/ return  /*<<effect.ml:75:18>>*/ caml_call1(f, k);
+     /*<<effect.ml:76:42>>*/ }
+     /*<<effect.ml:78:12>>*/  /*<<effect.ml:78:12>>*/ var
+     s =
+        /*<<effect.ml:78:12>>*/ caml_alloc_stack(handler[1], handler[2], effc);
+     /*<<effect.ml:79:4>>*/ return  /*<<effect.ml:79:4>>*/ jsoo_effect_not_supported
+            ();
+    /*<<effect.ml:79:23>>*/ }
+   function try_with(comp, arg, handler){
+    function effc(eff, k, last_fiber){
+      /*<<effect.ml:86:6>>*/  /*<<effect.ml:86:12>>*/ var
+      match =  /*<<effect.ml:86:12>>*/ caml_call1(handler[1], eff);
+     if(! match)
+       /*<<effect.ml:88:16>>*/ return  /*<<effect.ml:88:16>>*/ jsoo_effect_not_supported
+              ();
+     var f = match[1];
+      /*<<effect.ml:87:18>>*/ return  /*<<effect.ml:87:18>>*/ caml_call1(f, k);
+     /*<<effect.ml:88:42>>*/ }
+    function _c_(e){
+      /*<<effect.ml:90:47>>*/ throw  /*<<effect.ml:90:47>>*/ caml_maybe_attach_backtrace
+            (e, 1);
+     /*<<effect.ml:90:54>>*/ }
+     /*<<effect.ml:90:12>>*/  /*<<effect.ml:90:12>>*/ var
+     s =
+        /*<<effect.ml:90:12>>*/ caml_alloc_stack
+        (function(x){
+           /*<<effect.ml:90:34>>*/ return x;
+          /*<<effect.ml:90:35>>*/ },
+         _c_,
+         effc);
+     /*<<effect.ml:91:4>>*/ return  /*<<effect.ml:91:4>>*/ jsoo_effect_not_supported
+            ();
+    /*<<effect.ml:91:23>>*/ }
+    /*<<effect.ml:44:14>>*/  /*<<effect.ml:44:14>>*/ var
+    Deep =
+      [0,
+       continue$0,
+       discontinue,
+       discontinue_with_backtrace,
+       match_with,
+       try_with];
+   function fiber(f){
+     /*<<effect.ml:111:4>>*/ var
+      /*<<effect.ml:111:38>>*/ Initial_setup =
+       [248, cst_Initial_setup, caml_fresh_oo_id(0)],
+      /*<<effect.ml:112:18>>*/ E = [248, cst_E, caml_fresh_oo_id(0)];
+    function f$0(param){
+      /*<<effect.ml:113:16>>*/ return  /*<<effect.ml:113:18>>*/ caml_call1
+             (f,  /*<<effect.ml:113:18>>*/ jsoo_effect_not_supported());
+     /*<<effect.ml:113:45>>*/ }
+     /*<<effect.ml:114:4>>*/ function error(param){
+      /*<<effect.ml:114:18>>*/ return  /*<<effect.ml:114:18>>*/ caml_call1
+             (Stdlib[2], cst_impossible);
+     /*<<effect.ml:114:39>>*/ }
+    function effc(eff, k, last_fiber){
+      /*<<effect.ml:116:6>>*/ if(eff === Initial_setup)
+       /*<<effect.ml:117:29>>*/ throw [0, E, k];
+      /*<<effect.ml:118:13>>*/ return error(0);
+     /*<<effect.ml:118:21>>*/ }
+     /*<<effect.ml:120:12>>*/  /*<<effect.ml:120:12>>*/ var
+     s =  /*<<effect.ml:120:12>>*/ caml_alloc_stack(error, error, effc);
+     /*<<effect.ml:121:4>>*/ try{
+      /*<<effect.ml:121:10>>*/  /*<<effect.ml:121:10>>*/ jsoo_effect_not_supported
+      ();
+     var _b_ = 0;
+    }
+    catch(exn$0){
+     var exn = caml_wrap_exception(exn$0);
+     if(exn[1] !== E) throw caml_maybe_attach_backtrace(exn, 0);
+     var k = exn[2];
+      /*<<effect.ml:122:23>>*/ return k;
+    }
+     /*<<effect.ml:123:11>>*/ return error(0);
+    /*<<effect.ml:123:19>>*/ }
+   function continue_gen(k, resume_fun, v, handler){
+    function effc(eff, k, last_fiber){
+      /*<<effect.ml:142:6>>*/  /*<<effect.ml:142:12>>*/ var
+      match =  /*<<effect.ml:142:12>>*/ caml_call1(handler[3], eff);
+     if(! match)
+       /*<<effect.ml:144:16>>*/ return  /*<<effect.ml:144:16>>*/ jsoo_effect_not_supported
+              ();
+     var f = match[1];
+      /*<<effect.ml:143:18>>*/ return  /*<<effect.ml:143:18>>*/ caml_call1
+             (f, k);
+     /*<<effect.ml:144:42>>*/ }
+     /*<<effect.ml:146:16>>*/  /*<<effect.ml:146:16>>*/ var
+     stack =
+        /*<<effect.ml:146:16>>*/ runtime.caml_continuation_use_and_update_handler_noexc
+        (k, handler[1], handler[2], effc);
+     /*<<effect.ml:147:4>>*/ return  /*<<effect.ml:147:4>>*/ jsoo_effect_not_supported
+            ();
+    /*<<effect.ml:147:29>>*/ }
+   function continue_with(k, v, handler){
+     /*<<effect.ml:150:4>>*/ return continue_gen
+            (k,
+             function(x){
+               /*<<effect.ml:150:29>>*/ return x;
+              /*<<effect.ml:150:30>>*/ },
+             v,
+             handler);
+    /*<<effect.ml:150:41>>*/ }
+   function discontinue_with(k, v, handler){
+     /*<<effect.ml:153:4>>*/ return continue_gen
+            (k,
+             function(e){
+               /*<<effect.ml:153:29>>*/ throw  /*<<effect.ml:153:29>>*/ caml_maybe_attach_backtrace
+                     (e, 1);
+              /*<<effect.ml:153:36>>*/ },
+             v,
+             handler);
+    /*<<effect.ml:153:47>>*/ }
+   function discontinue_with_backtrace$0(k, v, bt, handler){
+     /*<<effect.ml:156:4>>*/ return continue_gen
+            (k,
+             function(e){
+               /*<<effect.ml:156:29>>*/ caml_restore_raw_backtrace(e, bt);
+               /*<<effect.ml:156:29>>*/ throw  /*<<effect.ml:156:29>>*/ caml_maybe_attach_backtrace
+                     (e, 0);
+              /*<<effect.ml:156:63>>*/ },
+             v,
+             handler);
+    /*<<effect.ml:156:74>>*/ }
+   var
+    Stdlib_Effect =
+      [0,
+       Unhandled,
+       Continuation_already_resumed,
+       Deep,
+       [0,
+        fiber,
+        continue_with,
+        discontinue_with,
+        discontinue_with_backtrace$0]];
+   runtime.caml_register_global(13, Stdlib_Effect, "Stdlib__Effect");
+   return;
+   /*<<?>>*/ }
+  (globalThis));
diff --git a/testing/dead_field.js b/testing/dead_field.js
new file mode 100644
index 0000000000..c9c740a5b2
--- /dev/null
+++ b/testing/dead_field.js
@@ -0,0 +1,29 @@
+// Generated by js_of_ocaml
+//# buildInfo:effects=false, kind=cmo, use-js-string=true, version=5.4.0+git-5.2.0-99-g50bcd077-dirty
+
+//# unitInfo: Provides: Dead_field
+//# unitInfo: Requires: Stdlib
+(function
+  (globalThis){
+   "use strict";
+   var runtime = globalThis.jsoo_runtime;
+   function caml_call1(f, a0){
+    return (f.l >= 0 ? f.l : f.l = f.length) == 1
+            ? f(a0)
+            : runtime.caml_call_gen(f, [a0]);
+   }
+   var
+    _d_ = undefined,
+    global_data = runtime.caml_get_global_data(),
+    Stdlib = global_data.Stdlib;
+   function _a_(_f_, _e_){
+    var _g_ = _f_ ? [0, 1, _d_, _e_] : [0, 3, _d_, 4];
+    return [0, _g_[1], _g_[3]];
+   }
+   var _b_ = _a_(0, 2)[2], _c_ = _a_(1, 1)[1] + _b_ | 0;
+   caml_call1(Stdlib[44], _c_);
+   var Dead_field = [0];
+   runtime.caml_register_global(1, Dead_field, "Dead_field");
+   return;
+  }
+  (globalThis));

From bbc3932060959168bebdca882c765631e384fed5 Mon Sep 17 00:00:00 2001
From: Micah Cantor <micahcantor01@gmail.com>
Date: Mon, 2 Oct 2023 15:44:41 -0500
Subject: [PATCH 082/112] fix live_instruction

---
 compiler/lib/global_deadcode.ml | 11 +++++------
 1 file changed, 5 insertions(+), 6 deletions(-)

diff --git a/compiler/lib/global_deadcode.ml b/compiler/lib/global_deadcode.ml
index f40a3981c5..2022864a8d 100644
--- a/compiler/lib/global_deadcode.ml
+++ b/compiler/lib/global_deadcode.ml
@@ -220,19 +220,18 @@ let liveness nv prog pure_funs (global_info : Global_flow.info) =
   in
   let live_instruction i =
     match i with
-    | Let (_x, e) ->
+    | Let (_x, e) -> (
         if not (pure_expr pure_funs e)
-        then (
-          let vars = expr_vars e in
-          Var.Set.iter add_top vars;
+        then
           match e with
           | Apply { f; args; _ } ->
               add_top f;
               List.iter
                 ~f:(fun x -> if variable_may_escape x global_info then add_top x)
                 args
-          | _ -> ())
-        else ()
+          | _ ->
+              let vars = expr_vars e in
+              Var.Set.iter add_top vars)
     | Assign (_, _) -> ()
     | Set_field (x, i, y) ->
         add_live x i;

From 09d353ed0db28f5d8ff099eb9253920fb2ec5daa Mon Sep 17 00:00:00 2001
From: Micah Cantor <micahcantor01@gmail.com>
Date: Mon, 2 Oct 2023 15:44:41 -0500
Subject: [PATCH 083/112] fix live_instruction

---
 compiler/lib/global_deadcode.ml   |    11 +-
 compiler/tests-full/stdlib.cma.js | 34020 ----------------------------
 testing/dead_field.js             |    29 -
 3 files changed, 5 insertions(+), 34055 deletions(-)
 delete mode 100644 compiler/tests-full/stdlib.cma.js
 delete mode 100644 testing/dead_field.js

diff --git a/compiler/lib/global_deadcode.ml b/compiler/lib/global_deadcode.ml
index f40a3981c5..2022864a8d 100644
--- a/compiler/lib/global_deadcode.ml
+++ b/compiler/lib/global_deadcode.ml
@@ -220,19 +220,18 @@ let liveness nv prog pure_funs (global_info : Global_flow.info) =
   in
   let live_instruction i =
     match i with
-    | Let (_x, e) ->
+    | Let (_x, e) -> (
         if not (pure_expr pure_funs e)
-        then (
-          let vars = expr_vars e in
-          Var.Set.iter add_top vars;
+        then
           match e with
           | Apply { f; args; _ } ->
               add_top f;
               List.iter
                 ~f:(fun x -> if variable_may_escape x global_info then add_top x)
                 args
-          | _ -> ())
-        else ()
+          | _ ->
+              let vars = expr_vars e in
+              Var.Set.iter add_top vars)
     | Assign (_, _) -> ()
     | Set_field (x, i, y) ->
         add_live x i;
diff --git a/compiler/tests-full/stdlib.cma.js b/compiler/tests-full/stdlib.cma.js
deleted file mode 100644
index e3d09981e8..0000000000
--- a/compiler/tests-full/stdlib.cma.js
+++ /dev/null
@@ -1,34020 +0,0 @@
-// Generated by js_of_ocaml
-//# buildInfo:effects=false, kind=cma, use-js-string=true, version=5.4.0+git-5.3.0-128-g266221e88f-dirty
-
-//# unitInfo: Provides: CamlinternalFormatBasics
-(function
-  (globalThis){
-   "use strict";
-   var runtime = globalThis.jsoo_runtime;
-   function erase_rel(param){
-     /*<<camlinternalFormatBasics.ml:528:8>>*/ if(typeof param === "number")
-      /*<<camlinternalFormatBasics.ml:562:20>>*/ return 0;
-    switch(param[0]){
-      case 0:
-       var rest = param[1];
-        /*<<camlinternalFormatBasics.ml:533:4>>*/ return [0, erase_rel(rest)];
-      case 1:
-       var rest$0 = param[1];
-        /*<<camlinternalFormatBasics.ml:535:4>>*/ return [1,
-               erase_rel(rest$0)];
-      case 2:
-       var rest$1 = param[1];
-        /*<<camlinternalFormatBasics.ml:537:4>>*/ return [2,
-               erase_rel(rest$1)];
-      case 3:
-       var rest$2 = param[1];
-        /*<<camlinternalFormatBasics.ml:539:4>>*/ return [3,
-               erase_rel(rest$2)];
-      case 4:
-       var rest$3 = param[1];
-        /*<<camlinternalFormatBasics.ml:543:4>>*/ return [4,
-               erase_rel(rest$3)];
-      case 5:
-       var rest$4 = param[1];
-        /*<<camlinternalFormatBasics.ml:541:4>>*/ return [5,
-               erase_rel(rest$4)];
-      case 6:
-       var rest$5 = param[1];
-        /*<<camlinternalFormatBasics.ml:545:4>>*/ return [6,
-               erase_rel(rest$5)];
-      case 7:
-       var rest$6 = param[1];
-        /*<<camlinternalFormatBasics.ml:547:4>>*/ return [7,
-               erase_rel(rest$6)];
-      case 8:
-       var rest$7 = param[2], ty = param[1];
-        /*<<camlinternalFormatBasics.ml:549:4>>*/ return [8,
-               ty,
-               erase_rel(rest$7)];
-      case 9:
-       var rest$8 = param[3], ty1 = param[1];
-        /*<<camlinternalFormatBasics.ml:551:4>>*/ return [9,
-               ty1,
-               ty1,
-               erase_rel(rest$8)];
-      case 10:
-       var rest$9 = param[1];
-        /*<<camlinternalFormatBasics.ml:553:4>>*/ return [10,
-               erase_rel(rest$9)];
-      case 11:
-       var rest$10 = param[1];
-        /*<<camlinternalFormatBasics.ml:555:4>>*/ return [11,
-               erase_rel(rest$10)];
-      case 12:
-       var rest$11 = param[1];
-        /*<<camlinternalFormatBasics.ml:557:4>>*/ return [12,
-               erase_rel(rest$11)];
-      case 13:
-       var rest$12 = param[1];
-        /*<<camlinternalFormatBasics.ml:559:4>>*/ return [13,
-               erase_rel(rest$12)];
-      default:
-       var rest$13 = param[1];
-        /*<<camlinternalFormatBasics.ml:561:4>>*/ return [14,
-               erase_rel(rest$13)];
-    }
-    /*<<camlinternalFormatBasics.ml:562:32>>*/ }
-   function concat_fmtty(fmtty1, fmtty2){
-     /*<<camlinternalFormatBasics.ml:590:21>>*/ if(typeof fmtty1 === "number")
-      /*<<camlinternalFormatBasics.ml:621:20>>*/ return fmtty2;
-    switch(fmtty1[0]){
-      case 0:
-       var rest = fmtty1[1];
-        /*<<camlinternalFormatBasics.ml:592:4>>*/ return [0,
-               concat_fmtty(rest, fmtty2)];
-      case 1:
-       var rest$0 = fmtty1[1];
-        /*<<camlinternalFormatBasics.ml:594:4>>*/ return [1,
-               concat_fmtty(rest$0, fmtty2)];
-      case 2:
-       var rest$1 = fmtty1[1];
-        /*<<camlinternalFormatBasics.ml:596:4>>*/ return [2,
-               concat_fmtty(rest$1, fmtty2)];
-      case 3:
-       var rest$2 = fmtty1[1];
-        /*<<camlinternalFormatBasics.ml:598:4>>*/ return [3,
-               concat_fmtty(rest$2, fmtty2)];
-      case 4:
-       var rest$3 = fmtty1[1];
-        /*<<camlinternalFormatBasics.ml:600:4>>*/ return [4,
-               concat_fmtty(rest$3, fmtty2)];
-      case 5:
-       var rest$4 = fmtty1[1];
-        /*<<camlinternalFormatBasics.ml:602:4>>*/ return [5,
-               concat_fmtty(rest$4, fmtty2)];
-      case 6:
-       var rest$5 = fmtty1[1];
-        /*<<camlinternalFormatBasics.ml:604:4>>*/ return [6,
-               concat_fmtty(rest$5, fmtty2)];
-      case 7:
-       var rest$6 = fmtty1[1];
-        /*<<camlinternalFormatBasics.ml:606:4>>*/ return [7,
-               concat_fmtty(rest$6, fmtty2)];
-      case 8:
-       var rest$7 = fmtty1[2], ty = fmtty1[1];
-        /*<<camlinternalFormatBasics.ml:618:4>>*/ return [8,
-               ty,
-               concat_fmtty(rest$7, fmtty2)];
-      case 9:
-       var rest$8 = fmtty1[3], ty2 = fmtty1[2], ty1 = fmtty1[1];
-        /*<<camlinternalFormatBasics.ml:620:4>>*/ return [9,
-               ty1,
-               ty2,
-               concat_fmtty(rest$8, fmtty2)];
-      case 10:
-       var rest$9 = fmtty1[1];
-        /*<<camlinternalFormatBasics.ml:608:4>>*/ return [10,
-               concat_fmtty(rest$9, fmtty2)];
-      case 11:
-       var rest$10 = fmtty1[1];
-        /*<<camlinternalFormatBasics.ml:610:4>>*/ return [11,
-               concat_fmtty(rest$10, fmtty2)];
-      case 12:
-       var rest$11 = fmtty1[1];
-        /*<<camlinternalFormatBasics.ml:612:4>>*/ return [12,
-               concat_fmtty(rest$11, fmtty2)];
-      case 13:
-       var rest$12 = fmtty1[1];
-        /*<<camlinternalFormatBasics.ml:614:4>>*/ return [13,
-               concat_fmtty(rest$12, fmtty2)];
-      default:
-       var rest$13 = fmtty1[1];
-        /*<<camlinternalFormatBasics.ml:616:4>>*/ return [14,
-               concat_fmtty(rest$13, fmtty2)];
-    }
-    /*<<camlinternalFormatBasics.ml:621:26>>*/ }
-   function concat_fmt(fmt1, fmt2){
-     /*<<camlinternalFormatBasics.ml:631:17>>*/ if(typeof fmt1 === "number")
-      /*<<camlinternalFormatBasics.ml:690:4>>*/ return fmt2;
-    switch(fmt1[0]){
-      case 0:
-       var rest = fmt1[1];
-        /*<<camlinternalFormatBasics.ml:649:4>>*/ return [0,
-               concat_fmt(rest, fmt2)];
-      case 1:
-       var rest$0 = fmt1[1];
-        /*<<camlinternalFormatBasics.ml:651:4>>*/ return [1,
-               concat_fmt(rest$0, fmt2)];
-      case 2:
-       var rest$1 = fmt1[2], pad = fmt1[1];
-        /*<<camlinternalFormatBasics.ml:633:4>>*/ return [2,
-               pad,
-               concat_fmt(rest$1, fmt2)];
-      case 3:
-       var rest$2 = fmt1[2], pad$0 = fmt1[1];
-        /*<<camlinternalFormatBasics.ml:635:4>>*/ return [3,
-               pad$0,
-               concat_fmt(rest$2, fmt2)];
-      case 4:
-       var rest$3 = fmt1[4], prec = fmt1[3], pad$1 = fmt1[2], iconv = fmt1[1];
-        /*<<camlinternalFormatBasics.ml:638:4>>*/ return [4,
-               iconv,
-               pad$1,
-               prec,
-               concat_fmt(rest$3, fmt2)];
-      case 5:
-       var
-        rest$4 = fmt1[4],
-        prec$0 = fmt1[3],
-        pad$2 = fmt1[2],
-        iconv$0 = fmt1[1];
-        /*<<camlinternalFormatBasics.ml:640:4>>*/ return [5,
-               iconv$0,
-               pad$2,
-               prec$0,
-               concat_fmt(rest$4, fmt2)];
-      case 6:
-       var
-        rest$5 = fmt1[4],
-        prec$1 = fmt1[3],
-        pad$3 = fmt1[2],
-        iconv$1 = fmt1[1];
-        /*<<camlinternalFormatBasics.ml:642:4>>*/ return [6,
-               iconv$1,
-               pad$3,
-               prec$1,
-               concat_fmt(rest$5, fmt2)];
-      case 7:
-       var
-        rest$6 = fmt1[4],
-        prec$2 = fmt1[3],
-        pad$4 = fmt1[2],
-        iconv$2 = fmt1[1];
-        /*<<camlinternalFormatBasics.ml:644:4>>*/ return [7,
-               iconv$2,
-               pad$4,
-               prec$2,
-               concat_fmt(rest$6, fmt2)];
-      case 8:
-       var
-        rest$7 = fmt1[4],
-        prec$3 = fmt1[3],
-        pad$5 = fmt1[2],
-        fconv = fmt1[1];
-        /*<<camlinternalFormatBasics.ml:646:4>>*/ return [8,
-               fconv,
-               pad$5,
-               prec$3,
-               concat_fmt(rest$7, fmt2)];
-      case 9:
-       var rest$8 = fmt1[2], pad$6 = fmt1[1];
-        /*<<camlinternalFormatBasics.ml:653:4>>*/ return [9,
-               pad$6,
-               concat_fmt(rest$8, fmt2)];
-      case 10:
-       var rest$9 = fmt1[1];
-        /*<<camlinternalFormatBasics.ml:663:4>>*/ return [10,
-               concat_fmt(rest$9, fmt2)];
-      case 11:
-       var rest$10 = fmt1[2], str = fmt1[1];
-        /*<<camlinternalFormatBasics.ml:666:4>>*/ return [11,
-               str,
-               concat_fmt(rest$10, fmt2)];
-      case 12:
-       var rest$11 = fmt1[2], chr = fmt1[1];
-        /*<<camlinternalFormatBasics.ml:668:4>>*/ return [12,
-               chr,
-               concat_fmt(rest$11, fmt2)];
-      case 13:
-       var rest$12 = fmt1[3], fmtty = fmt1[2], pad$7 = fmt1[1];
-        /*<<camlinternalFormatBasics.ml:671:4>>*/ return [13,
-               pad$7,
-               fmtty,
-               concat_fmt(rest$12, fmt2)];
-      case 14:
-       var rest$13 = fmt1[3], fmtty$0 = fmt1[2], pad$8 = fmt1[1];
-        /*<<camlinternalFormatBasics.ml:673:4>>*/ return [14,
-               pad$8,
-               fmtty$0,
-               concat_fmt(rest$13, fmt2)];
-      case 15:
-       var rest$14 = fmt1[1];
-        /*<<camlinternalFormatBasics.ml:655:4>>*/ return [15,
-               concat_fmt(rest$14, fmt2)];
-      case 16:
-       var rest$15 = fmt1[1];
-        /*<<camlinternalFormatBasics.ml:657:4>>*/ return [16,
-               concat_fmt(rest$15, fmt2)];
-      case 17:
-       var rest$16 = fmt1[2], fmting_lit = fmt1[1];
-        /*<<camlinternalFormatBasics.ml:685:4>>*/ return [17,
-               fmting_lit,
-               concat_fmt(rest$16, fmt2)];
-      case 18:
-       var rest$17 = fmt1[2], fmting_gen = fmt1[1];
-        /*<<camlinternalFormatBasics.ml:687:4>>*/ return [18,
-               fmting_gen,
-               concat_fmt(rest$17, fmt2)];
-      case 19:
-       var rest$18 = fmt1[1];
-        /*<<camlinternalFormatBasics.ml:661:4>>*/ return [19,
-               concat_fmt(rest$18, fmt2)];
-      case 20:
-       var rest$19 = fmt1[3], char_set = fmt1[2], width_opt = fmt1[1];
-        /*<<camlinternalFormatBasics.ml:676:4>>*/ return [20,
-               width_opt,
-               char_set,
-               concat_fmt(rest$19, fmt2)];
-      case 21:
-       var rest$20 = fmt1[2], counter = fmt1[1];
-        /*<<camlinternalFormatBasics.ml:678:4>>*/ return [21,
-               counter,
-               concat_fmt(rest$20, fmt2)];
-      case 22:
-       var rest$21 = fmt1[1];
-        /*<<camlinternalFormatBasics.ml:680:4>>*/ return [22,
-               concat_fmt(rest$21, fmt2)];
-      case 23:
-       var rest$22 = fmt1[2], ign = fmt1[1];
-        /*<<camlinternalFormatBasics.ml:682:4>>*/ return [23,
-               ign,
-               concat_fmt(rest$22, fmt2)];
-      default:
-       var rest$23 = fmt1[3], f = fmt1[2], arity = fmt1[1];
-        /*<<camlinternalFormatBasics.ml:659:4>>*/ return [24,
-               arity,
-               f,
-               concat_fmt(rest$23, fmt2)];
-    }
-    /*<<camlinternalFormatBasics.ml:690:8>>*/ }
-   var CamlinternalFormatBasics = [0, concat_fmtty, erase_rel, concat_fmt];
-   runtime.caml_register_global
-    (0, CamlinternalFormatBasics, "CamlinternalFormatBasics");
-   return;
-   /*<<?>>*/ }
-  (globalThis));
-
-//# unitInfo: Provides: Stdlib
-//# unitInfo: Requires: Assert_failure, CamlinternalFormatBasics, Division_by_zero, End_of_file, Failure, Invalid_argument, Match_failure, Not_found, Out_of_memory, Stack_overflow, Sys_blocked_io, Sys_error, Undefined_recursive_module
-(function
-  (globalThis){
-   "use strict";
-   var
-    runtime = globalThis.jsoo_runtime,
-    cst_false$0 = "false",
-    cst_true$0 = "true",
-    caml_atomic_cas = runtime.caml_atomic_cas,
-    caml_atomic_load = runtime.caml_atomic_load,
-    caml_blit_string = runtime.caml_blit_string,
-    caml_create_bytes = runtime.caml_create_bytes,
-    caml_float_of_string = runtime.caml_float_of_string,
-    caml_int64_float_of_bits = runtime.caml_int64_float_of_bits,
-    caml_int_of_string = runtime.caml_int_of_string,
-    caml_maybe_attach_backtrace = runtime.caml_maybe_attach_backtrace,
-    caml_ml_bytes_length = runtime.caml_ml_bytes_length,
-    caml_ml_channel_size = runtime.caml_ml_channel_size,
-    caml_ml_channel_size_64 = runtime.caml_ml_channel_size_64,
-    caml_ml_close_channel = runtime.caml_ml_close_channel,
-    caml_ml_flush = runtime.caml_ml_flush,
-    caml_ml_input = runtime.caml_ml_input,
-    caml_ml_input_char = runtime.caml_ml_input_char,
-    caml_ml_open_descriptor_in = runtime.caml_ml_open_descriptor_in,
-    caml_ml_open_descriptor_out = runtime.caml_ml_open_descriptor_out,
-    caml_ml_output = runtime.caml_ml_output,
-    caml_ml_output_bytes = runtime.caml_ml_output_bytes,
-    caml_ml_output_char = runtime.caml_ml_output_char,
-    caml_ml_set_binary_mode = runtime.caml_ml_set_binary_mode,
-    caml_ml_set_channel_name = runtime.caml_ml_set_channel_name,
-    caml_ml_string_length = runtime.caml_ml_string_length,
-    caml_string_notequal = runtime.caml_string_notequal,
-    caml_string_of_bytes = runtime.caml_string_of_bytes,
-    caml_sys_open = runtime.caml_sys_open,
-    caml_wrap_exception = runtime.caml_wrap_exception;
-    /*<<?>>*/ function caml_call1(f, a0){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 1
-            ? f(a0)
-            : runtime.caml_call_gen(f, [a0]);
-   }
-    /*<<?>>*/ function caml_call2(f, a0, a1){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 2
-            ? f(a0, a1)
-            : runtime.caml_call_gen(f, [a0, a1]);
-   }
-   var
-    global_data = runtime.caml_get_global_data(),
-    cst$0 = "%,",
-    cst = ".",
-    CamlinternalFormatBasics = global_data.CamlinternalFormatBasics,
-    Invalid_argument = global_data.Invalid_argument,
-    Failure = global_data.Failure,
-    Match_failure = global_data.Match_failure,
-    Assert_failure = global_data.Assert_failure,
-    Not_found = global_data.Not_found,
-    Out_of_memory = global_data.Out_of_memory,
-    Stack_overflow = global_data.Stack_overflow,
-    Sys_error = global_data.Sys_error,
-    End_of_file = global_data.End_of_file,
-    Division_by_zero = global_data.Division_by_zero,
-    Sys_blocked_io = global_data.Sys_blocked_io,
-    Undefined_recursive_module = global_data.Undefined_recursive_module,
-    cst_really_input = "really_input",
-    cst_input = "input",
-    _l_ = [0, 0, [0, 6, 0]],
-    _k_ = [0, 0, [0, 7, 0]],
-    cst_output_substring = "output_substring",
-    cst_output = "output",
-    _j_ = [0, 1, [0, 3, [0, 4, [0, 6, 0]]]],
-    _i_ = [0, 1, [0, 3, [0, 4, [0, 7, 0]]]],
-    _g_ = [0, 1],
-    _h_ = [0, 0],
-    cst_bool_of_string = "bool_of_string",
-    cst_true = cst_true$0,
-    cst_false = cst_false$0,
-    cst_char_of_int = "char_of_int",
-    cst_Stdlib_Exit = "Stdlib.Exit",
-    _a_ = runtime.caml_int64_create_lo_mi_hi(0, 0, 32752),
-    _b_ = runtime.caml_int64_create_lo_mi_hi(0, 0, 65520),
-    _c_ = runtime.caml_int64_create_lo_mi_hi(1, 0, 32752),
-    _d_ = runtime.caml_int64_create_lo_mi_hi(16777215, 16777215, 32751),
-    _e_ = runtime.caml_int64_create_lo_mi_hi(0, 0, 16),
-    _f_ = runtime.caml_int64_create_lo_mi_hi(0, 0, 15536);
-   function failwith(s){
-     /*<<stdlib.ml:29:17>>*/ throw  /*<<stdlib.ml:29:17>>*/ caml_maybe_attach_backtrace
-           ([0, Failure, s], 1);
-    /*<<stdlib.ml:29:33>>*/ }
-   function invalid_arg(s){
-     /*<<stdlib.ml:30:20>>*/ throw  /*<<stdlib.ml:30:20>>*/ caml_maybe_attach_backtrace
-           ([0, Invalid_argument, s], 1);
-    /*<<stdlib.ml:30:45>>*/ }
-    /*<<stdlib.ml:32:0>>*/  /*<<stdlib.ml:32:0>>*/ var
-    Exit = [248, cst_Stdlib_Exit, runtime.caml_fresh_oo_id(0)];
-   function min(x, y){
-     /*<<stdlib.ml:74:14>>*/ return  /*<<stdlib.ml:74:17>>*/ runtime.caml_lessequal
-             (x, y)
-            ? x
-            : y;
-    /*<<stdlib.ml:74:37>>*/ }
-   function max(x, y){
-     /*<<stdlib.ml:75:14>>*/ return  /*<<stdlib.ml:75:17>>*/ runtime.caml_greaterequal
-             (x, y)
-            ? x
-            : y;
-    /*<<stdlib.ml:75:37>>*/ }
-   function abs(x){
-     /*<<stdlib.ml:98:12>>*/ return 0 <= x ? x : - x | 0;
-    /*<<stdlib.ml:98:36>>*/ }
-   function lnot(x){
-     /*<<stdlib.ml:104:13>>*/ return x ^ -1;
-    /*<<stdlib.ml:104:24>>*/ }
-    /*<<stdlib.ml:180:2>>*/ var
-     /*<<stdlib.ml:180:2>>*/ infinity =
-       /*<<stdlib.ml:180:2>>*/ caml_int64_float_of_bits(_a_),
-     /*<<stdlib.ml:182:2>>*/ neg_infinity =
-       /*<<stdlib.ml:182:2>>*/ caml_int64_float_of_bits(_b_),
-     /*<<stdlib.ml:184:2>>*/ nan =
-       /*<<stdlib.ml:184:2>>*/ caml_int64_float_of_bits(_c_),
-     /*<<stdlib.ml:186:2>>*/ max_float =
-       /*<<stdlib.ml:186:2>>*/ caml_int64_float_of_bits(_d_),
-     /*<<stdlib.ml:188:2>>*/ min_float =
-       /*<<stdlib.ml:188:2>>*/ caml_int64_float_of_bits(_e_),
-     /*<<stdlib.ml:190:2>>*/ epsilon_float =
-       /*<<stdlib.ml:190:2>>*/ caml_int64_float_of_bits(_f_),
-    max_int = 2147483647,
-    min_int = -2147483648;
-   function symbol(s1, s2){
-     /*<<stdlib.ml:213:2>>*/ var
-     l1 = caml_ml_string_length(s1),
-     l2 = caml_ml_string_length(s2),
-      /*<<stdlib.ml:214:10>>*/ s =
-        /*<<stdlib.ml:214:10>>*/ caml_create_bytes(l1 + l2 | 0);
-     /*<<stdlib.ml:215:2>>*/  /*<<stdlib.ml:215:2>>*/ caml_blit_string
-     (s1, 0, s, 0, l1);
-     /*<<stdlib.ml:216:2>>*/  /*<<stdlib.ml:216:2>>*/ caml_blit_string
-     (s2, 0, s, l1, l2);
-    return caml_string_of_bytes(s);
-    /*<<stdlib.ml:217:26>>*/ }
-   function char_of_int(n){
-     /*<<stdlib.ml:224:2>>*/ if(0 <= n && 255 >= n)
-      /*<<stdlib.ml:224:58>>*/ return n;
-     /*<<stdlib.ml:224:27>>*/ return invalid_arg(cst_char_of_int);
-    /*<<stdlib.ml:224:78>>*/ }
-   function string_of_bool(b){
-     /*<<stdlib.ml:254:2>>*/ return b ? cst_true : cst_false;
-    /*<<stdlib.ml:254:31>>*/ }
-   function bool_of_string(param){
-     /*<<stdlib.ml:255:21>>*/ return caml_string_notequal(param, cst_false$0)
-            ? caml_string_notequal
-               (param, cst_true$0)
-              ? invalid_arg(cst_bool_of_string)
-              : 1
-            : 0;
-    /*<<stdlib.ml:258:37>>*/ }
-   function bool_of_string_opt(param){
-     /*<<stdlib.ml:260:25>>*/ return caml_string_notequal(param, cst_false$0)
-            ? caml_string_notequal(param, cst_true$0) ? 0 : _g_
-            : _h_;
-    /*<<stdlib.ml:263:13>>*/ }
-   function string_of_int(n){
-     /*<<stdlib.ml:266:2>>*/ return "" + n;
-    /*<<stdlib.ml:266:19>>*/ }
-   function int_of_string_opt(s){
-     /*<<stdlib.ml:272:2>>*/ try{
-      /*<<stdlib.ml:272:6>>*/  /*<<stdlib.ml:272:6>>*/ var
-      _B_ = [0,  /*<<stdlib.ml:272:11>>*/ caml_int_of_string(s)];
-      /*<<stdlib.ml:272:6>>*/ return _B_;
-    }
-    catch(_C_){
-     var _A_ = caml_wrap_exception(_C_);
-     if(_A_[1] === Failure)  /*<<stdlib.ml:273:20>>*/ return 0;
-     throw caml_maybe_attach_backtrace(_A_, 0);
-    }
-    /*<<stdlib.ml:273:24>>*/ }
-   function valid_float_lexem(s){
-     /*<<stdlib.ml:278:2>>*/ var l = caml_ml_string_length(s), i = 0;
-     /*<<stdlib.ml:280:4>>*/ for(;;){
-     if(l <= i)  /*<<stdlib.ml:280:19>>*/ return symbol(s, cst);
-      /*<<stdlib.ml:281:10>>*/  /*<<stdlib.ml:281:10>>*/ var
-      match =  /*<<stdlib.ml:281:10>>*/ runtime.caml_string_get(s, i);
-     a:
-     {
-      if(48 <= match){if(58 > match) break a;} else if(45 === match) break a;
-       /*<<stdlib.ml:279:2>>*/ return s;
-     }
-      /*<<stdlib.ml:282:26>>*/ var
-       /*<<stdlib.ml:282:26>>*/ i$0 = i + 1 | 0,
-      i = i$0;
-    }
-    /*<<stdlib.ml:285:8>>*/ }
-   function string_of_float(f){
-     /*<<stdlib.ml:287:24>>*/ return valid_float_lexem
-            ( /*<<stdlib.ml:287:42>>*/ runtime.caml_format_float("%.12g", f));
-    /*<<stdlib.ml:287:66>>*/ }
-   function float_of_string_opt(s){
-     /*<<stdlib.ml:293:2>>*/ try{
-      /*<<stdlib.ml:293:6>>*/  /*<<stdlib.ml:293:6>>*/ var
-      _y_ = [0,  /*<<stdlib.ml:293:11>>*/ caml_float_of_string(s)];
-      /*<<stdlib.ml:293:6>>*/ return _y_;
-    }
-    catch(_z_){
-     var _x_ = caml_wrap_exception(_z_);
-     if(_x_[1] === Failure)  /*<<stdlib.ml:294:20>>*/ return 0;
-     throw caml_maybe_attach_backtrace(_x_, 0);
-    }
-    /*<<stdlib.ml:294:24>>*/ }
-   function symbol$0(l1, l2){
-     /*<<stdlib.ml:299:2>>*/ if(! l1)  /*<<stdlib.ml:300:10>>*/ return l2;
-    var tl = l1[2], hd = l1[1];
-     /*<<stdlib.ml:301:16>>*/ return [0, hd, symbol$0(tl, l2)];
-    /*<<stdlib.ml:301:31>>*/ }
-    /*<<stdlib.ml:312:12>>*/ var
-     /*<<stdlib.ml:312:12>>*/ stdin =
-       /*<<stdlib.ml:312:12>>*/ caml_ml_open_descriptor_in(0),
-     /*<<stdlib.ml:313:13>>*/ stdout =
-       /*<<stdlib.ml:313:13>>*/ caml_ml_open_descriptor_out(1),
-     /*<<stdlib.ml:314:13>>*/ stderr =
-       /*<<stdlib.ml:314:13>>*/ caml_ml_open_descriptor_out(2);
-   function open_out_gen(mode, perm, name){
-     /*<<stdlib.ml:329:2>>*/  /*<<stdlib.ml:329:10>>*/ var
-     c =
-        /*<<stdlib.ml:329:10>>*/ caml_ml_open_descriptor_out
-        ( /*<<stdlib.ml:329:29>>*/ caml_sys_open(name, mode, perm));
-     /*<<stdlib.ml:330:2>>*/  /*<<stdlib.ml:330:2>>*/ caml_ml_set_channel_name
-     (c, name);
-     /*<<stdlib.ml:330:2>>*/ return c;
-    /*<<stdlib.ml:331:3>>*/ }
-   function open_out(name){
-     /*<<stdlib.ml:334:2>>*/ return open_out_gen(_i_, 438, name);
-    /*<<stdlib.ml:334:74>>*/ }
-   function open_out_bin(name){
-     /*<<stdlib.ml:337:2>>*/ return open_out_gen(_j_, 438, name);
-    /*<<stdlib.ml:337:76>>*/ }
-   function flush_all(param){
-     /*<<stdlib.ml:345:2>>*/ var
-     param$0 =  /*<<stdlib.ml:354:10>>*/ runtime.caml_ml_out_channels_list(0);
-     /*<<stdlib.ml:345:17>>*/ for(;;){
-     if(! param$0)  /*<<stdlib.ml:346:12>>*/ return 0;
-     var l = param$0[2], a = param$0[1];
-      /*<<stdlib.ml:348:8>>*/ try{
-       /*<<stdlib.ml:349:12>>*/  /*<<stdlib.ml:349:12>>*/ caml_ml_flush(a);
-     }
-     catch(_w_){
-      var _v_ = caml_wrap_exception(_w_);
-      if(_v_[1] !== Sys_error) throw caml_maybe_attach_backtrace(_v_, 0);
-     }
-     var param$0 = l;
-    }
-    /*<<stdlib.ml:354:32>>*/ }
-   function output_bytes(oc, s){
-     /*<<stdlib.ml:364:2>>*/ return  /*<<stdlib.ml:364:2>>*/ caml_ml_output_bytes
-            (oc, s, 0, caml_ml_bytes_length(s));
-    /*<<stdlib.ml:364:39>>*/ }
-   function output_string(oc, s){
-     /*<<stdlib.ml:367:2>>*/ return  /*<<stdlib.ml:367:2>>*/ caml_ml_output
-            (oc, s, 0, caml_ml_string_length(s));
-    /*<<stdlib.ml:367:47>>*/ }
-   function output(oc, s, ofs, len){
-     /*<<stdlib.ml:370:2>>*/ if
-     (0 <= ofs && 0 <= len && (caml_ml_bytes_length(s) - len | 0) >= ofs)
-      /*<<stdlib.ml:372:7>>*/ return  /*<<stdlib.ml:372:7>>*/ caml_ml_output_bytes
-             (oc, s, ofs, len);
-     /*<<stdlib.ml:371:7>>*/ return invalid_arg(cst_output);
-    /*<<stdlib.ml:372:33>>*/ }
-   function output_substring(oc, s, ofs, len){
-     /*<<stdlib.ml:375:2>>*/ if
-     (0 <= ofs && 0 <= len && (caml_ml_string_length(s) - len | 0) >= ofs)
-      /*<<stdlib.ml:377:7>>*/ return  /*<<stdlib.ml:377:7>>*/ caml_ml_output
-             (oc, s, ofs, len);
-     /*<<stdlib.ml:376:7>>*/ return invalid_arg(cst_output_substring);
-    /*<<stdlib.ml:377:40>>*/ }
-   function output_value(chan, v){
-     /*<<stdlib.ml:384:26>>*/ return  /*<<stdlib.ml:384:26>>*/ runtime.caml_output_value
-            (chan, v, 0);
-    /*<<stdlib.ml:384:54>>*/ }
-   function close_out(oc){
-     /*<<stdlib.ml:390:19>>*/  /*<<stdlib.ml:390:19>>*/ caml_ml_flush(oc);
-     /*<<stdlib.ml:390:29>>*/ return  /*<<stdlib.ml:390:29>>*/ caml_ml_close_channel
-            (oc);
-    /*<<stdlib.ml:390:49>>*/ }
-   function close_out_noerr(oc){
-     /*<<stdlib.ml:392:2>>*/ try{
-      /*<<stdlib.ml:392:7>>*/  /*<<stdlib.ml:392:7>>*/ caml_ml_flush(oc);
-    }
-    catch(_u_){}
-     /*<<stdlib.ml:393:2>>*/ try{
-      /*<<stdlib.ml:393:7>>*/  /*<<stdlib.ml:393:7>>*/ var
-      _s_ =  /*<<stdlib.ml:393:7>>*/ caml_ml_close_channel(oc);
-      /*<<stdlib.ml:393:7>>*/ return _s_;
-    }
-    catch(_t_){ /*<<stdlib.ml:393:38>>*/ return 0;}
-    /*<<stdlib.ml:393:41>>*/ }
-   function open_in_gen(mode, perm, name){
-     /*<<stdlib.ml:403:2>>*/  /*<<stdlib.ml:403:10>>*/ var
-     c =
-        /*<<stdlib.ml:403:10>>*/ caml_ml_open_descriptor_in
-        ( /*<<stdlib.ml:403:28>>*/ caml_sys_open(name, mode, perm));
-     /*<<stdlib.ml:404:2>>*/  /*<<stdlib.ml:404:2>>*/ caml_ml_set_channel_name
-     (c, name);
-     /*<<stdlib.ml:404:2>>*/ return c;
-    /*<<stdlib.ml:405:3>>*/ }
-   function open_in(name){
-     /*<<stdlib.ml:408:2>>*/ return open_in_gen(_k_, 0, name);
-    /*<<stdlib.ml:408:45>>*/ }
-   function open_in_bin(name){
-     /*<<stdlib.ml:411:2>>*/ return open_in_gen(_l_, 0, name);
-    /*<<stdlib.ml:411:47>>*/ }
-   function input(ic, s, ofs, len){
-     /*<<stdlib.ml:419:2>>*/ if
-     (0 <= ofs && 0 <= len && (caml_ml_bytes_length(s) - len | 0) >= ofs)
-      /*<<stdlib.ml:421:7>>*/ return  /*<<stdlib.ml:421:7>>*/ caml_ml_input
-             (ic, s, ofs, len);
-     /*<<stdlib.ml:420:7>>*/ return invalid_arg(cst_input);
-    /*<<stdlib.ml:421:32>>*/ }
-   function unsafe_really_input(ic, s, ofs, len){
-     /*<<stdlib.ml:424:2>>*/ var ofs$0 = ofs, len$0 = len;
-     /*<<stdlib.ml:424:2>>*/ for(;;){
-     if(0 >= len$0)  /*<<stdlib.ml:424:19>>*/ return 0;
-      /*<<stdlib.ml:425:12>>*/  /*<<stdlib.ml:425:12>>*/ var
-      r =  /*<<stdlib.ml:425:12>>*/ caml_ml_input(ic, s, ofs$0, len$0);
-      /*<<stdlib.ml:426:4>>*/ if(0 === r)
-       /*<<stdlib.ml:427:9>>*/ throw  /*<<stdlib.ml:427:9>>*/ caml_maybe_attach_backtrace
-             (End_of_file, 1);
-     var
-      len$1 = len$0 - r | 0,
-      ofs$1 = ofs$0 + r | 0,
-      ofs$0 = ofs$1,
-      len$0 = len$1;
-    }
-    /*<<stdlib.ml:429:5>>*/ }
-   function really_input(ic, s, ofs, len){
-     /*<<stdlib.ml:432:2>>*/ if
-     (0 <= ofs && 0 <= len && (caml_ml_bytes_length(s) - len | 0) >= ofs)
-      /*<<stdlib.ml:434:7>>*/ return unsafe_really_input(ic, s, ofs, len);
-     /*<<stdlib.ml:433:7>>*/ return invalid_arg(cst_really_input);
-    /*<<stdlib.ml:434:39>>*/ }
-   function really_input_string(ic, len){
-     /*<<stdlib.ml:437:2>>*/  /*<<stdlib.ml:437:10>>*/ var
-     s =  /*<<stdlib.ml:437:10>>*/ caml_create_bytes(len);
-     /*<<stdlib.ml:438:2>>*/ really_input(ic, s, 0, len);
-    return caml_string_of_bytes(s);
-    /*<<stdlib.ml:439:26>>*/ }
-   function input_line(chan){
-     /*<<stdlib.ml:444:2>>*/ function build_result(buf, pos, param){
-     var pos$0 = pos, param$0 = param;
-     for(;;){
-      if(! param$0)  /*<<stdlib.ml:445:10>>*/ return buf;
-       /*<<stdlib.ml:447:6>>*/ var
-       tl = param$0[2],
-       hd = param$0[1],
-        /*<<stdlib.ml:447:6>>*/ len =
-          /*<<stdlib.ml:447:6>>*/ caml_ml_bytes_length(hd);
-       /*<<stdlib.ml:448:6>>*/  /*<<stdlib.ml:448:6>>*/ runtime.caml_blit_bytes
-       (hd, 0, buf, pos$0 - len | 0, len);
-      var pos$1 = pos$0 - len | 0, pos$0 = pos$1, param$0 = tl;
-     }
-    }
-    var accu = 0, len = 0;
-     /*<<stdlib.ml:451:4>>*/ for(;;){
-      /*<<stdlib.ml:451:12>>*/  /*<<stdlib.ml:451:12>>*/ var
-      n =  /*<<stdlib.ml:451:12>>*/ runtime.caml_ml_input_scan_line(chan);
-      /*<<stdlib.ml:452:4>>*/ if(0 === n){
-      if(! accu)
-        /*<<stdlib.ml:454:14>>*/ throw  /*<<stdlib.ml:454:14>>*/ caml_maybe_attach_backtrace
-              (End_of_file, 1);
-      var
-       _r_ =
-         build_result
-          ( /*<<stdlib.ml:455:27>>*/ caml_create_bytes(len), len, accu);
-     }
-     else{
-      if(0 >= n){
-        /*<<stdlib.ml:465:16>>*/  /*<<stdlib.ml:465:16>>*/ var
-        beg =  /*<<stdlib.ml:465:16>>*/ caml_create_bytes(- n | 0);
-        /*<<stdlib.ml:466:12>>*/  /*<<stdlib.ml:466:12>>*/ caml_ml_input
-        (chan, beg, 0, - n | 0);
-        /*<<stdlib.ml:467:11>>*/ var
-        len$1 = len - n | 0,
-         /*<<stdlib.ml:467:11>>*/ accu$0 = [0, beg, accu],
-        accu = accu$0,
-        len = len$1;
-       continue;
-      }
-       /*<<stdlib.ml:457:16>>*/  /*<<stdlib.ml:457:16>>*/ var
-       res =  /*<<stdlib.ml:457:16>>*/ caml_create_bytes(n - 1 | 0);
-       /*<<stdlib.ml:458:13>>*/  /*<<stdlib.ml:458:13>>*/ caml_ml_input
-       (chan, res, 0, n - 1 | 0);
-       /*<<stdlib.ml:459:13>>*/  /*<<stdlib.ml:459:13>>*/ caml_ml_input_char
-       (chan);
-      if(accu)
-       var
-        len$0 = (len + n | 0) - 1 | 0,
-        _r_ =
-          build_result
-           ( /*<<stdlib.ml:463:27>>*/ caml_create_bytes(len$0),
-            len$0,
-            [0, res, accu]);
-      else
-       var _r_ = res;
-     }
-      /*<<stdlib.ml:469:28>>*/ return  /*<<stdlib.ml:469:28>>*/ caml_string_of_bytes
-             (_r_);
-    }
-    /*<<stdlib.ml:469:39>>*/ }
-   function close_in_noerr(ic){
-     /*<<stdlib.ml:478:24>>*/ try{
-      /*<<stdlib.ml:478:29>>*/  /*<<stdlib.ml:478:29>>*/ var
-      _p_ =  /*<<stdlib.ml:478:29>>*/ caml_ml_close_channel(ic);
-      /*<<stdlib.ml:478:29>>*/ return _p_;
-    }
-    catch(_q_){ /*<<stdlib.ml:478:51>>*/ return 0;}
-    /*<<stdlib.ml:478:54>>*/ }
-   function print_char(c){
-     /*<<stdlib.ml:484:19>>*/ return  /*<<stdlib.ml:484:19>>*/ caml_ml_output_char
-            (stdout, c);
-    /*<<stdlib.ml:484:39>>*/ }
-   function print_string(s){
-     /*<<stdlib.ml:485:21>>*/ return output_string(stdout, s);
-    /*<<stdlib.ml:485:43>>*/ }
-   function print_bytes(s){
-     /*<<stdlib.ml:486:20>>*/ return output_bytes(stdout, s);
-    /*<<stdlib.ml:486:41>>*/ }
-   function print_int(i){
-     /*<<stdlib.ml:487:18>>*/ return output_string(stdout, "" + i);
-    /*<<stdlib.ml:487:56>>*/ }
-   function print_float(f){
-     /*<<stdlib.ml:488:20>>*/ return output_string(stdout, string_of_float(f));
-    /*<<stdlib.ml:488:60>>*/ }
-   function print_endline(s){
-     /*<<stdlib.ml:490:2>>*/ output_string(stdout, s);
-     /*<<stdlib.ml:490:26>>*/  /*<<stdlib.ml:490:26>>*/ caml_ml_output_char
-     (stdout, 10);
-     /*<<stdlib.ml:490:51>>*/ return  /*<<stdlib.ml:490:51>>*/ caml_ml_flush
-            (stdout);
-    /*<<stdlib.ml:490:63>>*/ }
-   function print_newline(param){
-     /*<<stdlib.ml:491:23>>*/  /*<<stdlib.ml:491:23>>*/ caml_ml_output_char
-     (stdout, 10);
-     /*<<stdlib.ml:491:48>>*/ return  /*<<stdlib.ml:491:48>>*/ caml_ml_flush
-            (stdout);
-    /*<<stdlib.ml:491:60>>*/ }
-   function prerr_char(c){
-     /*<<stdlib.ml:495:19>>*/ return  /*<<stdlib.ml:495:19>>*/ caml_ml_output_char
-            (stderr, c);
-    /*<<stdlib.ml:495:39>>*/ }
-   function prerr_string(s){
-     /*<<stdlib.ml:496:21>>*/ return output_string(stderr, s);
-    /*<<stdlib.ml:496:43>>*/ }
-   function prerr_bytes(s){
-     /*<<stdlib.ml:497:20>>*/ return output_bytes(stderr, s);
-    /*<<stdlib.ml:497:41>>*/ }
-   function prerr_int(i){
-     /*<<stdlib.ml:498:18>>*/ return output_string(stderr, "" + i);
-    /*<<stdlib.ml:498:56>>*/ }
-   function prerr_float(f){
-     /*<<stdlib.ml:499:20>>*/ return output_string(stderr, string_of_float(f));
-    /*<<stdlib.ml:499:60>>*/ }
-   function prerr_endline(s){
-     /*<<stdlib.ml:501:2>>*/ output_string(stderr, s);
-     /*<<stdlib.ml:501:26>>*/  /*<<stdlib.ml:501:26>>*/ caml_ml_output_char
-     (stderr, 10);
-     /*<<stdlib.ml:501:51>>*/ return  /*<<stdlib.ml:501:51>>*/ caml_ml_flush
-            (stderr);
-    /*<<stdlib.ml:501:63>>*/ }
-   function prerr_newline(param){
-     /*<<stdlib.ml:502:23>>*/  /*<<stdlib.ml:502:23>>*/ caml_ml_output_char
-     (stderr, 10);
-     /*<<stdlib.ml:502:48>>*/ return  /*<<stdlib.ml:502:48>>*/ caml_ml_flush
-            (stderr);
-    /*<<stdlib.ml:502:60>>*/ }
-   function read_line(param){
-     /*<<stdlib.ml:506:19>>*/  /*<<stdlib.ml:506:19>>*/ caml_ml_flush(stdout);
-     /*<<stdlib.ml:312:12>>*/ return input_line(stdin);
-    /*<<stdlib.ml:506:49>>*/ }
-   function read_int(param){
-     /*<<stdlib.ml:507:18>>*/ return  /*<<stdlib.ml:507:18>>*/ caml_int_of_string
-            (read_line(0));
-    /*<<stdlib.ml:507:44>>*/ }
-   function read_int_opt(param){
-     /*<<stdlib.ml:508:22>>*/ return int_of_string_opt(read_line(0));
-    /*<<stdlib.ml:508:52>>*/ }
-   function read_float(param){
-     /*<<stdlib.ml:509:20>>*/ return  /*<<stdlib.ml:509:20>>*/ caml_float_of_string
-            (read_line(0));
-    /*<<stdlib.ml:509:48>>*/ }
-   function read_float_opt(param){
-     /*<<stdlib.ml:510:24>>*/ return float_of_string_opt(read_line(0));
-    /*<<stdlib.ml:510:56>>*/ }
-   function string_of_format(param){
-    var str = param[2];
-     /*<<stdlib.ml:536:44>>*/ return str;
-   }
-   function symbol$1(param, _n_){
-     /*<<stdlib.ml:544:10>>*/ var
-     str2 = _n_[2],
-     fmt2 = _n_[1],
-     str1 = param[2],
-     fmt1 = param[1],
-      /*<<stdlib.ml:544:10>>*/ _o_ = symbol(str1, symbol(cst$0, str2));
-     /*<<stdlib.ml:543:2>>*/ return [0,
-             /*<<stdlib.ml:543:10>>*/ caml_call2
-             (CamlinternalFormatBasics[3], fmt1, fmt2),
-            _o_];
-   }
-    /*<<stdlib.ml:557:20>>*/  /*<<stdlib.ml:557:20>>*/ var
-    exit_function = [0, flush_all];
-   function at_exit(f){
-     /*<<stdlib.ml:561:2>>*/ for(;;){
-      /*<<stdlib.ml:561:21>>*/ var
-       /*<<stdlib.ml:561:21>>*/ f_yet_to_run = [0, 1],
-       /*<<stdlib.ml:562:2>>*/ old_exit =
-         /*<<stdlib.ml:562:2>>*/ caml_atomic_load(exit_function),
-      new_exit$0 =
-        function(f_yet_to_run, old_exit){
-         function new_exit(param){
-           /*<<stdlib.ml:564:4>>*/ if(caml_atomic_cas(f_yet_to_run, 1, 0))
-            /*<<stdlib.ml:564:59>>*/  /*<<stdlib.ml:564:59>>*/ caml_call1
-            (f, 0);
-           /*<<stdlib.ml:564:59>>*/ return  /*<<stdlib.ml:564:59>>*/ caml_call1
-                  (old_exit, 0);
-          /*<<stdlib.ml:565:15>>*/ }
-         return new_exit;
-        },
-      new_exit = new_exit$0(f_yet_to_run, old_exit),
-      success = caml_atomic_cas(exit_function, old_exit, new_exit),
-       /*<<stdlib.ml:568:2>>*/ _m_ = 1 - success;
-     if(! _m_)  /*<<stdlib.ml:568:2>>*/ return _m_;
-    }
-    /*<<stdlib.ml:568:31>>*/ }
-    /*<<stdlib.ml:570:30>>*/  /*<<stdlib.ml:570:30>>*/ var
-    do_domain_local_at_exit =
-      [0,
-       function(param){
-         /*<<stdlib.ml:570:45>>*/ return 0;
-        /*<<stdlib.ml:570:47>>*/ }];
-   function do_at_exit(param){
-     /*<<stdlib.ml:573:2>>*/  /*<<stdlib.ml:573:2>>*/ caml_call1
-     (do_domain_local_at_exit[1], 0);
-     /*<<stdlib.ml:573:2>>*/ return  /*<<stdlib.ml:573:2>>*/ caml_call1
-            (caml_atomic_load(exit_function), 0);
-    /*<<stdlib.ml:574:31>>*/ }
-   function exit(retcode){
-     /*<<stdlib.ml:577:2>>*/ do_at_exit(0);
-     /*<<stdlib.ml:578:2>>*/ return  /*<<stdlib.ml:578:2>>*/ runtime.caml_sys_exit
-            (retcode);
-    /*<<stdlib.ml:578:18>>*/ }
-    /*<<stdlib.ml:580:8>>*/  /*<<stdlib.ml:580:8>>*/ runtime.caml_register_named_value
-    ("Pervasives.do_at_exit", do_at_exit);
-   var
-    Stdlib =
-      [0,
-       invalid_arg,
-       failwith,
-       Exit,
-       Match_failure,
-       Assert_failure,
-       Invalid_argument,
-       Failure,
-       Not_found,
-       Out_of_memory,
-       Stack_overflow,
-       Sys_error,
-       End_of_file,
-       Division_by_zero,
-       Sys_blocked_io,
-       Undefined_recursive_module,
-       min,
-       max,
-       abs,
-       max_int,
-       min_int,
-       lnot,
-       infinity,
-       neg_infinity,
-       nan,
-       max_float,
-       min_float,
-       epsilon_float,
-       symbol,
-       char_of_int,
-       string_of_bool,
-       bool_of_string_opt,
-       bool_of_string,
-       string_of_int,
-       int_of_string_opt,
-       string_of_float,
-       float_of_string_opt,
-       symbol$0,
-       stdin,
-       stdout,
-       stderr,
-       print_char,
-       print_string,
-       print_bytes,
-       print_int,
-       print_float,
-       print_endline,
-       print_newline,
-       prerr_char,
-       prerr_string,
-       prerr_bytes,
-       prerr_int,
-       prerr_float,
-       prerr_endline,
-       prerr_newline,
-       read_line,
-       read_int_opt,
-       read_int,
-       read_float_opt,
-       read_float,
-       open_out,
-       open_out_bin,
-       open_out_gen,
-       caml_ml_flush,
-       flush_all,
-       caml_ml_output_char,
-       output_string,
-       output_bytes,
-       output,
-       output_substring,
-       caml_ml_output_char,
-       runtime.caml_ml_output_int,
-       output_value,
-       runtime.caml_ml_seek_out,
-       runtime.caml_ml_pos_out,
-       caml_ml_channel_size,
-       close_out,
-       close_out_noerr,
-       caml_ml_set_binary_mode,
-       open_in,
-       open_in_bin,
-       open_in_gen,
-       caml_ml_input_char,
-       input_line,
-       input,
-       really_input,
-       really_input_string,
-       caml_ml_input_char,
-       runtime.caml_ml_input_int,
-       runtime.caml_input_value,
-       runtime.caml_ml_seek_in,
-       runtime.caml_ml_pos_in,
-       caml_ml_channel_size,
-       caml_ml_close_channel,
-       close_in_noerr,
-       caml_ml_set_binary_mode,
-       [0,
-        runtime.caml_ml_seek_out_64,
-        runtime.caml_ml_pos_out_64,
-        caml_ml_channel_size_64,
-        runtime.caml_ml_seek_in_64,
-        runtime.caml_ml_pos_in_64,
-        caml_ml_channel_size_64],
-       string_of_format,
-       symbol$1,
-       exit,
-       at_exit,
-       valid_float_lexem,
-       unsafe_really_input,
-       do_at_exit,
-       do_domain_local_at_exit];
-   runtime.caml_register_global(45, Stdlib, "Stdlib");
-   return;
-   /*<<?>>*/ }
-  (globalThis));
-
-//# unitInfo: Provides: Stdlib__Either
-(function(globalThis){
-   "use strict";
-   var runtime = globalThis.jsoo_runtime;
-    /*<<?>>*/ function caml_call1(f, a0){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 1
-            ? f(a0)
-            : runtime.caml_call_gen(f, [a0]);
-   }
-    /*<<?>>*/ function caml_call2(f, a0, a1){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 2
-            ? f(a0, a1)
-            : runtime.caml_call_gen(f, [a0, a1]);
-   }
-   function left(v){
-     /*<<either.ml:18:13>>*/ return [0, v];
-    /*<<either.ml:18:19>>*/ }
-   function right(v){
-     /*<<either.ml:19:14>>*/ return [1, v];
-    /*<<either.ml:19:21>>*/ }
-   function is_left(param){
-     /*<<either.ml:21:14>>*/ return 0 === param[0] ? 1 : 0;
-    /*<<either.ml:23:18>>*/ }
-   function is_right(param){
-     /*<<either.ml:25:15>>*/ return 0 === param[0] ? 0 : 1;
-    /*<<either.ml:27:17>>*/ }
-   function find_left(param){
-     /*<<either.ml:29:16>>*/ if(0 !== param[0])
-      /*<<either.ml:31:13>>*/ return 0;
-    var v = param[1];
-     /*<<either.ml:30:12>>*/ return [0, v];
-    /*<<either.ml:31:17>>*/ }
-   function find_right(param){
-     /*<<either.ml:33:17>>*/ if(0 === param[0])
-      /*<<either.ml:34:12>>*/ return 0;
-    var v = param[1];
-     /*<<either.ml:35:13>>*/ return [0, v];
-    /*<<either.ml:35:19>>*/ }
-   function map_left(f, e){
-     /*<<?>>*/ if(0 !== e[0])  /*<<either.ml:39:18>>*/ return e;
-    var v = e[1];
-     /*<<either.ml:38:12>>*/ return [0,
-             /*<<either.ml:38:17>>*/ caml_call1(f, v)];
-   }
-   function map_right(f, e){
-     /*<<?>>*/ if(0 === e[0])  /*<<either.ml:42:17>>*/ return e;
-    var v = e[1];
-     /*<<either.ml:43:13>>*/ return [1,
-             /*<<either.ml:43:19>>*/ caml_call1(f, v)];
-   }
-   function map(left, right, param){
-     /*<<?>>*/ if(0 === param[0]){
-     var v = param[1];
-      /*<<either.ml:46:12>>*/ return [0,
-              /*<<either.ml:46:17>>*/ caml_call1(left, v)];
-    }
-    var v$0 = param[1];
-     /*<<either.ml:47:13>>*/ return [1,
-             /*<<either.ml:47:19>>*/ caml_call1(right, v$0)];
-   }
-   function fold(left, right, param){
-     /*<<?>>*/ if(0 === param[0]){
-     var v = param[1];
-      /*<<either.ml:50:12>>*/ return  /*<<either.ml:50:12>>*/ caml_call1
-             (left, v);
-    }
-    var v$0 = param[1];
-     /*<<either.ml:51:13>>*/ return  /*<<either.ml:51:13>>*/ caml_call1
-            (right, v$0);
-   }
-   function equal(left, right, e1, e2){
-     /*<<either.ml:57:31>>*/ if(0 === e1[0]){
-     var v1 = e1[1];
-     if(0 === e2[0]){
-      var v2 = e2[1];
-       /*<<either.ml:58:22>>*/ return  /*<<either.ml:58:22>>*/ caml_call2
-              (left, v1, v2);
-     }
-    }
-    else{
-     var v1$0 = e1[1];
-     if(0 !== e2[0]){
-      var v2$0 = e2[1];
-       /*<<either.ml:59:24>>*/ return  /*<<either.ml:59:24>>*/ caml_call2
-              (right, v1$0, v2$0);
-     }
-    }
-     /*<<either.ml:60:39>>*/ return 0;
-    /*<<either.ml:60:44>>*/ }
-   function compare(left, right, e1, e2){
-     /*<<either.ml:62:33>>*/ if(0 === e1[0]){
-     var v1 = e1[1];
-     if(0 !== e2[0])  /*<<either.ml:65:21>>*/ return -1;
-     var v2 = e2[1];
-      /*<<either.ml:63:22>>*/ return  /*<<either.ml:63:22>>*/ caml_call2
-             (left, v1, v2);
-    }
-    var v1$0 = e1[1];
-    if(0 === e2[0])  /*<<either.ml:66:21>>*/ return 1;
-    var v2$0 = e2[1];
-     /*<<either.ml:64:24>>*/ return  /*<<either.ml:64:24>>*/ caml_call2
-            (right, v1$0, v2$0);
-    /*<<either.ml:66:22>>*/ }
-   var
-    Stdlib_Either =
-      [0,
-       left,
-       right,
-       is_left,
-       is_right,
-       find_left,
-       find_right,
-       map_left,
-       map_right,
-       map,
-       fold,
-       fold,
-       fold,
-       equal,
-       compare];
-   runtime.caml_register_global(0, Stdlib_Either, "Stdlib__Either");
-   return;
-   /*<<?>>*/ }
-  (globalThis));
-
-//# unitInfo: Provides: Stdlib__Sys
-//# unitInfo: Requires: Stdlib
-(function
-  (globalThis){
-   "use strict";
-    /*<<sys.ml.in:36:22>>*/ var
-    runtime = globalThis.jsoo_runtime,
-    caml_maybe_attach_backtrace = runtime.caml_maybe_attach_backtrace,
-    caml_wrap_exception = runtime.caml_wrap_exception,
-    global_data = runtime.caml_get_global_data(),
-    ocaml_version = "5.0.0",
-    ocaml_release = [0, 5, 0, 0, 0],
-    Stdlib = global_data.Stdlib,
-     /*<<sys.ml.in:36:22>>*/ executable_name =
-       /*<<sys.ml.in:36:22>>*/ runtime.caml_sys_executable_name(0),
-    os_type =  /*<<sys.ml.in:37:22>>*/ runtime.caml_sys_get_config(0)[1],
-    backend_type = [0, "js_of_ocaml"],
-    unix = runtime.caml_sys_const_ostype_unix(0),
-    win32 = runtime.caml_sys_const_ostype_win32(0),
-    cygwin = runtime.caml_sys_const_ostype_cygwin(0),
-    max_array_length = runtime.caml_sys_const_max_wosize(0),
-    max_floatarray_length = max_array_length / 2 | 0,
-    max_string_length = (4 * max_array_length | 0) - 1 | 0,
-    cst_Stdlib_Sys_Break = "Stdlib.Sys.Break",
-    big_endian = 0,
-    word_size = 32,
-    int_size = 32;
-   function getenv_opt(s){
-     /*<<sys.ml.in:59:2>>*/ try{
-      /*<<sys.ml.in:59:6>>*/  /*<<sys.ml.in:59:6>>*/ var
-      _d_ = [0,  /*<<sys.ml.in:59:11>>*/ runtime.caml_sys_getenv(s)];
-      /*<<sys.ml.in:59:6>>*/ return _d_;
-    }
-    catch(_e_){
-     var _c_ = caml_wrap_exception(_e_);
-     if(_c_ === Stdlib[8])  /*<<sys.ml.in:60:20>>*/ return 0;
-     throw caml_maybe_attach_backtrace(_c_, 0);
-    }
-    /*<<sys.ml.in:60:24>>*/ }
-    /*<<sys.ml.in:71:18>>*/  /*<<sys.ml.in:71:18>>*/ var interactive = [0, 0];
-   function set_signal(sig_num, sig_beh){ /*<<sys.ml.in:81:33>>*/ return 0;
-    /*<<sys.ml.in:81:63>>*/ }
-    /*<<sys.ml.in:112:0>>*/ var
-     /*<<sys.ml.in:112:0>>*/ Break =
-      [248, cst_Stdlib_Sys_Break, runtime.caml_fresh_oo_id(0)],
-    sigabrt = -1,
-    sigalrm = -2,
-    sigfpe = -3,
-    sighup = -4,
-    sigill = -5,
-    sigint = -6,
-    sigkill = -7,
-    sigpipe = -8,
-    sigquit = -9,
-    sigsegv = -10,
-    sigterm = -11,
-    sigusr1 = -12,
-    sigusr2 = -13,
-    sigchld = -14,
-    sigcont = -15,
-    sigstop = -16,
-    sigtstp = -17,
-    sigttin = -18,
-    sigttou = -19,
-    sigvtalrm = -20,
-    sigprof = -21,
-    sigbus = -22,
-    sigpoll = -23,
-    sigsys = -24,
-    sigtrap = -25,
-    sigurg = -26,
-    sigxcpu = -27,
-    sigxfsz = -28;
-   function catch_break(on){
-     /*<<sys.ml.in:115:2>>*/ return on ? 0 : 0;
-    /*<<sys.ml.in:118:36>>*/ }
-   var development_version = 0;
-   function Make(_b_, _a_){ /*<<sys.ml.in:162:70>>*/ return [0, 1];}
-    /*<<sys.ml.in:154:21>>*/ var
-     /*<<sys.ml.in:154:21>>*/ Immediate64 = [0, Make],
-    Stdlib_Sys =
-      [0,
-       executable_name,
-       getenv_opt,
-       interactive,
-       os_type,
-       backend_type,
-       unix,
-       win32,
-       cygwin,
-       word_size,
-       int_size,
-       big_endian,
-       max_string_length,
-       max_array_length,
-       max_floatarray_length,
-       set_signal,
-       sigabrt,
-       sigalrm,
-       sigfpe,
-       sighup,
-       sigill,
-       sigint,
-       sigkill,
-       sigpipe,
-       sigquit,
-       sigsegv,
-       sigterm,
-       sigusr1,
-       sigusr2,
-       sigchld,
-       sigcont,
-       sigstop,
-       sigtstp,
-       sigttin,
-       sigttou,
-       sigvtalrm,
-       sigprof,
-       sigbus,
-       sigpoll,
-       sigsys,
-       sigtrap,
-       sigurg,
-       sigxcpu,
-       sigxfsz,
-       Break,
-       catch_break,
-       ocaml_version,
-       development_version,
-       ocaml_release,
-       runtime.caml_ml_enable_runtime_warnings,
-       runtime.caml_ml_runtime_warnings_enabled,
-       Immediate64];
-   runtime.caml_register_global(4, Stdlib_Sys, "Stdlib__Sys");
-   return;
-   /*<<?>>*/ }
-  (globalThis));
-
-//# unitInfo: Provides: Stdlib__Obj
-//# unitInfo: Requires: Assert_failure, Stdlib, Stdlib__Sys
-(function
-  (globalThis){
-   "use strict";
-   var
-    runtime = globalThis.jsoo_runtime,
-    cst_Obj_extension_constructor$1 = "Obj.extension_constructor",
-    caml_maybe_attach_backtrace = runtime.caml_maybe_attach_backtrace,
-    caml_obj_tag = runtime.caml_obj_tag;
-    /*<<?>>*/ function caml_call1(f, a0){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 1
-            ? f(a0)
-            : runtime.caml_call_gen(f, [a0]);
-   }
-   var
-    global_data = runtime.caml_get_global_data(),
-    Stdlib = global_data.Stdlib,
-    Assert_failure = global_data.Assert_failure,
-    Stdlib_Sys = global_data.Stdlib__Sys,
-    cst_Obj_Ephemeron_blit_key = "Obj.Ephemeron.blit_key",
-    cst_Obj_Ephemeron_check_key = "Obj.Ephemeron.check_key",
-    cst_Obj_Ephemeron_unset_key = "Obj.Ephemeron.unset_key",
-    cst_Obj_Ephemeron_set_key = "Obj.Ephemeron.set_key",
-    cst_Obj_Ephemeron_get_key_copy = "Obj.Ephemeron.get_key_copy",
-    cst_Obj_Ephemeron_get_key = "Obj.Ephemeron.get_key",
-    cst_Obj_Ephemeron_create = "Obj.Ephemeron.create",
-    cst_Obj_extension_constructor$0 = cst_Obj_extension_constructor$1,
-    cst_Obj_extension_constructor = cst_Obj_extension_constructor$1,
-    _a_ = [0, "obj.ml", 97, 4];
-   function is_block(a){
-     /*<<obj.ml:26:34>>*/ return 1 - (typeof a === "number" ? 1 : 0);
-    /*<<obj.ml:26:48>>*/ }
-   var
-    double_field = runtime.caml_array_get,
-    set_double_field = runtime.caml_array_set,
-    first_non_constant_constructor = 0,
-    last_non_constant_constructor_ = 243,
-    forcing_tag = 244,
-    cont_tag = 245,
-    lazy_tag = 246,
-    closure_tag = 247,
-    object_tag = 248,
-    infix_tag = 249,
-    forward_tag = 250,
-    no_scan_tag = 251,
-    abstract_tag = 251,
-    string_tag = 252,
-    double_tag = 253,
-    double_array_tag = 254,
-    custom_tag = 255,
-    int_tag = 1000,
-    out_of_heap_tag = 1001,
-    unaligned_tag = 1002;
-   function info(obj){
-     /*<<obj.ml:97:4>>*/ if( /*<<obj.ml:97:12>>*/ caml_obj_tag(obj) !== 247)
-      /*<<obj.ml:97:4>>*/ throw  /*<<obj.ml:97:4>>*/ caml_maybe_attach_backtrace
-            ([0, Assert_failure, _a_], 1);
-     /*<<obj.ml:98:16>>*/ var
-      /*<<obj.ml:98:16>>*/ info =
-        /*<<obj.ml:98:16>>*/ runtime.caml_obj_raw_field(obj, 1),
-     arity = 64 === Stdlib_Sys[9] ? info >> 56 : info >> 24,
-      /*<<obj.ml:92:13>>*/ start_env = info << 8 >>> 9 | 0;
-     /*<<obj.ml:93:4>>*/ return [0, arity, start_env];
-    /*<<obj.ml:98:33>>*/ }
-   function of_val(x){
-     /*<<obj.ml:105:4>>*/ a:
-    {
-     if
-      (is_block(x)
-       &&  /*<<obj.ml:107:25>>*/ caml_obj_tag(x) !== 248 && 1 <= x.length - 1){var slot = x[1]; break a;}
-     var slot = x;
-    }
-    a:
-    {
-     if(is_block(slot) &&  /*<<obj.ml:111:28>>*/ caml_obj_tag(slot) === 248){var name = slot[1]; break a;}
-     var
-      name =
-         /*<<obj.ml:112:11>>*/ caml_call1
-         (Stdlib[1], cst_Obj_extension_constructor$0);
-    }
-    return  /*<<obj.ml:114:9>>*/ caml_obj_tag(name) === 252
-            ? slot
-            :  /*<<obj.ml:115:11>>*/ caml_call1
-              (Stdlib[1], cst_Obj_extension_constructor);
-    /*<<obj.ml:115:50>>*/ }
-   function name(slot){
-     /*<<obj.ml:118:5>>*/ return slot[1];
-    /*<<obj.ml:118:30>>*/ }
-   function id(slot){
-     /*<<obj.ml:121:5>>*/ return slot[2];
-    /*<<obj.ml:121:30>>*/ }
-    /*<<obj.ml:102:0>>*/ var
-     /*<<obj.ml:102:0>>*/ Extension_constructor = [0, of_val, name, id],
-    max_ephe_length = Stdlib_Sys[13] - 2 | 0;
-   function create(l){
-     /*<<obj.ml:135:4>>*/ var
-     _g_ = 0 <= l ? 1 : 0,
-     _h_ = _g_ ? l <= max_ephe_length ? 1 : 0 : _g_;
-    if(1 - _h_)
-      /*<<obj.ml:136:6>>*/  /*<<obj.ml:136:6>>*/ caml_call1
-      (Stdlib[1], cst_Obj_Ephemeron_create);
-     /*<<obj.ml:137:4>>*/ return  /*<<obj.ml:137:4>>*/ runtime.caml_ephe_create
-            (l);
-    /*<<obj.ml:137:12>>*/ }
-   function length(x){
-     /*<<obj.ml:139:17>>*/ return x.length - 1 - 2 | 0;
-    /*<<obj.ml:139:49>>*/ }
-   function raise_if_invalid_offset(e, o, msg){
-     /*<<obj.ml:142:4>>*/ var
-     _d_ = 0 <= o ? 1 : 0,
-     _e_ = _d_ ? o < length(e) ? 1 : 0 : _d_,
-     _f_ = 1 - _e_;
-    return _f_ ?  /*<<obj.ml:143:6>>*/ caml_call1(Stdlib[1], msg) : _f_;
-    /*<<obj.ml:143:21>>*/ }
-   function get_key(e, o){
-     /*<<obj.ml:147:4>>*/ raise_if_invalid_offset
-     (e, o, cst_Obj_Ephemeron_get_key);
-     /*<<obj.ml:148:4>>*/ return  /*<<obj.ml:148:4>>*/ runtime.caml_ephe_get_key
-            (e, o);
-    /*<<obj.ml:148:15>>*/ }
-   function get_key_copy(e, o){
-     /*<<obj.ml:152:4>>*/ raise_if_invalid_offset
-     (e, o, cst_Obj_Ephemeron_get_key_copy);
-     /*<<obj.ml:153:4>>*/ return  /*<<obj.ml:153:4>>*/ runtime.caml_ephe_get_key_copy
-            (e, o);
-    /*<<obj.ml:153:20>>*/ }
-   function set_key(e, o, x){
-     /*<<obj.ml:157:4>>*/ raise_if_invalid_offset
-     (e, o, cst_Obj_Ephemeron_set_key);
-     /*<<obj.ml:158:4>>*/ return  /*<<obj.ml:158:4>>*/ runtime.caml_ephe_set_key
-            (e, o, x);
-    /*<<obj.ml:158:17>>*/ }
-   function unset_key(e, o){
-     /*<<obj.ml:162:4>>*/ raise_if_invalid_offset
-     (e, o, cst_Obj_Ephemeron_unset_key);
-     /*<<obj.ml:163:4>>*/ return  /*<<obj.ml:163:4>>*/ runtime.caml_ephe_unset_key
-            (e, o);
-    /*<<obj.ml:163:17>>*/ }
-   function check_key(e, o){
-     /*<<obj.ml:167:4>>*/ raise_if_invalid_offset
-     (e, o, cst_Obj_Ephemeron_check_key);
-     /*<<obj.ml:168:4>>*/ return  /*<<obj.ml:168:4>>*/ runtime.caml_ephe_check_key
-            (e, o);
-    /*<<obj.ml:168:17>>*/ }
-   function blit_key(e1, o1, e2, o2, l){
-     /*<<obj.ml:174:4>>*/ if
-     (0 <= l
-      &&
-       0 <= o1
-       && (length(e1) - l | 0) >= o1 && 0 <= o2 && (length(e2) - l | 0) >= o2){
-     var
-      _b_ = 0 !== l ? 1 : 0,
-      _c_ =
-        _b_
-         ?  /*<<obj.ml:177:24>>*/ runtime.caml_ephe_blit_key
-           (e1, o1, e2, o2, l)
-         : _b_;
-      /*<<obj.ml:177:24>>*/ return _c_;
-    }
-     /*<<obj.ml:176:9>>*/ return  /*<<obj.ml:176:9>>*/ caml_call1
-            (Stdlib[1], cst_Obj_Ephemeron_blit_key);
-    /*<<obj.ml:177:46>>*/ }
-   var
-    Stdlib_Obj =
-      [0,
-       is_block,
-       double_field,
-       set_double_field,
-       first_non_constant_constructor,
-       last_non_constant_constructor_,
-       forcing_tag,
-       cont_tag,
-       lazy_tag,
-       closure_tag,
-       object_tag,
-       infix_tag,
-       forward_tag,
-       no_scan_tag,
-       abstract_tag,
-       string_tag,
-       double_tag,
-       double_array_tag,
-       custom_tag,
-       int_tag,
-       out_of_heap_tag,
-       unaligned_tag,
-       [0, info],
-       Extension_constructor,
-       [0,
-        create,
-        length,
-        get_key,
-        get_key_copy,
-        set_key,
-        unset_key,
-        check_key,
-        blit_key,
-        runtime.caml_ephe_get_data,
-        runtime.caml_ephe_get_data_copy,
-        runtime.caml_ephe_set_data,
-        runtime.caml_ephe_unset_data,
-        runtime.caml_ephe_check_data,
-        runtime.caml_ephe_blit_data,
-        max_ephe_length]];
-   runtime.caml_register_global(13, Stdlib_Obj, "Stdlib__Obj");
-   return;
-   /*<<?>>*/ }
-  (globalThis));
-
-//# unitInfo: Provides: Stdlib__Atomic
-(function(globalThis){
-   "use strict";
-   var
-    runtime = globalThis.jsoo_runtime,
-    caml_atomic_exchange = runtime.caml_atomic_exchange,
-    caml_atomic_fetch_add = runtime.caml_atomic_fetch_add;
-   function set(r, x){
-     /*<<atomic.ml:24:14>>*/ caml_atomic_exchange(r, x);
-    return 0;
-    /*<<atomic.ml:24:35>>*/ }
-   function incr(r){
-     /*<<atomic.ml:25:13>>*/ caml_atomic_fetch_add(r, 1);
-    return 0;
-    /*<<atomic.ml:25:39>>*/ }
-   function decr(r){
-     /*<<atomic.ml:26:13>>*/ caml_atomic_fetch_add(r, -1);
-    return 0;
-    /*<<atomic.ml:26:42>>*/ }
-   var
-    _a_ = caml_atomic_fetch_add,
-    _b_ = runtime.caml_atomic_cas,
-    _c_ = caml_atomic_exchange,
-    _d_ = runtime.caml_atomic_load,
-    Stdlib_Atomic =
-      [0,
-       function(_e_){ /*<<atomic.ml:17:0>>*/ return [0, _e_];},
-       _d_,
-       set,
-       _c_,
-       _b_,
-       _a_,
-       incr,
-       decr];
-   runtime.caml_register_global(0, Stdlib_Atomic, "Stdlib__Atomic");
-   return;
-   /*<<?>>*/ }
-  (globalThis));
-
-//# unitInfo: Provides: CamlinternalLazy
-//# unitInfo: Requires: Stdlib, Stdlib__Obj
-(function
-  (globalThis){
-   "use strict";
-   var
-    runtime = globalThis.jsoo_runtime,
-    caml_lazy_update_to_forward = runtime.caml_lazy_update_to_forward,
-    caml_maybe_attach_backtrace = runtime.caml_maybe_attach_backtrace,
-    caml_wrap_exception = runtime.caml_wrap_exception;
-    /*<<?>>*/ function caml_call1(f, a0){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 1
-            ? f(a0)
-            : runtime.caml_call_gen(f, [a0]);
-   }
-    /*<<camlinternalLazy.ml:20:0>>*/ var
-    global_data = runtime.caml_get_global_data(),
-    Stdlib_Obj = global_data.Stdlib__Obj,
-     /*<<camlinternalLazy.ml:20:0>>*/ Undefined =
-      [248, "CamlinternalLazy.Undefined", runtime.caml_fresh_oo_id(0)];
-   function force_gen_lazy_block(only_val, blk){
-     /*<<camlinternalLazy.ml:72:2>>*/ if
-     (0
-      !==
-        /*<<camlinternalLazy.ml:72:8>>*/ runtime.caml_lazy_update_to_forcing
-        (blk))
-      /*<<camlinternalLazy.ml:75:9>>*/ throw  /*<<camlinternalLazy.ml:75:9>>*/ caml_maybe_attach_backtrace
-            (Undefined, 1);
-    if(only_val){
-      /*<<camlinternalLazy.ml:61:25>>*/  /*<<camlinternalLazy.ml:61:25>>*/ var
-      closure$0 = blk[1];
-      /*<<camlinternalLazy.ml:62:2>>*/ blk[1] = 0;
-      /*<<camlinternalLazy.ml:63:15>>*/  /*<<camlinternalLazy.ml:63:15>>*/ var
-      result$0 =  /*<<camlinternalLazy.ml:63:15>>*/ caml_call1(closure$0, 0);
-      /*<<camlinternalLazy.ml:64:2>>*/ blk[1] = result$0;
-      /*<<camlinternalLazy.ml:65:2>>*/  /*<<camlinternalLazy.ml:65:2>>*/ caml_lazy_update_to_forward
-      (blk);
-      /*<<camlinternalLazy.ml:65:2>>*/ return result$0;
-    }
-     /*<<camlinternalLazy.ml:46:25>>*/  /*<<camlinternalLazy.ml:46:25>>*/ var
-     closure = blk[1];
-     /*<<camlinternalLazy.ml:47:2>>*/ blk[1] = 0;
-     /*<<camlinternalLazy.ml:47:2>>*/ try{
-      /*<<camlinternalLazy.ml:49:17>>*/  /*<<camlinternalLazy.ml:49:17>>*/ var
-      result =  /*<<camlinternalLazy.ml:49:17>>*/ caml_call1(closure, 0);
-      /*<<camlinternalLazy.ml:50:4>>*/ blk[1] = result;
-      /*<<camlinternalLazy.ml:51:4>>*/  /*<<camlinternalLazy.ml:51:4>>*/ caml_lazy_update_to_forward
-      (blk);
-      /*<<camlinternalLazy.ml:51:4>>*/ return result;
-    }
-    catch(e$0){
-     var e = caml_wrap_exception(e$0);
-      /*<<camlinternalLazy.ml:54:4>>*/ blk[1] =
-      function(param){
-        /*<<camlinternalLazy.ml:54:43>>*/ throw  /*<<camlinternalLazy.ml:54:43>>*/ caml_maybe_attach_backtrace
-              (e, 0);
-       /*<<camlinternalLazy.ml:54:50>>*/ };
-      /*<<camlinternalLazy.ml:55:4>>*/  /*<<camlinternalLazy.ml:55:4>>*/ runtime.caml_lazy_reset_to_lazy
-      (blk);
-      /*<<camlinternalLazy.ml:56:4>>*/ throw  /*<<camlinternalLazy.ml:56:4>>*/ caml_maybe_attach_backtrace
-            (e, 0);
-    }
-    /*<<camlinternalLazy.ml:75:24>>*/ }
-   function force_lazy_block(blk){
-     /*<<camlinternalLazy.ml:78:27>>*/ return force_gen_lazy_block(0, blk);
-    /*<<camlinternalLazy.ml:78:67>>*/ }
-   function force_gen(only_val, lzv){
-     /*<<camlinternalLazy.ml:93:2>>*/  /*<<camlinternalLazy.ml:99:10>>*/ var
-     t =  /*<<camlinternalLazy.ml:99:10>>*/ runtime.caml_obj_tag(lzv);
-    if(t === Stdlib_Obj[12])
-      /*<<camlinternalLazy.ml:101:13>>*/ return lzv[1];
-    if(t === Stdlib_Obj[6])
-      /*<<camlinternalLazy.ml:103:35>>*/ throw  /*<<camlinternalLazy.ml:103:35>>*/ caml_maybe_attach_backtrace
-            (Undefined, 1);
-    return t !== Stdlib_Obj[8] ? lzv : force_gen_lazy_block(only_val, lzv);
-    /*<<camlinternalLazy.ml:105:41>>*/ }
-   var CamlinternalLazy = [0, Undefined, force_lazy_block, force_gen];
-   runtime.caml_register_global(2, CamlinternalLazy, "CamlinternalLazy");
-   return;
-   /*<<?>>*/ }
-  (globalThis));
-
-//# unitInfo: Provides: Stdlib__Lazy
-//# unitInfo: Requires: CamlinternalLazy, Stdlib, Stdlib__Obj
-(function
-  (globalThis){
-   "use strict";
-   var runtime = globalThis.jsoo_runtime, caml_obj_tag = runtime.caml_obj_tag;
-    /*<<?>>*/ function caml_call1(f, a0){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 1
-            ? f(a0)
-            : runtime.caml_call_gen(f, [a0]);
-   }
-    /*<<?>>*/ function caml_call2(f, a0, a1){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 2
-            ? f(a0, a1)
-            : runtime.caml_call_gen(f, [a0, a1]);
-   }
-   var
-    global_data = runtime.caml_get_global_data(),
-    CamlinternalLazy = global_data.CamlinternalLazy,
-    Stdlib_Obj = global_data.Stdlib__Obj,
-    Undefined = CamlinternalLazy[1];
-   function force_val(l){
-     /*<<lazy.ml:56:18>>*/ return  /*<<lazy.ml:56:18>>*/ caml_call2
-            (CamlinternalLazy[3], 1, l);
-    /*<<lazy.ml:56:61>>*/ }
-   function from_fun(f){
-     /*<<lazy.ml:59:2>>*/  /*<<lazy.ml:59:10>>*/ var
-     x =  /*<<lazy.ml:59:10>>*/ runtime.caml_obj_block(Stdlib_Obj[8], 1);
-     /*<<lazy.ml:60:2>>*/ x[1] = f;
-     /*<<lazy.ml:60:2>>*/ return x;
-    /*<<lazy.ml:61:22>>*/ }
-   function from_val(v){
-     /*<<lazy.ml:64:2>>*/  /*<<lazy.ml:64:10>>*/ var
-     t =  /*<<lazy.ml:64:10>>*/ caml_obj_tag(v);
-    if
-     (t !== Stdlib_Obj[12]
-      && t !== Stdlib_Obj[8] && t !== Stdlib_Obj[6] && t !== Stdlib_Obj[16])
-      /*<<lazy.ml:69:5>>*/ return v;
-     /*<<lazy.ml:66:52>>*/ return  /*<<lazy.ml:66:52>>*/ runtime.caml_lazy_make_forward
-            (v);
-    /*<<lazy.ml:70:5>>*/ }
-   function is_val(l){
-     /*<<lazy.ml:72:26>>*/  /*<<lazy.ml:72:26>>*/ var _i_ = Stdlib_Obj[8];
-     /*<<lazy.ml:72:26>>*/ return  /*<<lazy.ml:72:26>>*/ caml_obj_tag(l)
-            !== _i_
-            ? 1
-            : 0;
-    /*<<lazy.ml:72:62>>*/ }
-   function map(f, x){
-     /*<<lazy.ml:75:2>>*/ return [246,
-            function(_f_){
-             var _g_ = caml_obj_tag(x);
-             a:
-             if(250 === _g_)
-              var _h_ = x[1];
-             else{
-              if(246 !== _g_ && 244 !== _g_){var _h_ = x; break a;}
-              var _h_ = caml_call1(CamlinternalLazy[2], x);
-             }
-              /*<<lazy.ml:75:10>>*/ return  /*<<lazy.ml:75:10>>*/ caml_call1
-                     (f, _h_);
-            }];
-    /*<<lazy.ml:75:20>>*/ }
-   function map_val(f, x){
-     /*<<lazy.ml:78:2>>*/ if(! is_val(x))
-      /*<<lazy.ml:80:12>>*/ return [246,
-             function(_c_){
-              var _d_ = caml_obj_tag(x);
-              a:
-              if(250 === _d_)
-               var _e_ = x[1];
-              else{
-               if(246 !== _d_ && 244 !== _d_){var _e_ = x; break a;}
-               var _e_ = caml_call1(CamlinternalLazy[2], x);
-              }
-               /*<<lazy.ml:80:15>>*/ return  /*<<lazy.ml:80:15>>*/ caml_call1
-                      (f, _e_);
-             }];
-    var _a_ = caml_obj_tag(x);
-    a:
-    if(250 === _a_)
-     var _b_ = x[1];
-    else{
-     if(246 !== _a_ && 244 !== _a_){var _b_ = x; break a;}
-     var _b_ = caml_call1(CamlinternalLazy[2], x);
-    }
-     /*<<lazy.ml:79:16>>*/ return from_val
-            ( /*<<lazy.ml:79:16>>*/ caml_call1(f, _b_));
-    /*<<lazy.ml:80:25>>*/ }
-   var
-    Stdlib_Lazy =
-      [0, Undefined, map, is_val, from_val, map_val, from_fun, force_val];
-   runtime.caml_register_global(2, Stdlib_Lazy, "Stdlib__Lazy");
-   return;
-   /*<<?>>*/ }
-  (globalThis));
-
-//# unitInfo: Provides: Stdlib__Seq
-//# unitInfo: Requires: Assert_failure, CamlinternalLazy, Stdlib, Stdlib__Atomic, Stdlib__Lazy
-(function
-  (globalThis){
-   "use strict";
-   var
-    runtime = globalThis.jsoo_runtime,
-    caml_maybe_attach_backtrace = runtime.caml_maybe_attach_backtrace;
-    /*<<?>>*/ function caml_call1(f, a0){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 1
-            ? f(a0)
-            : runtime.caml_call_gen(f, [a0]);
-   }
-    /*<<?>>*/ function caml_call2(f, a0, a1){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 2
-            ? f(a0, a1)
-            : runtime.caml_call_gen(f, [a0, a1]);
-   }
-    /*<<?>>*/ function caml_call3(f, a0, a1, a2){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 3
-            ? f(a0, a1, a2)
-            : runtime.caml_call_gen(f, [a0, a1, a2]);
-   }
-   var
-    global_data = runtime.caml_get_global_data(),
-    Assert_failure = global_data.Assert_failure,
-    Stdlib_Atomic = global_data.Stdlib__Atomic,
-    CamlinternalLazy = global_data.CamlinternalLazy,
-    Stdlib = global_data.Stdlib,
-    Stdlib_Lazy = global_data.Stdlib__Lazy,
-    _a_ = [0, "seq.ml", 596, 4],
-    cst_Seq_drop = "Seq.drop",
-    cst_Seq_take = "Seq.take",
-    cst_Seq_init = "Seq.init",
-    cst_Stdlib_Seq_Forced_twice = "Stdlib.Seq.Forced_twice";
-   function empty(param){
-     /*<<seq.ml:24:15>>*/ return 0;
-    /*<<seq.ml:24:18>>*/ }
-   function return$0(x, param){
-     /*<<seq.ml:26:18>>*/ return [0, x, empty];
-    /*<<seq.ml:26:33>>*/ }
-   function cons(x, next, param){
-     /*<<seq.ml:28:21>>*/ return [0, x, next];
-    /*<<seq.ml:28:35>>*/ }
-   function append(seq1, seq2, param){
-     /*<<seq.ml:31:2>>*/  /*<<seq.ml:31:8>>*/ var
-     match =  /*<<seq.ml:31:8>>*/ caml_call1(seq1, 0);
-    if(! match)
-      /*<<seq.ml:32:11>>*/ return  /*<<seq.ml:32:11>>*/ caml_call1(seq2, 0);
-    var next = match[2], x = match[1];
-     /*<<seq.ml:33:22>>*/ return [0,
-            x,
-            function(_aM_){ /*<<?>>*/ return append(next, seq2, _aM_);}];
-    /*<<seq.ml:33:48>>*/ }
-   function map(f, seq, param){
-     /*<<seq.ml:35:23>>*/  /*<<seq.ml:35:29>>*/ var
-     match =  /*<<seq.ml:35:29>>*/ caml_call1(seq, 0);
-    if(! match)  /*<<seq.ml:36:11>>*/ return 0;
-    var next = match[2], x = match[1];
-     /*<<seq.ml:37:33>>*/ function _aK_(_aL_){
-      /*<<?>>*/ return map(f, next, _aL_);
-    }
-     /*<<seq.ml:37:22>>*/ return [0,
-             /*<<seq.ml:37:28>>*/ caml_call1(f, x),
-            _aK_];
-    /*<<seq.ml:37:44>>*/ }
-   function filter_map(f, seq, param){
-     /*<<seq.ml:39:30>>*/ var seq$0 = seq;
-     /*<<seq.ml:39:30>>*/ for(;;){
-      /*<<seq.ml:39:36>>*/  /*<<seq.ml:39:36>>*/ var
-      match =  /*<<seq.ml:39:36>>*/ caml_call1(seq$0, 0);
-     if(! match)  /*<<seq.ml:40:11>>*/ return 0;
-      /*<<seq.ml:42:12>>*/ var
-      next = match[2],
-      x = match[1],
-       /*<<seq.ml:42:12>>*/ match$0 =  /*<<seq.ml:42:12>>*/ caml_call1(f, x);
-     if(match$0){
-      var y = match$0[1];
-       /*<<seq.ml:44:20>>*/ return [0,
-              y,
-              function(_aJ_){ /*<<?>>*/ return filter_map(f, next, _aJ_);}];
-     }
-     var seq$0 = next;
-    }
-    /*<<seq.ml:44:47>>*/ }
-   function filter(f, seq, param){
-     /*<<seq.ml:46:26>>*/ var seq$0 = seq;
-     /*<<seq.ml:46:26>>*/ for(;;){
-      /*<<seq.ml:46:32>>*/  /*<<seq.ml:46:32>>*/ var
-      match =  /*<<seq.ml:46:32>>*/ caml_call1(seq$0, 0);
-     if(! match)  /*<<seq.ml:47:11>>*/ return 0;
-     var next = match[2], x = match[1];
-      /*<<seq.ml:49:9>>*/ if( /*<<seq.ml:49:9>>*/ caml_call1(f, x))
-       /*<<seq.ml:50:11>>*/ return [0,
-              x,
-              function(_aI_){ /*<<?>>*/ return filter(f, next, _aI_);}];
-     var seq$0 = next;
-    }
-    /*<<seq.ml:51:27>>*/ }
-   function concat(seq, param){
-     /*<<seq.ml:53:24>>*/  /*<<seq.ml:53:30>>*/ var
-     match =  /*<<seq.ml:53:30>>*/ caml_call1(seq, 0);
-    if(! match)  /*<<seq.ml:54:11>>*/ return 0;
-    var next = match[2], x = match[1], _aG_ = 0;
-     /*<<seq.ml:56:5>>*/ return append
-            (x, function(_aH_){ /*<<?>>*/ return concat(next, _aH_);}, _aG_);
-    /*<<seq.ml:56:30>>*/ }
-   function flat_map(f, seq, param){
-     /*<<seq.ml:58:28>>*/  /*<<seq.ml:58:34>>*/ var
-     match =  /*<<seq.ml:58:34>>*/ caml_call1(seq, 0);
-    if(! match)  /*<<seq.ml:59:11>>*/ return 0;
-    var next = match[2], x = match[1], _aD_ = 0;
-     /*<<seq.ml:61:17>>*/ function _aE_(_aF_){
-      /*<<?>>*/ return flat_map(f, next, _aF_);
-    }
-     /*<<seq.ml:61:4>>*/ return append
-            ( /*<<seq.ml:61:11>>*/ caml_call1(f, x), _aE_, _aD_);
-    /*<<seq.ml:61:37>>*/ }
-   function fold_left(f, acc, seq){
-     /*<<seq.ml:66:2>>*/ var acc$0 = acc, seq$0 = seq;
-     /*<<seq.ml:66:2>>*/ for(;;){
-      /*<<seq.ml:66:8>>*/  /*<<seq.ml:66:8>>*/ var
-      match =  /*<<seq.ml:66:8>>*/ caml_call1(seq$0, 0);
-     if(! match)  /*<<seq.ml:67:13>>*/ return acc$0;
-      /*<<seq.ml:69:18>>*/ var
-      next = match[2],
-      x = match[1],
-       /*<<seq.ml:69:18>>*/ acc$1 =
-         /*<<seq.ml:69:18>>*/ caml_call2(f, acc$0, x),
-      acc$0 = acc$1,
-      seq$0 = next;
-    }
-    /*<<seq.ml:70:28>>*/ }
-   function iter(f, seq){
-     /*<<seq.ml:73:2>>*/ var seq$0 = seq;
-     /*<<seq.ml:73:2>>*/ for(;;){
-      /*<<seq.ml:73:8>>*/  /*<<seq.ml:73:8>>*/ var
-      match =  /*<<seq.ml:73:8>>*/ caml_call1(seq$0, 0);
-     if(! match)  /*<<seq.ml:74:13>>*/ return 0;
-     var next = match[2], x = match[1];
-      /*<<seq.ml:76:8>>*/  /*<<seq.ml:76:8>>*/ caml_call1(f, x);
-     var seq$0 = next;
-    }
-    /*<<seq.ml:77:19>>*/ }
-   function unfold(f, u, param){
-     /*<<seq.ml:80:2>>*/  /*<<seq.ml:80:8>>*/ var
-     match =  /*<<seq.ml:80:8>>*/ caml_call1(f, u);
-    if(! match)  /*<<seq.ml:81:12>>*/ return 0;
-    var match$0 = match[1], u$0 = match$0[2], x = match$0[1];
-     /*<<seq.ml:82:20>>*/ return [0,
-            x,
-            function(_aC_){ /*<<?>>*/ return unfold(f, u$0, _aC_);}];
-    /*<<seq.ml:82:41>>*/ }
-   function is_empty(xs){
-     /*<<seq.ml:85:2>>*/ return  /*<<seq.ml:85:8>>*/ caml_call1(xs, 0) ? 0 : 1;
-    /*<<seq.ml:89:11>>*/ }
-   function uncons(xs){
-     /*<<seq.ml:92:2>>*/  /*<<seq.ml:92:8>>*/ var
-     match =  /*<<seq.ml:92:8>>*/ caml_call1(xs, 0);
-    if(! match)  /*<<seq.ml:96:6>>*/ return 0;
-    var xs$0 = match[2], x = match[1];
-     /*<<seq.ml:94:6>>*/ return [0, [0, x, xs$0]];
-    /*<<seq.ml:96:10>>*/ }
-   function length(xs$1){
-     /*<<seq.ml:108:2>>*/ var accu = 0, xs = xs$1;
-     /*<<seq.ml:101:2>>*/ for(;;){
-      /*<<seq.ml:101:8>>*/  /*<<seq.ml:101:8>>*/ var
-      match =  /*<<seq.ml:101:8>>*/ caml_call1(xs, 0);
-     if(! match)  /*<<seq.ml:103:6>>*/ return accu;
-      /*<<seq.ml:105:6>>*/ var
-      xs$0 = match[2],
-       /*<<seq.ml:105:6>>*/ accu$0 = accu + 1 | 0,
-      accu = accu$0,
-      xs = xs$0;
-    }
-    /*<<seq.ml:108:17>>*/ }
-   function iteri(f, xs$1){
-     /*<<seq.ml:119:2>>*/ var i = 0, xs = xs$1;
-     /*<<seq.ml:111:2>>*/ for(;;){
-      /*<<seq.ml:111:8>>*/  /*<<seq.ml:111:8>>*/ var
-      match =  /*<<seq.ml:111:8>>*/ caml_call1(xs, 0);
-     if(! match)  /*<<seq.ml:113:6>>*/ return 0;
-     var xs$0 = match[2], x = match[1];
-      /*<<seq.ml:115:6>>*/  /*<<seq.ml:115:6>>*/ caml_call2(f, i, x);
-     var i$0 = i + 1 | 0, i = i$0, xs = xs$0;
-    }
-    /*<<seq.ml:119:18>>*/ }
-   function fold_lefti(f, accu$1, xs$1){
-     /*<<seq.ml:130:2>>*/ var accu = accu$1, i = 0, xs = xs$1;
-     /*<<seq.ml:122:2>>*/ for(;;){
-      /*<<seq.ml:122:8>>*/  /*<<seq.ml:122:8>>*/ var
-      match =  /*<<seq.ml:122:8>>*/ caml_call1(xs, 0);
-     if(! match)  /*<<seq.ml:124:6>>*/ return accu;
-      /*<<seq.ml:126:17>>*/ var
-      xs$0 = match[2],
-      x = match[1],
-       /*<<seq.ml:126:17>>*/ accu$0 =
-         /*<<seq.ml:126:17>>*/ caml_call3(f, accu, i, x),
-       /*<<seq.ml:127:6>>*/ i$0 = i + 1 | 0,
-      accu = accu$0,
-      i = i$0,
-      xs = xs$0;
-    }
-    /*<<seq.ml:130:28>>*/ }
-   function for_all(p, xs){
-     /*<<seq.ml:133:2>>*/ var xs$0 = xs;
-     /*<<seq.ml:133:2>>*/ for(;;){
-      /*<<seq.ml:133:8>>*/  /*<<seq.ml:133:8>>*/ var
-      match =  /*<<seq.ml:133:8>>*/ caml_call1(xs$0, 0);
-     if(! match)  /*<<seq.ml:135:6>>*/ return 1;
-      /*<<seq.ml:137:6>>*/ var
-      xs$1 = match[2],
-      x = match[1],
-       /*<<seq.ml:137:6>>*/ _aB_ =  /*<<seq.ml:137:6>>*/ caml_call1(p, x);
-      /*<<seq.ml:137:6>>*/ if(! _aB_)  /*<<seq.ml:137:6>>*/ return _aB_;
-     var xs$0 = xs$1;
-    }
-    /*<<seq.ml:137:25>>*/ }
-   function exists(p, xs){
-     /*<<seq.ml:140:2>>*/ var xs$0 = xs;
-     /*<<seq.ml:140:2>>*/ for(;;){
-      /*<<seq.ml:140:8>>*/  /*<<seq.ml:140:8>>*/ var
-      match =  /*<<seq.ml:140:8>>*/ caml_call1(xs$0, 0);
-     if(! match)  /*<<seq.ml:142:6>>*/ return 0;
-      /*<<seq.ml:144:6>>*/ var
-      xs$1 = match[2],
-      x = match[1],
-       /*<<seq.ml:144:6>>*/ _aA_ =  /*<<seq.ml:144:6>>*/ caml_call1(p, x);
-      /*<<seq.ml:144:6>>*/ if(_aA_)  /*<<seq.ml:144:6>>*/ return _aA_;
-     var xs$0 = xs$1;
-    }
-    /*<<seq.ml:144:24>>*/ }
-   function find(p, xs){
-     /*<<seq.ml:147:2>>*/ var xs$0 = xs;
-     /*<<seq.ml:147:2>>*/ for(;;){
-      /*<<seq.ml:147:8>>*/  /*<<seq.ml:147:8>>*/ var
-      match =  /*<<seq.ml:147:8>>*/ caml_call1(xs$0, 0);
-     if(! match)  /*<<seq.ml:149:6>>*/ return 0;
-     var xs$1 = match[2], x = match[1];
-      /*<<seq.ml:151:9>>*/ if( /*<<seq.ml:151:9>>*/ caml_call1(p, x))
-       /*<<seq.ml:151:18>>*/ return [0, x];
-     var xs$0 = xs$1;
-    }
-    /*<<seq.ml:151:39>>*/ }
-   function find_map(f, xs){
-     /*<<seq.ml:154:2>>*/ var xs$0 = xs;
-     /*<<seq.ml:154:2>>*/ for(;;){
-      /*<<seq.ml:154:8>>*/  /*<<seq.ml:154:8>>*/ var
-      match =  /*<<seq.ml:154:8>>*/ caml_call1(xs$0, 0);
-     if(! match)  /*<<seq.ml:156:6>>*/ return 0;
-      /*<<seq.ml:158:12>>*/ var
-      xs$1 = match[2],
-      x = match[1],
-       /*<<seq.ml:158:12>>*/ result =  /*<<seq.ml:158:12>>*/ caml_call1(f, x);
-     if(result)  /*<<seq.ml:162:10>>*/ return result;
-     var xs$0 = xs$1;
-    }
-    /*<<seq.ml:162:16>>*/ }
-   function iter2(f, xs, ys){
-     /*<<seq.ml:172:2>>*/ var xs$0 = xs, ys$0 = ys;
-     /*<<seq.ml:172:2>>*/ for(;;){
-      /*<<seq.ml:172:8>>*/  /*<<seq.ml:172:8>>*/ var
-      match =  /*<<seq.ml:172:8>>*/ caml_call1(xs$0, 0);
-     if(! match)  /*<<seq.ml:174:6>>*/ return 0;
-      /*<<seq.ml:176:12>>*/ var
-      xs$1 = match[2],
-      x = match[1],
-       /*<<seq.ml:176:12>>*/ match$0 =
-         /*<<seq.ml:176:12>>*/ caml_call1(ys$0, 0);
-     if(! match$0)  /*<<seq.ml:178:10>>*/ return 0;
-     var ys$1 = match$0[2], y = match$0[1];
-      /*<<seq.ml:180:10>>*/  /*<<seq.ml:180:10>>*/ caml_call2(f, x, y);
-     var xs$0 = xs$1, ys$0 = ys$1;
-    }
-    /*<<seq.ml:181:23>>*/ }
-   function fold_left2(f, accu, xs, ys){
-     /*<<seq.ml:184:2>>*/ var accu$0 = accu, xs$0 = xs, ys$0 = ys;
-     /*<<seq.ml:184:2>>*/ for(;;){
-      /*<<seq.ml:184:8>>*/  /*<<seq.ml:184:8>>*/ var
-      match =  /*<<seq.ml:184:8>>*/ caml_call1(xs$0, 0);
-     if(! match)  /*<<seq.ml:186:6>>*/ return accu$0;
-      /*<<seq.ml:188:12>>*/ var
-      xs$1 = match[2],
-      x = match[1],
-       /*<<seq.ml:188:12>>*/ match$0 =
-         /*<<seq.ml:188:12>>*/ caml_call1(ys$0, 0);
-     if(! match$0)  /*<<seq.ml:190:10>>*/ return accu$0;
-      /*<<seq.ml:192:21>>*/ var
-      ys$1 = match$0[2],
-      y = match$0[1],
-       /*<<seq.ml:192:21>>*/ accu$1 =
-         /*<<seq.ml:192:21>>*/ caml_call3(f, accu$0, x, y),
-      accu$0 = accu$1,
-      xs$0 = xs$1,
-      ys$0 = ys$1;
-    }
-    /*<<seq.ml:193:33>>*/ }
-   function for_all2(f, xs, ys){
-     /*<<seq.ml:196:2>>*/ var xs$0 = xs, ys$0 = ys;
-     /*<<seq.ml:196:2>>*/ for(;;){
-      /*<<seq.ml:196:8>>*/  /*<<seq.ml:196:8>>*/ var
-      match =  /*<<seq.ml:196:8>>*/ caml_call1(xs$0, 0);
-     if(! match)  /*<<seq.ml:198:6>>*/ return 1;
-      /*<<seq.ml:200:12>>*/ var
-      xs$1 = match[2],
-      x = match[1],
-       /*<<seq.ml:200:12>>*/ match$0 =
-         /*<<seq.ml:200:12>>*/ caml_call1(ys$0, 0);
-     if(! match$0)  /*<<seq.ml:202:10>>*/ return 1;
-      /*<<seq.ml:204:10>>*/ var
-      ys$1 = match$0[2],
-      y = match$0[1],
-       /*<<seq.ml:204:10>>*/ _az_ =  /*<<seq.ml:204:10>>*/ caml_call2(f, x, y);
-      /*<<seq.ml:204:10>>*/ if(! _az_)  /*<<seq.ml:204:10>>*/ return _az_;
-     var xs$0 = xs$1, ys$0 = ys$1;
-    }
-    /*<<seq.ml:204:35>>*/ }
-   function exists2(f, xs, ys){
-     /*<<seq.ml:207:2>>*/ var xs$0 = xs, ys$0 = ys;
-     /*<<seq.ml:207:2>>*/ for(;;){
-      /*<<seq.ml:207:8>>*/  /*<<seq.ml:207:8>>*/ var
-      match =  /*<<seq.ml:207:8>>*/ caml_call1(xs$0, 0);
-     if(! match)  /*<<seq.ml:209:6>>*/ return 0;
-      /*<<seq.ml:211:12>>*/ var
-      xs$1 = match[2],
-      x = match[1],
-       /*<<seq.ml:211:12>>*/ match$0 =
-         /*<<seq.ml:211:12>>*/ caml_call1(ys$0, 0);
-     if(! match$0)  /*<<seq.ml:213:10>>*/ return 0;
-      /*<<seq.ml:215:10>>*/ var
-      ys$1 = match$0[2],
-      y = match$0[1],
-       /*<<seq.ml:215:10>>*/ _ay_ =  /*<<seq.ml:215:10>>*/ caml_call2(f, x, y);
-      /*<<seq.ml:215:10>>*/ if(_ay_)  /*<<seq.ml:215:10>>*/ return _ay_;
-     var xs$0 = xs$1, ys$0 = ys$1;
-    }
-    /*<<seq.ml:215:34>>*/ }
-   function equal(eq, xs, ys){
-     /*<<seq.ml:218:2>>*/ var xs$0 = xs, ys$0 = ys;
-     /*<<seq.ml:218:2>>*/ for(;;){
-      /*<<seq.ml:218:8>>*/ var
-       /*<<seq.ml:218:8>>*/ match =  /*<<seq.ml:218:8>>*/ caml_call1(xs$0, 0),
-       /*<<seq.ml:218:14>>*/ match$0 =
-         /*<<seq.ml:218:14>>*/ caml_call1(ys$0, 0);
-     if(match){
-      if(match$0){
-        /*<<seq.ml:222:6>>*/ var
-        ys$1 = match$0[2],
-        y = match$0[1],
-        xs$1 = match[2],
-        x = match[1],
-         /*<<seq.ml:222:6>>*/ _ax_ =
-           /*<<seq.ml:222:6>>*/ caml_call2(eq, x, y);
-        /*<<seq.ml:222:6>>*/ if(! _ax_)  /*<<seq.ml:222:6>>*/ return _ax_;
-       var xs$0 = xs$1, ys$0 = ys$1;
-       continue;
-      }
-     }
-     else if(! match$0)  /*<<seq.ml:220:6>>*/ return 1;
-      /*<<seq.ml:225:6>>*/ return 0;
-    }
-    /*<<seq.ml:225:11>>*/ }
-   function compare(cmp, xs, ys){
-     /*<<seq.ml:228:2>>*/ var xs$0 = xs, ys$0 = ys;
-     /*<<seq.ml:228:2>>*/ for(;;){
-      /*<<seq.ml:228:8>>*/ var
-       /*<<seq.ml:228:8>>*/ match =  /*<<seq.ml:228:8>>*/ caml_call1(xs$0, 0),
-       /*<<seq.ml:228:14>>*/ match$0 =
-         /*<<seq.ml:228:14>>*/ caml_call1(ys$0, 0);
-     if(! match) return match$0 ? -1 : 0;
-     var xs$1 = match[2], x = match[1];
-     if(! match$0)  /*<<seq.ml:237:6>>*/ return 1;
-      /*<<seq.ml:232:14>>*/ var
-      ys$1 = match$0[2],
-      y = match$0[1],
-       /*<<seq.ml:232:14>>*/ c =  /*<<seq.ml:232:14>>*/ caml_call2(cmp, x, y);
-      /*<<seq.ml:233:6>>*/ if(0 !== c)  /*<<seq.ml:233:21>>*/ return c;
-     var xs$0 = xs$1, ys$0 = ys$1;
-    }
-    /*<<seq.ml:237:8>>*/ }
-   function init_aux(f, i, j, param){
-     /*<<seq.ml:244:2>>*/ if(i >= j)  /*<<seq.ml:248:4>>*/ return 0;
-    var _au_ = i + 1 | 0;
-     /*<<seq.ml:245:15>>*/ function _av_(_aw_){
-      /*<<?>>*/ return init_aux(f, _au_, j, _aw_);
-    }
-     /*<<seq.ml:244:16>>*/ return [0,
-             /*<<seq.ml:245:10>>*/ caml_call1(f, i),
-            _av_];
-    /*<<seq.ml:248:7>>*/ }
-   function init(n, f){
-     /*<<seq.ml:251:2>>*/ if(0 > n)
-      /*<<seq.ml:252:4>>*/ return  /*<<seq.ml:252:4>>*/ caml_call1
-             (Stdlib[1], cst_Seq_init);
-    var _as_ = 0;
-     /*<<seq.ml:254:4>>*/ return function(_at_){
-      /*<<?>>*/ return init_aux(f, _as_, n, _at_);};
-    /*<<seq.ml:254:18>>*/ }
-   function repeat(x, param){
-     /*<<seq.ml:257:2>>*/ return [0,
-            x,
-            function(_ar_){ /*<<?>>*/ return repeat(x, _ar_);}];
-    /*<<seq.ml:257:20>>*/ }
-   function forever(f, param){
-     /*<<seq.ml:260:13>>*/ function _ap_(_aq_){
-      /*<<?>>*/ return forever(f, _aq_);
-    }
-     /*<<seq.ml:260:2>>*/ return [0,
-             /*<<seq.ml:260:8>>*/ caml_call1(f, 0),
-            _ap_];
-    /*<<seq.ml:260:23>>*/ }
-   function cycle_nonempty(xs, param){
-     /*<<seq.ml:267:2>>*/  /*<<seq.ml:267:2>>*/ var _an_ = 0;
-     /*<<seq.ml:267:2>>*/ return append
-            (xs,
-             function(_ao_){ /*<<?>>*/ return cycle_nonempty(xs, _ao_);},
-             _an_);
-    /*<<seq.ml:267:34>>*/ }
-   function cycle(xs, param){
-     /*<<seq.ml:275:2>>*/  /*<<seq.ml:275:8>>*/ var
-     match =  /*<<seq.ml:275:8>>*/ caml_call1(xs, 0);
-    if(! match)  /*<<seq.ml:277:6>>*/ return 0;
-    var xs$0 = match[2], x = match[1];
-     /*<<seq.ml:279:26>>*/ function _ak_(_am_){
-      /*<<?>>*/ return cycle_nonempty(xs, _am_);
-    }
-     /*<<seq.ml:279:6>>*/ return [0,
-            x,
-            function(_al_){ /*<<?>>*/ return append(xs$0, _ak_, _al_);}];
-    /*<<seq.ml:279:46>>*/ }
-   function iterate1(f, x, param){
-     /*<<seq.ml:286:2>>*/  /*<<seq.ml:286:10>>*/ var
-     y =  /*<<seq.ml:286:10>>*/ caml_call1(f, x);
-     /*<<seq.ml:287:2>>*/ return [0,
-            y,
-            function(_aj_){ /*<<?>>*/ return iterate1(f, y, _aj_);}];
-    /*<<seq.ml:287:24>>*/ }
-   function iterate(f, x){
-     /*<<seq.ml:299:9>>*/ function _ag_(_ai_){
-      /*<<?>>*/ return iterate1(f, x, _ai_);
-    }
-     /*<<seq.ml:299:9>>*/ return function(_ah_){
-      /*<<?>>*/ return [0, x, _ag_];};
-    /*<<seq.ml:299:23>>*/ }
-   function mapi_aux(f, i, xs, param){
-     /*<<seq.ml:304:2>>*/  /*<<seq.ml:304:8>>*/ var
-     match =  /*<<seq.ml:304:8>>*/ caml_call1(xs, 0);
-    if(! match)  /*<<seq.ml:306:6>>*/ return 0;
-     /*<<seq.ml:308:6>>*/ var
-     xs$0 = match[2],
-     x = match[1],
-      /*<<seq.ml:308:6>>*/ _ad_ = i + 1 | 0;
-     /*<<seq.ml:308:19>>*/ function _ae_(_af_){
-      /*<<?>>*/ return mapi_aux(f, _ad_, xs$0, _af_);
-    }
-     /*<<seq.ml:308:6>>*/ return [0,
-             /*<<seq.ml:308:12>>*/ caml_call2(f, i, x),
-            _ae_];
-    /*<<seq.ml:308:39>>*/ }
-   function mapi(f, xs){
-     /*<<seq.ml:311:2>>*/ var _ab_ = 0;
-     /*<<seq.ml:311:2>>*/ return function(_ac_){
-      /*<<?>>*/ return mapi_aux(f, _ab_, xs, _ac_);};
-    /*<<seq.ml:311:17>>*/ }
-   function tail_scan(f, s, xs, param){
-     /*<<seq.ml:320:2>>*/  /*<<seq.ml:320:8>>*/ var
-     match =  /*<<seq.ml:320:8>>*/ caml_call1(xs, 0);
-    if(! match)  /*<<seq.ml:322:6>>*/ return 0;
-     /*<<seq.ml:324:14>>*/ var
-     xs$0 = match[2],
-     x = match[1],
-      /*<<seq.ml:324:14>>*/ s$0 =  /*<<seq.ml:324:14>>*/ caml_call2(f, s, x);
-     /*<<seq.ml:325:6>>*/ return [0,
-            s$0,
-            function(_aa_){ /*<<?>>*/ return tail_scan(f, s$0, xs$0, _aa_);}];
-    /*<<seq.ml:325:32>>*/ }
-   function scan(f, s, xs){
-     /*<<seq.ml:328:9>>*/ function _Z_(_$_){
-      /*<<?>>*/ return tail_scan(f, s, xs, _$_);
-    }
-     /*<<seq.ml:328:9>>*/ return function(___){
-      /*<<?>>*/ return [0, s, _Z_];};
-    /*<<seq.ml:328:27>>*/ }
-   function take_aux(n, xs){
-     /*<<seq.ml:334:2>>*/ return 0 === n
-            ? empty
-            : function
-             (param){
-               /*<<seq.ml:338:6>>*/  /*<<seq.ml:338:12>>*/ var
-               match =  /*<<seq.ml:338:12>>*/ caml_call1(xs, 0);
-              if(! match)  /*<<seq.ml:340:10>>*/ return 0;
-              var xs$0 = match[2], x = match[1];
-               /*<<seq.ml:342:10>>*/ return [0, x, take_aux(n - 1 | 0, xs$0)];
-              /*<<seq.ml:342:37>>*/ };
-    /*<<seq.ml:342:37>>*/ }
-   function take(n, xs){
-     /*<<seq.ml:345:2>>*/ if(n < 0)
-      /*<<seq.ml:345:16>>*/  /*<<seq.ml:345:16>>*/ caml_call1
-      (Stdlib[1], cst_Seq_take);
-     /*<<seq.ml:345:16>>*/ return take_aux(n, xs);
-    /*<<seq.ml:346:15>>*/ }
-   function drop(n, xs){
-     /*<<seq.ml:367:2>>*/ return 0 <= n
-            ? 0
-              === n
-              ? xs
-              : function
-               (param){
-                 /*<<seq.ml:372:6>>*/ var n$0 = n, xs$0 = xs;
-                 /*<<seq.ml:353:2>>*/ for(;;){
-                  /*<<seq.ml:353:8>>*/  /*<<seq.ml:353:8>>*/ var
-                  match =  /*<<seq.ml:353:8>>*/ caml_call1(xs$0, 0);
-                 if(! match)  /*<<seq.ml:355:6>>*/ return 0;
-                  /*<<seq.ml:357:6>>*/ var
-                  xs$1 = match[2],
-                   /*<<seq.ml:357:6>>*/ n$1 = n$0 - 1 | 0;
-                  /*<<seq.ml:358:6>>*/ if(0 === n$1)
-                   /*<<seq.ml:359:8>>*/ return  /*<<seq.ml:359:8>>*/ caml_call1
-                          (xs$1, 0);
-                 var n$0 = n$1, xs$0 = xs$1;
-                }
-                /*<<seq.ml:372:21>>*/ }
-            :  /*<<seq.ml:367:16>>*/ caml_call1(Stdlib[1], cst_Seq_drop);
-    /*<<seq.ml:372:21>>*/ }
-   function take_while(p, xs, param){
-     /*<<seq.ml:375:2>>*/  /*<<seq.ml:375:8>>*/ var
-     match =  /*<<seq.ml:375:8>>*/ caml_call1(xs, 0);
-    if(! match)  /*<<seq.ml:377:6>>*/ return 0;
-    var xs$0 = match[2], x = match[1];
-     /*<<seq.ml:379:9>>*/ return  /*<<seq.ml:379:9>>*/ caml_call1(p, x)
-            ? [0,
-              x,
-              function(_Y_){ /*<<?>>*/ return take_while(p, xs$0, _Y_);}]
-            : 0;
-    /*<<seq.ml:379:52>>*/ }
-   function drop_while(p, xs, param){
-     /*<<seq.ml:382:2>>*/ var xs$0 = xs;
-     /*<<seq.ml:382:2>>*/ for(;;){
-      /*<<seq.ml:382:8>>*/  /*<<seq.ml:382:8>>*/ var
-      node =  /*<<seq.ml:382:8>>*/ caml_call1(xs$0, 0);
-     if(! node)  /*<<seq.ml:384:6>>*/ return 0;
-     var xs$1 = node[2], x = node[1];
-      /*<<seq.ml:386:9>>*/ if(!  /*<<seq.ml:386:9>>*/ caml_call1(p, x))
-       /*<<seq.ml:386:42>>*/ return node;
-     var xs$0 = xs$1;
-    }
-    /*<<seq.ml:386:46>>*/ }
-   function group(eq, xs, param){
-     /*<<seq.ml:389:2>>*/  /*<<seq.ml:389:8>>*/ var
-     match =  /*<<seq.ml:389:8>>*/ caml_call1(xs, 0);
-    if(! match)  /*<<seq.ml:391:6>>*/ return 0;
-     /*<<seq.ml:393:64>>*/ var
-     xs$0 = match[2],
-     x = match[1],
-      /*<<seq.ml:393:64>>*/ _P_ =  /*<<seq.ml:393:64>>*/ caml_call1(eq, x);
-     /*<<seq.ml:393:52>>*/ function _Q_(_X_){
-      /*<<?>>*/ return drop_while(_P_, xs$0, _X_);
-    }
-     /*<<seq.ml:393:43>>*/ function _R_(_W_){
-      /*<<?>>*/ return group(eq, _Q_, _W_);
-    }
-     /*<<seq.ml:393:31>>*/  /*<<seq.ml:393:31>>*/ var
-     _S_ =  /*<<seq.ml:393:31>>*/ caml_call1(eq, x);
-     /*<<seq.ml:393:19>>*/ function _T_(_V_){
-      /*<<?>>*/ return take_while(_S_, xs$0, _V_);
-    }
-     /*<<seq.ml:393:6>>*/ return [0,
-            function(_U_){ /*<<?>>*/ return [0, x, _T_];},
-            _R_];
-    /*<<seq.ml:393:75>>*/ }
-    /*<<seq.ml:395:0>>*/ var
-     /*<<seq.ml:395:0>>*/ Forced_twice =
-      [248, cst_Stdlib_Seq_Forced_twice, runtime.caml_fresh_oo_id(0)],
-     /*<<seq.ml:395:0>>*/ to_lazy = Stdlib_Lazy[6];
-   function failure(param){
-     /*<<seq.ml:421:6>>*/ throw  /*<<seq.ml:421:6>>*/ caml_maybe_attach_backtrace
-           (Forced_twice, 1);
-    /*<<seq.ml:421:24>>*/ }
-   function memoize(xs){
-    function s$0(param){
-      /*<<seq.ml:440:4>>*/  /*<<seq.ml:440:10>>*/ var
-      match =  /*<<seq.ml:440:10>>*/ caml_call1(xs, 0);
-     if(! match)  /*<<seq.ml:442:8>>*/ return 0;
-     var xs$0 = match[2], x = match[1];
-      /*<<seq.ml:444:8>>*/ return [0, x, memoize(xs$0)];
-     /*<<seq.ml:444:28>>*/ }
-     /*<<seq.ml:414:14>>*/  /*<<seq.ml:414:14>>*/ var
-     s =  /*<<seq.ml:414:14>>*/ caml_call1(to_lazy, s$0);
-     /*<<seq.ml:414:14>>*/ return function(_O_){
-     var _N_ = runtime.caml_obj_tag(s);
-     if(250 === _N_) return s[1];
-     if(246 !== _N_ && 244 !== _N_)  /*<<seq.ml:409:14>>*/ return s;
-      /*<<seq.ml:409:14>>*/ return  /*<<seq.ml:409:14>>*/ caml_call1
-             (CamlinternalLazy[2], s);};
-    /*<<seq.ml:445:3>>*/ }
-   function once(xs){
-    function f(param){
-      /*<<seq.ml:449:4>>*/  /*<<seq.ml:449:10>>*/ var
-      match =  /*<<seq.ml:449:10>>*/ caml_call1(xs, 0);
-     if(! match)  /*<<seq.ml:451:8>>*/ return 0;
-     var xs$0 = match[2], x = match[1];
-      /*<<seq.ml:453:8>>*/ return [0, x, once(xs$0)];
-     /*<<seq.ml:453:25>>*/ }
-     /*<<seq.ml:428:17>>*/  /*<<seq.ml:428:17>>*/ var
-     action =  /*<<seq.ml:428:17>>*/ caml_call1(Stdlib_Atomic[1], f);
-     /*<<seq.ml:429:4>>*/ return function(param){
-      /*<<seq.ml:433:6>>*/  /*<<seq.ml:433:14>>*/ var
-      f =  /*<<seq.ml:433:14>>*/ caml_call2(Stdlib_Atomic[4], action, failure);
-      /*<<seq.ml:434:6>>*/ return  /*<<seq.ml:434:6>>*/ caml_call1(f, 0); /*<<seq.ml:434:9>>*/ };
-    /*<<seq.ml:454:3>>*/ }
-   function zip(xs, ys, param){
-     /*<<seq.ml:458:2>>*/  /*<<seq.ml:458:8>>*/ var
-     match =  /*<<seq.ml:458:8>>*/ caml_call1(xs, 0);
-    if(! match)  /*<<seq.ml:460:6>>*/ return 0;
-     /*<<seq.ml:462:12>>*/ var
-     xs$0 = match[2],
-     x = match[1],
-      /*<<seq.ml:462:12>>*/ match$0 =  /*<<seq.ml:462:12>>*/ caml_call1(ys, 0);
-    if(! match$0)  /*<<seq.ml:464:10>>*/ return 0;
-    var ys$0 = match$0[2], y = match$0[1];
-     /*<<seq.ml:466:10>>*/ return [0,
-            [0, x, y],
-            function(_M_){ /*<<?>>*/ return zip(xs$0, ys$0, _M_);}];
-    /*<<seq.ml:466:34>>*/ }
-   function map2(f, xs, ys, param){
-     /*<<seq.ml:469:2>>*/  /*<<seq.ml:469:8>>*/ var
-     match =  /*<<seq.ml:469:8>>*/ caml_call1(xs, 0);
-    if(! match)  /*<<seq.ml:471:6>>*/ return 0;
-     /*<<seq.ml:473:12>>*/ var
-     xs$0 = match[2],
-     x = match[1],
-      /*<<seq.ml:473:12>>*/ match$0 =  /*<<seq.ml:473:12>>*/ caml_call1(ys, 0);
-    if(! match$0)  /*<<seq.ml:475:10>>*/ return 0;
-    var ys$0 = match$0[2], y = match$0[1];
-     /*<<seq.ml:477:23>>*/ function _K_(_L_){
-      /*<<?>>*/ return map2(f, xs$0, ys$0, _L_);
-    }
-     /*<<seq.ml:477:10>>*/ return [0,
-             /*<<seq.ml:477:16>>*/ caml_call2(f, x, y),
-            _K_];
-    /*<<seq.ml:477:36>>*/ }
-   function interleave(xs, ys, param){
-     /*<<seq.ml:480:2>>*/  /*<<seq.ml:480:8>>*/ var
-     match =  /*<<seq.ml:480:8>>*/ caml_call1(xs, 0);
-    if(! match)
-      /*<<seq.ml:482:6>>*/ return  /*<<seq.ml:482:6>>*/ caml_call1(ys, 0);
-    var xs$0 = match[2], x = match[1];
-     /*<<seq.ml:484:6>>*/ return [0,
-            x,
-            function(_J_){ /*<<?>>*/ return interleave(ys, xs$0, _J_);}];
-    /*<<seq.ml:484:32>>*/ }
-   function sorted_merge1(cmp, x, xs, y, ys){
-     /*<<seq.ml:513:2>>*/ return 0
-            <  /*<<seq.ml:513:5>>*/ caml_call2(cmp, x, y)
-            ? [0,
-              y,
-              function(_H_){
-                /*<<seq.ml:499:8>>*/  /*<<seq.ml:499:8>>*/ var
-                match =  /*<<seq.ml:499:8>>*/ caml_call1(ys, 0);
-               if(! match)  /*<<seq.ml:501:6>>*/ return [0, x, xs];
-               var ys$0 = match[2], y = match[1];
-                /*<<seq.ml:503:6>>*/ return sorted_merge1(cmp, x, xs, y, ys$0);
-              }]
-            : [0,
-              x,
-              function(_I_){
-                /*<<seq.ml:506:8>>*/  /*<<seq.ml:506:8>>*/ var
-                match =  /*<<seq.ml:506:8>>*/ caml_call1(xs, 0);
-               if(! match)  /*<<seq.ml:508:6>>*/ return [0, y, ys];
-               var xs$0 = match[2], x = match[1];
-                /*<<seq.ml:510:6>>*/ return sorted_merge1(cmp, x, xs$0, y, ys);
-              }];
-    /*<<seq.ml:516:40>>*/ }
-   function sorted_merge(cmp, xs, ys, param){
-     /*<<seq.ml:519:2>>*/ var
-      /*<<seq.ml:519:8>>*/ match =  /*<<seq.ml:519:8>>*/ caml_call1(xs, 0),
-      /*<<seq.ml:519:14>>*/ match$0 =  /*<<seq.ml:519:14>>*/ caml_call1(ys, 0);
-    if(match){
-     if(match$0){
-      var ys$0 = match$0[2], y = match$0[1], xs$0 = match[2], x = match[1];
-       /*<<seq.ml:526:8>>*/ return sorted_merge1(cmp, x, xs$0, y, ys$0);
-     }
-     var c = match;
-    }
-    else{if(! match$0)  /*<<seq.ml:521:8>>*/ return 0; var c = match$0;}
-     /*<<seq.ml:524:8>>*/ return c;
-    /*<<seq.ml:526:35>>*/ }
-   function map_fst(xys, param){
-     /*<<seq.ml:530:2>>*/  /*<<seq.ml:530:8>>*/ var
-     match =  /*<<seq.ml:530:8>>*/ caml_call1(xys, 0);
-    if(! match)  /*<<seq.ml:532:6>>*/ return 0;
-    var xys$0 = match[2], x = match[1][1];
-     /*<<seq.ml:534:6>>*/ return [0,
-            x,
-            function(_G_){ /*<<?>>*/ return map_fst(xys$0, _G_);}];
-    /*<<seq.ml:534:27>>*/ }
-   function map_snd(xys, param){
-     /*<<seq.ml:537:2>>*/  /*<<seq.ml:537:8>>*/ var
-     match =  /*<<seq.ml:537:8>>*/ caml_call1(xys, 0);
-    if(! match)  /*<<seq.ml:539:6>>*/ return 0;
-    var xys$0 = match[2], y = match[1][2];
-     /*<<seq.ml:541:6>>*/ return [0,
-            y,
-            function(_F_){ /*<<?>>*/ return map_snd(xys$0, _F_);}];
-    /*<<seq.ml:541:27>>*/ }
-   function unzip(xys){
-     /*<<seq.ml:544:15>>*/ function _C_(_E_){
-      /*<<?>>*/ return map_snd(xys, _E_);
-    }
-     /*<<seq.ml:544:2>>*/ return [0,
-            function(_D_){ /*<<?>>*/ return map_fst(xys, _D_);},
-            _C_];
-    /*<<seq.ml:544:26>>*/ }
-   function filter_map_find_left_map(f, xs, param){
-     /*<<seq.ml:553:2>>*/ var xs$0 = xs;
-     /*<<seq.ml:553:2>>*/ for(;;){
-      /*<<seq.ml:553:8>>*/  /*<<seq.ml:553:8>>*/ var
-      match =  /*<<seq.ml:553:8>>*/ caml_call1(xs$0, 0);
-     if(! match)  /*<<seq.ml:555:6>>*/ return 0;
-      /*<<seq.ml:557:12>>*/ var
-      xs$1 = match[2],
-      x = match[1],
-       /*<<seq.ml:557:12>>*/ match$0 =  /*<<seq.ml:557:12>>*/ caml_call1(f, x);
-     if(0 === match$0[0]){
-      var y = match$0[1];
-       /*<<seq.ml:559:10>>*/ return [0,
-              y,
-              function(_B_){
-                /*<<?>>*/ return filter_map_find_left_map(f, xs$1, _B_);
-              }];
-     }
-     var xs$0 = xs$1;
-    }
-    /*<<seq.ml:561:42>>*/ }
-   function filter_map_find_right_map(f, xs, param){
-     /*<<seq.ml:564:2>>*/ var xs$0 = xs;
-     /*<<seq.ml:564:2>>*/ for(;;){
-      /*<<seq.ml:564:8>>*/  /*<<seq.ml:564:8>>*/ var
-      match =  /*<<seq.ml:564:8>>*/ caml_call1(xs$0, 0);
-     if(! match)  /*<<seq.ml:566:6>>*/ return 0;
-      /*<<seq.ml:568:12>>*/ var
-      xs$1 = match[2],
-      x = match[1],
-       /*<<seq.ml:568:12>>*/ match$0 =  /*<<seq.ml:568:12>>*/ caml_call1(f, x);
-     if(0 !== match$0[0]){
-      var z = match$0[1];
-       /*<<seq.ml:572:10>>*/ return [0,
-              z,
-              function(_A_){
-                /*<<?>>*/ return filter_map_find_right_map(f, xs$1, _A_);
-              }];
-     }
-     var xs$0 = xs$1;
-    }
-    /*<<seq.ml:572:50>>*/ }
-   function partition_map(f, xs){
-     /*<<seq.ml:576:2>>*/ function _x_(_z_){
-      /*<<?>>*/ return filter_map_find_right_map(f, xs, _z_);
-    }
-     /*<<seq.ml:575:2>>*/ return [0,
-            function(_y_){
-              /*<<?>>*/ return filter_map_find_left_map(f, xs, _y_);
-            },
-            _x_];
-    /*<<seq.ml:576:32>>*/ }
-   function partition(p, xs){
-    function _t_(x){
-      /*<<seq.ml:579:32>>*/ return 1 -  /*<<seq.ml:579:36>>*/ caml_call1(p, x);
-     /*<<seq.ml:579:41>>*/ }
-     /*<<seq.ml:579:15>>*/ function _u_(_w_){
-      /*<<?>>*/ return filter(_t_, xs, _w_);
-    }
-     /*<<seq.ml:579:2>>*/ return [0,
-            function(_v_){ /*<<?>>*/ return filter(p, xs, _v_);},
-            _u_];
-    /*<<seq.ml:579:45>>*/ }
-   function peel(xss){
-     /*<<seq.ml:591:2>>*/ return unzip
-            (function(_s_){ /*<<?>>*/ return filter_map(uncons, xss, _s_);});
-    /*<<seq.ml:591:31>>*/ }
-   function transpose(xss, param){
-     /*<<seq.ml:594:2>>*/ var
-      /*<<seq.ml:594:21>>*/ match = peel(xss),
-     tails = match[2],
-     heads = match[1];
-     /*<<seq.ml:595:5>>*/ if(! is_empty(heads))
-      /*<<seq.ml:600:4>>*/ return [0,
-             heads,
-             function(_r_){ /*<<?>>*/ return transpose(tails, _r_);}];
-     /*<<seq.ml:596:11>>*/ if(is_empty(tails))  /*<<seq.ml:597:4>>*/ return 0;
-     /*<<seq.ml:596:4>>*/ throw  /*<<seq.ml:596:4>>*/ caml_maybe_attach_backtrace
-           ([0, Assert_failure, _a_], 1);
-    /*<<seq.ml:600:33>>*/ }
-   function _b_(remainders, xss, param){
-     /*<<seq.ml:607:2>>*/  /*<<seq.ml:607:8>>*/ var
-     match =  /*<<seq.ml:607:8>>*/ caml_call1(xss, 0);
-    if(! match)  /*<<seq.ml:629:6>>*/ return transpose(remainders, 0);
-     /*<<seq.ml:609:18>>*/ var
-     xss$0 = match[2],
-     xs = match[1],
-      /*<<seq.ml:609:18>>*/ match$0 =  /*<<seq.ml:609:18>>*/ caml_call1(xs, 0);
-    if(match$0){
-      /*<<seq.ml:617:29>>*/ var
-      xs$0 = match$0[2],
-      x = match$0[1],
-       /*<<seq.ml:617:29>>*/ match$1 = peel(remainders),
-      tails = match$1[2],
-      heads = match$1[1],
-       /*<<seq.ml:618:40>>*/ _l_ =
-        function(_q_){ /*<<?>>*/ return [0, xs$0, tails];},
-       /*<<seq.ml:618:30>>*/ _m_ =
-        function(_p_){ /*<<?>>*/ return _b_(_l_, xss$0, _p_);};
-      /*<<seq.ml:618:10>>*/ return [0,
-             function(_o_){ /*<<?>>*/ return [0, x, heads];},
-             _m_];
-    }
-     /*<<seq.ml:623:29>>*/ var
-      /*<<seq.ml:623:29>>*/ match$2 = peel(remainders),
-     tails$0 = match$2[2],
-     heads$0 = match$2[1];
-     /*<<seq.ml:624:10>>*/ return [0,
-            heads$0,
-            function(_n_){ /*<<?>>*/ return _b_(tails$0, xss$0, _n_);}];
-    /*<<seq.ml:629:29>>*/ }
-   function map_product(f, xs, ys){
-    function _f_(x){
-     function _j_(y){
-       /*<<seq.ml:651:8>>*/ return  /*<<seq.ml:651:8>>*/ caml_call2(f, x, y);
-      /*<<seq.ml:651:13>>*/ }
-      /*<<seq.ml:650:10>>*/ return function(_k_){
-       /*<<?>>*/ return map(_j_, ys, _k_);};
-     /*<<seq.ml:652:10>>*/ }
-     /*<<seq.ml:648:20>>*/ function xss(_i_){
-      /*<<?>>*/ return map(_f_, xs, _i_);
-    }
-     /*<<seq.ml:645:2>>*/ function _e_(_h_){
-      /*<<?>>*/ return _b_(empty, xss, _h_);
-    }
-     /*<<seq.ml:648:9>>*/ return function(_g_){
-      /*<<?>>*/ return concat(_e_, _g_);};
-    /*<<seq.ml:654:4>>*/ }
-   function product(xs, ys){
-     /*<<seq.ml:657:2>>*/ return map_product
-            (function(x, y){
-               /*<<seq.ml:657:26>>*/ return [0, x, y];
-              /*<<seq.ml:657:32>>*/ },
-             xs,
-             ys);
-    /*<<seq.ml:657:39>>*/ }
-   function of_dispenser(it){
-    function c(param){
-      /*<<seq.ml:661:4>>*/  /*<<seq.ml:661:10>>*/ var
-      match =  /*<<seq.ml:661:10>>*/ caml_call1(it, 0);
-     if(! match)  /*<<seq.ml:663:8>>*/ return 0;
-     var x = match[1];
-      /*<<seq.ml:665:8>>*/ return [0, x, c];
-     /*<<seq.ml:665:19>>*/ }
-     /*<<seq.ml:667:2>>*/ return c;
-    /*<<seq.ml:667:3>>*/ }
-   function to_dispenser(xs){
-     /*<<seq.ml:670:2>>*/  /*<<seq.ml:670:10>>*/ var s = [0, xs];
-     /*<<seq.ml:671:2>>*/ return function(param){
-      /*<<seq.ml:672:4>>*/  /*<<seq.ml:672:10>>*/ var
-      match =  /*<<seq.ml:672:10>>*/ caml_call1(s[1], 0);
-     if(! match)  /*<<seq.ml:674:8>>*/ return 0;
-     var xs = match[2], x = match[1];
-     s[1] = xs;
-      /*<<seq.ml:677:8>>*/ return [0, x]; /*<<seq.ml:677:14>>*/ };
-    /*<<seq.ml:677:14>>*/ }
-   function ints(i, param){
-     /*<<seq.ml:682:2>>*/  /*<<seq.ml:682:2>>*/ var _c_ = i + 1 | 0;
-     /*<<seq.ml:682:2>>*/ return [0,
-            i,
-            function(_d_){ /*<<?>>*/ return ints(_c_, _d_);}];
-    /*<<seq.ml:682:24>>*/ }
-   var
-    Stdlib_Seq =
-      [0,
-       is_empty,
-       uncons,
-       length,
-       iter,
-       fold_left,
-       iteri,
-       fold_lefti,
-       for_all,
-       exists,
-       find,
-       find_map,
-       iter2,
-       fold_left2,
-       for_all2,
-       exists2,
-       equal,
-       compare,
-       empty,
-       return$0,
-       cons,
-       init,
-       unfold,
-       repeat,
-       forever,
-       cycle,
-       iterate,
-       map,
-       mapi,
-       filter,
-       filter_map,
-       scan,
-       take,
-       drop,
-       take_while,
-       drop_while,
-       group,
-       memoize,
-       Forced_twice,
-       once,
-       transpose,
-       append,
-       concat,
-       flat_map,
-       flat_map,
-       zip,
-       map2,
-       interleave,
-       sorted_merge,
-       product,
-       map_product,
-       unzip,
-       unzip,
-       partition_map,
-       partition,
-       of_dispenser,
-       to_dispenser,
-       ints];
-   runtime.caml_register_global(10, Stdlib_Seq, "Stdlib__Seq");
-   return;
-   /*<<?>>*/ }
-  (globalThis));
-
-//# unitInfo: Provides: Stdlib__Option
-//# unitInfo: Requires: Stdlib, Stdlib__Seq
-(function
-  (globalThis){
-   "use strict";
-   var runtime = globalThis.jsoo_runtime;
-    /*<<?>>*/ function caml_call1(f, a0){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 1
-            ? f(a0)
-            : runtime.caml_call_gen(f, [a0]);
-   }
-    /*<<?>>*/ function caml_call2(f, a0, a1){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 2
-            ? f(a0, a1)
-            : runtime.caml_call_gen(f, [a0, a1]);
-   }
-   var
-    global_data = runtime.caml_get_global_data(),
-    Stdlib_Seq = global_data.Stdlib__Seq,
-    Stdlib = global_data.Stdlib,
-    cst_option_is_None = "option is None",
-    none = 0;
-   function some(v){
-     /*<<option.ml:19:13>>*/ return [0, v];
-    /*<<option.ml:19:19>>*/ }
-   function value(o, default$0){
-     /*<<option.ml:20:23>>*/ if(! o)
-      /*<<option.ml:20:58>>*/ return default$0;
-    var v = o[1];
-     /*<<option.ml:20:46>>*/ return v;
-    /*<<option.ml:20:65>>*/ }
-   function get(param){
-     /*<<option.ml:21:10>>*/ if(! param)
-      /*<<option.ml:21:41>>*/ return  /*<<option.ml:21:41>>*/ caml_call1
-             (Stdlib[1], cst_option_is_None);
-    var v = param[1];
-     /*<<option.ml:21:29>>*/ return v;
-    /*<<option.ml:21:69>>*/ }
-   function bind(o, f){
-     /*<<option.ml:22:15>>*/ if(! o)  /*<<option.ml:22:36>>*/ return 0;
-    var v = o[1];
-     /*<<option.ml:22:53>>*/ return  /*<<option.ml:22:53>>*/ caml_call1(f, v);
-    /*<<option.ml:22:56>>*/ }
-   function join(param){
-     /*<<option.ml:23:11>>*/ if(! param)  /*<<option.ml:23:42>>*/ return 0;
-    var o = param[1];
-     /*<<option.ml:23:30>>*/ return o;
-    /*<<option.ml:23:46>>*/ }
-   function map(f, o){
-     /*<<option.ml:24:14>>*/ if(! o)  /*<<option.ml:24:35>>*/ return 0;
-    var v = o[1];
-     /*<<option.ml:24:52>>*/ return [0,
-             /*<<option.ml:24:57>>*/ caml_call1(f, v)];
-    /*<<option.ml:24:62>>*/ }
-   function fold(none, some, param){
-     /*<<?>>*/ if(! param)  /*<<option.ml:25:59>>*/ return none;
-    var v = param[1];
-     /*<<option.ml:25:42>>*/ return  /*<<option.ml:25:42>>*/ caml_call1
-            (some, v);
-   }
-   function iter(f, param){
-     /*<<?>>*/ if(! param)  /*<<option.ml:26:46>>*/ return 0;
-    var v = param[1];
-     /*<<option.ml:26:32>>*/ return  /*<<option.ml:26:32>>*/ caml_call1(f, v);
-   }
-   function is_none(param){
-     /*<<option.ml:27:14>>*/ return param ? 0 : 1;
-    /*<<option.ml:27:53>>*/ }
-   function is_some(param){
-     /*<<option.ml:28:14>>*/ return param ? 1 : 0;
-    /*<<option.ml:28:53>>*/ }
-   function equal(eq, o0, o1){
-     /*<<option.ml:30:21>>*/ if(o0){
-     if(o1){
-      var v1 = o1[1], v0 = o0[1];
-       /*<<option.ml:31:22>>*/ return  /*<<option.ml:31:22>>*/ caml_call2
-              (eq, v0, v1);
-     }
-    }
-    else if(! o1)  /*<<option.ml:32:16>>*/ return 1;
-     /*<<option.ml:33:7>>*/ return 0;
-    /*<<option.ml:33:12>>*/ }
-   function compare(cmp, o0, o1){
-     /*<<option.ml:35:24>>*/ if(! o0) return o1 ? -1 : 0;
-    var v0 = o0[1];
-    if(! o1)  /*<<option.ml:39:18>>*/ return 1;
-    var v1 = o1[1];
-     /*<<option.ml:36:22>>*/ return  /*<<option.ml:36:22>>*/ caml_call2
-            (cmp, v0, v1);
-    /*<<option.ml:39:19>>*/ }
-   function to_result(none, param){
-     /*<<?>>*/ if(! param)  /*<<option.ml:41:39>>*/ return [1, none];
-    var v = param[1];
-     /*<<option.ml:41:62>>*/ return [0, v];
-   }
-   function to_list(param){
-     /*<<option.ml:42:14>>*/ if(! param)  /*<<option.ml:42:31>>*/ return 0;
-    var v = param[1];
-     /*<<option.ml:42:46>>*/ return [0, v, 0];
-    /*<<option.ml:42:49>>*/ }
-   function to_seq(param){
-     /*<<option.ml:43:13>>*/ if(! param)
-      /*<<option.ml:43:30>>*/ return Stdlib_Seq[18];
-    var v = param[1];
-     /*<<option.ml:43:52>>*/ return  /*<<option.ml:43:52>>*/ caml_call1
-            (Stdlib_Seq[19], v);
-    /*<<option.ml:43:64>>*/ }
-   var
-    Stdlib_Option =
-      [0,
-       none,
-       some,
-       value,
-       get,
-       bind,
-       join,
-       map,
-       fold,
-       iter,
-       is_none,
-       is_some,
-       equal,
-       compare,
-       to_result,
-       to_list,
-       to_seq];
-   runtime.caml_register_global(3, Stdlib_Option, "Stdlib__Option");
-   return;
-   /*<<?>>*/ }
-  (globalThis));
-
-//# unitInfo: Provides: Stdlib__Result
-//# unitInfo: Requires: Stdlib, Stdlib__Seq
-(function
-  (globalThis){
-   "use strict";
-   var runtime = globalThis.jsoo_runtime;
-    /*<<?>>*/ function caml_call1(f, a0){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 1
-            ? f(a0)
-            : runtime.caml_call_gen(f, [a0]);
-   }
-    /*<<?>>*/ function caml_call2(f, a0, a1){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 2
-            ? f(a0, a1)
-            : runtime.caml_call_gen(f, [a0, a1]);
-   }
-   var
-    global_data = runtime.caml_get_global_data(),
-    Stdlib_Seq = global_data.Stdlib__Seq,
-    Stdlib = global_data.Stdlib,
-    cst_result_is_Ok = "result is Ok _",
-    cst_result_is_Error = "result is Error _";
-   function ok(v){
-     /*<<result.ml:18:11>>*/ return [0, v];
-    /*<<result.ml:18:15>>*/ }
-   function error(e){
-     /*<<result.ml:19:14>>*/ return [1, e];
-    /*<<result.ml:19:21>>*/ }
-   function value(r, default$0){
-     /*<<result.ml:20:23>>*/ if(0 !== r[0])
-      /*<<result.ml:20:59>>*/ return default$0;
-    var v = r[1];
-     /*<<result.ml:20:44>>*/ return v;
-    /*<<result.ml:20:66>>*/ }
-   function get_ok(param){
-     /*<<result.ml:21:13>>*/ if(0 !== param[0])
-      /*<<result.ml:21:45>>*/ return  /*<<result.ml:21:45>>*/ caml_call1
-             (Stdlib[1], cst_result_is_Error);
-    var v = param[1];
-     /*<<result.ml:21:30>>*/ return v;
-    /*<<result.ml:21:76>>*/ }
-   function get_error(param){
-     /*<<result.ml:22:16>>*/ if(0 === param[0])
-      /*<<result.ml:22:48>>*/ return  /*<<result.ml:22:48>>*/ caml_call1
-             (Stdlib[1], cst_result_is_Ok);
-    var e = param[1];
-     /*<<result.ml:22:36>>*/ return e;
-    /*<<result.ml:22:76>>*/ }
-   function bind(r, f){
-     /*<<result.ml:23:15>>*/ if(0 !== r[0])  /*<<result.ml:23:58>>*/ return r;
-    var v = r[1];
-     /*<<result.ml:23:36>>*/ return  /*<<result.ml:23:36>>*/ caml_call1(f, v);
-    /*<<result.ml:23:59>>*/ }
-   function join(e){
-     /*<<result.ml:24:11>>*/ if(0 !== e[0])  /*<<result.ml:24:48>>*/ return e;
-    var r = e[1];
-     /*<<result.ml:24:28>>*/ return r;
-    /*<<result.ml:24:49>>*/ }
-   function map(f, e){
-     /*<<?>>*/ if(0 !== e[0])  /*<<result.ml:25:56>>*/ return e;
-    var v = e[1];
-     /*<<result.ml:25:29>>*/ return [0,
-             /*<<result.ml:25:32>>*/ caml_call1(f, v)];
-   }
-   function map_error(f, v){
-     /*<<?>>*/ if(0 === v[0])  /*<<result.ml:26:65>>*/ return v;
-    var e = v[1];
-     /*<<result.ml:26:38>>*/ return [1,
-             /*<<result.ml:26:44>>*/ caml_call1(f, e)];
-   }
-   function fold(ok, error, param){
-     /*<<?>>*/ if(0 === param[0]){
-     var v = param[1];
-      /*<<result.ml:27:39>>*/ return  /*<<result.ml:27:39>>*/ caml_call1
-             (ok, v);
-    }
-    var e = param[1];
-     /*<<result.ml:27:57>>*/ return  /*<<result.ml:27:57>>*/ caml_call1
-            (error, e);
-   }
-   function iter(f, param){
-     /*<<?>>*/ if(0 !== param[0])  /*<<result.ml:28:47>>*/ return 0;
-    var v = param[1];
-     /*<<result.ml:28:30>>*/ return  /*<<result.ml:28:30>>*/ caml_call1(f, v);
-   }
-   function iter_error(f, param){
-     /*<<?>>*/ if(0 === param[0])  /*<<result.ml:29:53>>*/ return 0;
-    var e = param[1];
-     /*<<result.ml:29:39>>*/ return  /*<<result.ml:29:39>>*/ caml_call1(f, e);
-   }
-   function is_ok(param){
-     /*<<result.ml:30:12>>*/ return 0 === param[0] ? 1 : 0;
-    /*<<result.ml:30:52>>*/ }
-   function is_error(param){
-     /*<<result.ml:31:15>>*/ return 0 === param[0] ? 0 : 1;
-    /*<<result.ml:31:55>>*/ }
-   function equal(ok, error, r0, r1){
-     /*<<result.ml:33:29>>*/ if(0 === r0[0]){
-     var v0 = r0[1];
-     if(0 === r1[0]){
-      var v1 = r1[1];
-       /*<<result.ml:34:18>>*/ return  /*<<result.ml:34:18>>*/ caml_call2
-              (ok, v0, v1);
-     }
-    }
-    else{
-     var e0 = r0[1];
-     if(0 !== r1[0]){
-      var e1 = r1[1];
-       /*<<result.ml:35:24>>*/ return  /*<<result.ml:35:24>>*/ caml_call2
-              (error, e0, e1);
-     }
-    }
-     /*<<result.ml:36:10>>*/ return 0;
-    /*<<result.ml:36:15>>*/ }
-   function compare(ok, error, r0, r1){
-     /*<<result.ml:38:31>>*/ if(0 === r0[0]){
-     var v0 = r0[1];
-     if(0 !== r1[0])  /*<<result.ml:41:19>>*/ return -1;
-     var v1 = r1[1];
-      /*<<result.ml:39:18>>*/ return  /*<<result.ml:39:18>>*/ caml_call2
-             (ok, v0, v1);
-    }
-    var e0 = r0[1];
-    if(0 === r1[0])  /*<<result.ml:42:19>>*/ return 1;
-    var e1 = r1[1];
-     /*<<result.ml:40:24>>*/ return  /*<<result.ml:40:24>>*/ caml_call2
-            (error, e0, e1);
-    /*<<result.ml:42:20>>*/ }
-   function to_option(param){
-     /*<<result.ml:44:16>>*/ if(0 !== param[0])
-      /*<<result.ml:44:53>>*/ return 0;
-    var v = param[1];
-     /*<<result.ml:44:33>>*/ return [0, v];
-    /*<<result.ml:44:57>>*/ }
-   function to_list(param){
-     /*<<result.ml:45:14>>*/ if(0 !== param[0])
-      /*<<result.ml:45:48>>*/ return 0;
-    var v = param[1];
-     /*<<result.ml:45:31>>*/ return [0, v, 0];
-    /*<<result.ml:45:50>>*/ }
-   function to_seq(param){
-     /*<<result.ml:46:13>>*/ if(0 !== param[0])
-      /*<<result.ml:46:56>>*/ return Stdlib_Seq[18];
-    var v = param[1];
-     /*<<result.ml:46:30>>*/ return  /*<<result.ml:46:30>>*/ caml_call1
-            (Stdlib_Seq[19], v);
-    /*<<result.ml:46:65>>*/ }
-   var
-    Stdlib_Result =
-      [0,
-       ok,
-       error,
-       value,
-       get_ok,
-       get_error,
-       bind,
-       join,
-       map,
-       map_error,
-       fold,
-       iter,
-       iter_error,
-       is_ok,
-       is_error,
-       equal,
-       compare,
-       to_option,
-       to_list,
-       to_seq];
-   runtime.caml_register_global(4, Stdlib_Result, "Stdlib__Result");
-   return;
-   /*<<?>>*/ }
-  (globalThis));
-
-//# unitInfo: Provides: Stdlib__Bool
-(function(globalThis){
-   "use strict";
-   var
-    runtime = globalThis.jsoo_runtime,
-    cst_true = "true",
-    cst_false = "false";
-   function equal(_e_, _d_){ /*<<?>>*/ return _e_ === _d_ ? 1 : 0;}
-   var compare = runtime.caml_int_compare;
-   function to_float(param){
-     /*<<bool.ml:24:15>>*/ return param ? 1. : 0.;
-    /*<<bool.ml:24:48>>*/ }
-   function to_string(param){
-     /*<<bool.ml:33:16>>*/ return param ? cst_true : cst_false;
-    /*<<bool.ml:33:58>>*/ }
-   function _a_(_c_){ /*<<?>>*/ return _c_;}
-   var
-    Stdlib_Bool =
-      [0,
-       function(_b_){ /*<<?>>*/ return 1 - _b_;},
-       equal,
-       compare,
-       _a_,
-       to_float,
-       to_string];
-   runtime.caml_register_global(4, Stdlib_Bool, "Stdlib__Bool");
-   return;
-   /*<<?>>*/ }
-  (globalThis));
-
-//# unitInfo: Provides: Stdlib__Char
-//# unitInfo: Requires: Stdlib
-(function
-  (globalThis){
-   "use strict";
-   var
-    runtime = globalThis.jsoo_runtime,
-    caml_bytes_unsafe_set = runtime.caml_bytes_unsafe_set,
-    caml_create_bytes = runtime.caml_create_bytes,
-    caml_string_of_bytes = runtime.caml_string_of_bytes;
-    /*<<?>>*/ function caml_call1(f, a0){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 1
-            ? f(a0)
-            : runtime.caml_call_gen(f, [a0]);
-   }
-   var
-    global_data = runtime.caml_get_global_data(),
-    cst = "\\\\",
-    cst$0 = "\\'",
-    Stdlib = global_data.Stdlib,
-    cst_b = "\\b",
-    cst_t = "\\t",
-    cst_n = "\\n",
-    cst_r = "\\r",
-    cst_Char_chr = "Char.chr";
-   function chr(n){
-     /*<<char.ml:22:2>>*/ if(0 <= n && 255 >= n)
-      /*<<char.ml:22:55>>*/ return n;
-     /*<<char.ml:22:27>>*/ return  /*<<char.ml:22:27>>*/ caml_call1
-            (Stdlib[1], cst_Char_chr);
-    /*<<char.ml:22:67>>*/ }
-   function escaped(c){
-     /*<<char.ml:29:14>>*/ a:
-    {
-     if(40 <= c){
-      if(92 === c)  /*<<char.ml:31:12>>*/ return cst;
-      if(127 > c) break a;
-     }
-     else{
-      if(32 <= c){if(39 <= c)  /*<<char.ml:30:12>>*/ return cst$0; break a;}
-      if(14 > c)
-       switch(c){
-         case 8:
-           /*<<char.ml:35:12>>*/ return cst_b;
-         case 9:
-           /*<<char.ml:33:12>>*/ return cst_t;
-         case 10:
-           /*<<char.ml:32:12>>*/ return cst_n;
-         case 13:
-           /*<<char.ml:34:12>>*/ return cst_r;
-       }
-     }
-      /*<<char.ml:42:14>>*/  /*<<char.ml:42:14>>*/ var
-      s =  /*<<char.ml:42:14>>*/ caml_create_bytes(4);
-     caml_bytes_unsafe_set(s, 0, 92);
-     caml_bytes_unsafe_set(s, 1, 48 + (c / 100 | 0) | 0);
-     caml_bytes_unsafe_set(s, 2, 48 + ((c / 10 | 0) % 10 | 0) | 0);
-     caml_bytes_unsafe_set(s, 3, 48 + (c % 10 | 0) | 0);
-     return caml_string_of_bytes(s);
-    }
-     /*<<char.ml:37:14>>*/  /*<<char.ml:37:14>>*/ var
-     s$0 =  /*<<char.ml:37:14>>*/ caml_create_bytes(1);
-    caml_bytes_unsafe_set(s$0, 0, c);
-    return caml_string_of_bytes(s$0);
-    /*<<char.ml:47:24>>*/ }
-   function lowercase_ascii(c){
-     /*<<char.ml:49:22>>*/ return 25 < c - 65 >>> 0 ? c : c + 32 | 0;
-    /*<<char.ml:51:10>>*/ }
-   function uppercase_ascii(c){
-     /*<<char.ml:53:22>>*/ return 25 < c - 97 >>> 0 ? c : c - 32 | 0;
-    /*<<char.ml:55:10>>*/ }
-   function compare(c1, c2){
-     /*<<char.ml:59:20>>*/ return c1 - c2 | 0;
-    /*<<char.ml:59:37>>*/ }
-   function equal(c1, c2){
-     /*<<char.ml:60:28>>*/ return 0 === (c1 - c2 | 0) ? 1 : 0;
-    /*<<char.ml:60:45>>*/ }
-   var
-    Stdlib_Char =
-      [0, chr, escaped, lowercase_ascii, uppercase_ascii, compare, equal];
-   runtime.caml_register_global(8, Stdlib_Char, "Stdlib__Char");
-   return;
-   /*<<?>>*/ }
-  (globalThis));
-
-//# unitInfo: Provides: Stdlib__Uchar
-//# unitInfo: Requires: Assert_failure, Stdlib
-(function
-  (globalThis){
-   "use strict";
-   var
-    runtime = globalThis.jsoo_runtime,
-    cst_uchar_ml = "uchar.ml",
-    caml_format_int = runtime.caml_format_int,
-    caml_maybe_attach_backtrace = runtime.caml_maybe_attach_backtrace;
-    /*<<?>>*/ function caml_call1(f, a0){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 1
-            ? f(a0)
-            : runtime.caml_call_gen(f, [a0]);
-   }
-    /*<<?>>*/ function caml_call2(f, a0, a1){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 2
-            ? f(a0, a1)
-            : runtime.caml_call_gen(f, [a0, a1]);
-   }
-   var
-    global_data = runtime.caml_get_global_data(),
-    err_no_pred = "U+0000 has no predecessor",
-    err_no_succ = "U+10FFFF has no successor",
-    Assert_failure = global_data.Assert_failure,
-    Stdlib = global_data.Stdlib,
-    _d_ = [0, cst_uchar_ml, 88, 18],
-    _c_ = [0, cst_uchar_ml, 91, 7],
-    _b_ = [0, cst_uchar_ml, 80, 18],
-    _a_ = [0, cst_uchar_ml, 85, 7],
-    cst_is_not_a_latin1_character = " is not a latin1 character",
-    cst_U = "U+",
-    cst_is_not_an_Unicode_scalar_v = " is not an Unicode scalar value",
-    min = 0,
-    max = 1114111,
-    lo_bound = 55295,
-    hi_bound = 57344,
-    bom = 65279,
-    rep = 65533;
-   function succ(u){
-     /*<<uchar.ml:34:2>>*/ return u === 55295
-            ? hi_bound
-            : u === 1114111 ? caml_call1(Stdlib[1], err_no_succ) : u + 1 | 0;
-    /*<<uchar.ml:36:7>>*/ }
-   function pred(u){
-     /*<<uchar.ml:39:2>>*/ return u === 57344
-            ? lo_bound
-            : u === 0 ? caml_call1(Stdlib[1], err_no_pred) : u - 1 | 0;
-    /*<<uchar.ml:41:7>>*/ }
-   function is_valid(i){
-     /*<<uchar.ml:43:17>>*/ var
-     _o_ = 0 <= i ? 1 : 0,
-     _p_ = _o_ ? i <= 55295 ? 1 : 0 : _o_;
-    if(_p_)
-     var _q_ = _p_;
-    else
-     var _r_ = 57344 <= i ? 1 : 0, _q_ = _r_ ? i <= 1114111 ? 1 : 0 : _r_;
-    return _q_;
-    /*<<uchar.ml:43:75>>*/ }
-   function of_int(i){
-     /*<<uchar.ml:44:15>>*/ if(is_valid(i))  /*<<uchar.ml:44:34>>*/ return i;
-     /*<<uchar.ml:20:19>>*/  /*<<uchar.ml:20:19>>*/ var
-     _n_ =
-        /*<<uchar.ml:20:19>>*/ caml_call2
-        (Stdlib[28],
-          /*<<uchar.ml:20:19>>*/ caml_format_int("%X", i),
-         cst_is_not_an_Unicode_scalar_v);
-     /*<<uchar.ml:44:53>>*/ return  /*<<uchar.ml:44:53>>*/ caml_call1
-            (Stdlib[1], _n_);
-    /*<<uchar.ml:44:67>>*/ }
-   function is_char(u){
-     /*<<uchar.ml:48:16>>*/ return u < 256 ? 1 : 0;
-    /*<<uchar.ml:48:23>>*/ }
-   function of_char(c){
-     /*<<uchar.ml:49:16>>*/ return c;
-    /*<<uchar.ml:49:27>>*/ }
-   function to_char(u){
-     /*<<uchar.ml:51:2>>*/ if(255 >= u)  /*<<uchar.ml:52:2>>*/ return u;
-     /*<<uchar.ml:21:30>>*/ var
-      /*<<uchar.ml:21:30>>*/ _l_ =
-        /*<<uchar.ml:21:30>>*/ caml_call2
-        (Stdlib[28],
-          /*<<uchar.ml:21:30>>*/ caml_format_int("%04X", u),
-         cst_is_not_a_latin1_character),
-      /*<<uchar.ml:21:30>>*/ _m_ =
-        /*<<uchar.ml:21:30>>*/ caml_call2(Stdlib[28], cst_U, _l_);
-     /*<<uchar.ml:51:30>>*/ return  /*<<uchar.ml:51:30>>*/ caml_call1
-            (Stdlib[1], _m_);
-    /*<<uchar.ml:52:19>>*/ }
-   function unsafe_to_char(_k_){ /*<<?>>*/ return _k_;}
-   function equal(_j_, _i_){ /*<<?>>*/ return _j_ === _i_ ? 1 : 0;}
-   var compare = runtime.caml_int_compare;
-   function hash(_h_){ /*<<?>>*/ return _h_;}
-   function utf_decode_is_valid(d){
-     /*<<uchar.ml:73:37>>*/ return 1 === (d >>> 27 | 0) ? 1 : 0;
-    /*<<uchar.ml:73:58>>*/ }
-   function utf_decode_length(d){
-     /*<<uchar.ml:74:35>>*/ return (d >>> 24 | 0) & 7;
-    /*<<uchar.ml:74:65>>*/ }
-   function utf_decode_uchar(d){
-     /*<<uchar.ml:75:34>>*/ return d & 16777215;
-    /*<<uchar.ml:75:65>>*/ }
-   function utf_decode(n, u){
-     /*<<uchar.ml:76:30>>*/ return (8 | n) << 24 | u;
-    /*<<uchar.ml:76:72>>*/ }
-   function utf_decode_invalid(n){
-     /*<<uchar.ml:77:36>>*/ return n << 24 | 65533;
-    /*<<uchar.ml:77:63>>*/ }
-   function utf_8_byte_length(u){
-     /*<<uchar.ml:79:26>>*/ if(0 > u)
-      /*<<uchar.ml:80:18>>*/ throw  /*<<uchar.ml:80:18>>*/ caml_maybe_attach_backtrace
-            ([0, Assert_failure, _b_], 1);
-     /*<<uchar.ml:81:9>>*/ if(127 >= u)  /*<<uchar.ml:81:24>>*/ return 1;
-     /*<<uchar.ml:82:9>>*/ if(2047 >= u)  /*<<uchar.ml:82:24>>*/ return 2;
-     /*<<uchar.ml:83:9>>*/ if(65535 >= u)  /*<<uchar.ml:83:24>>*/ return 3;
-     /*<<uchar.ml:84:9>>*/ if(1114111 < u)
-      /*<<uchar.ml:85:7>>*/ throw  /*<<uchar.ml:85:7>>*/ caml_maybe_attach_backtrace
-            ([0, Assert_failure, _a_], 1);
-     /*<<uchar.ml:84:26>>*/ return 4;
-    /*<<uchar.ml:85:19>>*/ }
-   function utf_16_byte_length(u){
-     /*<<uchar.ml:87:27>>*/ if(0 > u)
-      /*<<uchar.ml:88:18>>*/ throw  /*<<uchar.ml:88:18>>*/ caml_maybe_attach_backtrace
-            ([0, Assert_failure, _d_], 1);
-     /*<<uchar.ml:89:9>>*/ if(65535 >= u)  /*<<uchar.ml:89:24>>*/ return 2;
-     /*<<uchar.ml:90:9>>*/ if(1114111 < u)
-      /*<<uchar.ml:91:7>>*/ throw  /*<<uchar.ml:91:7>>*/ caml_maybe_attach_backtrace
-            ([0, Assert_failure, _c_], 1);
-     /*<<uchar.ml:90:26>>*/ return 4;
-    /*<<uchar.ml:91:19>>*/ }
-   function _e_(_g_){ /*<<?>>*/ return _g_;}
-   var
-    Stdlib_Uchar =
-      [0,
-       min,
-       max,
-       bom,
-       rep,
-       succ,
-       pred,
-       is_valid,
-       of_int,
-       function(_f_){ /*<<?>>*/ return _f_;},
-       _e_,
-       is_char,
-       of_char,
-       to_char,
-       unsafe_to_char,
-       equal,
-       compare,
-       hash,
-       utf_decode_is_valid,
-       utf_decode_uchar,
-       utf_decode_length,
-       utf_decode,
-       utf_decode_invalid,
-       utf_8_byte_length,
-       utf_16_byte_length];
-   runtime.caml_register_global(13, Stdlib_Uchar, "Stdlib__Uchar");
-   return;
-   /*<<?>>*/ }
-  (globalThis));
-
-//# unitInfo: Provides: Stdlib__List
-//# unitInfo: Requires: Stdlib, Stdlib__Seq, Stdlib__Sys
-(function
-  (globalThis){
-   "use strict";
-   var
-    runtime = globalThis.jsoo_runtime,
-    cst_List_nth$1 = "List.nth",
-    caml_compare = runtime.caml_compare,
-    caml_maybe_attach_backtrace = runtime.caml_maybe_attach_backtrace;
-    /*<<?>>*/ function caml_call1(f, a0){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 1
-            ? f(a0)
-            : runtime.caml_call_gen(f, [a0]);
-   }
-    /*<<?>>*/ function caml_call2(f, a0, a1){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 2
-            ? f(a0, a1)
-            : runtime.caml_call_gen(f, [a0, a1]);
-   }
-    /*<<?>>*/ function caml_call3(f, a0, a1, a2){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 3
-            ? f(a0, a1, a2)
-            : runtime.caml_call_gen(f, [a0, a1, a2]);
-   }
-   var
-    global_data = runtime.caml_get_global_data(),
-    Stdlib = global_data.Stdlib,
-    Stdlib_Seq = global_data.Stdlib__Seq,
-    Stdlib_Sys = global_data.Stdlib__Sys,
-    cst_List_map2 = "List.map2",
-    cst_List_iter2 = "List.iter2",
-    cst_List_fold_left2 = "List.fold_left2",
-    cst_List_fold_right2 = "List.fold_right2",
-    cst_List_for_all2 = "List.for_all2",
-    cst_List_exists2 = "List.exists2",
-    _b_ = [0, 0, 0],
-    cst_List_combine = "List.combine",
-    cst_List_rev_map2 = "List.rev_map2",
-    cst_List_init = "List.init",
-    cst_List_nth$0 = cst_List_nth$1,
-    cst_nth = "nth",
-    cst_List_nth = cst_List_nth$1,
-    cst_tl = "tl",
-    cst_hd = "hd";
-   function length(l$0){
-     /*<<list.ml:25:15>>*/ var len = 0, param = l$0;
-    for(;;){
-     if(! param)  /*<<list.ml:22:10>>*/ return len;
-      /*<<list.ml:23:12>>*/ var
-      l = param[2],
-       /*<<list.ml:23:12>>*/ len$0 = len + 1 | 0,
-      len = len$0,
-      param = l;
-    }
-    /*<<list.ml:25:29>>*/ }
-   function cons(a, l){
-     /*<<list.ml:27:15>>*/ return [0, a, l];
-    /*<<list.ml:27:19>>*/ }
-   function hd(param){
-     /*<<list.ml:29:9>>*/ if(! param)
-      /*<<list.ml:30:10>>*/ return  /*<<list.ml:30:10>>*/ caml_call1
-             (Stdlib[2], cst_hd);
-    var a = param[1];
-     /*<<list.ml:31:12>>*/ return a;
-    /*<<list.ml:31:13>>*/ }
-   function tl(param){
-     /*<<list.ml:33:9>>*/ if(! param)
-      /*<<list.ml:34:10>>*/ return  /*<<list.ml:34:10>>*/ caml_call1
-             (Stdlib[2], cst_tl);
-    var l = param[2];
-     /*<<list.ml:35:12>>*/ return l;
-    /*<<list.ml:35:13>>*/ }
-   function nth(l, n){
-     /*<<list.ml:38:2>>*/ if(0 > n)
-      /*<<list.ml:38:16>>*/ return  /*<<list.ml:38:16>>*/ caml_call1
-             (Stdlib[1], cst_List_nth);
-    var l$0 = l, n$0 = n;
-     /*<<list.ml:40:4>>*/ for(;;){
-     if(! l$0)
-       /*<<list.ml:41:12>>*/ return  /*<<list.ml:41:12>>*/ caml_call1
-              (Stdlib[2], cst_nth);
-     var l$1 = l$0[2], a = l$0[1];
-      /*<<list.ml:42:14>>*/ if(0 === n$0)  /*<<list.ml:42:28>>*/ return a;
-      /*<<list.ml:42:35>>*/ var
-       /*<<list.ml:42:35>>*/ n$1 = n$0 - 1 | 0,
-      l$0 = l$1,
-      n$0 = n$1;
-    }
-    /*<<list.ml:43:16>>*/ }
-   function nth_opt(l, n){
-     /*<<list.ml:46:2>>*/ if(0 > n)
-      /*<<list.ml:46:16>>*/ return  /*<<list.ml:46:16>>*/ caml_call1
-             (Stdlib[1], cst_List_nth$0);
-    var l$0 = l, n$0 = n;
-     /*<<list.ml:48:4>>*/ for(;;){
-     if(! l$0)  /*<<list.ml:49:12>>*/ return 0;
-     var l$1 = l$0[2], a = l$0[1];
-      /*<<list.ml:50:14>>*/ if(0 === n$0)
-       /*<<list.ml:50:28>>*/ return [0, a];
-      /*<<list.ml:50:40>>*/ var
-       /*<<list.ml:50:40>>*/ n$1 = n$0 - 1 | 0,
-      l$0 = l$1,
-      n$0 = n$1;
-    }
-    /*<<list.ml:51:16>>*/ }
-   var append = Stdlib[37];
-   function rev_append(l1, l2){
-     /*<<list.ml:56:2>>*/ var l1$0 = l1, l2$0 = l2;
-     /*<<list.ml:56:2>>*/ for(;;){
-     if(! l1$0)  /*<<list.ml:57:10>>*/ return l2$0;
-      /*<<list.ml:58:27>>*/ var
-      l1$1 = l1$0[2],
-      a = l1$0[1],
-       /*<<list.ml:58:27>>*/ l2$1 = [0, a, l2$0],
-      l1$0 = l1$1,
-      l2$0 = l2$1;
-    }
-    /*<<list.ml:58:36>>*/ }
-   function rev(l){
-     /*<<list.ml:60:12>>*/ return rev_append(l, 0);
-    /*<<list.ml:60:27>>*/ }
-   function init_aux(i, n, f){
-     /*<<list.ml:67:2>>*/ if(n <= i)  /*<<list.ml:67:17>>*/ return 0;
-     /*<<list.ml:69:12>>*/  /*<<list.ml:69:12>>*/ var
-     r =  /*<<list.ml:69:12>>*/ caml_call1(f, i);
-     /*<<list.ml:70:4>>*/ return [0, r, init_aux(i + 1 | 0, n, f)];
-    /*<<list.ml:70:27>>*/ }
-   var rev_init_threshold = typeof Stdlib_Sys[5] === "number" ? 10000 : 50;
-   function init(len, f){
-     /*<<list.ml:80:2>>*/ if(0 > len)
-      /*<<list.ml:80:18>>*/ return  /*<<list.ml:80:18>>*/ caml_call1
-             (Stdlib[1], cst_List_init);
-    if(rev_init_threshold >= len)
-      /*<<list.ml:82:7>>*/ return init_aux(0, len, f);
-    var acc = 0, i = 0;
-     /*<<list.ml:63:2>>*/ for(;;){
-     if(len <= i)  /*<<list.ml:81:39>>*/ return rev(acc);
-      /*<<list.ml:64:24>>*/ var
-      i$0 = i + 1 | 0,
-       /*<<list.ml:64:24>>*/ acc$0 =
-        [0,  /*<<list.ml:64:25>>*/ caml_call1(f, i), acc],
-      acc = acc$0,
-      i = i$0;
-    }
-    /*<<list.ml:82:23>>*/ }
-   function flatten(param){
-     /*<<list.ml:84:18>>*/ if(! param)  /*<<list.ml:85:10>>*/ return 0;
-     /*<<list.ml:86:16>>*/ var
-     r = param[2],
-     l = param[1],
-      /*<<list.ml:86:16>>*/ _J_ = flatten(r);
-     /*<<list.ml:86:16>>*/ return  /*<<list.ml:86:16>>*/ caml_call2
-            (Stdlib[37], l, _J_);
-    /*<<list.ml:86:25>>*/ }
-   function map(f, param){
-     /*<<?>>*/ if(! param)  /*<<list.ml:91:10>>*/ return 0;
-     /*<<list.ml:92:20>>*/ var
-     l = param[2],
-     a = param[1],
-      /*<<list.ml:92:20>>*/ r =  /*<<list.ml:92:20>>*/ caml_call1(f, a);
-     /*<<list.ml:92:27>>*/ return [0, r, map(f, l)];
-   }
-   function _a_(i, f, param){
-     /*<<?>>*/ if(! param)  /*<<list.ml:95:10>>*/ return 0;
-     /*<<list.ml:96:20>>*/ var
-     l = param[2],
-     a = param[1],
-      /*<<list.ml:96:20>>*/ r =  /*<<list.ml:96:20>>*/ caml_call2(f, i, a);
-     /*<<list.ml:96:29>>*/ return [0, r, _a_(i + 1 | 0, f, l)];
-   }
-   function mapi(f, l){
-     /*<<list.ml:98:15>>*/ return _a_(0, f, l);
-    /*<<list.ml:98:25>>*/ }
-   function rev_map(f, l){
-     /*<<list.ml:101:2>>*/ var accu = 0, param = l;
-    for(;;){
-     if(! param)  /*<<list.ml:102:12>>*/ return accu;
-      /*<<list.ml:103:21>>*/ var
-      l$0 = param[2],
-      a = param[1],
-       /*<<list.ml:103:21>>*/ accu$0 =
-        [0,  /*<<list.ml:103:22>>*/ caml_call1(f, a), accu],
-      accu = accu$0,
-      param = l$0;
-    }
-    /*<<list.ml:105:13>>*/ }
-   function iter(f, param){
-    var param$0 = param;
-    for(;;){
-     if(! param$0)  /*<<list.ml:109:10>>*/ return 0;
-     var l = param$0[2], a = param$0[1];
-      /*<<list.ml:110:12>>*/  /*<<list.ml:110:12>>*/ caml_call1(f, a);
-     var param$0 = l;
-    }
-   }
-   function iteri(f, l$0){
-     /*<<list.ml:116:16>>*/ var i = 0, param = l$0;
-    for(;;){
-     if(! param)  /*<<list.ml:113:10>>*/ return 0;
-     var l = param[2], a = param[1];
-      /*<<list.ml:114:12>>*/  /*<<list.ml:114:12>>*/ caml_call2(f, i, a);
-     var i$0 = i + 1 | 0, i = i$0, param = l;
-    }
-    /*<<list.ml:116:27>>*/ }
-   function fold_left(f, accu, l){
-     /*<<list.ml:119:2>>*/ var accu$0 = accu, l$0 = l;
-     /*<<list.ml:119:2>>*/ for(;;){
-     if(! l$0)  /*<<list.ml:120:10>>*/ return accu$0;
-      /*<<list.ml:121:24>>*/ var
-      l$1 = l$0[2],
-      a = l$0[1],
-       /*<<list.ml:121:24>>*/ accu$1 =
-         /*<<list.ml:121:24>>*/ caml_call2(f, accu$0, a),
-      accu$0 = accu$1,
-      l$0 = l$1;
-    }
-    /*<<list.ml:121:36>>*/ }
-   function fold_right(f, l, accu){
-     /*<<list.ml:124:2>>*/ if(! l)  /*<<list.ml:125:10>>*/ return accu;
-    var l$0 = l[2], a = l[1];
-     /*<<list.ml:126:16>>*/ return  /*<<list.ml:126:16>>*/ caml_call2
-            (f, a, fold_right(f, l$0, accu));
-    /*<<list.ml:126:37>>*/ }
-   function map2(f, l1, l2){
-     /*<<list.ml:129:2>>*/ if(l1){
-     if(l2){
-       /*<<list.ml:131:32>>*/ var
-       l2$0 = l2[2],
-       a2 = l2[1],
-       l1$0 = l1[2],
-       a1 = l1[1],
-        /*<<list.ml:131:32>>*/ r =
-          /*<<list.ml:131:32>>*/ caml_call2(f, a1, a2);
-       /*<<list.ml:131:43>>*/ return [0, r, map2(f, l1$0, l2$0)];
-     }
-    }
-    else if(! l2)  /*<<list.ml:130:16>>*/ return 0;
-     /*<<list.ml:132:14>>*/ return  /*<<list.ml:132:14>>*/ caml_call1
-            (Stdlib[1], cst_List_map2);
-    /*<<list.ml:132:37>>*/ }
-   function rev_map2(f, l1, l2){
-     /*<<list.ml:135:2>>*/ var accu = 0, l1$0 = l1, l2$0 = l2;
-     /*<<list.ml:136:4>>*/ for(;;){
-     if(l1$0){
-      if(l2$0){
-        /*<<list.ml:138:34>>*/ var
-        l2$1 = l2$0[2],
-        a2 = l2$0[1],
-        l1$1 = l1$0[2],
-        a1 = l1$0[1],
-         /*<<list.ml:138:34>>*/ accu$0 =
-          [0,  /*<<list.ml:138:35>>*/ caml_call2(f, a1, a2), accu],
-        accu = accu$0,
-        l1$0 = l1$1,
-        l2$0 = l2$1;
-       continue;
-      }
-     }
-     else if(! l2$0)  /*<<list.ml:137:18>>*/ return accu;
-      /*<<list.ml:139:16>>*/ return  /*<<list.ml:139:16>>*/ caml_call1
-             (Stdlib[1], cst_List_rev_map2);
-    }
-    /*<<list.ml:141:18>>*/ }
-   function iter2(f, l1, l2){
-     /*<<list.ml:145:2>>*/ var l1$0 = l1, l2$0 = l2;
-     /*<<list.ml:145:2>>*/ for(;;){
-     if(l1$0){
-      if(l2$0){
-       var l2$1 = l2$0[2], a2 = l2$0[1], l1$1 = l1$0[2], a1 = l1$0[1];
-        /*<<list.ml:147:24>>*/  /*<<list.ml:147:24>>*/ caml_call2(f, a1, a2);
-       var l1$0 = l1$1, l2$0 = l2$1;
-       continue;
-      }
-     }
-     else if(! l2$0)  /*<<list.ml:146:16>>*/ return 0;
-      /*<<list.ml:148:14>>*/ return  /*<<list.ml:148:14>>*/ caml_call1
-             (Stdlib[1], cst_List_iter2);
-    }
-    /*<<list.ml:148:38>>*/ }
-   function fold_left2(f, accu, l1, l2){
-     /*<<list.ml:151:2>>*/ var accu$0 = accu, l1$0 = l1, l2$0 = l2;
-     /*<<list.ml:151:2>>*/ for(;;){
-     if(l1$0){
-      if(l2$0){
-        /*<<list.ml:153:37>>*/ var
-        l2$1 = l2$0[2],
-        a2 = l2$0[1],
-        l1$1 = l1$0[2],
-        a1 = l1$0[1],
-         /*<<list.ml:153:37>>*/ accu$1 =
-           /*<<list.ml:153:37>>*/ caml_call3(f, accu$0, a1, a2),
-        accu$0 = accu$1,
-        l1$0 = l1$1,
-        l2$0 = l2$1;
-       continue;
-      }
-     }
-     else if(! l2$0)  /*<<list.ml:152:16>>*/ return accu$0;
-      /*<<list.ml:154:14>>*/ return  /*<<list.ml:154:14>>*/ caml_call1
-             (Stdlib[1], cst_List_fold_left2);
-    }
-    /*<<list.ml:154:43>>*/ }
-   function fold_right2(f, l1, l2, accu){
-     /*<<list.ml:157:2>>*/ if(l1){
-     if(l2){
-      var l2$0 = l2[2], a2 = l2[1], l1$0 = l1[2], a1 = l1[1];
-       /*<<list.ml:159:32>>*/ return  /*<<list.ml:159:32>>*/ caml_call3
-              (f, a1, a2, fold_right2(f, l1$0, l2$0, accu));
-     }
-    }
-    else if(! l2)  /*<<list.ml:158:16>>*/ return accu;
-     /*<<list.ml:160:14>>*/ return  /*<<list.ml:160:14>>*/ caml_call1
-            (Stdlib[1], cst_List_fold_right2);
-    /*<<list.ml:160:44>>*/ }
-   function for_all(p, param){
-    var param$0 = param;
-    for(;;){
-     if(! param$0)  /*<<list.ml:163:10>>*/ return 1;
-      /*<<list.ml:164:12>>*/ var
-      l = param$0[2],
-      a = param$0[1],
-       /*<<list.ml:164:12>>*/ _I_ =  /*<<list.ml:164:12>>*/ caml_call1(p, a);
-      /*<<list.ml:164:12>>*/ if(! _I_)  /*<<list.ml:164:12>>*/ return _I_;
-     var param$0 = l;
-    }
-   }
-   function exists(p, param){
-    var param$0 = param;
-    for(;;){
-     if(! param$0)  /*<<list.ml:167:10>>*/ return 0;
-      /*<<list.ml:168:12>>*/ var
-      l = param$0[2],
-      a = param$0[1],
-       /*<<list.ml:168:12>>*/ _H_ =  /*<<list.ml:168:12>>*/ caml_call1(p, a);
-      /*<<list.ml:168:12>>*/ if(_H_)  /*<<list.ml:168:12>>*/ return _H_;
-     var param$0 = l;
-    }
-   }
-   function for_all2(p, l1, l2){
-     /*<<list.ml:171:2>>*/ var l1$0 = l1, l2$0 = l2;
-     /*<<list.ml:171:2>>*/ for(;;){
-     if(l1$0){
-      if(l2$0){
-        /*<<list.ml:173:24>>*/ var
-        l2$1 = l2$0[2],
-        a2 = l2$0[1],
-        l1$1 = l1$0[2],
-        a1 = l1$0[1],
-         /*<<list.ml:173:24>>*/ _G_ =
-           /*<<list.ml:173:24>>*/ caml_call2(p, a1, a2);
-        /*<<list.ml:173:24>>*/ if(! _G_)  /*<<list.ml:173:24>>*/ return _G_;
-       var l1$0 = l1$1, l2$0 = l2$1;
-       continue;
-      }
-     }
-     else if(! l2$0)  /*<<list.ml:172:16>>*/ return 1;
-      /*<<list.ml:174:14>>*/ return  /*<<list.ml:174:14>>*/ caml_call1
-             (Stdlib[1], cst_List_for_all2);
-    }
-    /*<<list.ml:174:41>>*/ }
-   function exists2(p, l1, l2){
-     /*<<list.ml:177:2>>*/ var l1$0 = l1, l2$0 = l2;
-     /*<<list.ml:177:2>>*/ for(;;){
-     if(l1$0){
-      if(l2$0){
-        /*<<list.ml:179:24>>*/ var
-        l2$1 = l2$0[2],
-        a2 = l2$0[1],
-        l1$1 = l1$0[2],
-        a1 = l1$0[1],
-         /*<<list.ml:179:24>>*/ _F_ =
-           /*<<list.ml:179:24>>*/ caml_call2(p, a1, a2);
-        /*<<list.ml:179:24>>*/ if(_F_)  /*<<list.ml:179:24>>*/ return _F_;
-       var l1$0 = l1$1, l2$0 = l2$1;
-       continue;
-      }
-     }
-     else if(! l2$0)  /*<<list.ml:178:16>>*/ return 0;
-      /*<<list.ml:180:14>>*/ return  /*<<list.ml:180:14>>*/ caml_call1
-             (Stdlib[1], cst_List_exists2);
-    }
-    /*<<list.ml:180:40>>*/ }
-   function mem(x, param){
-    var param$0 = param;
-    for(;;){
-     if(! param$0)  /*<<list.ml:183:10>>*/ return 0;
-     var
-      l = param$0[2],
-      a = param$0[1],
-      _E_ = 0 ===  /*<<list.ml:184:12>>*/ caml_compare(a, x) ? 1 : 0;
-     if(_E_) return _E_;
-     var param$0 = l;
-    }
-   }
-   function memq(x, param){
-    var param$0 = param;
-    for(;;){
-     if(! param$0)  /*<<list.ml:187:10>>*/ return 0;
-     var l = param$0[2], a = param$0[1], _D_ = a === x ? 1 : 0;
-     if(_D_) return _D_;
-     var param$0 = l;
-    }
-   }
-   function assoc(x, param){
-    var param$0 = param;
-    for(;;){
-     if(! param$0)
-       /*<<list.ml:191:10>>*/ throw  /*<<list.ml:191:10>>*/ caml_maybe_attach_backtrace
-             (Stdlib[8], 1);
-     var l = param$0[2], match = param$0[1], b = match[2], a = match[1];
-      /*<<list.ml:192:19>>*/ if
-      (0 ===  /*<<list.ml:192:19>>*/ caml_compare(a, x))
-       /*<<list.ml:192:40>>*/ return b;
-     var param$0 = l;
-    }
-   }
-   function assoc_opt(x, param){
-    var param$0 = param;
-    for(;;){
-     if(! param$0)  /*<<list.ml:195:10>>*/ return 0;
-     var l = param$0[2], match = param$0[1], b = match[2], a = match[1];
-      /*<<list.ml:196:19>>*/ if
-      (0 ===  /*<<list.ml:196:19>>*/ caml_compare(a, x))
-       /*<<list.ml:196:40>>*/ return [0, b];
-     var param$0 = l;
-    }
-   }
-   function assq(x, param){
-    var param$0 = param;
-    for(;;){
-     if(! param$0)
-       /*<<list.ml:199:10>>*/ throw  /*<<list.ml:199:10>>*/ caml_maybe_attach_backtrace
-             (Stdlib[8], 1);
-     var l = param$0[2], match = param$0[1], b = match[2], a = match[1];
-     if(a === x)  /*<<list.ml:200:31>>*/ return b;
-     var param$0 = l;
-    }
-   }
-   function assq_opt(x, param){
-    var param$0 = param;
-    for(;;){
-     if(! param$0)  /*<<list.ml:203:10>>*/ return 0;
-     var l = param$0[2], match = param$0[1], b = match[2], a = match[1];
-     if(a === x)  /*<<list.ml:204:31>>*/ return [0, b];
-     var param$0 = l;
-    }
-   }
-   function mem_assoc(x, param){
-    var param$0 = param;
-    for(;;){
-     if(! param$0)  /*<<list.ml:207:10>>*/ return 0;
-     var
-      l = param$0[2],
-      a = param$0[1][1],
-      _C_ = 0 ===  /*<<list.ml:208:19>>*/ caml_compare(a, x) ? 1 : 0;
-     if(_C_) return _C_;
-     var param$0 = l;
-    }
-   }
-   function mem_assq(x, param){
-    var param$0 = param;
-    for(;;){
-     if(! param$0)  /*<<list.ml:211:10>>*/ return 0;
-     var l = param$0[2], a = param$0[1][1], _B_ = a === x ? 1 : 0;
-     if(_B_) return _B_;
-     var param$0 = l;
-    }
-   }
-   function remove_assoc(x, param){
-     /*<<?>>*/ if(! param)  /*<<list.ml:215:10>>*/ return 0;
-    var l = param[2], pair = param[1], a = pair[1];
-     /*<<list.ml:217:9>>*/ return 0
-            ===  /*<<list.ml:217:9>>*/ caml_compare(a, x)
-            ? l
-            : [0, pair, remove_assoc(x, l)];
-   }
-   function remove_assq(x, param){
-     /*<<?>>*/ if(! param)  /*<<list.ml:220:10>>*/ return 0;
-    var l = param[2], pair = param[1], a = pair[1];
-    return a === x ? l : [0, pair, remove_assq(x, l)];
-   }
-   function find(p, param){
-    var param$0 = param;
-    for(;;){
-     if(! param$0)
-       /*<<list.ml:224:10>>*/ throw  /*<<list.ml:224:10>>*/ caml_maybe_attach_backtrace
-             (Stdlib[8], 1);
-     var l = param$0[2], x = param$0[1];
-      /*<<list.ml:225:17>>*/ if( /*<<list.ml:225:17>>*/ caml_call1(p, x))
-       /*<<list.ml:225:26>>*/ return x;
-     var param$0 = l;
-    }
-   }
-   function find_opt(p, param){
-    var param$0 = param;
-    for(;;){
-     if(! param$0)  /*<<list.ml:228:10>>*/ return 0;
-     var l = param$0[2], x = param$0[1];
-      /*<<list.ml:229:17>>*/ if( /*<<list.ml:229:17>>*/ caml_call1(p, x))
-       /*<<list.ml:229:26>>*/ return [0, x];
-     var param$0 = l;
-    }
-   }
-   function find_map(f, param){
-    var param$0 = param;
-    for(;;){
-     if(! param$0)  /*<<list.ml:232:10>>*/ return 0;
-      /*<<list.ml:234:17>>*/ var
-      l = param$0[2],
-      x = param$0[1],
-       /*<<list.ml:234:17>>*/ result =
-         /*<<list.ml:234:17>>*/ caml_call1(f, x);
-     if(result)  /*<<list.ml:235:29>>*/ return result;
-     var param$0 = l;
-    }
-   }
-   function find_all(p){
-     /*<<list.ml:240:2>>*/  /*<<list.ml:243:2>>*/ var accu = 0;
-     /*<<list.ml:243:2>>*/ return function(param$0){
-     var accu$0 = accu, param = param$0;
-     for(;;){
-      if(! param)  /*<<list.ml:241:10>>*/ return rev(accu$0);
-      var l = param[2], x = param[1];
-       /*<<list.ml:242:17>>*/ if( /*<<list.ml:242:17>>*/ caml_call1(p, x))
-        /*<<list.ml:242:31>>*/ var
-         /*<<list.ml:242:31>>*/ accu$1 = [0, x, accu$0],
-        accu$0 = accu$1,
-        param = l;
-      else
-       var param = l;
-     }};
-    /*<<list.ml:243:9>>*/ }
-   function filteri(p, l){
-     /*<<list.ml:248:2>>*/ var i = 0, acc = 0, param = l;
-    for(;;){
-     if(! param)  /*<<list.ml:249:10>>*/ return rev(acc);
-      /*<<list.ml:250:28>>*/ var
-      l$0 = param[2],
-      x = param[1],
-       /*<<list.ml:250:28>>*/ acc$0 =
-         /*<<list.ml:250:28>>*/ caml_call2(p, i, x) ? [0, x, acc] : acc,
-      i$0 = i + 1 | 0,
-      i = i$0,
-      acc = acc$0,
-      param = l$0;
-    }
-    /*<<list.ml:252:12>>*/ }
-   function filter_map(f){
-     /*<<list.ml:255:2>>*/  /*<<list.ml:262:2>>*/ var accu = 0;
-     /*<<list.ml:262:2>>*/ return function(param$0){
-     var accu$0 = accu, param = param$0;
-     for(;;){
-      if(! param)  /*<<list.ml:256:12>>*/ return rev(accu$0);
-       /*<<list.ml:258:14>>*/ var
-       l = param[2],
-       x = param[1],
-        /*<<list.ml:258:14>>*/ match =
-          /*<<list.ml:258:14>>*/ caml_call1(f, x);
-      if(match)
-        /*<<list.ml:260:24>>*/ var
-        v = match[1],
-         /*<<list.ml:260:24>>*/ accu$1 = [0, v, accu$0],
-        accu$0 = accu$1,
-        param = l;
-      else
-       var param = l;
-     }};
-    /*<<list.ml:262:8>>*/ }
-   function concat_map(f, l){
-     /*<<list.ml:265:2>>*/ var acc = 0, param = l;
-    for(;;){
-     if(! param)  /*<<list.ml:266:12>>*/ return rev(acc);
-      /*<<list.ml:268:16>>*/ var
-      l$0 = param[2],
-      x = param[1],
-       /*<<list.ml:268:16>>*/ xs =  /*<<list.ml:268:16>>*/ caml_call1(f, x),
-       /*<<list.ml:269:13>>*/ acc$0 = rev_append(xs, acc),
-      acc = acc$0,
-      param = l$0;
-    }
-    /*<<list.ml:270:15>>*/ }
-   function fold_left_map(f, accu, l){
-     /*<<list.ml:273:2>>*/ var accu$0 = accu, l_accu = 0, param = l;
-    for(;;){
-     if(! param)  /*<<list.ml:274:12>>*/ return [0, accu$0, rev(l_accu)];
-      /*<<list.ml:276:22>>*/ var
-      l$0 = param[2],
-      x = param[1],
-       /*<<list.ml:276:22>>*/ match =
-         /*<<list.ml:276:22>>*/ caml_call2(f, accu$0, x),
-      x$0 = match[2],
-      accu$1 = match[1],
-       /*<<list.ml:277:17>>*/ l_accu$0 = [0, x$0, l_accu],
-      accu$0 = accu$1,
-      l_accu = l_accu$0,
-      param = l$0;
-    }
-    /*<<list.ml:278:15>>*/ }
-   function partition(p, l){
-     /*<<list.ml:281:2>>*/ var yes = 0, no = 0, param = l;
-    for(;;){
-     if(! param){
-       /*<<list.ml:282:20>>*/  /*<<list.ml:282:20>>*/ var _A_ = rev(no);
-       /*<<list.ml:282:10>>*/ return [0, rev(yes), _A_];
-     }
-     var l$0 = param[2], x = param[1];
-      /*<<list.ml:283:17>>*/ if( /*<<list.ml:283:17>>*/ caml_call1(p, x))
-       /*<<list.ml:283:31>>*/ var
-        /*<<list.ml:283:31>>*/ yes$0 = [0, x, yes],
-       yes = yes$0,
-       param = l$0;
-     else
-       /*<<list.ml:283:61>>*/ var
-        /*<<list.ml:283:61>>*/ no$0 = [0, x, no],
-       no = no$0,
-       param = l$0;
-    }
-    /*<<list.ml:284:14>>*/ }
-   function partition_map(p, l){
-     /*<<list.ml:287:2>>*/ var left = 0, right = 0, param = l;
-    for(;;){
-     if(! param){
-       /*<<list.ml:288:21>>*/  /*<<list.ml:288:21>>*/ var _z_ = rev(right);
-       /*<<list.ml:288:10>>*/ return [0, rev(left), _z_];
-     }
-      /*<<list.ml:290:17>>*/ var
-      l$0 = param[2],
-      x = param[1],
-       /*<<list.ml:290:17>>*/ match =  /*<<list.ml:290:17>>*/ caml_call1(p, x);
-     if(0 === match[0])
-       /*<<list.ml:291:31>>*/ var
-       v = match[1],
-        /*<<list.ml:291:31>>*/ left$0 = [0, v, left],
-       left = left$0,
-       param = l$0;
-     else
-       /*<<list.ml:292:37>>*/ var
-       v$0 = match[1],
-        /*<<list.ml:292:37>>*/ right$0 = [0, v$0, right],
-       right = right$0,
-       param = l$0;
-    }
-    /*<<list.ml:295:14>>*/ }
-   function split(param){
-     /*<<list.ml:297:16>>*/ if(! param)  /*<<list.ml:298:10>>*/ return _b_;
-     /*<<list.ml:300:21>>*/ var
-     l = param[2],
-     match = param[1],
-     y = match[2],
-     x = match[1],
-      /*<<list.ml:300:21>>*/ match$0 = split(l),
-     ry = match$0[2],
-     rx = match$0[1];
-     /*<<list.ml:300:32>>*/ return [0, [0, x, rx], [0, y, ry]];
-    /*<<list.ml:300:46>>*/ }
-   function combine(l1, l2){
-     /*<<list.ml:303:2>>*/ if(l1){
-     if(l2){
-      var l2$0 = l2[2], a2 = l2[1], l1$0 = l1[2], a1 = l1[1];
-       /*<<list.ml:305:24>>*/ return [0, [0, a1, a2], combine(l1$0, l2$0)];
-     }
-    }
-    else if(! l2)  /*<<list.ml:304:16>>*/ return 0;
-     /*<<list.ml:306:14>>*/ return  /*<<list.ml:306:14>>*/ caml_call1
-            (Stdlib[1], cst_List_combine);
-    /*<<list.ml:306:40>>*/ }
-   function merge(cmp, l1, l2){
-     /*<<list.ml:311:2>>*/ if(! l1)  /*<<list.ml:312:14>>*/ return l2;
-    if(! l2)  /*<<list.ml:313:14>>*/ return l1;
-    var t2 = l2[2], h2 = l2[1], t1 = l1[2], h1 = l1[1];
-     /*<<list.ml:315:9>>*/ return 0
-            <  /*<<list.ml:315:9>>*/ caml_call2(cmp, h1, h2)
-            ? [0, h2, merge(cmp, l1, t2)]
-            : [0, h1, merge(cmp, t1, l2)];
-    /*<<list.ml:317:32>>*/ }
-   function stable_sort(cmp, l){
-    function sort(n, l){
-      /*<<list.ml:340:4>>*/ if(2 === n){
-      if(l){
-       var match = l[2];
-       if(match){
-         /*<<list.ml:342:19>>*/ var
-         tl = match[2],
-         x2 = match[1],
-         x1 = l[1],
-          /*<<list.ml:342:19>>*/ s =
-           0 <  /*<<list.ml:342:19>>*/ caml_call2(cmp, x1, x2)
-            ? [0, x2, [0, x1, 0]]
-            : [0, x1, [0, x2, 0]];
-         /*<<list.ml:343:8>>*/ return [0, s, tl];
-       }
-      }
-     }
-     else if(3 === n && l){
-      var _y_ = l[2];
-      if(_y_){
-       var match$2 = _y_[2];
-       if(match$2){
-         /*<<list.ml:346:13>>*/ var
-         tl$1 = match$2[2],
-         x3 = match$2[1],
-         x2$0 = _y_[1],
-         x1$0 = l[1],
-          /*<<list.ml:346:13>>*/ s$0 =
-           0 <  /*<<list.ml:346:13>>*/ caml_call2(cmp, x1$0, x2$0)
-            ? 0
-              <  /*<<list.ml:350:18>>*/ caml_call2(cmp, x1$0, x3)
-              ? 0
-                <  /*<<list.ml:351:18>>*/ caml_call2(cmp, x2$0, x3)
-                ? [0, x3, [0, x2$0, [0, x1$0, 0]]]
-                : [0, x2$0, [0, x3, [0, x1$0, 0]]]
-              : [0, x2$0, [0, x1$0, [0, x3, 0]]]
-            : 0
-              <  /*<<list.ml:347:15>>*/ caml_call2(cmp, x2$0, x3)
-              ? 0
-                <  /*<<list.ml:348:20>>*/ caml_call2(cmp, x1$0, x3)
-                ? [0, x3, [0, x1$0, [0, x2$0, 0]]]
-                : [0, x1$0, [0, x3, [0, x2$0, 0]]]
-              : [0, x1$0, [0, x2$0, [0, x3, 0]]];
-         /*<<list.ml:354:8>>*/ return [0, s$0, tl$1];
-       }
-      }
-     }
-      /*<<list.ml:358:21>>*/ var
-      n1 = n >> 1,
-      n2 = n - n1 | 0,
-       /*<<list.ml:358:21>>*/ match$0 = rev_sort(n1, l),
-      l2$0 = match$0[2],
-      s1 = match$0[1],
-       /*<<list.ml:359:21>>*/ match$1 = rev_sort(n2, l2$0),
-      tl$0 = match$1[2],
-      s2 = match$1[1],
-      l1 = s1,
-      l2 = s2,
-      accu = 0;
-      /*<<list.ml:331:4>>*/ for(;;){
-      if(l1){
-       if(l2){
-        var t2 = l2[2], h2 = l2[1], t1 = l1[2], h1 = l1[1];
-         /*<<list.ml:335:11>>*/ if
-         (0 <  /*<<list.ml:335:11>>*/ caml_call2(cmp, h1, h2)){
-          /*<<list.ml:336:33>>*/ var
-           /*<<list.ml:336:33>>*/ accu$0 = [0, h1, accu],
-          l1 = t1,
-          accu = accu$0;
-         continue;
-        }
-         /*<<list.ml:337:33>>*/ var
-          /*<<list.ml:337:33>>*/ accu$1 = [0, h2, accu],
-         l2 = t2,
-         accu = accu$1;
-        continue;
-       }
-       var _x_ = rev_append(l1, accu);
-      }
-      else
-       var _x_ = rev_append(l2, accu);
-       /*<<list.ml:360:8>>*/ return [0, _x_, tl$0];
-     }
-     /*<<list.ml:360:36>>*/ }
-    function rev_sort(n, l){
-      /*<<list.ml:362:4>>*/ if(2 === n){
-      if(l){
-       var match = l[2];
-       if(match){
-         /*<<list.ml:364:19>>*/ var
-         tl = match[2],
-         x2 = match[1],
-         x1 = l[1],
-          /*<<list.ml:364:19>>*/ s =
-           0 <  /*<<list.ml:364:19>>*/ caml_call2(cmp, x1, x2)
-            ? [0, x1, [0, x2, 0]]
-            : [0, x2, [0, x1, 0]];
-         /*<<list.ml:365:8>>*/ return [0, s, tl];
-       }
-      }
-     }
-     else if(3 === n && l){
-      var _w_ = l[2];
-      if(_w_){
-       var match$2 = _w_[2];
-       if(match$2){
-         /*<<list.ml:368:13>>*/ var
-         tl$1 = match$2[2],
-         x3 = match$2[1],
-         x2$0 = _w_[1],
-         x1$0 = l[1],
-          /*<<list.ml:368:13>>*/ s$0 =
-           0 <  /*<<list.ml:368:13>>*/ caml_call2(cmp, x1$0, x2$0)
-            ? 0
-              <  /*<<list.ml:369:15>>*/ caml_call2(cmp, x2$0, x3)
-              ? [0, x1$0, [0, x2$0, [0, x3, 0]]]
-              : 0
-                <  /*<<list.ml:370:20>>*/ caml_call2(cmp, x1$0, x3)
-                ? [0, x1$0, [0, x3, [0, x2$0, 0]]]
-                : [0, x3, [0, x1$0, [0, x2$0, 0]]]
-            : 0
-              <  /*<<list.ml:372:18>>*/ caml_call2(cmp, x1$0, x3)
-              ? [0, x2$0, [0, x1$0, [0, x3, 0]]]
-              : 0
-                <  /*<<list.ml:373:18>>*/ caml_call2(cmp, x2$0, x3)
-                ? [0, x2$0, [0, x3, [0, x1$0, 0]]]
-                : [0, x3, [0, x2$0, [0, x1$0, 0]]];
-         /*<<list.ml:376:8>>*/ return [0, s$0, tl$1];
-       }
-      }
-     }
-      /*<<list.ml:380:21>>*/ var
-      n1 = n >> 1,
-      n2 = n - n1 | 0,
-       /*<<list.ml:380:21>>*/ match$0 = sort(n1, l),
-      l2$0 = match$0[2],
-      s1 = match$0[1],
-       /*<<list.ml:381:21>>*/ match$1 = sort(n2, l2$0),
-      tl$0 = match$1[2],
-      s2 = match$1[1],
-      l1 = s1,
-      l2 = s2,
-      accu = 0;
-      /*<<list.ml:322:4>>*/ for(;;){
-      if(l1){
-       if(l2){
-        var t2 = l2[2], h2 = l2[1], t1 = l1[2], h1 = l1[1];
-         /*<<list.ml:326:11>>*/ if
-         (0 <  /*<<list.ml:326:11>>*/ caml_call2(cmp, h1, h2)){
-          /*<<list.ml:328:29>>*/ var
-           /*<<list.ml:328:29>>*/ accu$0 = [0, h2, accu],
-          l2 = t2,
-          accu = accu$0;
-         continue;
-        }
-         /*<<list.ml:327:29>>*/ var
-          /*<<list.ml:327:29>>*/ accu$1 = [0, h1, accu],
-         l1 = t1,
-         accu = accu$1;
-        continue;
-       }
-       var _v_ = rev_append(l1, accu);
-      }
-      else
-       var _v_ = rev_append(l2, accu);
-       /*<<list.ml:382:8>>*/ return [0, _v_, tl$0];
-     }
-     /*<<list.ml:382:32>>*/ }
-     /*<<list.ml:384:12>>*/  /*<<list.ml:384:12>>*/ var len = length(l);
-     /*<<list.ml:385:2>>*/ return 2 <= len ? sort(len, l)[1] : l;
-    /*<<list.ml:385:41>>*/ }
-   function sort_uniq(cmp, l){
-    function sort(n, l){
-      /*<<list.ml:450:4>>*/ if(2 === n){
-      if(l){
-       var match = l[2];
-       if(match){
-         /*<<list.ml:453:18>>*/ var
-         tl = match[2],
-         x2 = match[1],
-         x1 = l[1],
-          /*<<list.ml:453:18>>*/ c$0 =
-            /*<<list.ml:453:18>>*/ caml_call2(cmp, x1, x2),
-          /*<<list.ml:454:10>>*/ s =
-           0 === c$0
-            ? [0, x1, 0]
-            : 0 <= c$0 ? [0, x2, [0, x1, 0]] : [0, x1, [0, x2, 0]];
-         /*<<list.ml:456:8>>*/ return [0, s, tl];
-       }
-      }
-     }
-     else if(3 === n && l){
-      var _p_ = l[2];
-      if(_p_){
-       var match$2 = _p_[2];
-       if(match$2){
-         /*<<list.ml:459:18>>*/ var
-         tl$1 = match$2[2],
-         x3 = match$2[1],
-         x2$0 = _p_[1],
-         x1$0 = l[1],
-          /*<<list.ml:459:18>>*/ c$1 =
-            /*<<list.ml:459:18>>*/ caml_call2(cmp, x1$0, x2$0);
-         /*<<list.ml:460:10>>*/ if(0 === c$1)
-          /*<<list.ml:461:20>>*/ var
-           /*<<list.ml:461:20>>*/ c$2 =
-             /*<<list.ml:461:20>>*/ caml_call2(cmp, x2$0, x3),
-           /*<<list.ml:462:12>>*/ _q_ =
-            0 === c$2
-             ? [0, x2$0, 0]
-             : 0 <= c$2 ? [0, x3, [0, x2$0, 0]] : [0, x2$0, [0, x3, 0]],
-          s$0 = _q_;
-        else if(0 <= c$1){
-          /*<<list.ml:473:20>>*/  /*<<list.ml:473:20>>*/ var
-          c$3 =  /*<<list.ml:473:20>>*/ caml_call2(cmp, x1$0, x3);
-          /*<<list.ml:474:12>>*/ if(0 === c$3)
-          var _r_ = [0, x2$0, [0, x1$0, 0]];
-         else if(0 <= c$3)
-           /*<<list.ml:477:22>>*/ var
-            /*<<list.ml:477:22>>*/ c$4 =
-              /*<<list.ml:477:22>>*/ caml_call2(cmp, x2$0, x3),
-            /*<<list.ml:478:14>>*/ _s_ =
-             0 === c$4
-              ? [0, x2$0, [0, x1$0, 0]]
-              : 0
-                <= c$4
-                ? [0, x3, [0, x2$0, [0, x1$0, 0]]]
-                : [0, x2$0, [0, x3, [0, x1$0, 0]]],
-           _r_ = _s_;
-         else
-          var _r_ = [0, x2$0, [0, x1$0, [0, x3, 0]]];
-         var s$0 = _r_;
-        }
-        else{
-          /*<<list.ml:464:20>>*/  /*<<list.ml:464:20>>*/ var
-          c$5 =  /*<<list.ml:464:20>>*/ caml_call2(cmp, x2$0, x3);
-          /*<<list.ml:465:12>>*/ if(0 === c$5)
-          var _t_ = [0, x1$0, [0, x2$0, 0]];
-         else if(0 <= c$5)
-           /*<<list.ml:468:22>>*/ var
-            /*<<list.ml:468:22>>*/ c$6 =
-              /*<<list.ml:468:22>>*/ caml_call2(cmp, x1$0, x3),
-            /*<<list.ml:469:14>>*/ _u_ =
-             0 === c$6
-              ? [0, x1$0, [0, x2$0, 0]]
-              : 0
-                <= c$6
-                ? [0, x3, [0, x1$0, [0, x2$0, 0]]]
-                : [0, x1$0, [0, x3, [0, x2$0, 0]]],
-           _t_ = _u_;
-         else
-          var _t_ = [0, x1$0, [0, x2$0, [0, x3, 0]]];
-         var s$0 = _t_;
-        }
-         /*<<list.ml:482:8>>*/ return [0, s$0, tl$1];
-       }
-      }
-     }
-      /*<<list.ml:486:21>>*/ var
-      n1 = n >> 1,
-      n2 = n - n1 | 0,
-       /*<<list.ml:486:21>>*/ match$0 = rev_sort(n1, l),
-      l2$0 = match$0[2],
-      s1 = match$0[1],
-       /*<<list.ml:487:21>>*/ match$1 = rev_sort(n2, l2$0),
-      tl$0 = match$1[2],
-      s2 = match$1[1],
-      l1 = s1,
-      l2 = s2,
-      accu = 0;
-      /*<<list.ml:439:4>>*/ for(;;){
-      if(l1){
-       if(l2){
-         /*<<list.ml:443:16>>*/ var
-         t2 = l2[2],
-         h2 = l2[1],
-         t1 = l1[2],
-         h1 = l1[1],
-          /*<<list.ml:443:16>>*/ c =
-            /*<<list.ml:443:16>>*/ caml_call2(cmp, h1, h2);
-         /*<<list.ml:444:8>>*/ if(0 === c){
-          /*<<list.ml:444:42>>*/ var
-           /*<<list.ml:444:42>>*/ accu$0 = [0, h1, accu],
-          l1 = t1,
-          l2 = t2,
-          accu = accu$0;
-         continue;
-        }
-        if(0 < c){
-          /*<<list.ml:446:33>>*/ var
-           /*<<list.ml:446:33>>*/ accu$1 = [0, h1, accu],
-          l1 = t1,
-          accu = accu$1;
-         continue;
-        }
-         /*<<list.ml:447:33>>*/ var
-          /*<<list.ml:447:33>>*/ accu$2 = [0, h2, accu],
-         l2 = t2,
-         accu = accu$2;
-        continue;
-       }
-       var _o_ = rev_append(l1, accu);
-      }
-      else
-       var _o_ = rev_append(l2, accu);
-       /*<<list.ml:488:8>>*/ return [0, _o_, tl$0];
-     }
-     /*<<list.ml:488:36>>*/ }
-    function rev_sort(n, l){
-      /*<<list.ml:490:4>>*/ if(2 === n){
-      if(l){
-       var match = l[2];
-       if(match){
-         /*<<list.ml:493:18>>*/ var
-         tl = match[2],
-         x2 = match[1],
-         x1 = l[1],
-          /*<<list.ml:493:18>>*/ c$0 =
-            /*<<list.ml:493:18>>*/ caml_call2(cmp, x1, x2),
-          /*<<list.ml:494:10>>*/ s =
-           0 === c$0
-            ? [0, x1, 0]
-            : 0 < c$0 ? [0, x1, [0, x2, 0]] : [0, x2, [0, x1, 0]];
-         /*<<list.ml:496:8>>*/ return [0, s, tl];
-       }
-      }
-     }
-     else if(3 === n && l){
-      var _i_ = l[2];
-      if(_i_){
-       var match$2 = _i_[2];
-       if(match$2){
-         /*<<list.ml:499:18>>*/ var
-         tl$1 = match$2[2],
-         x3 = match$2[1],
-         x2$0 = _i_[1],
-         x1$0 = l[1],
-          /*<<list.ml:499:18>>*/ c$1 =
-            /*<<list.ml:499:18>>*/ caml_call2(cmp, x1$0, x2$0);
-         /*<<list.ml:500:10>>*/ if(0 === c$1)
-          /*<<list.ml:501:20>>*/ var
-           /*<<list.ml:501:20>>*/ c$2 =
-             /*<<list.ml:501:20>>*/ caml_call2(cmp, x2$0, x3),
-           /*<<list.ml:502:12>>*/ _j_ =
-            0 === c$2
-             ? [0, x2$0, 0]
-             : 0 < c$2 ? [0, x2$0, [0, x3, 0]] : [0, x3, [0, x2$0, 0]],
-          s$0 = _j_;
-        else if(0 < c$1){
-          /*<<list.ml:504:20>>*/  /*<<list.ml:504:20>>*/ var
-          c$3 =  /*<<list.ml:504:20>>*/ caml_call2(cmp, x2$0, x3);
-          /*<<list.ml:505:12>>*/ if(0 === c$3)
-          var _k_ = [0, x1$0, [0, x2$0, 0]];
-         else if(0 < c$3)
-          var _k_ = [0, x1$0, [0, x2$0, [0, x3, 0]]];
-         else
-           /*<<list.ml:508:22>>*/ var
-            /*<<list.ml:508:22>>*/ c$4 =
-              /*<<list.ml:508:22>>*/ caml_call2(cmp, x1$0, x3),
-            /*<<list.ml:509:14>>*/ _l_ =
-             0 === c$4
-              ? [0, x1$0, [0, x2$0, 0]]
-              : 0
-                < c$4
-                ? [0, x1$0, [0, x3, [0, x2$0, 0]]]
-                : [0, x3, [0, x1$0, [0, x2$0, 0]]],
-           _k_ = _l_;
-         var s$0 = _k_;
-        }
-        else{
-          /*<<list.ml:513:20>>*/  /*<<list.ml:513:20>>*/ var
-          c$5 =  /*<<list.ml:513:20>>*/ caml_call2(cmp, x1$0, x3);
-          /*<<list.ml:514:12>>*/ if(0 === c$5)
-          var _m_ = [0, x2$0, [0, x1$0, 0]];
-         else if(0 < c$5)
-          var _m_ = [0, x2$0, [0, x1$0, [0, x3, 0]]];
-         else
-           /*<<list.ml:517:22>>*/ var
-            /*<<list.ml:517:22>>*/ c$6 =
-              /*<<list.ml:517:22>>*/ caml_call2(cmp, x2$0, x3),
-            /*<<list.ml:518:14>>*/ _n_ =
-             0 === c$6
-              ? [0, x2$0, [0, x1$0, 0]]
-              : 0
-                < c$6
-                ? [0, x2$0, [0, x3, [0, x1$0, 0]]]
-                : [0, x3, [0, x2$0, [0, x1$0, 0]]],
-           _m_ = _n_;
-         var s$0 = _m_;
-        }
-         /*<<list.ml:522:8>>*/ return [0, s$0, tl$1];
-       }
-      }
-     }
-      /*<<list.ml:526:21>>*/ var
-      n1 = n >> 1,
-      n2 = n - n1 | 0,
-       /*<<list.ml:526:21>>*/ match$0 = sort(n1, l),
-      l2$0 = match$0[2],
-      s1 = match$0[1],
-       /*<<list.ml:527:21>>*/ match$1 = sort(n2, l2$0),
-      tl$0 = match$1[2],
-      s2 = match$1[1],
-      l1 = s1,
-      l2 = s2,
-      accu = 0;
-      /*<<list.ml:428:4>>*/ for(;;){
-      if(l1){
-       if(l2){
-         /*<<list.ml:432:16>>*/ var
-         t2 = l2[2],
-         h2 = l2[1],
-         t1 = l1[2],
-         h1 = l1[1],
-          /*<<list.ml:432:16>>*/ c =
-            /*<<list.ml:432:16>>*/ caml_call2(cmp, h1, h2);
-         /*<<list.ml:433:8>>*/ if(0 === c){
-          /*<<list.ml:433:38>>*/ var
-           /*<<list.ml:433:38>>*/ accu$0 = [0, h1, accu],
-          l1 = t1,
-          l2 = t2,
-          accu = accu$0;
-         continue;
-        }
-        if(0 <= c){
-          /*<<list.ml:436:29>>*/ var
-           /*<<list.ml:436:29>>*/ accu$1 = [0, h2, accu],
-          l2 = t2,
-          accu = accu$1;
-         continue;
-        }
-         /*<<list.ml:435:29>>*/ var
-          /*<<list.ml:435:29>>*/ accu$2 = [0, h1, accu],
-         l1 = t1,
-         accu = accu$2;
-        continue;
-       }
-       var _h_ = rev_append(l1, accu);
-      }
-      else
-       var _h_ = rev_append(l2, accu);
-       /*<<list.ml:528:8>>*/ return [0, _h_, tl$0];
-     }
-     /*<<list.ml:528:32>>*/ }
-     /*<<list.ml:530:12>>*/  /*<<list.ml:530:12>>*/ var len = length(l);
-     /*<<list.ml:531:2>>*/ return 2 <= len ? sort(len, l)[1] : l;
-    /*<<list.ml:531:41>>*/ }
-   function compare_lengths(l1, l2){
-     /*<<list.ml:535:2>>*/ var l1$0 = l1, l2$0 = l2;
-     /*<<list.ml:535:2>>*/ for(;;){
-     if(! l1$0) return l2$0 ? -1 : 0;
-     if(! l2$0)  /*<<list.ml:538:13>>*/ return 1;
-     var l2$1 = l2$0[2], l1$1 = l1$0[2], l1$0 = l1$1, l2$0 = l2$1;
-    }
-    /*<<list.ml:539:45>>*/ }
-   function compare_length_with(l, n){
-     /*<<list.ml:542:2>>*/ var l$0 = l, n$0 = n;
-     /*<<list.ml:542:2>>*/ for(;;){
-     if(! l$0) return 0 === n$0 ? 0 : 0 < n$0 ? -1 : 1;
-     var l$1 = l$0[2];
-      /*<<list.ml:547:4>>*/ if(0 >= n$0)  /*<<list.ml:547:19>>*/ return 1;
-      /*<<list.ml:548:6>>*/ var
-       /*<<list.ml:548:6>>*/ n$1 = n$0 - 1 | 0,
-      l$0 = l$1,
-      n$0 = n$1;
-    }
-    /*<<list.ml:548:33>>*/ }
-   function equal(eq, l1, l2){
-     /*<<list.ml:558:2>>*/ var l1$0 = l1, l2$0 = l2;
-     /*<<list.ml:558:2>>*/ for(;;){
-     if(l1$0){
-      if(l2$0){
-        /*<<list.ml:561:22>>*/ var
-        l2$1 = l2$0[2],
-        a2 = l2$0[1],
-        l1$1 = l1$0[2],
-        a1 = l1$0[1],
-         /*<<list.ml:561:22>>*/ _g_ =
-           /*<<list.ml:561:22>>*/ caml_call2(eq, a1, a2);
-        /*<<list.ml:561:22>>*/ if(! _g_)  /*<<list.ml:561:22>>*/ return _g_;
-       var l1$0 = l1$1, l2$0 = l2$1;
-       continue;
-      }
-     }
-     else if(! l2$0)  /*<<list.ml:559:14>>*/ return 1;
-      /*<<list.ml:560:27>>*/ return 0;
-    }
-    /*<<list.ml:561:48>>*/ }
-   function compare(cmp, l1, l2){
-     /*<<list.ml:564:2>>*/ var l1$0 = l1, l2$0 = l2;
-     /*<<list.ml:564:2>>*/ for(;;){
-     if(! l1$0) return l2$0 ? -1 : 0;
-     var l1$1 = l1$0[2], a1 = l1$0[1];
-     if(! l2$0)  /*<<list.ml:567:16>>*/ return 1;
-      /*<<list.ml:569:12>>*/ var
-      l2$1 = l2$0[2],
-      a2 = l2$0[1],
-       /*<<list.ml:569:12>>*/ c =
-         /*<<list.ml:569:12>>*/ caml_call2(cmp, a1, a2);
-      /*<<list.ml:570:4>>*/ if(0 !== c)  /*<<list.ml:570:19>>*/ return c;
-     var l1$0 = l1$1, l2$0 = l2$1;
-    }
-    /*<<list.ml:571:26>>*/ }
-   function to_seq(l){
-     /*<<list.ml:576:2>>*/ function aux(l, param){
-      /*<<list.ml:576:21>>*/ if(! l)  /*<<list.ml:577:12>>*/ return 0;
-     var tail = l[2], x = l[1];
-      /*<<list.ml:578:19>>*/ return [0,
-             x,
-             function(_f_){ /*<<?>>*/ return aux(tail, _f_);}];
-     /*<<list.ml:578:41>>*/ }
-     /*<<list.ml:580:2>>*/ return function(_e_){
-      /*<<?>>*/ return aux(l, _e_);};
-    /*<<list.ml:580:7>>*/ }
-   function of_seq(seq){
-    function direct(depth, seq){
-      /*<<list.ml:584:4>>*/ if(0 === depth){
-      var
-       _c_ = 0,
-       _d_ =
-         function(acc, x){
-           /*<<list.ml:586:34>>*/ return [0, x, acc];
-          /*<<list.ml:586:40>>*/ };
-       /*<<list.ml:586:6>>*/ return rev
-              ( /*<<list.ml:586:6>>*/ caml_call3(Stdlib_Seq[5], _d_, _c_, seq));
-     }
-      /*<<list.ml:588:15>>*/  /*<<list.ml:588:15>>*/ var
-      match =  /*<<list.ml:588:15>>*/ caml_call1(seq, 0);
-     if(! match)  /*<<list.ml:589:19>>*/ return 0;
-     var next = match[2], x = match[1];
-      /*<<list.ml:590:30>>*/ return [0, x, direct(depth - 1 | 0, next)];
-     /*<<list.ml:590:56>>*/ }
-     /*<<list.ml:592:2>>*/ return direct(500, seq);
-    /*<<list.ml:592:16>>*/ }
-   var
-    Stdlib_List =
-      [0,
-       length,
-       compare_lengths,
-       compare_length_with,
-       cons,
-       hd,
-       tl,
-       nth,
-       nth_opt,
-       rev,
-       init,
-       append,
-       rev_append,
-       flatten,
-       flatten,
-       equal,
-       compare,
-       iter,
-       iteri,
-       map,
-       mapi,
-       rev_map,
-       filter_map,
-       concat_map,
-       fold_left_map,
-       fold_left,
-       fold_right,
-       iter2,
-       map2,
-       rev_map2,
-       fold_left2,
-       fold_right2,
-       for_all,
-       exists,
-       for_all2,
-       exists2,
-       mem,
-       memq,
-       find,
-       find_opt,
-       find_map,
-       find_all,
-       find_all,
-       filteri,
-       partition,
-       partition_map,
-       assoc,
-       assoc_opt,
-       assq,
-       assq_opt,
-       mem_assoc,
-       mem_assq,
-       remove_assoc,
-       remove_assq,
-       split,
-       combine,
-       stable_sort,
-       stable_sort,
-       stable_sort,
-       sort_uniq,
-       merge,
-       to_seq,
-       of_seq];
-   runtime.caml_register_global(18, Stdlib_List, "Stdlib__List");
-   return;
-   /*<<?>>*/ }
-  (globalThis));
-
-//# unitInfo: Provides: Stdlib__Int
-(function(globalThis){
-   "use strict";
-   var runtime = globalThis.jsoo_runtime, zero = 0, one = 1, minus_one = -1;
-   function abs(x){
-     /*<<int.ml:29:12>>*/ return 0 <= x ? x : - x | 0;
-    /*<<int.ml:29:36>>*/ }
-   var max_int = 2147483647, min_int = -2147483648;
-   function lognot(x){
-     /*<<int.ml:35:15>>*/ return x ^ -1;
-    /*<<int.ml:35:28>>*/ }
-   function equal(_b_, _a_){ /*<<?>>*/ return _b_ === _a_ ? 1 : 0;}
-   var compare = runtime.caml_int_compare;
-   function min(x, y){
-     /*<<int.ml:41:18>>*/ return x <= y ? x : y;
-    /*<<int.ml:41:41>>*/ }
-   function max(x, y){
-     /*<<int.ml:42:18>>*/ return y <= x ? x : y;
-    /*<<int.ml:42:41>>*/ }
-   function to_string(x){
-     /*<<int.ml:52:18>>*/ return "" + x;
-    /*<<int.ml:52:35>>*/ }
-   var
-    Stdlib_Int =
-      [0,
-       zero,
-       one,
-       minus_one,
-       abs,
-       max_int,
-       min_int,
-       lognot,
-       equal,
-       compare,
-       min,
-       max,
-       to_string];
-   runtime.caml_register_global(1, Stdlib_Int, "Stdlib__Int");
-   return;
-   /*<<?>>*/ }
-  (globalThis));
-
-//# unitInfo: Provides: Stdlib__Bytes
-//# unitInfo: Requires: Assert_failure, Stdlib, Stdlib__Char, Stdlib__Int, Stdlib__Seq, Stdlib__Sys, Stdlib__Uchar
-(function
-  (globalThis){
-   "use strict";
-   var
-    runtime = globalThis.jsoo_runtime,
-    cst_bytes_ml = "bytes.ml",
-    cst_index_out_of_bounds$3 = "index out of bounds",
-    caml_blit_bytes = runtime.caml_blit_bytes,
-    caml_bswap16 = runtime.caml_bswap16,
-    caml_bytes_get = runtime.caml_bytes_get,
-    caml_bytes_get16 = runtime.caml_bytes_get16,
-    caml_bytes_get32 = runtime.caml_bytes_get32,
-    caml_bytes_get64 = runtime.caml_bytes_get64,
-    caml_bytes_of_string = runtime.caml_bytes_of_string,
-    caml_bytes_set = runtime.caml_bytes_set,
-    caml_bytes_set16 = runtime.caml_bytes_set16,
-    caml_bytes_set32 = runtime.caml_bytes_set32,
-    caml_bytes_set64 = runtime.caml_bytes_set64,
-    caml_bytes_unsafe_get = runtime.caml_bytes_unsafe_get,
-    caml_bytes_unsafe_set = runtime.caml_bytes_unsafe_set,
-    caml_create_bytes = runtime.caml_create_bytes,
-    caml_fill_bytes = runtime.caml_fill_bytes,
-    caml_int32_bswap = runtime.caml_int32_bswap,
-    caml_int64_bswap = runtime.caml_int64_bswap,
-    caml_maybe_attach_backtrace = runtime.caml_maybe_attach_backtrace,
-    caml_ml_bytes_length = runtime.caml_ml_bytes_length,
-    caml_string_of_bytes = runtime.caml_string_of_bytes,
-    caml_wrap_exception = runtime.caml_wrap_exception;
-    /*<<?>>*/ function caml_call1(f, a0){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 1
-            ? f(a0)
-            : runtime.caml_call_gen(f, [a0]);
-   }
-    /*<<?>>*/ function caml_call2(f, a0, a1){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 2
-            ? f(a0, a1)
-            : runtime.caml_call_gen(f, [a0, a1]);
-   }
-   var
-    global_data = runtime.caml_get_global_data(),
-    Stdlib = global_data.Stdlib,
-    Stdlib_Uchar = global_data.Stdlib__Uchar,
-    Assert_failure = global_data.Assert_failure,
-    Stdlib_Sys = global_data.Stdlib__Sys,
-    Stdlib_Int = global_data.Stdlib__Int,
-    Stdlib_Seq = global_data.Stdlib__Seq,
-    Stdlib_Char = global_data.Stdlib__Char,
-    cst_index_out_of_bounds$2 = cst_index_out_of_bounds$3,
-    _f_ = [0, cst_bytes_ml, 820, 20],
-    _e_ = [0, cst_bytes_ml, 831, 9],
-    cst_index_out_of_bounds$1 = cst_index_out_of_bounds$3,
-    cst_index_out_of_bounds$0 = cst_index_out_of_bounds$3,
-    _d_ = [0, cst_bytes_ml, 766, 20],
-    _c_ = [0, cst_bytes_ml, 777, 9],
-    cst_index_out_of_bounds = cst_index_out_of_bounds$3,
-    _b_ = [0, cst_bytes_ml, 654, 20],
-    _a_ = [0, cst_bytes_ml, 679, 9],
-    cst_Bytes_of_seq_cannot_grow_b = "Bytes.of_seq: cannot grow bytes",
-    cst_String_rcontains_from_Byte =
-      "String.rcontains_from / Bytes.rcontains_from",
-    cst_String_contains_from_Bytes =
-      "String.contains_from / Bytes.contains_from",
-    cst_String_rindex_from_opt_Byt =
-      "String.rindex_from_opt / Bytes.rindex_from_opt",
-    cst_String_rindex_from_Bytes_r = "String.rindex_from / Bytes.rindex_from",
-    cst_String_index_from_opt_Byte =
-      "String.index_from_opt / Bytes.index_from_opt",
-    cst_String_index_from_Bytes_in = "String.index_from / Bytes.index_from",
-    cst_Bytes_concat = "Bytes.concat",
-    cst_String_blit_Bytes_blit_str = "String.blit / Bytes.blit_string",
-    cst_Bytes_blit = "Bytes.blit",
-    cst_String_fill_Bytes_fill = "String.fill / Bytes.fill",
-    cst_Bytes_extend = "Bytes.extend",
-    cst_String_sub_Bytes_sub = "String.sub / Bytes.sub";
-   function make(n, c){
-     /*<<bytes.ml:42:2>>*/  /*<<bytes.ml:42:10>>*/ var
-     s =  /*<<bytes.ml:42:10>>*/ caml_create_bytes(n);
-     /*<<bytes.ml:43:2>>*/  /*<<bytes.ml:43:2>>*/ caml_fill_bytes(s, 0, n, c);
-     /*<<bytes.ml:43:2>>*/ return s;
-    /*<<bytes.ml:44:3>>*/ }
-   function init(n, f){
-     /*<<bytes.ml:47:2>>*/ var
-      /*<<bytes.ml:47:10>>*/ s =  /*<<bytes.ml:47:10>>*/ caml_create_bytes(n),
-      /*<<bytes.ml:48:2>>*/ _aq_ = n - 1 | 0,
-      /*<<bytes.ml:47:10>>*/ _ap_ = 0;
-    if(_aq_ >= 0){
-     var i = _ap_;
-     for(;;){
-      caml_bytes_unsafe_set(s, i,  /*<<bytes.ml:49:19>>*/ caml_call1(f, i));
-       /*<<bytes.ml:48:2>>*/  /*<<bytes.ml:48:2>>*/ var _ar_ = i + 1 | 0;
-      if(_aq_ === i) break;
-      var i = _ar_;
-     }
-    }
-     /*<<bytes.ml:51:2>>*/ return s;
-    /*<<bytes.ml:51:3>>*/ }
-    /*<<bytes.ml:53:12>>*/  /*<<bytes.ml:53:12>>*/ var
-    empty =  /*<<bytes.ml:53:12>>*/ caml_create_bytes(0);
-   function copy(s){
-     /*<<bytes.ml:56:2>>*/ var
-     len = caml_ml_bytes_length(s),
-      /*<<bytes.ml:57:10>>*/ r =
-        /*<<bytes.ml:57:10>>*/ caml_create_bytes(len);
-     /*<<bytes.ml:58:2>>*/  /*<<bytes.ml:58:2>>*/ caml_blit_bytes
-     (s, 0, r, 0, len);
-     /*<<bytes.ml:58:2>>*/ return r;
-    /*<<bytes.ml:59:3>>*/ }
-   function to_string(b){
-     /*<<bytes.ml:61:18>>*/ return  /*<<bytes.ml:61:35>>*/ caml_string_of_bytes
-            (copy(b));
-    /*<<bytes.ml:61:43>>*/ }
-   function of_string(s){
-     /*<<bytes.ml:62:18>>*/ return copy(caml_bytes_of_string(s));
-    /*<<bytes.ml:62:43>>*/ }
-   function sub(s, ofs, len){
-     /*<<bytes.ml:65:2>>*/ if
-     (0 <= ofs && 0 <= len && (caml_ml_bytes_length(s) - len | 0) >= ofs){
-      /*<<bytes.ml:68:12>>*/  /*<<bytes.ml:68:12>>*/ var
-      r =  /*<<bytes.ml:68:12>>*/ caml_create_bytes(len);
-      /*<<bytes.ml:69:4>>*/  /*<<bytes.ml:69:4>>*/ caml_blit_bytes
-      (s, ofs, r, 0, len);
-      /*<<bytes.ml:69:4>>*/ return r;
-    }
-     /*<<bytes.ml:66:7>>*/ return  /*<<bytes.ml:66:7>>*/ caml_call1
-            (Stdlib[1], cst_String_sub_Bytes_sub);
-    /*<<bytes.ml:71:5>>*/ }
-   function sub_string(b, ofs, len){
-     /*<<bytes.ml:73:27>>*/ return  /*<<bytes.ml:73:44>>*/ caml_string_of_bytes
-            (sub(b, ofs, len));
-    /*<<bytes.ml:73:59>>*/ }
-   function symbol(a, b){
-     /*<<bytes.ml:77:2>>*/ var
-     c = a + b | 0,
-     _ao_ = b < 0 ? 1 : 0,
-     match = c < 0 ? 1 : 0;
-    a:
-    {
-     if(a < 0){if(_ao_ && ! match) break a;} else if(! _ao_ && match) break a;
-      /*<<bytes.ml:81:9>>*/ return c;
-    }
-     /*<<bytes.ml:80:27>>*/ return  /*<<bytes.ml:80:27>>*/ caml_call1
-            (Stdlib[1], cst_Bytes_extend);
-    /*<<bytes.ml:81:10>>*/ }
-   function extend(s, left, right){
-     /*<<bytes.ml:84:2>>*/ var
-      /*<<bytes.ml:84:12>>*/ len =
-       symbol(symbol(caml_ml_bytes_length(s), left), right),
-      /*<<bytes.ml:85:10>>*/ r =
-        /*<<bytes.ml:85:10>>*/ caml_create_bytes(len);
-    if(0 <= left)
-     var dstoff = left, srcoff = 0;
-    else
-     var dstoff = 0, srcoff = - left | 0;
-     /*<<bytes.ml:87:15>>*/  /*<<bytes.ml:87:15>>*/ var
-     cpylen =
-        /*<<bytes.ml:87:15>>*/ caml_call2
-        (Stdlib_Int[10],
-         caml_ml_bytes_length(s) - srcoff | 0,
-         len - dstoff | 0);
-    if(0 < cpylen)
-      /*<<bytes.ml:88:21>>*/  /*<<bytes.ml:88:21>>*/ caml_blit_bytes
-      (s, srcoff, r, dstoff, cpylen);
-     /*<<bytes.ml:88:21>>*/ return r;
-    /*<<bytes.ml:89:3>>*/ }
-   function fill(s, ofs, len, c){
-     /*<<bytes.ml:92:2>>*/ if
-     (0 <= ofs && 0 <= len && (caml_ml_bytes_length(s) - len | 0) >= ofs)
-      /*<<bytes.ml:94:7>>*/ return  /*<<bytes.ml:94:7>>*/ caml_fill_bytes
-             (s, ofs, len, c);
-     /*<<bytes.ml:93:7>>*/ return  /*<<bytes.ml:93:7>>*/ caml_call1
-            (Stdlib[1], cst_String_fill_Bytes_fill);
-    /*<<bytes.ml:94:30>>*/ }
-   function blit(s1, ofs1, s2, ofs2, len){
-     /*<<bytes.ml:97:2>>*/ if
-     (0 <= len
-      &&
-       0 <= ofs1
-       &&
-        (caml_ml_bytes_length(s1) - len | 0) >= ofs1
-        && 0 <= ofs2 && (caml_ml_bytes_length(s2) - len | 0) >= ofs2)
-      /*<<bytes.ml:100:7>>*/ return  /*<<bytes.ml:100:7>>*/ caml_blit_bytes
-             (s1, ofs1, s2, ofs2, len);
-     /*<<bytes.ml:99:7>>*/ return  /*<<bytes.ml:99:7>>*/ caml_call1
-            (Stdlib[1], cst_Bytes_blit);
-    /*<<bytes.ml:100:38>>*/ }
-   function blit_string(s1, ofs1, s2, ofs2, len){
-     /*<<bytes.ml:103:2>>*/ if
-     (0 <= len
-      &&
-       0 <= ofs1
-       &&
-        (runtime.caml_ml_string_length(s1) - len | 0) >= ofs1
-        && 0 <= ofs2 && (caml_ml_bytes_length(s2) - len | 0) >= ofs2)
-      /*<<bytes.ml:106:7>>*/ return  /*<<bytes.ml:106:7>>*/ runtime.caml_blit_string
-             (s1, ofs1, s2, ofs2, len);
-     /*<<bytes.ml:105:7>>*/ return  /*<<bytes.ml:105:7>>*/ caml_call1
-            (Stdlib[1], cst_String_blit_Bytes_blit_str);
-    /*<<bytes.ml:106:45>>*/ }
-   function iter(f, a){
-     /*<<bytes.ml:110:2>>*/ var
-     _am_ = caml_ml_bytes_length(a) - 1 | 0,
-      /*<<bytes.ml:110:2>>*/ _al_ = 0;
-    if(_am_ >= 0){
-     var i = _al_;
-     for(;;){
-       /*<<bytes.ml:110:31>>*/  /*<<bytes.ml:110:31>>*/ caml_call1
-       (f, caml_bytes_unsafe_get(a, i));
-       /*<<bytes.ml:110:31>>*/  /*<<bytes.ml:110:31>>*/ var _an_ = i + 1 | 0;
-      if(_am_ === i) break;
-      var i = _an_;
-     }
-    }
-    return 0;
-    /*<<bytes.ml:110:53>>*/ }
-   function iteri(f, a){
-     /*<<bytes.ml:114:2>>*/ var
-     _aj_ = caml_ml_bytes_length(a) - 1 | 0,
-      /*<<bytes.ml:114:2>>*/ _ai_ = 0;
-    if(_aj_ >= 0){
-     var i = _ai_;
-     for(;;){
-       /*<<bytes.ml:114:31>>*/  /*<<bytes.ml:114:31>>*/ caml_call2
-       (f, i, caml_bytes_unsafe_get(a, i));
-       /*<<bytes.ml:114:31>>*/  /*<<bytes.ml:114:31>>*/ var _ak_ = i + 1 | 0;
-      if(_aj_ === i) break;
-      var i = _ak_;
-     }
-    }
-    return 0;
-    /*<<bytes.ml:114:56>>*/ }
-   function concat(sep, l){
-     /*<<?>>*/ if(! l)  /*<<bytes.ml:53:12>>*/ return empty;
-    var seplen = caml_ml_bytes_length(sep), acc = 0, param = l, pos$1 = 0;
-    for(;;){
-     if(param){
-      var hd = param[1];
-      if(param[2]){
-       var
-        tl = param[2],
-        x = (caml_ml_bytes_length(hd) + seplen | 0) + acc | 0,
-        acc$0 =
-          acc <= x
-           ? x
-           :  /*<<bytes.ml:116:48>>*/ caml_call1(Stdlib[1], cst_Bytes_concat),
-        acc = acc$0,
-        param = tl;
-       continue;
-      }
-      var _ah_ = caml_ml_bytes_length(hd) + acc | 0;
-     }
-     else
-      var _ah_ = acc;
-      /*<<bytes.ml:136:12>>*/ var
-       /*<<bytes.ml:136:12>>*/ dst =
-         /*<<bytes.ml:136:12>>*/ caml_create_bytes(_ah_),
-      pos = pos$1,
-      param$0 = l;
-     for(;;){
-      if(! param$0)  /*<<bytes.ml:124:10>>*/ return dst;
-      var hd$0 = param$0[1];
-      if(! param$0[2]){
-        /*<<bytes.ml:126:4>>*/  /*<<bytes.ml:126:4>>*/ caml_blit_bytes
-        (hd$0, 0, dst, pos, caml_ml_bytes_length(hd$0));
-        /*<<bytes.ml:126:4>>*/ return dst;
-      }
-      var tl$0 = param$0[2];
-       /*<<bytes.ml:128:4>>*/  /*<<bytes.ml:128:4>>*/ caml_blit_bytes
-       (hd$0, 0, dst, pos,  /*<<bytes.ml:128:4>>*/ caml_ml_bytes_length(hd$0));
-       /*<<bytes.ml:129:4>>*/  /*<<bytes.ml:129:4>>*/ caml_blit_bytes
-       (sep, 0, dst, pos + caml_ml_bytes_length(hd$0) | 0, seplen);
-      var
-       pos$0 = (pos + caml_ml_bytes_length(hd$0) | 0) + seplen | 0,
-       pos = pos$0,
-       param$0 = tl$0;
-     }
-    }
-   }
-   function cat(s1, s2){
-     /*<<bytes.ml:140:2>>*/ var
-     l1 = caml_ml_bytes_length(s1),
-      /*<<bytes.ml:141:2>>*/ l2 =
-        /*<<bytes.ml:141:2>>*/ caml_ml_bytes_length(s2),
-      /*<<bytes.ml:142:10>>*/ r =
-        /*<<bytes.ml:142:10>>*/ caml_create_bytes(l1 + l2 | 0);
-     /*<<bytes.ml:143:2>>*/  /*<<bytes.ml:143:2>>*/ caml_blit_bytes
-     (s1, 0, r, 0, l1);
-     /*<<bytes.ml:144:2>>*/  /*<<bytes.ml:144:2>>*/ caml_blit_bytes
-     (s2, 0, r, l1, l2);
-     /*<<bytes.ml:144:2>>*/ return r;
-    /*<<bytes.ml:145:3>>*/ }
-   function is_space(param){
-     /*<<bytes.ml:151:15>>*/  /*<<bytes.ml:151:15>>*/ var
-     _ag_ = param - 9 | 0;
-    a:
-    {
-     if(4 < _ag_ >>> 0){if(23 !== _ag_) break a;} else if(2 === _ag_) break a;
-      /*<<bytes.ml:152:41>>*/ return 1;
-    }
-     /*<<bytes.ml:153:9>>*/ return 0;
-    /*<<bytes.ml:153:14>>*/ }
-   function trim(s){
-     /*<<bytes.ml:156:2>>*/ var
-     len = caml_ml_bytes_length(s),
-      /*<<bytes.ml:157:10>>*/ i = [0, 0];
-    for(;;){
-      /*<<bytes.ml:158:20>>*/ if
-      (i[1] < len && is_space(caml_bytes_unsafe_get(s, i[1]))){i[1]++; continue;}
-      /*<<bytes.ml:161:10>>*/  /*<<bytes.ml:161:10>>*/ var
-      j = [0, len - 1 | 0];
-     for(;;){
-       /*<<bytes.ml:162:20>>*/ if
-       (i[1] <= j[1] && is_space(caml_bytes_unsafe_get(s, j[1]))){j[1] += -1; continue;}
-      return i[1] <= j[1] ? sub(s, i[1], (j[1] - i[1] | 0) + 1 | 0) : empty;
-     }
-    }
-    /*<<bytes.ml:168:9>>*/ }
-   function unsafe_escape(s){
-     /*<<bytes.ml:184:2>>*/ var
-      /*<<bytes.ml:184:10>>*/ n = [0, 0],
-     _$_ = caml_ml_bytes_length(s) - 1 | 0,
-      /*<<bytes.ml:184:10>>*/ ___ = 0;
-    if(_$_ >= 0){
-     var i$0 = ___;
-     for(;;){
-      var match = caml_bytes_unsafe_get(s, i$0);
-      a:
-      {
-       b:
-       {
-        c:
-        {
-         if(32 <= match){
-          var _ad_ = match - 34 | 0;
-          if(58 < _ad_ >>> 0){
-           if(93 <= _ad_) break c;
-          }
-          else if(56 < _ad_ - 1 >>> 0) break b;
-          var _ae_ = 1;
-          break a;
-         }
-         if(11 <= match){
-          if(13 === match) break b;
-         }
-         else if(8 <= match) break b;
-        }
-        var _ae_ = 4;
-        break a;
-       }
-       var _ae_ = 2;
-      }
-      n[1] = n[1] + _ae_ | 0;
-       /*<<bytes.ml:185:2>>*/  /*<<bytes.ml:185:2>>*/ var _af_ = i$0 + 1 | 0;
-      if(_$_ === i$0) break;
-      var i$0 = _af_;
-     }
-    }
-    if(n[1] === caml_ml_bytes_length(s))  /*<<bytes.ml:192:24>>*/ return s;
-     /*<<bytes.ml:194:13>>*/  /*<<bytes.ml:194:13>>*/ var
-     s$0 =  /*<<bytes.ml:194:13>>*/ caml_create_bytes(n[1]);
-    n[1] = 0;
-     /*<<bytes.ml:196:4>>*/ var
-     _ab_ = caml_ml_bytes_length(s) - 1 | 0,
-      /*<<bytes.ml:196:4>>*/ _aa_ = 0;
-    if(_ab_ >= 0){
-     var i = _aa_;
-     for(;;){
-      var c = caml_bytes_unsafe_get(s, i);
-      a:
-      {
-       b:
-       {
-        c:
-        {
-         if(35 <= c){
-          if(92 !== c){if(127 <= c) break c; break b;}
-         }
-         else{
-          if(32 > c){
-           if(14 <= c) break c;
-           switch(c){
-             case 8:
-              caml_bytes_unsafe_set(s$0, n[1], 92);
-              n[1]++;
-              caml_bytes_unsafe_set(s$0, n[1], 98);
-              break a;
-             case 9:
-              caml_bytes_unsafe_set(s$0, n[1], 92);
-              n[1]++;
-              caml_bytes_unsafe_set(s$0, n[1], 116);
-              break a;
-             case 10:
-              caml_bytes_unsafe_set(s$0, n[1], 92);
-              n[1]++;
-              caml_bytes_unsafe_set(s$0, n[1], 110);
-              break a;
-             case 13:
-              caml_bytes_unsafe_set(s$0, n[1], 92);
-              n[1]++;
-              caml_bytes_unsafe_set(s$0, n[1], 114);
-              break a;
-             default: break c;
-           }
-          }
-          if(34 > c) break b;
-         }
-         caml_bytes_unsafe_set(s$0, n[1], 92);
-         n[1]++;
-         caml_bytes_unsafe_set(s$0, n[1], c);
-         break a;
-        }
-        caml_bytes_unsafe_set(s$0, n[1], 92);
-        n[1]++;
-        caml_bytes_unsafe_set(s$0, n[1], 48 + (c / 100 | 0) | 0);
-        n[1]++;
-        caml_bytes_unsafe_set(s$0, n[1], 48 + ((c / 10 | 0) % 10 | 0) | 0);
-        n[1]++;
-        caml_bytes_unsafe_set(s$0, n[1], 48 + (c % 10 | 0) | 0);
-        break a;
-       }
-       caml_bytes_unsafe_set(s$0, n[1], c);
-      }
-      n[1]++;
-       /*<<bytes.ml:196:4>>*/  /*<<bytes.ml:196:4>>*/ var _ac_ = i + 1 | 0;
-      if(_ab_ === i) break;
-      var i = _ac_;
-     }
-    }
-     /*<<bytes.ml:221:4>>*/ return s$0;
-    /*<<bytes.ml:222:5>>*/ }
-   function escaped(b){
-     /*<<bytes.ml:225:2>>*/  /*<<bytes.ml:225:10>>*/ var b$0 = copy(b);
-     /*<<bytes.ml:228:2>>*/ return unsafe_escape(b$0);
-    /*<<bytes.ml:228:17>>*/ }
-   function map(f, s){
-     /*<<bytes.ml:231:2>>*/ var l = caml_ml_bytes_length(s);
-     /*<<bytes.ml:232:2>>*/ if(0 === l)  /*<<bytes.ml:232:16>>*/ return s;
-     /*<<bytes.ml:233:12>>*/ var
-      /*<<bytes.ml:233:12>>*/ r =
-        /*<<bytes.ml:233:12>>*/ caml_create_bytes(l),
-      /*<<bytes.ml:234:4>>*/ _Y_ = l - 1 | 0,
-      /*<<bytes.ml:233:12>>*/ _X_ = 0;
-    if(_Y_ >= 0){
-     var i = _X_;
-     for(;;){
-      caml_bytes_unsafe_set
-       (r,
-        i,
-         /*<<bytes.ml:234:41>>*/ caml_call1(f, caml_bytes_unsafe_get(s, i)));
-       /*<<bytes.ml:234:4>>*/  /*<<bytes.ml:234:4>>*/ var _Z_ = i + 1 | 0;
-      if(_Y_ === i) break;
-      var i = _Z_;
-     }
-    }
-     /*<<bytes.ml:235:4>>*/ return r;
-    /*<<bytes.ml:236:5>>*/ }
-   function mapi(f, s){
-     /*<<bytes.ml:239:2>>*/ var l = caml_ml_bytes_length(s);
-     /*<<bytes.ml:240:2>>*/ if(0 === l)  /*<<bytes.ml:240:16>>*/ return s;
-     /*<<bytes.ml:241:12>>*/ var
-      /*<<bytes.ml:241:12>>*/ r =
-        /*<<bytes.ml:241:12>>*/ caml_create_bytes(l),
-      /*<<bytes.ml:242:4>>*/ _V_ = l - 1 | 0,
-      /*<<bytes.ml:241:12>>*/ _U_ = 0;
-    if(_V_ >= 0){
-     var i = _U_;
-     for(;;){
-      caml_bytes_unsafe_set
-       (r,
-        i,
-         /*<<bytes.ml:242:41>>*/ caml_call2(f, i, caml_bytes_unsafe_get(s, i)));
-       /*<<bytes.ml:242:4>>*/  /*<<bytes.ml:242:4>>*/ var _W_ = i + 1 | 0;
-      if(_V_ === i) break;
-      var i = _W_;
-     }
-    }
-     /*<<bytes.ml:243:4>>*/ return r;
-    /*<<bytes.ml:244:5>>*/ }
-   function fold_left(f, x, a){
-     /*<<bytes.ml:247:2>>*/ var
-      /*<<bytes.ml:247:10>>*/ r = [0, x],
-     _S_ = caml_ml_bytes_length(a) - 1 | 0,
-      /*<<bytes.ml:247:10>>*/ _R_ = 0;
-    if(_S_ >= 0){
-     var i = _R_;
-     for(;;){
-      r[1] =
-        /*<<bytes.ml:249:9>>*/ caml_call2
-        (f, r[1], caml_bytes_unsafe_get(a, i));
-       /*<<bytes.ml:248:2>>*/  /*<<bytes.ml:248:2>>*/ var _T_ = i + 1 | 0;
-      if(_S_ === i) break;
-      var i = _T_;
-     }
-    }
-    return r[1];
-    /*<<bytes.ml:251:4>>*/ }
-   function fold_right(f, a, x){
-     /*<<bytes.ml:254:2>>*/ var
-      /*<<bytes.ml:254:10>>*/ r = [0, x],
-      /*<<bytes.ml:255:2>>*/ _P_ =
-        /*<<bytes.ml:255:2>>*/ caml_ml_bytes_length(a) - 1 | 0;
-    if(_P_ >= 0){
-     var i = _P_;
-     for(;;){
-      r[1] =
-        /*<<bytes.ml:256:9>>*/ caml_call2
-        (f, caml_bytes_unsafe_get(a, i), r[1]);
-       /*<<bytes.ml:255:2>>*/  /*<<bytes.ml:255:2>>*/ var _Q_ = i - 1 | 0;
-      if(0 === i) break;
-      var i = _Q_;
-     }
-    }
-    return r[1];
-    /*<<bytes.ml:258:4>>*/ }
-   function exists(p, s){
-     /*<<bytes.ml:261:2>>*/ var n = caml_ml_bytes_length(s), i = 0;
-     /*<<bytes.ml:263:4>>*/ for(;;){
-     if(i === n)  /*<<bytes.ml:263:18>>*/ return 0;
-      /*<<bytes.ml:264:12>>*/ if
-      ( /*<<bytes.ml:264:12>>*/ caml_call1(p, caml_bytes_unsafe_get(s, i)))
-       /*<<bytes.ml:264:36>>*/ return 1;
-      /*<<bytes.ml:265:9>>*/ var
-       /*<<bytes.ml:265:9>>*/ i$0 = i + 1 | 0,
-      i = i$0;
-    }
-    /*<<bytes.ml:266:8>>*/ }
-   function for_all(p, s){
-     /*<<bytes.ml:269:2>>*/ var n = caml_ml_bytes_length(s), i = 0;
-     /*<<bytes.ml:271:4>>*/ for(;;){
-     if(i === n)  /*<<bytes.ml:271:18>>*/ return 1;
-      /*<<bytes.ml:272:12>>*/ if
-      (!  /*<<bytes.ml:272:12>>*/ caml_call1(p, caml_bytes_unsafe_get(s, i)))
-       /*<<bytes.ml:273:9>>*/ return 0;
-      /*<<bytes.ml:272:36>>*/ var
-       /*<<bytes.ml:272:36>>*/ i$0 = i + 1 | 0,
-      i = i$0;
-    }
-    /*<<bytes.ml:274:8>>*/ }
-   function uppercase_ascii(s){
-     /*<<bytes.ml:276:24>>*/ return map(Stdlib_Char[4], s);
-    /*<<bytes.ml:276:50>>*/ }
-   function lowercase_ascii(s){
-     /*<<bytes.ml:277:24>>*/ return map(Stdlib_Char[3], s);
-    /*<<bytes.ml:277:50>>*/ }
-   function apply1(f, s){
-     /*<<bytes.ml:280:2>>*/ if(0 === caml_ml_bytes_length(s))
-      /*<<bytes.ml:280:23>>*/ return s;
-     /*<<bytes.ml:281:12>>*/  /*<<bytes.ml:281:12>>*/ var r = copy(s);
-    caml_bytes_unsafe_set
-     (r,
-      0,
-       /*<<bytes.ml:282:19>>*/ caml_call1(f, caml_bytes_unsafe_get(s, 0)));
-     /*<<bytes.ml:283:4>>*/ return r;
-    /*<<bytes.ml:284:5>>*/ }
-   function capitalize_ascii(s){
-     /*<<bytes.ml:286:25>>*/ return apply1(Stdlib_Char[4], s);
-    /*<<bytes.ml:286:54>>*/ }
-   function uncapitalize_ascii(s){
-     /*<<bytes.ml:287:27>>*/ return apply1(Stdlib_Char[3], s);
-    /*<<bytes.ml:287:56>>*/ }
-   function starts_with(prefix, s){
-     /*<<bytes.ml:291:2>>*/ var
-     len_s = caml_ml_bytes_length(s),
-     len_pre = caml_ml_bytes_length(prefix),
-     _O_ = len_pre <= len_s ? 1 : 0;
-    if(! _O_) return _O_;
-    var i = 0;
-     /*<<bytes.ml:294:4>>*/ for(;;){
-     if(i === len_pre)  /*<<bytes.ml:294:24>>*/ return 1;
-     if(caml_bytes_unsafe_get(s, i) !== caml_bytes_unsafe_get(prefix, i))
-       /*<<bytes.ml:295:55>>*/ return 0;
-      /*<<bytes.ml:296:9>>*/ var
-       /*<<bytes.ml:296:9>>*/ i$0 = i + 1 | 0,
-      i = i$0;
-    }
-    /*<<bytes.ml:297:30>>*/ }
-   function ends_with(suffix, s){
-     /*<<bytes.ml:301:2>>*/ var
-     len_s = caml_ml_bytes_length(s),
-     len_suf = caml_ml_bytes_length(suffix),
-     diff = len_s - len_suf | 0,
-     _N_ = 0 <= diff ? 1 : 0;
-    if(! _N_) return _N_;
-    var i = 0;
-     /*<<bytes.ml:305:4>>*/ for(;;){
-     if(i === len_suf)  /*<<bytes.ml:305:24>>*/ return 1;
-     if
-      (caml_bytes_unsafe_get(s, diff + i | 0)
-       !== caml_bytes_unsafe_get(suffix, i))
-       /*<<bytes.ml:306:64>>*/ return 0;
-      /*<<bytes.ml:307:9>>*/ var
-       /*<<bytes.ml:307:9>>*/ i$0 = i + 1 | 0,
-      i = i$0;
-    }
-    /*<<bytes.ml:308:23>>*/ }
-   function index_rec(s, lim, i, c){
-     /*<<bytes.ml:312:2>>*/ var i$0 = i;
-     /*<<bytes.ml:312:2>>*/ for(;;){
-     if(lim <= i$0)
-       /*<<bytes.ml:312:19>>*/ throw  /*<<bytes.ml:312:19>>*/ caml_maybe_attach_backtrace
-             (Stdlib[8], 1);
-     if(caml_bytes_unsafe_get(s, i$0) === c)
-       /*<<bytes.ml:313:29>>*/ return i$0;
-     var i$1 = i$0 + 1 | 0, i$0 = i$1;
-    }
-    /*<<bytes.ml:313:61>>*/ }
-   function index(s, c){
-     /*<<bytes.ml:316:16>>*/ return index_rec
-            (s, caml_ml_bytes_length(s), 0, c);
-    /*<<bytes.ml:316:42>>*/ }
-   function index_rec_opt(s, lim, i, c){
-     /*<<bytes.ml:320:2>>*/ var i$0 = i;
-     /*<<bytes.ml:320:2>>*/ for(;;){
-     if(lim <= i$0)  /*<<bytes.ml:320:19>>*/ return 0;
-     if(caml_bytes_unsafe_get(s, i$0) === c)
-       /*<<bytes.ml:321:29>>*/ return [0, i$0];
-     var i$1 = i$0 + 1 | 0, i$0 = i$1;
-    }
-    /*<<bytes.ml:321:70>>*/ }
-   function index_opt(s, c){
-     /*<<bytes.ml:324:20>>*/ return index_rec_opt
-            (s, caml_ml_bytes_length(s), 0, c);
-    /*<<bytes.ml:324:50>>*/ }
-   function index_from(s, i, c){
-     /*<<bytes.ml:328:2>>*/ var l = caml_ml_bytes_length(s);
-    if(0 <= i && l >= i)  /*<<bytes.ml:330:2>>*/ return index_rec(s, l, i, c);
-     /*<<bytes.ml:329:25>>*/ return  /*<<bytes.ml:329:25>>*/ caml_call1
-            (Stdlib[1], cst_String_index_from_Bytes_in);
-    /*<<bytes.ml:330:19>>*/ }
-   function index_from_opt(s, i, c){
-     /*<<bytes.ml:334:2>>*/ var l = caml_ml_bytes_length(s);
-    if(0 <= i && l >= i)
-      /*<<bytes.ml:338:4>>*/ return index_rec_opt(s, l, i, c);
-     /*<<bytes.ml:336:4>>*/ return  /*<<bytes.ml:336:4>>*/ caml_call1
-            (Stdlib[1], cst_String_index_from_opt_Byte);
-    /*<<bytes.ml:338:25>>*/ }
-   function rindex_rec(s, i, c){
-     /*<<bytes.ml:342:2>>*/ var i$0 = i;
-     /*<<bytes.ml:342:2>>*/ for(;;){
-     if(0 > i$0)
-       /*<<bytes.ml:342:16>>*/ throw  /*<<bytes.ml:342:16>>*/ caml_maybe_attach_backtrace
-             (Stdlib[8], 1);
-     if(caml_bytes_unsafe_get(s, i$0) === c)
-       /*<<bytes.ml:343:29>>*/ return i$0;
-     var i$1 = i$0 - 1 | 0, i$0 = i$1;
-    }
-    /*<<bytes.ml:343:58>>*/ }
-   function rindex(s, c){
-     /*<<bytes.ml:346:17>>*/ return rindex_rec
-            (s, caml_ml_bytes_length(s) - 1 | 0, c);
-    /*<<bytes.ml:346:46>>*/ }
-   function rindex_from(s, i, c){
-     /*<<bytes.ml:350:2>>*/ if(-1 <= i && caml_ml_bytes_length(s) > i)
-      /*<<bytes.ml:353:4>>*/ return rindex_rec(s, i, c);
-     /*<<bytes.ml:351:4>>*/ return  /*<<bytes.ml:351:4>>*/ caml_call1
-            (Stdlib[1], cst_String_rindex_from_Bytes_r);
-    /*<<bytes.ml:353:20>>*/ }
-   function rindex_rec_opt(s, i, c){
-     /*<<bytes.ml:357:2>>*/ var i$0 = i;
-     /*<<bytes.ml:357:2>>*/ for(;;){
-     if(0 > i$0)  /*<<bytes.ml:357:16>>*/ return 0;
-     if(caml_bytes_unsafe_get(s, i$0) === c)
-       /*<<bytes.ml:358:29>>*/ return [0, i$0];
-     var i$1 = i$0 - 1 | 0, i$0 = i$1;
-    }
-    /*<<bytes.ml:358:67>>*/ }
-   function rindex_opt(s, c){
-     /*<<bytes.ml:361:21>>*/ return rindex_rec_opt
-            (s, caml_ml_bytes_length(s) - 1 | 0, c);
-    /*<<bytes.ml:361:54>>*/ }
-   function rindex_from_opt(s, i, c){
-     /*<<bytes.ml:365:2>>*/ if(-1 <= i && caml_ml_bytes_length(s) > i)
-      /*<<bytes.ml:368:4>>*/ return rindex_rec_opt(s, i, c);
-     /*<<bytes.ml:366:4>>*/ return  /*<<bytes.ml:366:4>>*/ caml_call1
-            (Stdlib[1], cst_String_rindex_from_opt_Byt);
-    /*<<bytes.ml:368:24>>*/ }
-   function contains_from(s, i, c){
-     /*<<bytes.ml:373:2>>*/ var l = caml_ml_bytes_length(s);
-    if(0 <= i && l >= i)
-      /*<<bytes.ml:377:4>>*/ try{
-       /*<<bytes.ml:377:15>>*/ index_rec(s, l, i, c);
-       /*<<bytes.ml:377:36>>*/  /*<<bytes.ml:377:36>>*/ var _L_ = 1;
-       /*<<bytes.ml:377:36>>*/ return _L_;
-     }
-     catch(_M_){
-      var _K_ = caml_wrap_exception(_M_);
-      if(_K_ === Stdlib[8])  /*<<bytes.ml:377:59>>*/ return 0;
-      throw caml_maybe_attach_backtrace(_K_, 0);
-     }
-     /*<<bytes.ml:375:4>>*/ return  /*<<bytes.ml:375:4>>*/ caml_call1
-            (Stdlib[1], cst_String_contains_from_Bytes);
-    /*<<bytes.ml:377:64>>*/ }
-   function contains(s, c){
-     /*<<bytes.ml:381:19>>*/ return contains_from(s, 0, c);
-    /*<<bytes.ml:381:38>>*/ }
-   function rcontains_from(s, i, c){
-     /*<<bytes.ml:385:2>>*/ if(0 <= i && caml_ml_bytes_length(s) > i)
-      /*<<bytes.ml:388:4>>*/ try{
-       /*<<bytes.ml:388:15>>*/ rindex_rec(s, i, c);
-       /*<<bytes.ml:388:35>>*/  /*<<bytes.ml:388:35>>*/ var _I_ = 1;
-       /*<<bytes.ml:388:35>>*/ return _I_;
-     }
-     catch(_J_){
-      var _H_ = caml_wrap_exception(_J_);
-      if(_H_ === Stdlib[8])  /*<<bytes.ml:388:58>>*/ return 0;
-      throw caml_maybe_attach_backtrace(_H_, 0);
-     }
-     /*<<bytes.ml:386:4>>*/ return  /*<<bytes.ml:386:4>>*/ caml_call1
-            (Stdlib[1], cst_String_rcontains_from_Byte);
-    /*<<bytes.ml:388:63>>*/ }
-   var compare = runtime.caml_bytes_compare;
-   function split_on_char(sep, s){
-     /*<<bytes.ml:398:2>>*/ var
-      /*<<bytes.ml:398:10>>*/ r = [0, 0],
-      /*<<bytes.ml:399:10>>*/ j =
-       [0,  /*<<bytes.ml:399:2>>*/ caml_ml_bytes_length(s)],
-      /*<<bytes.ml:400:2>>*/ _D_ =
-        /*<<bytes.ml:400:2>>*/ caml_ml_bytes_length(s) - 1 | 0;
-    if(_D_ >= 0){
-     var i = _D_;
-     for(;;){
-      if(caml_bytes_unsafe_get(s, i) === sep){
-       var _F_ = r[1];
-       r[1] = [0, sub(s, i + 1 | 0, (j[1] - i | 0) - 1 | 0), _F_];
-       j[1] = i;
-      }
-       /*<<bytes.ml:400:2>>*/  /*<<bytes.ml:400:2>>*/ var _G_ = i - 1 | 0;
-      if(0 === i) break;
-      var i = _G_;
-     }
-    }
-    var _E_ = r[1];
-     /*<<bytes.ml:406:2>>*/ return [0, sub(s, 0, j[1]), _E_];
-    /*<<bytes.ml:406:18>>*/ }
-   function to_seq(s){
-    function aux(i, param){
-      /*<<bytes.ml:412:4>>*/ if(i === caml_ml_bytes_length(s))
-       /*<<bytes.ml:412:25>>*/ return 0;
-      /*<<bytes.ml:414:14>>*/ var
-       /*<<bytes.ml:414:14>>*/ x =
-         /*<<bytes.ml:414:14>>*/ caml_bytes_get(s, i),
-       /*<<bytes.ml:414:14>>*/ _B_ = i + 1 | 0;
-      /*<<bytes.ml:415:6>>*/ return [0,
-             x,
-             function(_C_){ /*<<?>>*/ return aux(_B_, _C_);}];
-     /*<<bytes.ml:415:29>>*/ }
-     /*<<bytes.ml:417:2>>*/  /*<<bytes.ml:417:2>>*/ var _z_ = 0;
-     /*<<bytes.ml:417:2>>*/ return function(_A_){
-      /*<<?>>*/ return aux(_z_, _A_);};
-    /*<<bytes.ml:417:7>>*/ }
-   function to_seqi(s){
-    function aux(i, param){
-      /*<<bytes.ml:421:4>>*/ if(i === caml_ml_bytes_length(s))
-       /*<<bytes.ml:421:25>>*/ return 0;
-      /*<<bytes.ml:423:14>>*/ var
-       /*<<bytes.ml:423:14>>*/ x =
-         /*<<bytes.ml:423:14>>*/ caml_bytes_get(s, i),
-       /*<<bytes.ml:423:14>>*/ _x_ = i + 1 | 0;
-      /*<<bytes.ml:424:6>>*/ return [0,
-             [0, i, x],
-             function(_y_){ /*<<?>>*/ return aux(_x_, _y_);}];
-     /*<<bytes.ml:424:33>>*/ }
-     /*<<bytes.ml:426:2>>*/  /*<<bytes.ml:426:2>>*/ var _v_ = 0;
-     /*<<bytes.ml:426:2>>*/ return function(_w_){
-      /*<<?>>*/ return aux(_v_, _w_);};
-    /*<<bytes.ml:426:7>>*/ }
-   function of_seq(i){
-     /*<<bytes.ml:429:2>>*/ var
-      /*<<bytes.ml:429:10>>*/ n = [0, 0],
-      /*<<bytes.ml:430:12>>*/ buf = [0, make(256, 0)];
-    function _u_(c){
-      /*<<bytes.ml:441:7>>*/ if(n[1] === caml_ml_bytes_length(buf[1])){
-       /*<<bytes.ml:433:18>>*/  /*<<bytes.ml:433:18>>*/ var
-       new_len =
-          /*<<bytes.ml:433:18>>*/ caml_call2
-          (Stdlib_Int[10],
-           2 * caml_ml_bytes_length(buf[1]) | 0,
-           Stdlib_Sys[12]);
-      if(caml_ml_bytes_length(buf[1]) === new_len)
-        /*<<bytes.ml:434:34>>*/  /*<<bytes.ml:434:34>>*/ caml_call1
-        (Stdlib[2], cst_Bytes_of_seq_cannot_grow_b);
-       /*<<bytes.ml:435:18>>*/  /*<<bytes.ml:435:18>>*/ var
-       new_buf = make(new_len, 0);
-       /*<<bytes.ml:436:4>>*/ blit(buf[1], 0, new_buf, 0, n[1]);
-      buf[1] = new_buf;
-     }
-      /*<<bytes.ml:442:7>>*/  /*<<bytes.ml:442:7>>*/ caml_bytes_set
-      (buf[1], n[1], c);
-     n[1]++;
-     return 0;
-     /*<<bytes.ml:443:13>>*/ }
-     /*<<bytes.ml:439:2>>*/  /*<<bytes.ml:439:2>>*/ caml_call2
-     (Stdlib_Seq[4], _u_, i);
-    return sub(buf[1], 0, n[1]);
-    /*<<bytes.ml:445:15>>*/ }
-   function unsafe_get_uint16_le(b, i){
-     /*<<bytes.ml:470:2>>*/ return Stdlib_Sys[11]
-            ?  /*<<bytes.ml:471:14>>*/ caml_bswap16
-              ( /*<<bytes.ml:471:14>>*/ caml_bytes_get16(b, i))
-            :  /*<<bytes.ml:472:7>>*/ caml_bytes_get16(b, i);
-    /*<<bytes.ml:472:31>>*/ }
-   function unsafe_get_uint16_be(b, i){
-     /*<<bytes.ml:475:2>>*/ return Stdlib_Sys[11]
-            ?  /*<<bytes.ml:476:7>>*/ caml_bytes_get16(b, i)
-            :  /*<<bytes.ml:477:14>>*/ caml_bswap16
-              ( /*<<bytes.ml:477:14>>*/ caml_bytes_get16(b, i));
-    /*<<bytes.ml:477:40>>*/ }
-   function get_int8(b, i){
-     /*<<bytes.ml:480:2>>*/ var
-      /*<<bytes.ml:480:2>>*/ _s_ = Stdlib_Sys[10] - 8 | 0,
-     _t_ = Stdlib_Sys[10] - 8 | 0;
-    return  /*<<bytes.ml:480:3>>*/ caml_bytes_get(b, i) << _t_ >> _s_;
-    /*<<bytes.ml:480:65>>*/ }
-   function get_uint16_le(b, i){
-     /*<<bytes.ml:483:2>>*/ return Stdlib_Sys[11]
-            ?  /*<<bytes.ml:483:32>>*/ caml_bswap16
-              ( /*<<bytes.ml:483:32>>*/ caml_bytes_get16(b, i))
-            :  /*<<bytes.ml:484:7>>*/ caml_bytes_get16(b, i);
-    /*<<bytes.ml:484:24>>*/ }
-   function get_uint16_be(b, i){
-     /*<<bytes.ml:487:2>>*/ return Stdlib_Sys[11]
-            ?  /*<<bytes.ml:488:7>>*/ caml_bytes_get16(b, i)
-            :  /*<<bytes.ml:487:36>>*/ caml_bswap16
-              ( /*<<bytes.ml:487:36>>*/ caml_bytes_get16(b, i));
-    /*<<bytes.ml:488:24>>*/ }
-   function get_int16_ne(b, i){
-     /*<<bytes.ml:491:2>>*/ var
-      /*<<bytes.ml:491:2>>*/ _q_ = Stdlib_Sys[10] - 16 | 0,
-     _r_ = Stdlib_Sys[10] - 16 | 0;
-    return  /*<<bytes.ml:491:3>>*/ caml_bytes_get16(b, i) << _r_ >> _q_;
-    /*<<bytes.ml:491:71>>*/ }
-   function get_int16_le(b, i){
-     /*<<bytes.ml:494:2>>*/ var
-      /*<<bytes.ml:494:2>>*/ _o_ = Stdlib_Sys[10] - 16 | 0,
-     _p_ = Stdlib_Sys[10] - 16 | 0;
-    return get_uint16_le(b, i) << _p_ >> _o_;
-    /*<<bytes.ml:494:71>>*/ }
-   function get_int16_be(b, i){
-     /*<<bytes.ml:497:2>>*/ var
-      /*<<bytes.ml:497:2>>*/ _m_ = Stdlib_Sys[10] - 16 | 0,
-     _n_ = Stdlib_Sys[10] - 16 | 0;
-    return get_uint16_be(b, i) << _n_ >> _m_;
-    /*<<bytes.ml:497:71>>*/ }
-   function get_int32_le(b, i){
-     /*<<bytes.ml:500:2>>*/ return Stdlib_Sys[11]
-            ?  /*<<bytes.ml:500:25>>*/ caml_int32_bswap
-              ( /*<<bytes.ml:500:32>>*/ caml_bytes_get32(b, i))
-            :  /*<<bytes.ml:501:7>>*/ caml_bytes_get32(b, i);
-    /*<<bytes.ml:501:23>>*/ }
-   function get_int32_be(b, i){
-     /*<<bytes.ml:504:2>>*/ return Stdlib_Sys[11]
-            ?  /*<<bytes.ml:505:7>>*/ caml_bytes_get32(b, i)
-            :  /*<<bytes.ml:504:29>>*/ caml_int32_bswap
-              ( /*<<bytes.ml:504:36>>*/ caml_bytes_get32(b, i));
-    /*<<bytes.ml:505:23>>*/ }
-   function get_int64_le(b, i){
-     /*<<bytes.ml:508:2>>*/ return Stdlib_Sys[11]
-            ?  /*<<bytes.ml:508:25>>*/ caml_int64_bswap
-              ( /*<<bytes.ml:508:32>>*/ caml_bytes_get64(b, i))
-            :  /*<<bytes.ml:509:7>>*/ caml_bytes_get64(b, i);
-    /*<<bytes.ml:509:23>>*/ }
-   function get_int64_be(b, i){
-     /*<<bytes.ml:512:2>>*/ return Stdlib_Sys[11]
-            ?  /*<<bytes.ml:513:7>>*/ caml_bytes_get64(b, i)
-            :  /*<<bytes.ml:512:29>>*/ caml_int64_bswap
-              ( /*<<bytes.ml:512:36>>*/ caml_bytes_get64(b, i));
-    /*<<bytes.ml:513:23>>*/ }
-   function unsafe_set_uint16_le(b, i, x){
-     /*<<bytes.ml:516:2>>*/ return Stdlib_Sys[11]
-            ?  /*<<bytes.ml:517:7>>*/ caml_bytes_set16(b, i, caml_bswap16(x))
-            :  /*<<bytes.ml:518:7>>*/ caml_bytes_set16(b, i, x);
-    /*<<bytes.ml:518:33>>*/ }
-   function unsafe_set_uint16_be(b, i, x){
-     /*<<bytes.ml:521:2>>*/ return Stdlib_Sys[11]
-            ?  /*<<bytes.ml:522:7>>*/ caml_bytes_set16(b, i, x)
-            :  /*<<bytes.ml:523:2>>*/ caml_bytes_set16(b, i, caml_bswap16(x));
-    /*<<bytes.ml:523:37>>*/ }
-   function set_int16_le(b, i, x){
-     /*<<bytes.ml:526:2>>*/ return Stdlib_Sys[11]
-            ?  /*<<bytes.ml:526:25>>*/ caml_bytes_set16(b, i, caml_bswap16(x))
-            :  /*<<bytes.ml:527:7>>*/ caml_bytes_set16(b, i, x);
-    /*<<bytes.ml:527:25>>*/ }
-   function set_int16_be(b, i, x){
-     /*<<bytes.ml:530:2>>*/ return Stdlib_Sys[11]
-            ?  /*<<bytes.ml:531:7>>*/ caml_bytes_set16(b, i, x)
-            :  /*<<bytes.ml:530:29>>*/ caml_bytes_set16(b, i, caml_bswap16(x));
-    /*<<bytes.ml:531:25>>*/ }
-   function set_int32_le(b, i, x){
-     /*<<bytes.ml:534:2>>*/ return Stdlib_Sys[11]
-            ?  /*<<bytes.ml:534:25>>*/ caml_bytes_set32
-              (b, i,  /*<<bytes.ml:534:42>>*/ caml_int32_bswap(x))
-            :  /*<<bytes.ml:535:7>>*/ caml_bytes_set32(b, i, x);
-    /*<<bytes.ml:535:25>>*/ }
-   function set_int32_be(b, i, x){
-     /*<<bytes.ml:538:2>>*/ return Stdlib_Sys[11]
-            ?  /*<<bytes.ml:539:7>>*/ caml_bytes_set32(b, i, x)
-            :  /*<<bytes.ml:538:29>>*/ caml_bytes_set32
-              (b, i,  /*<<bytes.ml:538:46>>*/ caml_int32_bswap(x));
-    /*<<bytes.ml:539:25>>*/ }
-   function set_int64_le(b, i, x){
-     /*<<bytes.ml:542:2>>*/ return Stdlib_Sys[11]
-            ?  /*<<bytes.ml:542:25>>*/ caml_bytes_set64
-              (b, i,  /*<<bytes.ml:542:42>>*/ caml_int64_bswap(x))
-            :  /*<<bytes.ml:543:7>>*/ caml_bytes_set64(b, i, x);
-    /*<<bytes.ml:543:25>>*/ }
-   function set_int64_be(b, i, x){
-     /*<<bytes.ml:546:2>>*/ return Stdlib_Sys[11]
-            ?  /*<<bytes.ml:547:7>>*/ caml_bytes_set64(b, i, x)
-            :  /*<<bytes.ml:546:29>>*/ caml_bytes_set64
-              (b, i,  /*<<bytes.ml:546:46>>*/ caml_int64_bswap(x));
-    /*<<bytes.ml:547:25>>*/ }
-   var
-    set_uint8 = caml_bytes_set,
-    set_uint16_ne = caml_bytes_set16,
-    dec_invalid = Stdlib_Uchar[22];
-   function dec_ret(n, u){
-     /*<<bytes.ml:557:27>>*/  /*<<bytes.ml:557:46>>*/ var
-     _l_ =  /*<<bytes.ml:557:46>>*/ caml_call1(Stdlib_Uchar[9], u);
-     /*<<bytes.ml:557:46>>*/ return  /*<<bytes.ml:557:46>>*/ caml_call2
-            (Stdlib_Uchar[21], n, _l_);
-    /*<<bytes.ml:557:69>>*/ }
-   function not_in_x80_to_xBF(b){
-     /*<<bytes.ml:575:35>>*/ return 2 !== (b >>> 6 | 0) ? 1 : 0;
-    /*<<bytes.ml:575:50>>*/ }
-   function not_in_xA0_to_xBF(b){
-     /*<<bytes.ml:576:35>>*/ return 5 !== (b >>> 5 | 0) ? 1 : 0;
-    /*<<bytes.ml:576:51>>*/ }
-   function not_in_x80_to_x9F(b){
-     /*<<bytes.ml:577:35>>*/ return 4 !== (b >>> 5 | 0) ? 1 : 0;
-    /*<<bytes.ml:577:51>>*/ }
-   function not_in_x90_to_xBF(b){
-     /*<<bytes.ml:578:35>>*/ var
-     _j_ = b < 144 ? 1 : 0,
-     _k_ = _j_ || (191 < b ? 1 : 0);
-    return _k_;
-    /*<<bytes.ml:578:55>>*/ }
-   function not_in_x80_to_x8F(b){
-     /*<<bytes.ml:579:35>>*/ return 8 !== (b >>> 4 | 0) ? 1 : 0;
-    /*<<bytes.ml:579:49>>*/ }
-   function utf_8_uchar_3(b0, b1, b2){
-     /*<<bytes.ml:586:2>>*/ return (b0 & 15) << 12 | (b1 & 63) << 6 | b2 & 63;
-    /*<<bytes.ml:588:18>>*/ }
-   function utf_8_uchar_4(b0, b1, b2, b3){
-     /*<<bytes.ml:591:2>>*/ return (b0 & 7) << 18 | (b1 & 63) << 12
-           | (b2 & 63) << 6
-           | b3 & 63;
-    /*<<bytes.ml:594:18>>*/ }
-   function get_utf_8_uchar(b, i){
-     /*<<bytes.ml:597:2>>*/ var
-      /*<<bytes.ml:597:11>>*/ b0 =
-        /*<<bytes.ml:597:11>>*/ caml_bytes_get(b, i),
-      /*<<bytes.ml:599:2>>*/ max =
-        /*<<bytes.ml:599:2>>*/ caml_ml_bytes_length(b) - 1 | 0;
-    a:
-    {
-      /*<<bytes.ml:600:2>>*/ if(224 <= b0){
-      if(237 <= b0){
-       if(245 <= b0) break a;
-       switch(b0 - 237 | 0){
-         case 0:
-           /*<<bytes.ml:619:6>>*/  /*<<bytes.ml:619:6>>*/ var i$0 = i + 1 | 0;
-          if(max < i$0)
-            /*<<bytes.ml:619:39>>*/ return  /*<<bytes.ml:619:39>>*/ caml_call1
-                   (dec_invalid, 1);
-           /*<<bytes.ml:620:15>>*/  /*<<bytes.ml:620:15>>*/ var
-           b1 =  /*<<bytes.ml:620:15>>*/ caml_bytes_unsafe_get(b, i$0);
-           /*<<bytes.ml:620:29>>*/ if(not_in_x80_to_x9F(b1))
-            /*<<bytes.ml:620:55>>*/ return  /*<<bytes.ml:620:55>>*/ caml_call1
-                   (dec_invalid, 1);
-           /*<<bytes.ml:621:6>>*/  /*<<bytes.ml:621:6>>*/ var
-           i$1 = i$0 + 1 | 0;
-          if(max < i$1)
-            /*<<bytes.ml:621:39>>*/ return  /*<<bytes.ml:621:39>>*/ caml_call1
-                   (dec_invalid, 2);
-           /*<<bytes.ml:622:15>>*/  /*<<bytes.ml:622:15>>*/ var
-           b2 =  /*<<bytes.ml:622:15>>*/ caml_bytes_unsafe_get(b, i$1);
-           /*<<bytes.ml:622:29>>*/ return not_in_x80_to_xBF(b2)
-                  ?  /*<<bytes.ml:622:55>>*/ caml_call1(dec_invalid, 2)
-                  : dec_ret(3, utf_8_uchar_3(b0, b1, b2));
-         case 3:
-           /*<<bytes.ml:625:6>>*/  /*<<bytes.ml:625:6>>*/ var i$4 = i + 1 | 0;
-          if(max < i$4)
-            /*<<bytes.ml:625:39>>*/ return  /*<<bytes.ml:625:39>>*/ caml_call1
-                   (dec_invalid, 1);
-           /*<<bytes.ml:626:15>>*/  /*<<bytes.ml:626:15>>*/ var
-           b1$1 =  /*<<bytes.ml:626:15>>*/ caml_bytes_unsafe_get(b, i$4);
-           /*<<bytes.ml:626:29>>*/ if(not_in_x90_to_xBF(b1$1))
-            /*<<bytes.ml:626:55>>*/ return  /*<<bytes.ml:626:55>>*/ caml_call1
-                   (dec_invalid, 1);
-           /*<<bytes.ml:627:6>>*/  /*<<bytes.ml:627:6>>*/ var
-           i$5 = i$4 + 1 | 0;
-          if(max < i$5)
-            /*<<bytes.ml:627:39>>*/ return  /*<<bytes.ml:627:39>>*/ caml_call1
-                   (dec_invalid, 2);
-           /*<<bytes.ml:628:15>>*/  /*<<bytes.ml:628:15>>*/ var
-           b2$1 =  /*<<bytes.ml:628:15>>*/ caml_bytes_unsafe_get(b, i$5);
-           /*<<bytes.ml:628:29>>*/ if(not_in_x80_to_xBF(b2$1))
-            /*<<bytes.ml:628:55>>*/ return  /*<<bytes.ml:628:55>>*/ caml_call1
-                   (dec_invalid, 2);
-           /*<<bytes.ml:629:6>>*/  /*<<bytes.ml:629:6>>*/ var
-           i$6 = i$5 + 1 | 0;
-          if(max < i$6)
-            /*<<bytes.ml:629:39>>*/ return  /*<<bytes.ml:629:39>>*/ caml_call1
-                   (dec_invalid, 3);
-           /*<<bytes.ml:630:15>>*/  /*<<bytes.ml:630:15>>*/ var
-           b3 =  /*<<bytes.ml:630:15>>*/ caml_bytes_unsafe_get(b, i$6);
-           /*<<bytes.ml:630:29>>*/ return not_in_x80_to_xBF(b3)
-                  ?  /*<<bytes.ml:630:55>>*/ caml_call1(dec_invalid, 3)
-                  : dec_ret(4, utf_8_uchar_4(b0, b1$1, b2$1, b3));
-         case 7:
-           /*<<bytes.ml:641:6>>*/  /*<<bytes.ml:641:6>>*/ var
-           i$10 = i + 1 | 0;
-          if(max < i$10)
-            /*<<bytes.ml:641:39>>*/ return  /*<<bytes.ml:641:39>>*/ caml_call1
-                   (dec_invalid, 1);
-           /*<<bytes.ml:642:15>>*/  /*<<bytes.ml:642:15>>*/ var
-           b1$3 =  /*<<bytes.ml:642:15>>*/ caml_bytes_unsafe_get(b, i$10);
-           /*<<bytes.ml:642:29>>*/ if(not_in_x80_to_x8F(b1$3))
-            /*<<bytes.ml:642:55>>*/ return  /*<<bytes.ml:642:55>>*/ caml_call1
-                   (dec_invalid, 1);
-           /*<<bytes.ml:643:6>>*/  /*<<bytes.ml:643:6>>*/ var
-           i$11 = i$10 + 1 | 0;
-          if(max < i$11)
-            /*<<bytes.ml:643:39>>*/ return  /*<<bytes.ml:643:39>>*/ caml_call1
-                   (dec_invalid, 2);
-           /*<<bytes.ml:644:15>>*/  /*<<bytes.ml:644:15>>*/ var
-           b2$3 =  /*<<bytes.ml:644:15>>*/ caml_bytes_unsafe_get(b, i$11);
-           /*<<bytes.ml:644:29>>*/ if(not_in_x80_to_xBF(b2$3))
-            /*<<bytes.ml:644:55>>*/ return  /*<<bytes.ml:644:55>>*/ caml_call1
-                   (dec_invalid, 2);
-           /*<<bytes.ml:645:6>>*/  /*<<bytes.ml:645:6>>*/ var
-           i$12 = i$11 + 1 | 0;
-          if(max < i$12)
-            /*<<bytes.ml:645:39>>*/ return  /*<<bytes.ml:645:39>>*/ caml_call1
-                   (dec_invalid, 3);
-           /*<<bytes.ml:646:15>>*/  /*<<bytes.ml:646:15>>*/ var
-           b3$1 =  /*<<bytes.ml:646:15>>*/ caml_bytes_unsafe_get(b, i$12);
-           /*<<bytes.ml:646:29>>*/ return not_in_x80_to_xBF(b3$1)
-                  ?  /*<<bytes.ml:646:55>>*/ caml_call1(dec_invalid, 3)
-                  : dec_ret(4, utf_8_uchar_4(b0, b1$3, b2$3, b3$1));
-         case 1:
-         case 2: break;
-         default:
-           /*<<bytes.ml:633:6>>*/  /*<<bytes.ml:633:6>>*/ var i$7 = i + 1 | 0;
-          if(max < i$7)
-            /*<<bytes.ml:633:39>>*/ return  /*<<bytes.ml:633:39>>*/ caml_call1
-                   (dec_invalid, 1);
-           /*<<bytes.ml:634:15>>*/  /*<<bytes.ml:634:15>>*/ var
-           b1$2 =  /*<<bytes.ml:634:15>>*/ caml_bytes_unsafe_get(b, i$7);
-           /*<<bytes.ml:634:29>>*/ if(not_in_x80_to_xBF(b1$2))
-            /*<<bytes.ml:634:55>>*/ return  /*<<bytes.ml:634:55>>*/ caml_call1
-                   (dec_invalid, 1);
-           /*<<bytes.ml:635:6>>*/  /*<<bytes.ml:635:6>>*/ var
-           i$8 = i$7 + 1 | 0;
-          if(max < i$8)
-            /*<<bytes.ml:635:39>>*/ return  /*<<bytes.ml:635:39>>*/ caml_call1
-                   (dec_invalid, 2);
-           /*<<bytes.ml:636:15>>*/  /*<<bytes.ml:636:15>>*/ var
-           b2$2 =  /*<<bytes.ml:636:15>>*/ caml_bytes_unsafe_get(b, i$8);
-           /*<<bytes.ml:636:29>>*/ if(not_in_x80_to_xBF(b2$2))
-            /*<<bytes.ml:636:55>>*/ return  /*<<bytes.ml:636:55>>*/ caml_call1
-                   (dec_invalid, 2);
-           /*<<bytes.ml:637:6>>*/  /*<<bytes.ml:637:6>>*/ var
-           i$9 = i$8 + 1 | 0;
-          if(max < i$9)
-            /*<<bytes.ml:637:39>>*/ return  /*<<bytes.ml:637:39>>*/ caml_call1
-                   (dec_invalid, 3);
-           /*<<bytes.ml:638:15>>*/  /*<<bytes.ml:638:15>>*/ var
-           b3$0 =  /*<<bytes.ml:638:15>>*/ caml_bytes_unsafe_get(b, i$9);
-           /*<<bytes.ml:638:29>>*/ return not_in_x80_to_xBF(b3$0)
-                  ?  /*<<bytes.ml:638:55>>*/ caml_call1(dec_invalid, 3)
-                  : dec_ret(4, utf_8_uchar_4(b0, b1$2, b2$2, b3$0));
-       }
-      }
-      else if(225 > b0){
-        /*<<bytes.ml:607:6>>*/  /*<<bytes.ml:607:6>>*/ var i$13 = i + 1 | 0;
-       if(max < i$13)
-         /*<<bytes.ml:607:39>>*/ return  /*<<bytes.ml:607:39>>*/ caml_call1
-                (dec_invalid, 1);
-        /*<<bytes.ml:608:15>>*/  /*<<bytes.ml:608:15>>*/ var
-        b1$4 =  /*<<bytes.ml:608:15>>*/ caml_bytes_unsafe_get(b, i$13);
-        /*<<bytes.ml:608:29>>*/ if(not_in_xA0_to_xBF(b1$4))
-         /*<<bytes.ml:608:55>>*/ return  /*<<bytes.ml:608:55>>*/ caml_call1
-                (dec_invalid, 1);
-        /*<<bytes.ml:609:6>>*/  /*<<bytes.ml:609:6>>*/ var
-        i$14 = i$13 + 1 | 0;
-       if(max < i$14)
-         /*<<bytes.ml:609:39>>*/ return  /*<<bytes.ml:609:39>>*/ caml_call1
-                (dec_invalid, 2);
-        /*<<bytes.ml:610:15>>*/  /*<<bytes.ml:610:15>>*/ var
-        b2$4 =  /*<<bytes.ml:610:15>>*/ caml_bytes_unsafe_get(b, i$14);
-        /*<<bytes.ml:610:29>>*/ return not_in_x80_to_xBF(b2$4)
-               ?  /*<<bytes.ml:610:55>>*/ caml_call1(dec_invalid, 2)
-               : dec_ret(3, utf_8_uchar_3(b0, b1$4, b2$4));
-      }
-       /*<<bytes.ml:613:6>>*/  /*<<bytes.ml:613:6>>*/ var i$2 = i + 1 | 0;
-      if(max < i$2)
-        /*<<bytes.ml:613:39>>*/ return  /*<<bytes.ml:613:39>>*/ caml_call1
-               (dec_invalid, 1);
-       /*<<bytes.ml:614:15>>*/  /*<<bytes.ml:614:15>>*/ var
-       b1$0 =  /*<<bytes.ml:614:15>>*/ caml_bytes_unsafe_get(b, i$2);
-       /*<<bytes.ml:614:29>>*/ if(not_in_x80_to_xBF(b1$0))
-        /*<<bytes.ml:614:55>>*/ return  /*<<bytes.ml:614:55>>*/ caml_call1
-               (dec_invalid, 1);
-       /*<<bytes.ml:615:6>>*/  /*<<bytes.ml:615:6>>*/ var i$3 = i$2 + 1 | 0;
-      if(max < i$3)
-        /*<<bytes.ml:615:39>>*/ return  /*<<bytes.ml:615:39>>*/ caml_call1
-               (dec_invalid, 2);
-       /*<<bytes.ml:616:15>>*/  /*<<bytes.ml:616:15>>*/ var
-       b2$0 =  /*<<bytes.ml:616:15>>*/ caml_bytes_unsafe_get(b, i$3);
-       /*<<bytes.ml:616:29>>*/ return not_in_x80_to_xBF(b2$0)
-              ?  /*<<bytes.ml:616:55>>*/ caml_call1(dec_invalid, 2)
-              : dec_ret(3, utf_8_uchar_3(b0, b1$0, b2$0));
-     }
-     if(128 > b0)  /*<<bytes.ml:601:24>>*/ return dec_ret(1, b0);
-     if(194 <= b0){
-       /*<<bytes.ml:603:6>>*/  /*<<bytes.ml:603:6>>*/ var i$15 = i + 1 | 0;
-      if(max < i$15)
-        /*<<bytes.ml:603:39>>*/ return  /*<<bytes.ml:603:39>>*/ caml_call1
-               (dec_invalid, 1);
-       /*<<bytes.ml:604:15>>*/  /*<<bytes.ml:604:15>>*/ var
-       b1$5 =  /*<<bytes.ml:604:15>>*/ caml_bytes_unsafe_get(b, i$15);
-       /*<<bytes.ml:604:29>>*/ return not_in_x80_to_xBF(b1$5)
-              ?  /*<<bytes.ml:604:55>>*/ caml_call1(dec_invalid, 1)
-              : dec_ret(2, (b0 & 31) << 6 | b1$5 & 63);
-     }
-    }
-     /*<<bytes.ml:648:9>>*/ return  /*<<bytes.ml:648:9>>*/ caml_call1
-            (dec_invalid, 1);
-    /*<<bytes.ml:648:22>>*/ }
-   function set_utf_8_uchar(b, i, u){
-     /*<<bytes.ml:651:2>>*/ function set(_i_, _h_, _g_){
-      /*<<?>>*/ caml_bytes_unsafe_set(_i_, _h_, _g_);
-     return 0;
-    }
-     /*<<bytes.ml:652:2>>*/ var
-      /*<<bytes.ml:652:2>>*/ max =
-        /*<<bytes.ml:652:2>>*/ caml_ml_bytes_length(b) - 1 | 0,
-      /*<<bytes.ml:653:8>>*/ u$0 =
-        /*<<bytes.ml:653:8>>*/ caml_call1(Stdlib_Uchar[10], u);
-     /*<<bytes.ml:654:11>>*/ if(0 > u$0)
-      /*<<bytes.ml:654:20>>*/ throw  /*<<bytes.ml:654:20>>*/ caml_maybe_attach_backtrace
-            ([0, Assert_failure, _b_], 1);
-     /*<<bytes.ml:655:11>>*/ if(127 >= u$0){
-      /*<<bytes.ml:656:6>>*/  /*<<bytes.ml:656:6>>*/ caml_bytes_set(b, i, u$0);
-      /*<<bytes.ml:656:6>>*/ return 1;
-    }
-     /*<<bytes.ml:658:11>>*/ if(2047 >= u$0){
-      /*<<bytes.ml:659:6>>*/  /*<<bytes.ml:659:6>>*/ var last$1 = i + 1 | 0;
-     return max < last$1
-             ? 0
-             : ( /*<<bytes.ml:661:7>>*/ caml_bytes_set
-                (b, i, 192 | u$0 >>> 6 | 0),
-               set(b, last$1, 128 | u$0 & 63),
-               2);
-    }
-     /*<<bytes.ml:664:11>>*/ if(65535 >= u$0){
-      /*<<bytes.ml:665:6>>*/  /*<<bytes.ml:665:6>>*/ var last$0 = i + 2 | 0;
-     return max < last$0
-             ? 0
-             : ( /*<<bytes.ml:667:7>>*/ caml_bytes_set
-                (b, i, 224 | u$0 >>> 12 | 0),
-               set(b, i + 1 | 0, 128 | (u$0 >>> 6 | 0) & 63),
-               set(b, last$0, 128 | u$0 & 63),
-               3);
-    }
-     /*<<bytes.ml:671:11>>*/ if(1114111 < u$0)
-      /*<<bytes.ml:679:9>>*/ throw  /*<<bytes.ml:679:9>>*/ caml_maybe_attach_backtrace
-            ([0, Assert_failure, _a_], 1);
-     /*<<bytes.ml:672:6>>*/  /*<<bytes.ml:672:6>>*/ var last = i + 3 | 0;
-    return max < last
-            ? 0
-            : ( /*<<bytes.ml:674:7>>*/ caml_bytes_set
-               (b, i, 240 | u$0 >>> 18 | 0),
-              set(b, i + 1 | 0, 128 | (u$0 >>> 12 | 0) & 63),
-              set(b, i + 2 | 0, 128 | (u$0 >>> 6 | 0) & 63),
-              set(b, last, 128 | u$0 & 63),
-              4);
-    /*<<bytes.ml:679:21>>*/ }
-   function is_valid_utf_8(b){
-     /*<<bytes.ml:682:2>>*/ var max = caml_ml_bytes_length(b) - 1 | 0, i = 0;
-     /*<<bytes.ml:683:4>>*/ for(;;){
-     if(max < i)  /*<<bytes.ml:683:20>>*/ return 1;
-      /*<<bytes.ml:685:26>>*/  /*<<bytes.ml:685:26>>*/ var
-      match =  /*<<bytes.ml:685:26>>*/ caml_bytes_unsafe_get(b, i);
-     a:
-     {
-      if(224 <= match){
-       if(237 <= match){
-        if(245 <= match) break a;
-        switch(match - 237 | 0){
-          case 0:
-            /*<<bytes.ml:708:8>>*/  /*<<bytes.ml:708:8>>*/ var
-            last = i + 2 | 0;
-            /*<<bytes.ml:711:11>>*/ if
-            (max >= last
-             &&
-              !
-              not_in_x80_to_x9F
-               ( /*<<bytes.ml:710:29>>*/ caml_bytes_unsafe_get(b, i + 1 | 0))
-              &&
-               !
-               not_in_x80_to_xBF
-                ( /*<<bytes.ml:711:29>>*/ caml_bytes_unsafe_get(b, last))){
-             /*<<bytes.ml:713:13>>*/ var
-              /*<<bytes.ml:713:13>>*/ i$0 = last + 1 | 0,
-             i = i$0;
-            continue;
-           }
-            /*<<bytes.ml:712:13>>*/ return 0;
-          case 3:
-            /*<<bytes.ml:715:8>>*/  /*<<bytes.ml:715:8>>*/ var
-            last$1 = i + 3 | 0;
-            /*<<bytes.ml:719:11>>*/ if
-            (max >= last$1
-             &&
-              !
-              not_in_x90_to_xBF
-               ( /*<<bytes.ml:717:29>>*/ caml_bytes_unsafe_get(b, i + 1 | 0))
-              &&
-               !
-               not_in_x80_to_xBF
-                ( /*<<bytes.ml:718:29>>*/ caml_bytes_unsafe_get(b, i + 2 | 0))
-               &&
-                !
-                not_in_x80_to_xBF
-                 ( /*<<bytes.ml:719:29>>*/ caml_bytes_unsafe_get(b, last$1))){
-             /*<<bytes.ml:721:13>>*/ var
-              /*<<bytes.ml:721:13>>*/ i$2 = last$1 + 1 | 0,
-             i = i$2;
-            continue;
-           }
-            /*<<bytes.ml:720:13>>*/ return 0;
-          case 7:
-            /*<<bytes.ml:731:8>>*/  /*<<bytes.ml:731:8>>*/ var
-            last$3 = i + 3 | 0;
-            /*<<bytes.ml:735:11>>*/ if
-            (max >= last$3
-             &&
-              !
-              not_in_x80_to_x8F
-               ( /*<<bytes.ml:733:29>>*/ caml_bytes_unsafe_get(b, i + 1 | 0))
-              &&
-               !
-               not_in_x80_to_xBF
-                ( /*<<bytes.ml:734:29>>*/ caml_bytes_unsafe_get(b, i + 2 | 0))
-               &&
-                !
-                not_in_x80_to_xBF
-                 ( /*<<bytes.ml:735:29>>*/ caml_bytes_unsafe_get(b, last$3))){
-             /*<<bytes.ml:737:13>>*/ var
-              /*<<bytes.ml:737:13>>*/ i$4 = last$3 + 1 | 0,
-             i = i$4;
-            continue;
-           }
-            /*<<bytes.ml:736:13>>*/ return 0;
-          case 1:
-          case 2: break;
-          default:
-            /*<<bytes.ml:723:8>>*/  /*<<bytes.ml:723:8>>*/ var
-            last$2 = i + 3 | 0;
-            /*<<bytes.ml:727:11>>*/ if
-            (max >= last$2
-             &&
-              !
-              not_in_x80_to_xBF
-               ( /*<<bytes.ml:725:29>>*/ caml_bytes_unsafe_get(b, i + 1 | 0))
-              &&
-               !
-               not_in_x80_to_xBF
-                ( /*<<bytes.ml:726:29>>*/ caml_bytes_unsafe_get(b, i + 2 | 0))
-               &&
-                !
-                not_in_x80_to_xBF
-                 ( /*<<bytes.ml:727:29>>*/ caml_bytes_unsafe_get(b, last$2))){
-             /*<<bytes.ml:729:13>>*/ var
-              /*<<bytes.ml:729:13>>*/ i$3 = last$2 + 1 | 0,
-             i = i$3;
-            continue;
-           }
-            /*<<bytes.ml:728:13>>*/ return 0;
-        }
-       }
-       else if(225 > match){
-         /*<<bytes.ml:694:8>>*/  /*<<bytes.ml:694:8>>*/ var
-         last$4 = i + 2 | 0;
-         /*<<bytes.ml:697:11>>*/ if
-         (max >= last$4
-          &&
-           !
-           not_in_xA0_to_xBF
-            ( /*<<bytes.ml:696:29>>*/ caml_bytes_unsafe_get(b, i + 1 | 0))
-           &&
-            !
-            not_in_x80_to_xBF
-             ( /*<<bytes.ml:697:29>>*/ caml_bytes_unsafe_get(b, last$4))){
-          /*<<bytes.ml:699:13>>*/ var
-           /*<<bytes.ml:699:13>>*/ i$5 = last$4 + 1 | 0,
-          i = i$5;
-         continue;
-        }
-         /*<<bytes.ml:698:13>>*/ return 0;
-       }
-        /*<<bytes.ml:701:8>>*/  /*<<bytes.ml:701:8>>*/ var last$0 = i + 2 | 0;
-        /*<<bytes.ml:704:11>>*/ if
-        (max >= last$0
-         &&
-          !
-          not_in_x80_to_xBF
-           ( /*<<bytes.ml:703:29>>*/ caml_bytes_unsafe_get(b, i + 1 | 0))
-          &&
-           !
-           not_in_x80_to_xBF
-            ( /*<<bytes.ml:704:29>>*/ caml_bytes_unsafe_get(b, last$0))){
-         /*<<bytes.ml:706:13>>*/ var
-          /*<<bytes.ml:706:13>>*/ i$1 = last$0 + 1 | 0,
-         i = i$1;
-        continue;
-       }
-        /*<<bytes.ml:705:13>>*/ return 0;
-      }
-      if(128 > match){
-        /*<<bytes.ml:686:26>>*/ var
-         /*<<bytes.ml:686:26>>*/ i$7 = i + 1 | 0,
-        i = i$7;
-       continue;
-      }
-      if(194 <= match){
-        /*<<bytes.ml:688:8>>*/  /*<<bytes.ml:688:8>>*/ var last$5 = i + 1 | 0;
-        /*<<bytes.ml:690:11>>*/ if
-        (max >= last$5
-         &&
-          !
-          not_in_x80_to_xBF
-           ( /*<<bytes.ml:690:29>>*/ caml_bytes_unsafe_get(b, last$5))){
-         /*<<bytes.ml:692:13>>*/ var
-          /*<<bytes.ml:692:13>>*/ i$6 = last$5 + 1 | 0,
-         i = i$6;
-        continue;
-       }
-        /*<<bytes.ml:691:13>>*/ return 0;
-      }
-     }
-      /*<<bytes.ml:738:11>>*/ return 0;
-    }
-    /*<<bytes.ml:740:25>>*/ }
-   function get_utf_16be_uchar(b, i){
-     /*<<bytes.ml:745:2>>*/  /*<<bytes.ml:746:2>>*/ var
-     max =  /*<<bytes.ml:746:2>>*/ caml_ml_bytes_length(b) - 1 | 0;
-    if(0 <= i && max >= i){
-     if(i === max)
-       /*<<bytes.ml:748:18>>*/ return  /*<<bytes.ml:748:18>>*/ caml_call1
-              (dec_invalid, 1);
-      /*<<bytes.ml:749:8>>*/  /*<<bytes.ml:749:8>>*/ var
-      hi = unsafe_get_uint16_be(b, i);
-     if(55296 <= hi && 57343 >= hi){
-       /*<<bytes.ml:751:11>>*/ if(56319 < hi)
-        /*<<bytes.ml:751:25>>*/ return  /*<<bytes.ml:751:25>>*/ caml_call1
-               (dec_invalid, 2);
-       /*<<bytes.ml:753:6>>*/  /*<<bytes.ml:753:6>>*/ var last = i + 3 | 0;
-      if(max < last) return caml_call1(dec_invalid, (max - i | 0) + 1 | 0);
-       /*<<bytes.ml:755:12>>*/  /*<<bytes.ml:755:12>>*/ var
-       lo = unsafe_get_uint16_be(b, i + 2 | 0);
-      if(56320 <= lo && 57343 >= lo){
-       var u = ((hi & 1023) << 10 | lo & 1023) + 65536 | 0;
-        /*<<bytes.ml:759:10>>*/ return dec_ret(4, u);
-      }
-       /*<<bytes.ml:756:43>>*/ return  /*<<bytes.ml:756:43>>*/ caml_call1
-              (dec_invalid, 2);
-     }
-      /*<<bytes.ml:750:39>>*/ return dec_ret(2, hi);
-    }
-     /*<<bytes.ml:747:27>>*/ return  /*<<bytes.ml:747:27>>*/ caml_call1
-            (Stdlib[1], cst_index_out_of_bounds);
-    /*<<bytes.ml:759:21>>*/ }
-   function set_utf_16be_uchar(b, i, u){
-     /*<<bytes.ml:762:2>>*/  /*<<bytes.ml:763:2>>*/ var
-     max =  /*<<bytes.ml:763:2>>*/ caml_ml_bytes_length(b) - 1 | 0;
-    if(0 <= i && max >= i){
-      /*<<bytes.ml:765:8>>*/  /*<<bytes.ml:765:8>>*/ var
-      u$0 =  /*<<bytes.ml:765:8>>*/ caml_call1(Stdlib_Uchar[10], u);
-      /*<<bytes.ml:766:11>>*/ if(0 > u$0)
-       /*<<bytes.ml:766:20>>*/ throw  /*<<bytes.ml:766:20>>*/ caml_maybe_attach_backtrace
-             ([0, Assert_failure, _d_], 1);
-      /*<<bytes.ml:767:11>>*/ if(65535 >= u$0){
-       /*<<bytes.ml:768:6>>*/  /*<<bytes.ml:768:6>>*/ var last$0 = i + 1 | 0;
-      return max < last$0 ? 0 : (unsafe_set_uint16_be(b, i, u$0), 2);
-     }
-      /*<<bytes.ml:770:11>>*/ if(1114111 < u$0)
-       /*<<bytes.ml:777:9>>*/ throw  /*<<bytes.ml:777:9>>*/ caml_maybe_attach_backtrace
-             ([0, Assert_failure, _c_], 1);
-      /*<<bytes.ml:771:6>>*/  /*<<bytes.ml:771:6>>*/ var last = i + 3 | 0;
-     if(max < last)  /*<<bytes.ml:772:25>>*/ return 0;
-      /*<<bytes.ml:773:6>>*/ var
-       /*<<bytes.ml:773:6>>*/ u$1 = u$0 - 65536 | 0,
-      hi = 55296 | u$1 >>> 10 | 0,
-      lo = 56320 | u$1 & 1023;
-      /*<<bytes.ml:776:6>>*/ unsafe_set_uint16_be(b, i, hi);
-      /*<<bytes.ml:776:18>>*/ unsafe_set_uint16_be(b, i + 2 | 0, lo);
-      /*<<bytes.ml:776:18>>*/ return 4;
-    }
-     /*<<bytes.ml:764:27>>*/ return  /*<<bytes.ml:764:27>>*/ caml_call1
-            (Stdlib[1], cst_index_out_of_bounds$0);
-    /*<<bytes.ml:777:21>>*/ }
-   function is_valid_utf_16be(b){
-     /*<<bytes.ml:780:2>>*/ var max = caml_ml_bytes_length(b) - 1 | 0, i = 0;
-     /*<<bytes.ml:781:4>>*/ for(;;){
-     if(max < i)  /*<<bytes.ml:782:20>>*/ return 1;
-     if(i === max)  /*<<bytes.ml:783:20>>*/ return 0;
-      /*<<bytes.ml:784:10>>*/  /*<<bytes.ml:784:10>>*/ var
-      u = unsafe_get_uint16_be(b, i);
-     if(55296 <= u && 57343 >= u){
-       /*<<bytes.ml:786:13>>*/ if(56319 < u)
-        /*<<bytes.ml:786:27>>*/ return 0;
-       /*<<bytes.ml:788:8>>*/  /*<<bytes.ml:788:8>>*/ var last = i + 3 | 0;
-      if(max < last)  /*<<bytes.ml:789:27>>*/ return 0;
-       /*<<bytes.ml:790:14>>*/  /*<<bytes.ml:790:14>>*/ var
-       u$0 = unsafe_get_uint16_be(b, i + 2 | 0);
-      if(56320 <= u$0 && 57343 >= u$0){
-        /*<<bytes.ml:792:17>>*/ var
-         /*<<bytes.ml:792:17>>*/ i$1 = i + 4 | 0,
-        i = i$1;
-       continue;
-      }
-       /*<<bytes.ml:791:45>>*/ return 0;
-     }
-      /*<<bytes.ml:785:41>>*/ var
-       /*<<bytes.ml:785:41>>*/ i$0 = i + 2 | 0,
-      i = i$0;
-    }
-    /*<<bytes.ml:794:25>>*/ }
-   function get_utf_16le_uchar(b, i){
-     /*<<bytes.ml:799:2>>*/  /*<<bytes.ml:800:2>>*/ var
-     max =  /*<<bytes.ml:800:2>>*/ caml_ml_bytes_length(b) - 1 | 0;
-    if(0 <= i && max >= i){
-     if(i === max)
-       /*<<bytes.ml:802:18>>*/ return  /*<<bytes.ml:802:18>>*/ caml_call1
-              (dec_invalid, 1);
-      /*<<bytes.ml:803:8>>*/  /*<<bytes.ml:803:8>>*/ var
-      hi = unsafe_get_uint16_le(b, i);
-     if(55296 <= hi && 57343 >= hi){
-       /*<<bytes.ml:805:11>>*/ if(56319 < hi)
-        /*<<bytes.ml:805:25>>*/ return  /*<<bytes.ml:805:25>>*/ caml_call1
-               (dec_invalid, 2);
-       /*<<bytes.ml:807:6>>*/  /*<<bytes.ml:807:6>>*/ var last = i + 3 | 0;
-      if(max < last) return caml_call1(dec_invalid, (max - i | 0) + 1 | 0);
-       /*<<bytes.ml:809:12>>*/  /*<<bytes.ml:809:12>>*/ var
-       lo = unsafe_get_uint16_le(b, i + 2 | 0);
-      if(56320 <= lo && 57343 >= lo){
-       var u = ((hi & 1023) << 10 | lo & 1023) + 65536 | 0;
-        /*<<bytes.ml:813:10>>*/ return dec_ret(4, u);
-      }
-       /*<<bytes.ml:810:43>>*/ return  /*<<bytes.ml:810:43>>*/ caml_call1
-              (dec_invalid, 2);
-     }
-      /*<<bytes.ml:804:39>>*/ return dec_ret(2, hi);
-    }
-     /*<<bytes.ml:801:27>>*/ return  /*<<bytes.ml:801:27>>*/ caml_call1
-            (Stdlib[1], cst_index_out_of_bounds$1);
-    /*<<bytes.ml:813:21>>*/ }
-   function set_utf_16le_uchar(b, i, u){
-     /*<<bytes.ml:816:2>>*/  /*<<bytes.ml:817:2>>*/ var
-     max =  /*<<bytes.ml:817:2>>*/ caml_ml_bytes_length(b) - 1 | 0;
-    if(0 <= i && max >= i){
-      /*<<bytes.ml:819:8>>*/  /*<<bytes.ml:819:8>>*/ var
-      u$0 =  /*<<bytes.ml:819:8>>*/ caml_call1(Stdlib_Uchar[10], u);
-      /*<<bytes.ml:820:11>>*/ if(0 > u$0)
-       /*<<bytes.ml:820:20>>*/ throw  /*<<bytes.ml:820:20>>*/ caml_maybe_attach_backtrace
-             ([0, Assert_failure, _f_], 1);
-      /*<<bytes.ml:821:11>>*/ if(65535 >= u$0){
-       /*<<bytes.ml:822:6>>*/  /*<<bytes.ml:822:6>>*/ var last$0 = i + 1 | 0;
-      return max < last$0 ? 0 : (unsafe_set_uint16_le(b, i, u$0), 2);
-     }
-      /*<<bytes.ml:824:11>>*/ if(1114111 < u$0)
-       /*<<bytes.ml:831:9>>*/ throw  /*<<bytes.ml:831:9>>*/ caml_maybe_attach_backtrace
-             ([0, Assert_failure, _e_], 1);
-      /*<<bytes.ml:825:6>>*/  /*<<bytes.ml:825:6>>*/ var last = i + 3 | 0;
-     if(max < last)  /*<<bytes.ml:826:25>>*/ return 0;
-      /*<<bytes.ml:827:6>>*/ var
-       /*<<bytes.ml:827:6>>*/ u$1 = u$0 - 65536 | 0,
-      hi = 55296 | u$1 >>> 10 | 0,
-      lo = 56320 | u$1 & 1023;
-      /*<<bytes.ml:830:6>>*/ unsafe_set_uint16_le(b, i, hi);
-      /*<<bytes.ml:830:18>>*/ unsafe_set_uint16_le(b, i + 2 | 0, lo);
-      /*<<bytes.ml:830:18>>*/ return 4;
-    }
-     /*<<bytes.ml:818:27>>*/ return  /*<<bytes.ml:818:27>>*/ caml_call1
-            (Stdlib[1], cst_index_out_of_bounds$2);
-    /*<<bytes.ml:831:21>>*/ }
-   function is_valid_utf_16le(b){
-     /*<<bytes.ml:834:2>>*/ var max = caml_ml_bytes_length(b) - 1 | 0, i = 0;
-     /*<<bytes.ml:835:4>>*/ for(;;){
-     if(max < i)  /*<<bytes.ml:836:20>>*/ return 1;
-     if(i === max)  /*<<bytes.ml:837:20>>*/ return 0;
-      /*<<bytes.ml:838:10>>*/  /*<<bytes.ml:838:10>>*/ var
-      u = unsafe_get_uint16_le(b, i);
-     if(55296 <= u && 57343 >= u){
-       /*<<bytes.ml:840:13>>*/ if(56319 < u)
-        /*<<bytes.ml:840:27>>*/ return 0;
-       /*<<bytes.ml:842:8>>*/  /*<<bytes.ml:842:8>>*/ var last = i + 3 | 0;
-      if(max < last)  /*<<bytes.ml:843:27>>*/ return 0;
-       /*<<bytes.ml:844:14>>*/  /*<<bytes.ml:844:14>>*/ var
-       u$0 = unsafe_get_uint16_le(b, i + 2 | 0);
-      if(56320 <= u$0 && 57343 >= u$0){
-        /*<<bytes.ml:846:17>>*/ var
-         /*<<bytes.ml:846:17>>*/ i$1 = i + 4 | 0,
-        i = i$1;
-       continue;
-      }
-       /*<<bytes.ml:845:45>>*/ return 0;
-     }
-      /*<<bytes.ml:839:41>>*/ var
-       /*<<bytes.ml:839:41>>*/ i$0 = i + 2 | 0,
-      i = i$0;
-    }
-    /*<<bytes.ml:848:25>>*/ }
-   var
-    Stdlib_Bytes =
-      [0,
-       make,
-       init,
-       empty,
-       copy,
-       of_string,
-       to_string,
-       sub,
-       sub_string,
-       extend,
-       fill,
-       blit,
-       blit_string,
-       concat,
-       cat,
-       iter,
-       iteri,
-       map,
-       mapi,
-       fold_left,
-       fold_right,
-       for_all,
-       exists,
-       trim,
-       escaped,
-       index,
-       index_opt,
-       rindex,
-       rindex_opt,
-       index_from,
-       index_from_opt,
-       rindex_from,
-       rindex_from_opt,
-       contains,
-       contains_from,
-       rcontains_from,
-       uppercase_ascii,
-       lowercase_ascii,
-       capitalize_ascii,
-       uncapitalize_ascii,
-       compare,
-       runtime.caml_bytes_equal,
-       starts_with,
-       ends_with,
-       caml_string_of_bytes,
-       caml_bytes_of_string,
-       split_on_char,
-       to_seq,
-       to_seqi,
-       of_seq,
-       get_utf_8_uchar,
-       set_utf_8_uchar,
-       is_valid_utf_8,
-       get_utf_16be_uchar,
-       set_utf_16be_uchar,
-       is_valid_utf_16be,
-       get_utf_16le_uchar,
-       set_utf_16le_uchar,
-       is_valid_utf_16le,
-       caml_bytes_get,
-       get_int8,
-       caml_bytes_get16,
-       get_uint16_be,
-       get_uint16_le,
-       get_int16_ne,
-       get_int16_be,
-       get_int16_le,
-       caml_bytes_get32,
-       get_int32_be,
-       get_int32_le,
-       caml_bytes_get64,
-       get_int64_be,
-       get_int64_le,
-       set_uint8,
-       caml_bytes_set,
-       set_uint16_ne,
-       set_int16_be,
-       set_int16_le,
-       caml_bytes_set16,
-       set_int16_be,
-       set_int16_le,
-       caml_bytes_set32,
-       set_int32_be,
-       set_int32_le,
-       caml_bytes_set64,
-       set_int64_be,
-       set_int64_le,
-       unsafe_escape];
-   runtime.caml_register_global(30, Stdlib_Bytes, "Stdlib__Bytes");
-   return;
-   /*<<?>>*/ }
-  (globalThis));
-
-//# unitInfo: Provides: Stdlib__String
-//# unitInfo: Requires: Stdlib, Stdlib__Bytes
-(function
-  (globalThis){
-   "use strict";
-   var
-    runtime = globalThis.jsoo_runtime,
-    cst$0 = "",
-    caml_blit_string = runtime.caml_blit_string,
-    caml_maybe_attach_backtrace = runtime.caml_maybe_attach_backtrace,
-    caml_ml_string_length = runtime.caml_ml_string_length,
-    caml_string_equal = runtime.caml_string_equal,
-    caml_string_hash = runtime.caml_string_hash,
-    caml_string_unsafe_get = runtime.caml_string_unsafe_get,
-    caml_wrap_exception = runtime.caml_wrap_exception;
-    /*<<?>>*/ function caml_call1(f, a0){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 1
-            ? f(a0)
-            : runtime.caml_call_gen(f, [a0]);
-   }
-    /*<<?>>*/ function caml_call2(f, a0, a1){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 2
-            ? f(a0, a1)
-            : runtime.caml_call_gen(f, [a0, a1]);
-   }
-    /*<<?>>*/ function caml_call3(f, a0, a1, a2){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 3
-            ? f(a0, a1, a2)
-            : runtime.caml_call_gen(f, [a0, a1, a2]);
-   }
-   var
-    global_data = runtime.caml_get_global_data(),
-    cst = cst$0,
-    empty = cst$0,
-    Stdlib = global_data.Stdlib,
-    Stdlib_Bytes = global_data.Stdlib__Bytes,
-    bts = Stdlib_Bytes[44],
-    bos = Stdlib_Bytes[45],
-    cst_String_rcontains_from_Byte =
-      "String.rcontains_from / Bytes.rcontains_from",
-    cst_String_contains_from_Bytes =
-      "String.contains_from / Bytes.contains_from",
-    cst_String_rindex_from_opt_Byt =
-      "String.rindex_from_opt / Bytes.rindex_from_opt",
-    cst_String_rindex_from_Bytes_r = "String.rindex_from / Bytes.rindex_from",
-    cst_String_index_from_opt_Byte =
-      "String.index_from_opt / Bytes.index_from_opt",
-    cst_String_index_from_Bytes_in = "String.index_from / Bytes.index_from",
-    cst_String_concat = "String.concat";
-   function make(n, c){
-     /*<<string.ml:36:2>>*/ return  /*<<string.ml:36:2>>*/ caml_call1
-            (bts,  /*<<string.ml:36:2>>*/ caml_call2(Stdlib_Bytes[1], n, c));
-    /*<<string.ml:36:19>>*/ }
-   function init(n, f){
-     /*<<string.ml:38:2>>*/ return  /*<<string.ml:38:2>>*/ caml_call1
-            (bts,  /*<<string.ml:38:2>>*/ caml_call2(Stdlib_Bytes[2], n, f));
-    /*<<string.ml:38:19>>*/ }
-   var of_bytes = Stdlib_Bytes[6], to_bytes = Stdlib_Bytes[5];
-   function sub(s, ofs, len){
-     /*<<string.ml:43:2>>*/  /*<<string.ml:43:8>>*/ var
-     _X_ =  /*<<string.ml:43:8>>*/ caml_call1(bos, s);
-     /*<<string.ml:43:2>>*/ return  /*<<string.ml:43:2>>*/ caml_call1
-            (bts,
-              /*<<string.ml:43:2>>*/ caml_call3
-              (Stdlib_Bytes[7], _X_, ofs, len));
-    /*<<string.ml:43:30>>*/ }
-   var blit = Stdlib_Bytes[12];
-   function concat(sep, l){
-     /*<<?>>*/ if(! l)  /*<<string.ml:64:10>>*/ return cst;
-    var seplen = caml_ml_string_length(sep), acc = 0, param = l, pos$1 = 0;
-    for(;;){
-     if(param){
-      var hd = param[1];
-      if(param[2]){
-       var
-        tl = param[2],
-        x = (caml_ml_string_length(hd) + seplen | 0) + acc | 0,
-        acc$0 =
-          acc <= x
-           ? x
-           :  /*<<string.ml:47:48>>*/ caml_call1(Stdlib[1], cst_String_concat),
-        acc = acc$0,
-        param = tl;
-       continue;
-      }
-      var _W_ = caml_ml_string_length(hd) + acc | 0;
-     }
-     else
-      var _W_ = acc;
-      /*<<string.ml:67:12>>*/ var
-       /*<<string.ml:67:12>>*/ dst =
-         /*<<string.ml:67:12>>*/ runtime.caml_create_bytes(_W_),
-      pos = pos$1,
-      param$0 = l;
-     for(;;){
-      if(param$0){
-       var hd$0 = param$0[1];
-       if(param$0[2]){
-        var tl$0 = param$0[2];
-         /*<<string.ml:59:4>>*/  /*<<string.ml:59:4>>*/ caml_blit_string
-         (hd$0,
-          0,
-          dst,
-          pos,
-           /*<<string.ml:59:4>>*/ caml_ml_string_length(hd$0));
-         /*<<string.ml:60:4>>*/  /*<<string.ml:60:4>>*/ caml_blit_string
-         (sep, 0, dst, pos + caml_ml_string_length(hd$0) | 0, seplen);
-        var
-         pos$0 = (pos + caml_ml_string_length(hd$0) | 0) + seplen | 0,
-         pos = pos$0,
-         param$0 = tl$0;
-        continue;
-       }
-        /*<<string.ml:57:4>>*/  /*<<string.ml:57:4>>*/ caml_blit_string
-        (hd$0, 0, dst, pos, caml_ml_string_length(hd$0));
-      }
-       /*<<string.ml:66:10>>*/ return  /*<<string.ml:66:10>>*/ caml_call1
-              (bts, dst);
-     }
-    }
-   }
-   var cat = Stdlib[28];
-   function iter(f, s){
-     /*<<string.ml:74:2>>*/ var
-     _U_ = caml_ml_string_length(s) - 1 | 0,
-      /*<<string.ml:74:2>>*/ _T_ = 0;
-    if(_U_ >= 0){
-     var i = _T_;
-     for(;;){
-       /*<<string.ml:74:31>>*/  /*<<string.ml:74:31>>*/ caml_call1
-       (f, caml_string_unsafe_get(s, i));
-       /*<<string.ml:74:31>>*/  /*<<string.ml:74:31>>*/ var _V_ = i + 1 | 0;
-      if(_U_ === i) break;
-      var i = _V_;
-     }
-    }
-    return 0;
-    /*<<string.ml:74:54>>*/ }
-   function iteri(f, s){
-     /*<<string.ml:78:2>>*/ var
-     _R_ = caml_ml_string_length(s) - 1 | 0,
-      /*<<string.ml:78:2>>*/ _Q_ = 0;
-    if(_R_ >= 0){
-     var i = _Q_;
-     for(;;){
-       /*<<string.ml:78:31>>*/  /*<<string.ml:78:31>>*/ caml_call2
-       (f, i, caml_string_unsafe_get(s, i));
-       /*<<string.ml:78:31>>*/  /*<<string.ml:78:31>>*/ var _S_ = i + 1 | 0;
-      if(_R_ === i) break;
-      var i = _S_;
-     }
-    }
-    return 0;
-    /*<<string.ml:78:56>>*/ }
-   function map(f, s){
-     /*<<string.ml:81:2>>*/  /*<<string.ml:81:10>>*/ var
-     _P_ =  /*<<string.ml:81:10>>*/ caml_call1(bos, s);
-     /*<<string.ml:81:2>>*/ return  /*<<string.ml:81:2>>*/ caml_call1
-            (bts,
-              /*<<string.ml:81:2>>*/ caml_call2(Stdlib_Bytes[17], f, _P_));
-    /*<<string.ml:81:24>>*/ }
-   function mapi(f, s){
-     /*<<string.ml:83:2>>*/  /*<<string.ml:83:11>>*/ var
-     _O_ =  /*<<string.ml:83:11>>*/ caml_call1(bos, s);
-     /*<<string.ml:83:2>>*/ return  /*<<string.ml:83:2>>*/ caml_call1
-            (bts,
-              /*<<string.ml:83:2>>*/ caml_call2(Stdlib_Bytes[18], f, _O_));
-    /*<<string.ml:83:25>>*/ }
-   function fold_right(f, x, a){
-     /*<<string.ml:85:2>>*/  /*<<string.ml:85:17>>*/ var
-     _N_ =  /*<<string.ml:85:17>>*/ caml_call1(bos, x);
-     /*<<string.ml:85:2>>*/ return  /*<<string.ml:85:2>>*/ caml_call3
-            (Stdlib_Bytes[20], f, _N_, a);
-    /*<<string.ml:85:26>>*/ }
-   function fold_left(f, a, x){
-     /*<<string.ml:87:2>>*/  /*<<string.ml:87:18>>*/ var
-     _M_ =  /*<<string.ml:87:18>>*/ caml_call1(bos, x);
-     /*<<string.ml:87:18>>*/ return  /*<<string.ml:87:18>>*/ caml_call3
-            (Stdlib_Bytes[19], f, a, _M_);
-    /*<<string.ml:87:25>>*/ }
-   function exists(f, s){
-     /*<<string.ml:89:2>>*/  /*<<string.ml:89:13>>*/ var
-     _L_ =  /*<<string.ml:89:13>>*/ caml_call1(bos, s);
-     /*<<string.ml:89:13>>*/ return  /*<<string.ml:89:13>>*/ caml_call2
-            (Stdlib_Bytes[22], f, _L_);
-    /*<<string.ml:89:20>>*/ }
-   function for_all(f, s){
-     /*<<string.ml:91:2>>*/  /*<<string.ml:91:14>>*/ var
-     _K_ =  /*<<string.ml:91:14>>*/ caml_call1(bos, s);
-     /*<<string.ml:91:14>>*/ return  /*<<string.ml:91:14>>*/ caml_call2
-            (Stdlib_Bytes[21], f, _K_);
-    /*<<string.ml:91:21>>*/ }
-   function is_space(param){
-     /*<<string.ml:97:15>>*/  /*<<string.ml:97:15>>*/ var _J_ = param - 9 | 0;
-    a:
-    {
-     if(4 < _J_ >>> 0){if(23 !== _J_) break a;} else if(2 === _J_) break a;
-      /*<<string.ml:98:41>>*/ return 1;
-    }
-     /*<<string.ml:99:9>>*/ return 0;
-    /*<<string.ml:99:14>>*/ }
-   function trim(s){
-     /*<<string.ml:102:2>>*/ if
-     ( /*<<string.ml:102:5>>*/ caml_string_equal(s, cst$0))
-      /*<<string.ml:102:17>>*/ return s;
-     /*<<string.ml:103:39>>*/ if
-     (!
-      is_space(caml_string_unsafe_get(s, 0))
-      &&
-       !
-       is_space(caml_string_unsafe_get(s, caml_ml_string_length(s) - 1 | 0)))
-      /*<<string.ml:105:7>>*/ return s;
-     /*<<string.ml:104:21>>*/  /*<<string.ml:104:21>>*/ var
-     _I_ =  /*<<string.ml:104:21>>*/ caml_call1(bos, s);
-     /*<<string.ml:104:13>>*/ return  /*<<string.ml:104:13>>*/ caml_call1
-            (bts,  /*<<string.ml:104:13>>*/ caml_call1(Stdlib_Bytes[23], _I_));
-    /*<<string.ml:105:8>>*/ }
-   function escaped(s){
-     /*<<string.ml:108:2>>*/  /*<<string.ml:108:10>>*/ var
-     b =  /*<<string.ml:108:10>>*/ caml_call1(bos, s);
-     /*<<string.ml:111:6>>*/ return  /*<<string.ml:111:6>>*/ caml_call1
-            (bts,  /*<<string.ml:111:6>>*/ caml_call1(Stdlib_Bytes[87], b));
-    /*<<string.ml:111:25>>*/ }
-   function index_rec(s, lim, i, c){
-     /*<<string.ml:115:2>>*/ var i$0 = i;
-     /*<<string.ml:115:2>>*/ for(;;){
-     if(lim <= i$0)
-       /*<<string.ml:115:19>>*/ throw  /*<<string.ml:115:19>>*/ caml_maybe_attach_backtrace
-             (Stdlib[8], 1);
-     if(caml_string_unsafe_get(s, i$0) === c)
-       /*<<string.ml:116:29>>*/ return i$0;
-     var i$1 = i$0 + 1 | 0, i$0 = i$1;
-    }
-    /*<<string.ml:116:61>>*/ }
-   function index(s, c){
-     /*<<string.ml:119:16>>*/ return index_rec
-            (s, caml_ml_string_length(s), 0, c);
-    /*<<string.ml:119:42>>*/ }
-   function index_rec_opt(s, lim, i, c){
-     /*<<string.ml:123:2>>*/ var i$0 = i;
-     /*<<string.ml:123:2>>*/ for(;;){
-     if(lim <= i$0)  /*<<string.ml:123:19>>*/ return 0;
-     if(caml_string_unsafe_get(s, i$0) === c)
-       /*<<string.ml:124:29>>*/ return [0, i$0];
-     var i$1 = i$0 + 1 | 0, i$0 = i$1;
-    }
-    /*<<string.ml:124:70>>*/ }
-   function index_opt(s, c){
-     /*<<string.ml:127:20>>*/ return index_rec_opt
-            (s, caml_ml_string_length(s), 0, c);
-    /*<<string.ml:127:50>>*/ }
-   function index_from(s, i, c){
-     /*<<string.ml:131:2>>*/ var l = caml_ml_string_length(s);
-    if(0 <= i && l >= i)
-      /*<<string.ml:133:4>>*/ return index_rec(s, l, i, c);
-     /*<<string.ml:132:25>>*/ return  /*<<string.ml:132:25>>*/ caml_call1
-            (Stdlib[1], cst_String_index_from_Bytes_in);
-    /*<<string.ml:133:21>>*/ }
-   function index_from_opt(s, i, c){
-     /*<<string.ml:137:2>>*/ var l = caml_ml_string_length(s);
-    if(0 <= i && l >= i)
-      /*<<string.ml:141:4>>*/ return index_rec_opt(s, l, i, c);
-     /*<<string.ml:139:4>>*/ return  /*<<string.ml:139:4>>*/ caml_call1
-            (Stdlib[1], cst_String_index_from_opt_Byte);
-    /*<<string.ml:141:25>>*/ }
-   function rindex_rec(s, i, c){
-     /*<<string.ml:145:2>>*/ var i$0 = i;
-     /*<<string.ml:145:2>>*/ for(;;){
-     if(0 > i$0)
-       /*<<string.ml:145:16>>*/ throw  /*<<string.ml:145:16>>*/ caml_maybe_attach_backtrace
-             (Stdlib[8], 1);
-     if(caml_string_unsafe_get(s, i$0) === c)
-       /*<<string.ml:146:29>>*/ return i$0;
-     var i$1 = i$0 - 1 | 0, i$0 = i$1;
-    }
-    /*<<string.ml:146:58>>*/ }
-   function rindex(s, c){
-     /*<<string.ml:149:17>>*/ return rindex_rec
-            (s, caml_ml_string_length(s) - 1 | 0, c);
-    /*<<string.ml:149:46>>*/ }
-   function rindex_from(s, i, c){
-     /*<<string.ml:153:2>>*/ if(-1 <= i && caml_ml_string_length(s) > i)
-      /*<<string.ml:156:4>>*/ return rindex_rec(s, i, c);
-     /*<<string.ml:154:4>>*/ return  /*<<string.ml:154:4>>*/ caml_call1
-            (Stdlib[1], cst_String_rindex_from_Bytes_r);
-    /*<<string.ml:156:20>>*/ }
-   function rindex_rec_opt(s, i, c){
-     /*<<string.ml:160:2>>*/ var i$0 = i;
-     /*<<string.ml:160:2>>*/ for(;;){
-     if(0 > i$0)  /*<<string.ml:160:16>>*/ return 0;
-     if(caml_string_unsafe_get(s, i$0) === c)
-       /*<<string.ml:161:29>>*/ return [0, i$0];
-     var i$1 = i$0 - 1 | 0, i$0 = i$1;
-    }
-    /*<<string.ml:161:67>>*/ }
-   function rindex_opt(s, c){
-     /*<<string.ml:164:21>>*/ return rindex_rec_opt
-            (s, caml_ml_string_length(s) - 1 | 0, c);
-    /*<<string.ml:164:54>>*/ }
-   function rindex_from_opt(s, i, c){
-     /*<<string.ml:168:2>>*/ if(-1 <= i && caml_ml_string_length(s) > i)
-      /*<<string.ml:171:4>>*/ return rindex_rec_opt(s, i, c);
-     /*<<string.ml:169:4>>*/ return  /*<<string.ml:169:4>>*/ caml_call1
-            (Stdlib[1], cst_String_rindex_from_opt_Byt);
-    /*<<string.ml:171:24>>*/ }
-   function contains_from(s, i, c){
-     /*<<string.ml:175:2>>*/ var l = caml_ml_string_length(s);
-    if(0 <= i && l >= i)
-      /*<<string.ml:179:4>>*/ try{
-       /*<<string.ml:179:15>>*/ index_rec(s, l, i, c);
-       /*<<string.ml:179:36>>*/  /*<<string.ml:179:36>>*/ var _G_ = 1;
-       /*<<string.ml:179:36>>*/ return _G_;
-     }
-     catch(_H_){
-      var _F_ = caml_wrap_exception(_H_);
-      if(_F_ === Stdlib[8])  /*<<string.ml:179:59>>*/ return 0;
-      throw caml_maybe_attach_backtrace(_F_, 0);
-     }
-     /*<<string.ml:177:4>>*/ return  /*<<string.ml:177:4>>*/ caml_call1
-            (Stdlib[1], cst_String_contains_from_Bytes);
-    /*<<string.ml:179:64>>*/ }
-   function contains(s, c){
-     /*<<string.ml:182:19>>*/ return contains_from(s, 0, c);
-    /*<<string.ml:182:38>>*/ }
-   function rcontains_from(s, i, c){
-     /*<<string.ml:186:2>>*/ if(0 <= i && caml_ml_string_length(s) > i)
-      /*<<string.ml:189:4>>*/ try{
-       /*<<string.ml:189:15>>*/ rindex_rec(s, i, c);
-       /*<<string.ml:189:35>>*/  /*<<string.ml:189:35>>*/ var _D_ = 1;
-       /*<<string.ml:189:35>>*/ return _D_;
-     }
-     catch(_E_){
-      var _C_ = caml_wrap_exception(_E_);
-      if(_C_ === Stdlib[8])  /*<<string.ml:189:58>>*/ return 0;
-      throw caml_maybe_attach_backtrace(_C_, 0);
-     }
-     /*<<string.ml:187:4>>*/ return  /*<<string.ml:187:4>>*/ caml_call1
-            (Stdlib[1], cst_String_rcontains_from_Byte);
-    /*<<string.ml:189:63>>*/ }
-   function uppercase_ascii(s){
-     /*<<string.ml:192:2>>*/  /*<<string.ml:192:20>>*/ var
-     _B_ =  /*<<string.ml:192:20>>*/ caml_call1(bos, s);
-     /*<<string.ml:192:2>>*/ return  /*<<string.ml:192:2>>*/ caml_call1
-            (bts,  /*<<string.ml:192:2>>*/ caml_call1(Stdlib_Bytes[36], _B_));
-    /*<<string.ml:192:34>>*/ }
-   function lowercase_ascii(s){
-     /*<<string.ml:194:2>>*/  /*<<string.ml:194:20>>*/ var
-     _A_ =  /*<<string.ml:194:20>>*/ caml_call1(bos, s);
-     /*<<string.ml:194:2>>*/ return  /*<<string.ml:194:2>>*/ caml_call1
-            (bts,  /*<<string.ml:194:2>>*/ caml_call1(Stdlib_Bytes[37], _A_));
-    /*<<string.ml:194:34>>*/ }
-   function capitalize_ascii(s){
-     /*<<string.ml:196:2>>*/  /*<<string.ml:196:21>>*/ var
-     _z_ =  /*<<string.ml:196:21>>*/ caml_call1(bos, s);
-     /*<<string.ml:196:2>>*/ return  /*<<string.ml:196:2>>*/ caml_call1
-            (bts,  /*<<string.ml:196:2>>*/ caml_call1(Stdlib_Bytes[38], _z_));
-    /*<<string.ml:196:35>>*/ }
-   function uncapitalize_ascii(s){
-     /*<<string.ml:198:2>>*/  /*<<string.ml:198:23>>*/ var
-     _y_ =  /*<<string.ml:198:23>>*/ caml_call1(bos, s);
-     /*<<string.ml:198:2>>*/ return  /*<<string.ml:198:2>>*/ caml_call1
-            (bts,  /*<<string.ml:198:2>>*/ caml_call1(Stdlib_Bytes[39], _y_));
-    /*<<string.ml:198:37>>*/ }
-   function starts_with(prefix, s){
-     /*<<string.ml:202:2>>*/ var
-     len_s = caml_ml_string_length(s),
-     len_pre = caml_ml_string_length(prefix),
-     _x_ = len_pre <= len_s ? 1 : 0;
-    if(! _x_) return _x_;
-    var i = 0;
-     /*<<string.ml:205:4>>*/ for(;;){
-     if(i === len_pre)  /*<<string.ml:205:24>>*/ return 1;
-     if(caml_string_unsafe_get(s, i) !== caml_string_unsafe_get(prefix, i))
-       /*<<string.ml:206:55>>*/ return 0;
-      /*<<string.ml:207:9>>*/ var
-       /*<<string.ml:207:9>>*/ i$0 = i + 1 | 0,
-      i = i$0;
-    }
-    /*<<string.ml:208:30>>*/ }
-   function ends_with(suffix, s){
-     /*<<string.ml:212:2>>*/ var
-     len_s = caml_ml_string_length(s),
-     len_suf = caml_ml_string_length(suffix),
-     diff = len_s - len_suf | 0,
-     _w_ = 0 <= diff ? 1 : 0;
-    if(! _w_) return _w_;
-    var i = 0;
-     /*<<string.ml:216:4>>*/ for(;;){
-     if(i === len_suf)  /*<<string.ml:216:24>>*/ return 1;
-     if
-      (caml_string_unsafe_get(s, diff + i | 0)
-       !== caml_string_unsafe_get(suffix, i))
-       /*<<string.ml:217:64>>*/ return 0;
-      /*<<string.ml:218:9>>*/ var
-       /*<<string.ml:218:9>>*/ i$0 = i + 1 | 0,
-      i = i$0;
-    }
-    /*<<string.ml:219:23>>*/ }
-   function hash(x){
-     /*<<string.ml:222:13>>*/ return  /*<<string.ml:222:13>>*/ caml_string_hash
-            (0, x);
-    /*<<string.ml:222:28>>*/ }
-   function split_on_char(sep, s){
-     /*<<string.ml:226:2>>*/ var
-      /*<<string.ml:226:10>>*/ r = [0, 0],
-      /*<<string.ml:227:10>>*/ j =
-       [0,  /*<<string.ml:227:2>>*/ caml_ml_string_length(s)],
-      /*<<string.ml:228:2>>*/ _s_ =
-        /*<<string.ml:228:2>>*/ caml_ml_string_length(s) - 1 | 0;
-    if(_s_ >= 0){
-     var i = _s_;
-     for(;;){
-      if(caml_string_unsafe_get(s, i) === sep){
-       var _u_ = r[1];
-       r[1] = [0, sub(s, i + 1 | 0, (j[1] - i | 0) - 1 | 0), _u_];
-       j[1] = i;
-      }
-       /*<<string.ml:228:2>>*/  /*<<string.ml:228:2>>*/ var _v_ = i - 1 | 0;
-      if(0 === i) break;
-      var i = _v_;
-     }
-    }
-    var _t_ = r[1];
-     /*<<string.ml:234:2>>*/ return [0, sub(s, 0, j[1]), _t_];
-    /*<<string.ml:234:18>>*/ }
-   var compare = runtime.caml_string_compare;
-   function to_seq(s){
-     /*<<string.ml:243:15>>*/  /*<<string.ml:243:15>>*/ var
-     _r_ =  /*<<string.ml:243:15>>*/ caml_call1(bos, s);
-     /*<<string.ml:243:15>>*/ return  /*<<string.ml:243:15>>*/ caml_call1
-            (Stdlib_Bytes[47], _r_);
-    /*<<string.ml:243:32>>*/ }
-   function to_seqi(s){
-     /*<<string.ml:245:16>>*/  /*<<string.ml:245:16>>*/ var
-     _q_ =  /*<<string.ml:245:16>>*/ caml_call1(bos, s);
-     /*<<string.ml:245:16>>*/ return  /*<<string.ml:245:16>>*/ caml_call1
-            (Stdlib_Bytes[48], _q_);
-    /*<<string.ml:245:34>>*/ }
-   function of_seq(g){
-     /*<<string.ml:247:15>>*/ return  /*<<string.ml:247:15>>*/ caml_call1
-            (bts,  /*<<string.ml:247:15>>*/ caml_call1(Stdlib_Bytes[49], g));
-    /*<<string.ml:247:32>>*/ }
-   function get_utf_8_uchar(s, i){
-     /*<<string.ml:251:26>>*/  /*<<string.ml:251:44>>*/ var
-     _p_ =  /*<<string.ml:251:44>>*/ caml_call1(bos, s);
-     /*<<string.ml:251:26>>*/ return  /*<<string.ml:251:26>>*/ caml_call2
-            (Stdlib_Bytes[50], _p_, i);
-    /*<<string.ml:251:53>>*/ }
-   function is_valid_utf_8(s){
-     /*<<string.ml:252:23>>*/  /*<<string.ml:252:40>>*/ var
-     _o_ =  /*<<string.ml:252:40>>*/ caml_call1(bos, s);
-     /*<<string.ml:252:40>>*/ return  /*<<string.ml:252:40>>*/ caml_call1
-            (Stdlib_Bytes[52], _o_);
-    /*<<string.ml:252:47>>*/ }
-   function get_utf_16be_uchar(s, i){
-     /*<<string.ml:254:29>>*/  /*<<string.ml:254:50>>*/ var
-     _n_ =  /*<<string.ml:254:50>>*/ caml_call1(bos, s);
-     /*<<string.ml:254:29>>*/ return  /*<<string.ml:254:29>>*/ caml_call2
-            (Stdlib_Bytes[53], _n_, i);
-    /*<<string.ml:254:59>>*/ }
-   function is_valid_utf_16be(s){
-     /*<<string.ml:255:26>>*/  /*<<string.ml:255:46>>*/ var
-     _m_ =  /*<<string.ml:255:46>>*/ caml_call1(bos, s);
-     /*<<string.ml:255:46>>*/ return  /*<<string.ml:255:46>>*/ caml_call1
-            (Stdlib_Bytes[55], _m_);
-    /*<<string.ml:255:53>>*/ }
-   function get_utf_16le_uchar(s, i){
-     /*<<string.ml:257:29>>*/  /*<<string.ml:257:50>>*/ var
-     _l_ =  /*<<string.ml:257:50>>*/ caml_call1(bos, s);
-     /*<<string.ml:257:29>>*/ return  /*<<string.ml:257:29>>*/ caml_call2
-            (Stdlib_Bytes[56], _l_, i);
-    /*<<string.ml:257:59>>*/ }
-   function is_valid_utf_16le(s){
-     /*<<string.ml:258:26>>*/  /*<<string.ml:258:46>>*/ var
-     _k_ =  /*<<string.ml:258:46>>*/ caml_call1(bos, s);
-     /*<<string.ml:258:46>>*/ return  /*<<string.ml:258:46>>*/ caml_call1
-            (Stdlib_Bytes[58], _k_);
-    /*<<string.ml:258:53>>*/ }
-   function get_int8(s, i){
-     /*<<string.ml:267:19>>*/  /*<<string.ml:267:30>>*/ var
-     _j_ =  /*<<string.ml:267:30>>*/ caml_call1(bos, s);
-     /*<<string.ml:267:19>>*/ return  /*<<string.ml:267:19>>*/ caml_call2
-            (Stdlib_Bytes[60], _j_, i);
-    /*<<string.ml:267:39>>*/ }
-   function get_uint16_le(s, i){
-     /*<<string.ml:268:24>>*/  /*<<string.ml:268:40>>*/ var
-     _i_ =  /*<<string.ml:268:40>>*/ caml_call1(bos, s);
-     /*<<string.ml:268:24>>*/ return  /*<<string.ml:268:24>>*/ caml_call2
-            (Stdlib_Bytes[63], _i_, i);
-    /*<<string.ml:268:49>>*/ }
-   function get_uint16_be(s, i){
-     /*<<string.ml:269:24>>*/  /*<<string.ml:269:40>>*/ var
-     _h_ =  /*<<string.ml:269:40>>*/ caml_call1(bos, s);
-     /*<<string.ml:269:24>>*/ return  /*<<string.ml:269:24>>*/ caml_call2
-            (Stdlib_Bytes[62], _h_, i);
-    /*<<string.ml:269:49>>*/ }
-   function get_int16_ne(s, i){
-     /*<<string.ml:270:23>>*/  /*<<string.ml:270:38>>*/ var
-     _g_ =  /*<<string.ml:270:38>>*/ caml_call1(bos, s);
-     /*<<string.ml:270:23>>*/ return  /*<<string.ml:270:23>>*/ caml_call2
-            (Stdlib_Bytes[64], _g_, i);
-    /*<<string.ml:270:47>>*/ }
-   function get_int16_le(s, i){
-     /*<<string.ml:271:23>>*/  /*<<string.ml:271:38>>*/ var
-     _f_ =  /*<<string.ml:271:38>>*/ caml_call1(bos, s);
-     /*<<string.ml:271:23>>*/ return  /*<<string.ml:271:23>>*/ caml_call2
-            (Stdlib_Bytes[66], _f_, i);
-    /*<<string.ml:271:47>>*/ }
-   function get_int16_be(s, i){
-     /*<<string.ml:272:23>>*/  /*<<string.ml:272:38>>*/ var
-     _e_ =  /*<<string.ml:272:38>>*/ caml_call1(bos, s);
-     /*<<string.ml:272:23>>*/ return  /*<<string.ml:272:23>>*/ caml_call2
-            (Stdlib_Bytes[65], _e_, i);
-    /*<<string.ml:272:47>>*/ }
-   function get_int32_le(s, i){
-     /*<<string.ml:273:23>>*/  /*<<string.ml:273:38>>*/ var
-     _d_ =  /*<<string.ml:273:38>>*/ caml_call1(bos, s);
-     /*<<string.ml:273:23>>*/ return  /*<<string.ml:273:23>>*/ caml_call2
-            (Stdlib_Bytes[69], _d_, i);
-    /*<<string.ml:273:47>>*/ }
-   function get_int32_be(s, i){
-     /*<<string.ml:274:23>>*/  /*<<string.ml:274:38>>*/ var
-     _c_ =  /*<<string.ml:274:38>>*/ caml_call1(bos, s);
-     /*<<string.ml:274:23>>*/ return  /*<<string.ml:274:23>>*/ caml_call2
-            (Stdlib_Bytes[68], _c_, i);
-    /*<<string.ml:274:47>>*/ }
-   function get_int64_le(s, i){
-     /*<<string.ml:275:23>>*/  /*<<string.ml:275:38>>*/ var
-     _b_ =  /*<<string.ml:275:38>>*/ caml_call1(bos, s);
-     /*<<string.ml:275:23>>*/ return  /*<<string.ml:275:23>>*/ caml_call2
-            (Stdlib_Bytes[72], _b_, i);
-    /*<<string.ml:275:47>>*/ }
-   function get_int64_be(s, i){
-     /*<<string.ml:276:23>>*/  /*<<string.ml:276:38>>*/ var
-     _a_ =  /*<<string.ml:276:38>>*/ caml_call1(bos, s);
-     /*<<string.ml:276:23>>*/ return  /*<<string.ml:276:23>>*/ caml_call2
-            (Stdlib_Bytes[71], _a_, i);
-    /*<<string.ml:276:47>>*/ }
-   var
-    Stdlib_String =
-      [0,
-       make,
-       init,
-       empty,
-       of_bytes,
-       to_bytes,
-       concat,
-       cat,
-       caml_string_equal,
-       compare,
-       starts_with,
-       ends_with,
-       contains_from,
-       rcontains_from,
-       contains,
-       sub,
-       split_on_char,
-       map,
-       mapi,
-       fold_left,
-       fold_right,
-       for_all,
-       exists,
-       trim,
-       escaped,
-       uppercase_ascii,
-       lowercase_ascii,
-       capitalize_ascii,
-       uncapitalize_ascii,
-       iter,
-       iteri,
-       index_from,
-       index_from_opt,
-       rindex_from,
-       rindex_from_opt,
-       index,
-       index_opt,
-       rindex,
-       rindex_opt,
-       to_seq,
-       to_seqi,
-       of_seq,
-       get_utf_8_uchar,
-       is_valid_utf_8,
-       get_utf_16be_uchar,
-       is_valid_utf_16be,
-       get_utf_16le_uchar,
-       is_valid_utf_16le,
-       blit,
-       runtime.caml_string_get,
-       get_int8,
-       runtime.caml_string_get16,
-       get_uint16_be,
-       get_uint16_le,
-       get_int16_ne,
-       get_int16_be,
-       get_int16_le,
-       runtime.caml_string_get32,
-       hash,
-       caml_string_hash,
-       get_int32_be,
-       get_int32_le,
-       runtime.caml_string_get64,
-       get_int64_be,
-       get_int64_le];
-   runtime.caml_register_global(12, Stdlib_String, "Stdlib__String");
-   return;
-   /*<<?>>*/ }
-  (globalThis));
-
-//# unitInfo: Provides: Stdlib__Unit
-(function(globalThis){
-   "use strict";
-   var runtime = globalThis.jsoo_runtime, cst = "()";
-   function equal(param, _b_){
-     /*<<unit.ml:18:18>>*/ return 1;
-    /*<<unit.ml:18:22>>*/ }
-   function compare(param, _a_){
-     /*<<unit.ml:19:20>>*/ return 0;
-    /*<<unit.ml:19:21>>*/ }
-   function to_string(param){
-     /*<<unit.ml:20:19>>*/ return cst;
-    /*<<unit.ml:20:23>>*/ }
-   var Stdlib_Unit = [0, equal, compare, to_string];
-   runtime.caml_register_global(1, Stdlib_Unit, "Stdlib__Unit");
-   return;
-   /*<<?>>*/ }
-  (globalThis));
-
-//# unitInfo: Provides: Stdlib__Marshal
-//# unitInfo: Requires: Stdlib, Stdlib__Bytes
-(function
-  (globalThis){
-   "use strict";
-   var
-    runtime = globalThis.jsoo_runtime,
-    cst_Marshal_from_bytes$1 = "Marshal.from_bytes",
-    caml_marshal_data_size = runtime.caml_marshal_data_size,
-    caml_ml_bytes_length = runtime.caml_ml_bytes_length;
-    /*<<?>>*/ function caml_call1(f, a0){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 1
-            ? f(a0)
-            : runtime.caml_call_gen(f, [a0]);
-   }
-   var
-    global_data = runtime.caml_get_global_data(),
-    Stdlib_Bytes = global_data.Stdlib__Bytes,
-    Stdlib = global_data.Stdlib,
-    cst_Marshal_from_bytes = cst_Marshal_from_bytes$1,
-    cst_Marshal_from_bytes$0 = cst_Marshal_from_bytes$1,
-    cst_Marshal_data_size = "Marshal.data_size",
-    cst_Marshal_to_buffer_substrin =
-      "Marshal.to_buffer: substring out of bounds";
-   function to_buffer(buff, ofs, len, v, flags){
-     /*<<marshal.ml:33:2>>*/ if
-     (0 <= ofs && 0 <= len && (caml_ml_bytes_length(buff) - len | 0) >= ofs)
-      /*<<marshal.ml:35:7>>*/ return  /*<<marshal.ml:35:7>>*/ runtime.caml_output_value_to_buffer
-             (buff, ofs, len, v, flags);
-     /*<<marshal.ml:34:7>>*/ return  /*<<marshal.ml:34:7>>*/ caml_call1
-            (Stdlib[1], cst_Marshal_to_buffer_substrin);
-    /*<<marshal.ml:35:44>>*/ }
-   var header_size = 20;
-   function data_size(buff, ofs){
-     /*<<marshal.ml:49:2>>*/ if
-     (0 <= ofs && (caml_ml_bytes_length(buff) - 20 | 0) >= ofs)
-      /*<<marshal.ml:51:7>>*/ return  /*<<marshal.ml:51:7>>*/ caml_marshal_data_size
-             (buff, ofs);
-     /*<<marshal.ml:50:7>>*/ return  /*<<marshal.ml:50:7>>*/ caml_call1
-            (Stdlib[1], cst_Marshal_data_size);
-    /*<<marshal.ml:51:32>>*/ }
-   function total_size(buff, ofs){
-     /*<<marshal.ml:52:26>>*/ return 20 + data_size(buff, ofs) | 0;
-    /*<<marshal.ml:52:58>>*/ }
-   function from_bytes(buff, ofs){
-     /*<<marshal.ml:55:2>>*/ if
-     (0 <= ofs && (caml_ml_bytes_length(buff) - 20 | 0) >= ofs){
-      /*<<marshal.ml:58:14>>*/  /*<<marshal.ml:58:14>>*/ var
-      len =  /*<<marshal.ml:58:14>>*/ caml_marshal_data_size(buff, ofs);
-     return (caml_ml_bytes_length(buff) - (20 + len | 0) | 0) < ofs
-             ?  /*<<marshal.ml:60:9>>*/ caml_call1
-               (Stdlib[1], cst_Marshal_from_bytes$0)
-             :  /*<<marshal.ml:61:9>>*/ runtime.caml_input_value_from_bytes
-               (buff, ofs);
-    }
-     /*<<marshal.ml:56:7>>*/ return  /*<<marshal.ml:56:7>>*/ caml_call1
-            (Stdlib[1], cst_Marshal_from_bytes);
-    /*<<marshal.ml:62:5>>*/ }
-   function from_string(buff, ofs){
-     /*<<marshal.ml:67:2>>*/ return from_bytes
-            ( /*<<marshal.ml:67:13>>*/ caml_call1(Stdlib_Bytes[45], buff),
-             ofs);
-    /*<<marshal.ml:67:46>>*/ }
-   var
-    Stdlib_Marshal =
-      [0,
-       runtime.caml_output_value,
-       to_buffer,
-       runtime.caml_input_value,
-       from_bytes,
-       from_string,
-       header_size,
-       data_size,
-       total_size];
-   runtime.caml_register_global(6, Stdlib_Marshal, "Stdlib__Marshal");
-   return;
-   /*<<?>>*/ }
-  (globalThis));
-
-//# unitInfo: Provides: Stdlib__Array
-//# unitInfo: Requires: Assert_failure, Stdlib, Stdlib__Seq
-(function
-  (globalThis){
-   "use strict";
-   var
-    runtime = globalThis.jsoo_runtime,
-    caml_array_sub = runtime.caml_array_sub,
-    caml_check_bound = runtime.caml_check_bound,
-    caml_make_vect = runtime.caml_make_vect,
-    caml_maybe_attach_backtrace = runtime.caml_maybe_attach_backtrace,
-    caml_wrap_exception = runtime.caml_wrap_exception;
-    /*<<?>>*/ function caml_call1(f, a0){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 1
-            ? f(a0)
-            : runtime.caml_call_gen(f, [a0]);
-   }
-    /*<<?>>*/ function caml_call2(f, a0, a1){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 2
-            ? f(a0, a1)
-            : runtime.caml_call_gen(f, [a0, a1]);
-   }
-    /*<<?>>*/ function caml_call3(f, a0, a1, a2){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 3
-            ? f(a0, a1, a2)
-            : runtime.caml_call_gen(f, [a0, a1, a2]);
-   }
-    /*<<array.ml:37:20>>*/ var
-    global_data = runtime.caml_get_global_data(),
-    Stdlib_Seq = global_data.Stdlib__Seq,
-    Assert_failure = global_data.Assert_failure,
-    Stdlib = global_data.Stdlib,
-     /*<<array.ml:37:20>>*/ Floatarray = [0],
-    _a_ = [0, "array.ml", 319, 4],
-    cst_Array_combine = "Array.combine",
-    cst_Array_exists2 = "Array.exists2",
-    cst_Array_for_all2 = "Array.for_all2",
-    cst_Array_map2_arrays_must_hav =
-      "Array.map2: arrays must have the same length",
-    cst_Array_iter2_arrays_must_ha =
-      "Array.iter2: arrays must have the same length",
-    cst_Array_blit = "Array.blit",
-    cst_Array_fill = "Array.fill",
-    cst_Array_sub = "Array.sub",
-    cst_Array_init = "Array.init",
-    cst_Stdlib_Array_Bottom = "Stdlib.Array.Bottom";
-   function init(l, f){
-     /*<<array.ml:48:2>>*/ if(0 === l)  /*<<array.ml:48:16>>*/ return [0];
-    if(0 > l)
-      /*<<array.ml:49:16>>*/ return  /*<<array.ml:49:16>>*/ caml_call1
-             (Stdlib[1], cst_Array_init);
-     /*<<array.ml:53:13>>*/ var
-      /*<<array.ml:53:13>>*/ res =
-        /*<<array.ml:53:13>>*/ caml_make_vect
-        (l,  /*<<array.ml:53:22>>*/ caml_call1(f, 0)),
-      /*<<array.ml:54:3>>*/ _as_ = l - 1 | 0,
-      /*<<array.ml:53:13>>*/ _ar_ = 1;
-    if(_as_ >= 1){
-     var i = _ar_;
-     for(;;){
-       /*<<array.ml:55:5>>*/ res[1 + i] =
-        /*<<array.ml:55:22>>*/ caml_call1(f, i);
-       /*<<array.ml:55:5>>*/  /*<<array.ml:55:5>>*/ var _at_ = i + 1 | 0;
-      if(_as_ === i) break;
-      var i = _at_;
-     }
-    }
-     /*<<array.ml:57:3>>*/ return res;
-    /*<<array.ml:57:6>>*/ }
-   function make_matrix(sx, sy, init){
-     /*<<array.ml:60:2>>*/ var
-      /*<<array.ml:60:12>>*/ res =
-        /*<<array.ml:60:12>>*/ caml_make_vect(sx, [0]),
-      /*<<array.ml:61:2>>*/ _ap_ = sx - 1 | 0,
-      /*<<array.ml:60:12>>*/ _ao_ = 0;
-    if(_ap_ >= 0){
-     var x = _ao_;
-     for(;;){
-      res[1 + x] =  /*<<array.ml:62:21>>*/ caml_make_vect(sy, init);
-       /*<<array.ml:61:2>>*/  /*<<array.ml:61:2>>*/ var _aq_ = x + 1 | 0;
-      if(_ap_ === x) break;
-      var x = _aq_;
-     }
-    }
-     /*<<array.ml:64:2>>*/ return res;
-    /*<<array.ml:64:5>>*/ }
-   function copy(a){
-     /*<<array.ml:67:2>>*/ var l = a.length - 1;
-     /*<<array.ml:67:22>>*/ return 0 === l
-            ? [0]
-            :  /*<<array.ml:67:46>>*/ caml_array_sub(a, 0, l);
-    /*<<array.ml:67:62>>*/ }
-   function append(a1, a2){
-     /*<<array.ml:70:2>>*/ var l1 = a1.length - 1;
-     /*<<array.ml:71:2>>*/ return 0 === l1
-            ? copy(a2)
-            : 0
-              === a2.length - 1
-              ?  /*<<array.ml:72:29>>*/ caml_array_sub(a1, 0, l1)
-              :  /*<<array.ml:73:7>>*/ runtime.caml_array_append(a1, a2);
-    /*<<array.ml:73:24>>*/ }
-   function sub(a, ofs, len){
-     /*<<array.ml:76:2>>*/ if
-     (0 <= ofs && 0 <= len && (a.length - 1 - len | 0) >= ofs)
-      /*<<array.ml:78:7>>*/ return  /*<<array.ml:78:7>>*/ caml_array_sub
-             (a, ofs, len);
-     /*<<array.ml:77:7>>*/ return  /*<<array.ml:77:7>>*/ caml_call1
-            (Stdlib[1], cst_Array_sub);
-    /*<<array.ml:78:27>>*/ }
-   function fill(a, ofs, len, v){
-     /*<<array.ml:81:2>>*/ if
-     (0 <= ofs && 0 <= len && (a.length - 1 - len | 0) >= ofs)
-      /*<<array.ml:83:7>>*/ return  /*<<array.ml:83:7>>*/ runtime.caml_array_fill
-             (a, ofs, len, v);
-     /*<<array.ml:82:7>>*/ return  /*<<array.ml:82:7>>*/ caml_call1
-            (Stdlib[1], cst_Array_fill);
-    /*<<array.ml:83:30>>*/ }
-   function blit(a1, ofs1, a2, ofs2, len){
-     /*<<array.ml:86:2>>*/ if
-     (0 <= len
-      &&
-       0 <= ofs1
-       &&
-        (a1.length - 1 - len | 0) >= ofs1
-        && 0 <= ofs2 && (a2.length - 1 - len | 0) >= ofs2)
-      /*<<array.ml:89:7>>*/ return  /*<<array.ml:89:7>>*/ runtime.caml_array_blit
-             (a1, ofs1, a2, ofs2, len);
-     /*<<array.ml:88:7>>*/ return  /*<<array.ml:88:7>>*/ caml_call1
-            (Stdlib[1], cst_Array_blit);
-    /*<<array.ml:89:38>>*/ }
-   function iter(f, a){
-     /*<<array.ml:92:2>>*/ var
-     _am_ = a.length - 1 - 1 | 0,
-      /*<<array.ml:92:2>>*/ _al_ = 0;
-    if(_am_ >= 0){
-     var i = _al_;
-     for(;;){
-       /*<<array.ml:92:31>>*/  /*<<array.ml:92:31>>*/ caml_call1(f, a[1 + i]);
-       /*<<array.ml:92:31>>*/  /*<<array.ml:92:31>>*/ var _an_ = i + 1 | 0;
-      if(_am_ === i) break;
-      var i = _an_;
-     }
-    }
-    return 0;
-    /*<<array.ml:92:53>>*/ }
-   function iter2(f, a, b){
-     /*<<array.ml:95:2>>*/ if(a.length - 1 !== b.length - 1)
-      /*<<array.ml:96:4>>*/ return  /*<<array.ml:96:4>>*/ caml_call1
-             (Stdlib[1], cst_Array_iter2_arrays_must_ha);
-     /*<<array.ml:98:4>>*/ var
-     _aj_ = a.length - 1 - 1 | 0,
-      /*<<array.ml:98:4>>*/ _ai_ = 0;
-    if(_aj_ >= 0){
-     var i = _ai_;
-     for(;;){
-       /*<<array.ml:98:33>>*/  /*<<array.ml:98:33>>*/ caml_call2
-       (f, a[1 + i], b[1 + i]);
-       /*<<array.ml:98:33>>*/  /*<<array.ml:98:33>>*/ var _ak_ = i + 1 | 0;
-      if(_aj_ === i) break;
-      var i = _ak_;
-     }
-    }
-    return 0;
-    /*<<array.ml:98:73>>*/ }
-   function map(f, a){
-     /*<<array.ml:101:2>>*/ var l = a.length - 1;
-     /*<<array.ml:102:2>>*/ if(0 === l)  /*<<array.ml:102:16>>*/ return [0];
-     /*<<array.ml:103:12>>*/ var
-      /*<<array.ml:103:12>>*/ r =
-        /*<<array.ml:103:12>>*/ caml_make_vect
-        (l,  /*<<array.ml:103:21>>*/ caml_call1(f, a[1])),
-      /*<<array.ml:104:4>>*/ _ag_ = l - 1 | 0,
-      /*<<array.ml:103:12>>*/ _af_ = 1;
-    if(_ag_ >= 1){
-     var i = _af_;
-     for(;;){
-       /*<<array.ml:105:6>>*/ r[1 + i] =
-        /*<<array.ml:105:21>>*/ caml_call1(f, a[1 + i]);
-       /*<<array.ml:105:6>>*/  /*<<array.ml:105:6>>*/ var _ah_ = i + 1 | 0;
-      if(_ag_ === i) break;
-      var i = _ah_;
-     }
-    }
-     /*<<array.ml:107:4>>*/ return r;
-    /*<<array.ml:108:5>>*/ }
-   function map2(f, a, b){
-     /*<<array.ml:111:2>>*/ var
-     la = a.length - 1,
-      /*<<array.ml:112:2>>*/ lb = b.length - 1;
-    if(la !== lb)
-      /*<<array.ml:114:4>>*/ return  /*<<array.ml:114:4>>*/ caml_call1
-             (Stdlib[1], cst_Array_map2_arrays_must_hav);
-    if(0 === la)  /*<<array.ml:116:19>>*/ return [0];
-     /*<<array.ml:117:14>>*/ var
-      /*<<array.ml:117:14>>*/ r =
-        /*<<array.ml:117:14>>*/ caml_make_vect
-        (la,  /*<<array.ml:117:24>>*/ caml_call2(f, a[1], b[1])),
-      /*<<array.ml:118:6>>*/ _ad_ = la - 1 | 0,
-      /*<<array.ml:117:14>>*/ _ac_ = 1;
-    if(_ad_ >= 1){
-     var i = _ac_;
-     for(;;){
-       /*<<array.ml:119:8>>*/ r[1 + i] =
-        /*<<array.ml:119:23>>*/ caml_call2(f, a[1 + i], b[1 + i]);
-       /*<<array.ml:119:8>>*/  /*<<array.ml:119:8>>*/ var _ae_ = i + 1 | 0;
-      if(_ad_ === i) break;
-      var i = _ae_;
-     }
-    }
-     /*<<array.ml:121:6>>*/ return r;
-    /*<<array.ml:123:5>>*/ }
-   function iteri(f, a){
-     /*<<array.ml:126:2>>*/ var
-     _aa_ = a.length - 1 - 1 | 0,
-      /*<<array.ml:126:2>>*/ _$_ = 0;
-    if(_aa_ >= 0){
-     var i = _$_;
-     for(;;){
-       /*<<array.ml:126:31>>*/  /*<<array.ml:126:31>>*/ caml_call2
-       (f, i, a[1 + i]);
-       /*<<array.ml:126:31>>*/  /*<<array.ml:126:31>>*/ var _ab_ = i + 1 | 0;
-      if(_aa_ === i) break;
-      var i = _ab_;
-     }
-    }
-    return 0;
-    /*<<array.ml:126:56>>*/ }
-   function mapi(f, a){
-     /*<<array.ml:129:2>>*/ var l = a.length - 1;
-     /*<<array.ml:130:2>>*/ if(0 === l)  /*<<array.ml:130:16>>*/ return [0];
-     /*<<array.ml:131:12>>*/ var
-      /*<<array.ml:131:12>>*/ r =
-        /*<<array.ml:131:12>>*/ caml_make_vect
-        (l,  /*<<array.ml:131:21>>*/ caml_call2(f, 0, a[1])),
-      /*<<array.ml:132:4>>*/ _Z_ = l - 1 | 0,
-      /*<<array.ml:131:12>>*/ _Y_ = 1;
-    if(_Z_ >= 1){
-     var i = _Y_;
-     for(;;){
-       /*<<array.ml:133:6>>*/ r[1 + i] =
-        /*<<array.ml:133:21>>*/ caml_call2(f, i, a[1 + i]);
-       /*<<array.ml:133:6>>*/  /*<<array.ml:133:6>>*/ var ___ = i + 1 | 0;
-      if(_Z_ === i) break;
-      var i = ___;
-     }
-    }
-     /*<<array.ml:135:4>>*/ return r;
-    /*<<array.ml:136:5>>*/ }
-   function to_list(a){
-     /*<<array.ml:139:2>>*/ var i$1 = a.length - 1 - 1 | 0, i = i$1, res = 0;
-     /*<<array.ml:140:4>>*/ for(;;){
-     if(0 > i)  /*<<array.ml:140:18>>*/ return res;
-      /*<<array.ml:140:42>>*/ var
-       /*<<array.ml:140:42>>*/ res$0 = [0, a[1 + i], res],
-       /*<<array.ml:140:42>>*/ i$0 = i - 1 | 0,
-      i = i$0,
-      res = res$0;
-    }
-    /*<<array.ml:141:26>>*/ }
-   function list_length(accu, param){
-    var accu$0 = accu, param$0 = param;
-    for(;;){
-     if(! param$0)  /*<<array.ml:145:10>>*/ return accu$0;
-      /*<<array.ml:146:12>>*/ var
-      t = param$0[2],
-       /*<<array.ml:146:12>>*/ accu$1 = accu$0 + 1 | 0,
-      accu$0 = accu$1,
-      param$0 = t;
-    }
-   }
-   function of_list(l){
-     /*<<array.ml:148:14>>*/ if(! l)  /*<<array.ml:149:10>>*/ return [0];
-     /*<<array.ml:151:14>>*/ var
-     tl = l[2],
-     hd = l[1],
-      /*<<array.ml:151:14>>*/ a =
-        /*<<array.ml:151:14>>*/ caml_make_vect(list_length(0, l), hd),
-     i = 1,
-     param = tl;
-    for(;;){
-     if(! param)  /*<<array.ml:152:6>>*/ return a;
-     var tl$0 = param[2], hd$0 = param[1];
-      /*<<array.ml:154:20>>*/ a[1 + i] = hd$0;
-      /*<<array.ml:152:6>>*/ var
-       /*<<array.ml:152:6>>*/ i$0 = i + 1 | 0,
-      i = i$0,
-      param = tl$0;
-    }
-    /*<<array.ml:155:15>>*/ }
-   function fold_left(f, x, a){
-     /*<<array.ml:158:2>>*/ var
-      /*<<array.ml:158:10>>*/ r = [0, x],
-     _W_ = a.length - 1 - 1 | 0,
-      /*<<array.ml:158:10>>*/ _V_ = 0;
-    if(_W_ >= 0){
-     var i = _V_;
-     for(;;){
-      r[1] =  /*<<array.ml:160:9>>*/ caml_call2(f, r[1], a[1 + i]);
-       /*<<array.ml:159:2>>*/  /*<<array.ml:159:2>>*/ var _X_ = i + 1 | 0;
-      if(_W_ === i) break;
-      var i = _X_;
-     }
-    }
-    return r[1];
-    /*<<array.ml:162:4>>*/ }
-   function fold_left_map(f, acc, input_array){
-     /*<<array.ml:165:2>>*/ var len = input_array.length - 1;
-     /*<<array.ml:166:2>>*/ if(0 === len)
-      /*<<array.ml:166:18>>*/ return [0, acc, [0]];
-     /*<<array.ml:167:19>>*/ var
-      /*<<array.ml:167:19>>*/ match =
-        /*<<array.ml:167:19>>*/ caml_call2(f, acc, input_array[1]),
-     elt = match[2],
-     acc$0 = match[1],
-      /*<<array.ml:168:23>>*/ output_array =
-        /*<<array.ml:168:23>>*/ caml_make_vect(len, elt),
-      /*<<array.ml:169:14>>*/ acc$1 = [0, acc$0],
-      /*<<array.ml:170:4>>*/ _T_ = len - 1 | 0,
-      /*<<array.ml:169:14>>*/ _S_ = 1;
-    if(_T_ >= 1){
-     var i = _S_;
-     for(;;){
-       /*<<array.ml:171:22>>*/ var
-        /*<<array.ml:171:22>>*/ match$0 =
-          /*<<array.ml:171:22>>*/ caml_call2(f, acc$1[1], input_array[1 + i]),
-       elt$0 = match$0[2],
-       acc$2 = match$0[1];
-      acc$1[1] = acc$2;
-       /*<<array.ml:173:6>>*/ output_array[1 + i] = elt$0;
-       /*<<array.ml:170:4>>*/  /*<<array.ml:170:4>>*/ var _U_ = i + 1 | 0;
-      if(_T_ === i) break;
-      var i = _U_;
-     }
-    }
-     /*<<array.ml:175:4>>*/ return [0, acc$1[1], output_array];
-    /*<<array.ml:176:5>>*/ }
-   function fold_right(f, a, x){
-     /*<<array.ml:179:2>>*/ var
-      /*<<array.ml:179:10>>*/ r = [0, x],
-      /*<<array.ml:180:2>>*/ _Q_ = a.length - 1 - 1 | 0;
-    if(_Q_ >= 0){
-     var i = _Q_;
-     for(;;){
-      r[1] =  /*<<array.ml:181:9>>*/ caml_call2(f, a[1 + i], r[1]);
-       /*<<array.ml:180:2>>*/  /*<<array.ml:180:2>>*/ var _R_ = i - 1 | 0;
-      if(0 === i) break;
-      var i = _R_;
-     }
-    }
-    return r[1];
-    /*<<array.ml:183:4>>*/ }
-   function exists(p, a){
-     /*<<array.ml:186:2>>*/ var n = a.length - 1, i = 0;
-     /*<<array.ml:188:4>>*/ for(;;){
-     if(i === n)  /*<<array.ml:188:18>>*/ return 0;
-      /*<<array.ml:189:12>>*/ if
-      ( /*<<array.ml:189:12>>*/ caml_call1(p, a[1 + i]))
-       /*<<array.ml:189:36>>*/ return 1;
-      /*<<array.ml:190:9>>*/ var
-       /*<<array.ml:190:9>>*/ i$0 = i + 1 | 0,
-      i = i$0;
-    }
-    /*<<array.ml:191:8>>*/ }
-   function for_all(p, a){
-     /*<<array.ml:194:2>>*/ var n = a.length - 1, i = 0;
-     /*<<array.ml:196:4>>*/ for(;;){
-     if(i === n)  /*<<array.ml:196:18>>*/ return 1;
-      /*<<array.ml:197:12>>*/ if
-      (!  /*<<array.ml:197:12>>*/ caml_call1(p, a[1 + i]))
-       /*<<array.ml:198:9>>*/ return 0;
-      /*<<array.ml:197:36>>*/ var
-       /*<<array.ml:197:36>>*/ i$0 = i + 1 | 0,
-      i = i$0;
-    }
-    /*<<array.ml:199:8>>*/ }
-   function for_all2(p, l1, l2){
-     /*<<array.ml:202:2>>*/ var n1 = l1.length - 1, n2 = l2.length - 1;
-    if(n1 !== n2)
-      /*<<array.ml:204:19>>*/ return  /*<<array.ml:204:19>>*/ caml_call1
-             (Stdlib[1], cst_Array_for_all2);
-    var i = 0;
-     /*<<array.ml:206:4>>*/ for(;;){
-     if(i === n1)  /*<<array.ml:206:19>>*/ return 1;
-      /*<<array.ml:207:12>>*/ if
-      (!  /*<<array.ml:207:12>>*/ caml_call2(p, l1[1 + i], l2[1 + i]))
-       /*<<array.ml:208:9>>*/ return 0;
-      /*<<array.ml:207:55>>*/ var
-       /*<<array.ml:207:55>>*/ i$0 = i + 1 | 0,
-      i = i$0;
-    }
-    /*<<array.ml:209:8>>*/ }
-   function exists2(p, l1, l2){
-     /*<<array.ml:212:2>>*/ var n1 = l1.length - 1, n2 = l2.length - 1;
-    if(n1 !== n2)
-      /*<<array.ml:214:19>>*/ return  /*<<array.ml:214:19>>*/ caml_call1
-             (Stdlib[1], cst_Array_exists2);
-    var i = 0;
-     /*<<array.ml:216:4>>*/ for(;;){
-     if(i === n1)  /*<<array.ml:216:19>>*/ return 0;
-      /*<<array.ml:217:12>>*/ if
-      ( /*<<array.ml:217:12>>*/ caml_call2(p, l1[1 + i], l2[1 + i]))
-       /*<<array.ml:217:55>>*/ return 1;
-      /*<<array.ml:218:9>>*/ var
-       /*<<array.ml:218:9>>*/ i$0 = i + 1 | 0,
-      i = i$0;
-    }
-    /*<<array.ml:219:8>>*/ }
-   function mem(x, a){
-     /*<<array.ml:222:2>>*/ var n = a.length - 1, i = 0;
-     /*<<array.ml:224:4>>*/ for(;;){
-     if(i === n)  /*<<array.ml:224:18>>*/ return 0;
-      /*<<array.ml:225:12>>*/ if
-      (0 ===  /*<<array.ml:225:12>>*/ runtime.caml_compare(a[1 + i], x))
-       /*<<array.ml:225:48>>*/ return 1;
-      /*<<array.ml:226:9>>*/ var
-       /*<<array.ml:226:9>>*/ i$0 = i + 1 | 0,
-      i = i$0;
-    }
-    /*<<array.ml:227:8>>*/ }
-   function memq(x, a){
-     /*<<array.ml:230:2>>*/ var n = a.length - 1, i = 0;
-     /*<<array.ml:232:4>>*/ for(;;){
-     if(i === n)  /*<<array.ml:232:18>>*/ return 0;
-     if(x === a[1 + i])  /*<<array.ml:233:39>>*/ return 1;
-      /*<<array.ml:234:9>>*/ var
-       /*<<array.ml:234:9>>*/ i$0 = i + 1 | 0,
-      i = i$0;
-    }
-    /*<<array.ml:235:8>>*/ }
-   function find_opt(p, a){
-     /*<<array.ml:238:2>>*/ var n = a.length - 1, i = 0;
-     /*<<array.ml:240:4>>*/ for(;;){
-     if(i === n)  /*<<array.ml:240:18>>*/ return 0;
-      /*<<array.ml:242:14>>*/  /*<<array.ml:242:14>>*/ var x = a[1 + i];
-      /*<<array.ml:243:9>>*/ if( /*<<array.ml:243:9>>*/ caml_call1(p, x))
-       /*<<array.ml:243:18>>*/ return [0, x];
-      /*<<array.ml:244:11>>*/ var
-       /*<<array.ml:244:11>>*/ i$0 = i + 1 | 0,
-      i = i$0;
-    }
-    /*<<array.ml:246:8>>*/ }
-   function find_map(f, a){
-     /*<<array.ml:249:2>>*/ var n = a.length - 1, i = 0;
-     /*<<array.ml:251:4>>*/ for(;;){
-     if(i === n)  /*<<array.ml:251:18>>*/ return 0;
-      /*<<array.ml:253:12>>*/  /*<<array.ml:253:12>>*/ var
-      r =  /*<<array.ml:253:12>>*/ caml_call1(f, a[1 + i]);
-     if(r)  /*<<array.ml:255:23>>*/ return r;
-      /*<<array.ml:254:16>>*/ var
-       /*<<array.ml:254:16>>*/ i$0 = i + 1 | 0,
-      i = i$0;
-    }
-    /*<<array.ml:257:8>>*/ }
-   function split(x){
-     /*<<array.ml:260:2>>*/ if
-     ( /*<<array.ml:260:5>>*/ runtime.caml_equal(x, [0]))
-      /*<<array.ml:260:19>>*/ return [0, [0], [0]];
-     /*<<array.ml:263:4>>*/ var
-     match = x[1],
-     b0 = match[2],
-     a0 = match[1],
-      /*<<array.ml:263:4>>*/ n = x.length - 1,
-      /*<<array.ml:264:12>>*/ a =
-        /*<<array.ml:264:12>>*/ caml_make_vect(n, a0),
-      /*<<array.ml:265:12>>*/ b =
-        /*<<array.ml:265:12>>*/ caml_make_vect(n, b0),
-      /*<<array.ml:266:4>>*/ _O_ = n - 1 | 0,
-      /*<<array.ml:265:12>>*/ _N_ = 1;
-    if(_O_ >= 1){
-     var i = _N_;
-     for(;;){
-      var match$0 = x[1 + i], bi = match$0[2], ai = match$0[1];
-       /*<<array.ml:268:6>>*/ a[1 + i] = ai;
-       /*<<array.ml:269:6>>*/ b[1 + i] = bi;
-       /*<<array.ml:266:4>>*/  /*<<array.ml:266:4>>*/ var _P_ = i + 1 | 0;
-      if(_O_ === i) break;
-      var i = _P_;
-     }
-    }
-     /*<<array.ml:271:4>>*/ return [0, a, b];
-    /*<<array.ml:272:5>>*/ }
-   function combine(a, b){
-     /*<<array.ml:275:2>>*/ var
-     na = a.length - 1,
-      /*<<array.ml:276:2>>*/ nb = b.length - 1;
-    if(na !== nb)
-      /*<<array.ml:277:19>>*/  /*<<array.ml:277:19>>*/ caml_call1
-      (Stdlib[1], cst_Array_combine);
-    if(0 === na)  /*<<array.ml:278:17>>*/ return [0];
-     /*<<array.ml:280:12>>*/ var
-      /*<<array.ml:280:12>>*/ x =
-        /*<<array.ml:280:12>>*/ caml_make_vect(na, [0, a[1], b[1]]),
-      /*<<array.ml:281:4>>*/ _L_ = na - 1 | 0,
-      /*<<array.ml:280:12>>*/ _K_ = 1;
-    if(_L_ >= 1){
-     var i = _K_;
-     for(;;){
-      x[1 + i] = [0, a[1 + i], b[1 + i]];
-       /*<<array.ml:281:4>>*/  /*<<array.ml:281:4>>*/ var _M_ = i + 1 | 0;
-      if(_L_ === i) break;
-      var i = _M_;
-     }
-    }
-     /*<<array.ml:284:4>>*/ return x;
-    /*<<array.ml:285:5>>*/ }
-    /*<<array.ml:287:0>>*/  /*<<array.ml:287:0>>*/ var
-    Bottom = [248, cst_Stdlib_Array_Bottom, runtime.caml_fresh_oo_id(0)];
-   function sort(cmp, a){
-    function maxson(l, i){
-      /*<<array.ml:290:4>>*/ var
-      i31 = ((i + i | 0) + i | 0) + 1 | 0,
-       /*<<array.ml:291:12>>*/ x = [0, i31];
-     if((i31 + 2 | 0) < l){
-       /*<<array.ml:292:22>>*/ var
-        /*<<array.ml:292:22>>*/ _D_ = i31 + 1 | 0,
-        /*<<array.ml:293:25>>*/ _E_ = caml_check_bound(a, _D_)[1 + _D_];
-      if
-       ( /*<<array.ml:293:9>>*/ caml_call2
-         (cmp, caml_check_bound(a, i31)[1 + i31], _E_)
-        < 0)
-       x[1] = i31 + 1 | 0;
-       /*<<array.ml:294:6>>*/ var
-        /*<<array.ml:294:6>>*/ _F_ = i31 + 2 | 0,
-        /*<<array.ml:294:24>>*/ _G_ = caml_check_bound(a, _F_)[1 + _F_],
-       _H_ = x[1];
-      if
-       ( /*<<array.ml:294:9>>*/ caml_call2
-         (cmp, caml_check_bound(a, _H_)[1 + _H_], _G_)
-        < 0)
-       x[1] = i31 + 2 | 0;
-      return x[1];
-     }
-     if((i31 + 1 | 0) < l){
-       /*<<array.ml:297:38>>*/ var
-       _I_ = i31 + 1 | 0,
-        /*<<array.ml:297:38>>*/ _J_ = caml_check_bound(a, _I_)[1 + _I_];
-       /*<<array.ml:297:22>>*/ if
-       (0
-        >
-          /*<<array.ml:297:22>>*/ caml_call2
-          (cmp, caml_check_bound(a, i31)[1 + i31], _J_))
-        /*<<array.ml:298:11>>*/ return i31 + 1 | 0;
-     }
-     if(i31 < l)  /*<<array.ml:299:27>>*/ return i31;
-      /*<<array.ml:299:36>>*/ throw  /*<<array.ml:299:36>>*/ caml_maybe_attach_backtrace
-            ([0, Bottom, i], 1);
-     /*<<array.ml:299:52>>*/ }
-    var l = a.length - 1, _x_ = ((l + 1 | 0) / 3 | 0) - 1 | 0;
-    if(_x_ >= 0){
-     var i$6 = _x_;
-     for(;;){
-       /*<<array.ml:328:50>>*/  /*<<array.ml:328:50>>*/ var
-       e$1 = caml_check_bound(a, i$6)[1 + i$6];
-       /*<<array.ml:310:22>>*/ try{
-       var i = i$6;
-        /*<<array.ml:302:4>>*/ for(;;){
-         /*<<array.ml:302:12>>*/  /*<<array.ml:302:12>>*/ var
-         j = maxson(l, i);
-         /*<<array.ml:303:7>>*/ if
-         (0
-          >=
-            /*<<array.ml:303:7>>*/ caml_call2
-            (cmp, caml_check_bound(a, j)[1 + j], e$1)){
-          /*<<array.ml:306:13>>*/ caml_check_bound(a, i)[1 + i] = e$1;
-         break;
-        }
-         /*<<array.ml:304:14>>*/  /*<<array.ml:304:14>>*/ var
-         _u_ = caml_check_bound(a, j)[1 + j];
-         /*<<array.ml:304:6>>*/ caml_check_bound(a, i)[1 + i] = _u_;
-        var i = j;
-       }
-      }
-      catch(exn$0){
-       var exn = caml_wrap_exception(exn$0);
-       if(exn[1] !== Bottom) throw caml_maybe_attach_backtrace(exn, 0);
-       var i$0 = exn[2];
-        /*<<array.ml:310:61>>*/ caml_check_bound(a, i$0)[1 + i$0] = e$1;
-      }
-       /*<<array.ml:328:38>>*/  /*<<array.ml:328:38>>*/ var _C_ = i$6 - 1 | 0;
-      if(0 === i$6) break;
-      var i$6 = _C_;
-     }
-    }
-     /*<<array.ml:329:2>>*/  /*<<array.ml:329:2>>*/ var _y_ = l - 1 | 0;
-    if(_y_ >= 2){
-     var i$4 = _y_;
-     a:
-     for(;;){
-       /*<<array.ml:330:12>>*/  /*<<array.ml:330:12>>*/ var
-       e$0 = caml_check_bound(a, i$4)[1 + i$4];
-       /*<<array.ml:331:4>>*/ a[1 + i$4] = caml_check_bound(a, 0)[1];
-      var i$5 = 0;
-       /*<<array.ml:316:19>>*/ try{
-       var i$1 = i$5;
-        /*<<array.ml:312:4>>*/ for(;;){
-         /*<<array.ml:312:12>>*/ var
-          /*<<array.ml:312:12>>*/ j$0 = maxson(i$4, i$1),
-          /*<<array.ml:313:12>>*/ _v_ = caml_check_bound(a, j$0)[1 + j$0];
-         /*<<array.ml:313:4>>*/ caml_check_bound(a, i$1)[1 + i$1] = _v_;
-        var i$1 = j$0;
-       }
-      }
-      catch(exn){
-       var exn$0 = caml_wrap_exception(exn);
-       if(exn$0[1] !== Bottom) throw caml_maybe_attach_backtrace(exn$0, 0);
-       var i$2 = exn$0[2], i$3 = i$2;
-        /*<<array.ml:318:4>>*/ for(;;){
-        var father = (i$3 - 1 | 0) / 3 | 0;
-        if(i$3 === father)
-          /*<<array.ml:319:4>>*/ throw  /*<<array.ml:319:4>>*/ caml_maybe_attach_backtrace
-                ([0, Assert_failure, _a_], 1);
-         /*<<array.ml:320:7>>*/ if
-         (0
-          <=
-            /*<<array.ml:320:7>>*/ caml_call2
-            (cmp, caml_check_bound(a, father)[1 + father], e$0))
-          /*<<array.ml:323:13>>*/ caml_check_bound(a, i$3)[1 + i$3] = e$0;
-        else{
-          /*<<array.ml:321:14>>*/  /*<<array.ml:321:14>>*/ var
-          _w_ = caml_check_bound(a, father)[1 + father];
-          /*<<array.ml:321:6>>*/ caml_check_bound(a, i$3)[1 + i$3] = _w_;
-         if(0 < father){var i$3 = father; continue;}
-          /*<<array.ml:322:49>>*/ caml_check_bound(a, 0)[1] = e$0;
-        }
-         /*<<array.ml:329:2>>*/  /*<<array.ml:329:2>>*/ var _B_ = i$4 - 1 | 0;
-        if(2 === i$4) break a;
-        var i$4 = _B_;
-        break;
-       }
-      }
-     }
-    }
-    var _z_ = 1 < l ? 1 : 0;
-    if(_z_){
-      /*<<array.ml:334:25>>*/  /*<<array.ml:334:25>>*/ var
-      e = caml_check_bound(a, 1)[2];
-      /*<<array.ml:334:38>>*/ a[2] = caml_check_bound(a, 0)[1];
-      /*<<array.ml:334:57>>*/ a[1] = e;
-     var _A_ = 0;
-    }
-    else
-     var _A_ = _z_;
-     /*<<array.ml:334:57>>*/ return _A_;
-    /*<<array.ml:334:67>>*/ }
-   function stable_sort(cmp, a){
-    function merge(src1ofs, src1len, src2, src2ofs, src2len, dst, dstofs){
-      /*<<array.ml:340:4>>*/ var
-      src1r = src1ofs + src1len | 0,
-      src2r = src2ofs + src2len | 0,
-       /*<<array.ml:357:44>>*/ s2$1 =
-        caml_check_bound(src2, src2ofs)[1 + src2ofs],
-       /*<<array.ml:357:20>>*/ s1$1 =
-        caml_check_bound(a, src1ofs)[1 + src1ofs],
-      i1 = src1ofs,
-      s1 = s1$1,
-      i2 = src2ofs,
-      s2 = s2$1,
-      d = dstofs;
-      /*<<array.ml:342:6>>*/ for(;;)
-       /*<<array.ml:342:9>>*/ if
-       (0 <  /*<<array.ml:342:9>>*/ caml_call2(cmp, s1, s2)){
-        /*<<array.ml:350:8>>*/ caml_check_bound(dst, d)[1 + d] = s2;
-        /*<<array.ml:350:8>>*/  /*<<array.ml:350:8>>*/ var i2$0 = i2 + 1 | 0;
-       if(i2$0 >= src2r) return blit(a, i1, dst, d + 1 | 0, src1r - i1 | 0);
-        /*<<array.ml:353:10>>*/ var
-         /*<<array.ml:353:10>>*/ d$0 = d + 1 | 0,
-         /*<<array.ml:353:24>>*/ s2$0 = caml_check_bound(src2, i2$0)[1 + i2$0],
-        i2 = i2$0,
-        s2 = s2$0,
-        d = d$0;
-      }
-      else{
-        /*<<array.ml:343:8>>*/ caml_check_bound(dst, d)[1 + d] = s1;
-        /*<<array.ml:343:8>>*/  /*<<array.ml:343:8>>*/ var i1$0 = i1 + 1 | 0;
-       if(i1$0 >= src1r)
-        return blit(src2, i2, dst, d + 1 | 0, src2r - i2 | 0);
-        /*<<array.ml:346:10>>*/ var
-         /*<<array.ml:346:10>>*/ d$1 = d + 1 | 0,
-         /*<<array.ml:346:18>>*/ s1$0 = caml_check_bound(a, i1$0)[1 + i1$0],
-        i1 = i1$0,
-        s1 = s1$0,
-        d = d$1;
-      }
-     /*<<array.ml:357:70>>*/ }
-    function isortto(srcofs, dst, dstofs, len){
-      /*<<array.ml:360:4>>*/ var
-      _m_ = len - 1 | 0,
-       /*<<array.ml:360:4>>*/ _l_ = 0;
-     if(_m_ >= 0){
-      var i = _l_;
-      a:
-      for(;;){
-        /*<<array.ml:361:14>>*/ var
-        _n_ = srcofs + i | 0,
-         /*<<array.ml:361:14>>*/ e = caml_check_bound(a, _n_)[1 + _n_],
-         /*<<array.ml:362:14>>*/ j = [0, (dstofs + i | 0) - 1 | 0];
-       for(;;){
-        if(dstofs <= j[1]){
-         var _o_ = j[1];
-          /*<<array.ml:363:29>>*/ if
-          (0
-           <
-             /*<<array.ml:363:29>>*/ caml_call2
-             (cmp, caml_check_bound(dst, _o_)[1 + _o_], e)){
-           /*<<array.ml:364:25>>*/ var
-           _p_ = j[1],
-            /*<<array.ml:364:25>>*/ _q_ = caml_check_bound(dst, _p_)[1 + _p_],
-           _r_ = j[1] + 1 | 0;
-           /*<<array.ml:364:8>>*/ caml_check_bound(dst, _r_)[1 + _r_] = _q_;
-          j[1] += -1;
-          continue;
-         }
-        }
-        var _s_ = j[1] + 1 | 0;
-         /*<<array.ml:367:6>>*/ caml_check_bound(dst, _s_)[1 + _s_] = e;
-         /*<<array.ml:360:4>>*/  /*<<array.ml:360:4>>*/ var _t_ = i + 1 | 0;
-        if(_m_ === i) break a;
-        var i = _t_;
-        break;
-       }
-      }
-     }
-     return 0;
-     /*<<array.ml:368:8>>*/ }
-    function sortto(srcofs, dst, dstofs, len){
-      /*<<array.ml:371:4>>*/ if(len <= 5)
-       /*<<array.ml:371:26>>*/ return isortto(srcofs, dst, dstofs, len);
-     var l1 = len / 2 | 0, l2 = len - l1 | 0;
-      /*<<array.ml:374:6>>*/ sortto(srcofs + l1 | 0, dst, dstofs + l1 | 0, l2);
-      /*<<array.ml:375:6>>*/ sortto(srcofs, a, srcofs + l2 | 0, l1);
-      /*<<array.ml:375:6>>*/ return merge
-             (srcofs + l2 | 0, l1, dst, dstofs + l1 | 0, l2, dst, dstofs);
-     /*<<array.ml:377:7>>*/ }
-    var l = a.length - 1;
-    if(l <= 5)  /*<<array.ml:380:22>>*/ return isortto(0, a, 0, l);
-     /*<<array.ml:383:12>>*/ var
-     l1 = l / 2 | 0,
-     l2 = l - l1 | 0,
-      /*<<array.ml:383:12>>*/ t =
-        /*<<array.ml:383:12>>*/ caml_make_vect(l2, caml_check_bound(a, 0)[1]);
-     /*<<array.ml:384:4>>*/ sortto(l1, t, 0, l2);
-     /*<<array.ml:385:4>>*/ sortto(0, a, l2, l1);
-     /*<<array.ml:385:4>>*/ return merge(l2, l1, t, 0, l2, a, 0);
-    /*<<array.ml:387:5>>*/ }
-   function to_seq(a){
-    function aux(i, param){
-      /*<<array.ml:396:4>>*/ if(i >= a.length - 1)
-       /*<<array.ml:400:9>>*/ return 0;
-      /*<<array.ml:398:14>>*/ var
-       /*<<array.ml:398:14>>*/ x = a[1 + i],
-       /*<<array.ml:398:14>>*/ _j_ = i + 1 | 0;
-      /*<<array.ml:399:6>>*/ return [0,
-             x,
-             function(_k_){ /*<<?>>*/ return aux(_j_, _k_);}];
-     /*<<array.ml:400:16>>*/ }
-     /*<<array.ml:402:2>>*/  /*<<array.ml:402:2>>*/ var _h_ = 0;
-     /*<<array.ml:402:2>>*/ return function(_i_){
-      /*<<?>>*/ return aux(_h_, _i_);};
-    /*<<array.ml:402:7>>*/ }
-   function to_seqi(a){
-    function aux(i, param){
-      /*<<array.ml:406:4>>*/ if(i >= a.length - 1)
-       /*<<array.ml:410:9>>*/ return 0;
-      /*<<array.ml:408:14>>*/ var
-       /*<<array.ml:408:14>>*/ x = a[1 + i],
-       /*<<array.ml:408:14>>*/ _f_ = i + 1 | 0;
-      /*<<array.ml:409:6>>*/ return [0,
-             [0, i, x],
-             function(_g_){ /*<<?>>*/ return aux(_f_, _g_);}];
-     /*<<array.ml:410:16>>*/ }
-     /*<<array.ml:412:2>>*/  /*<<array.ml:412:2>>*/ var _d_ = 0;
-     /*<<array.ml:412:2>>*/ return function(_e_){
-      /*<<?>>*/ return aux(_d_, _e_);};
-    /*<<array.ml:412:7>>*/ }
-   function of_seq(i$2){
-     /*<<array.ml:426:2>>*/ var _b_ = 0;
-    function _c_(acc, x){
-      /*<<array.ml:426:38>>*/ return [0, x, acc];
-     /*<<array.ml:426:44>>*/ }
-     /*<<array.ml:426:10>>*/  /*<<array.ml:426:10>>*/ var
-     l =  /*<<array.ml:426:10>>*/ caml_call3(Stdlib_Seq[5], _c_, _b_, i$2);
-    if(! l)  /*<<array.ml:415:10>>*/ return [0];
-     /*<<array.ml:417:16>>*/ var
-     tl = l[2],
-     hd = l[1],
-      /*<<array.ml:417:16>>*/ len = list_length(0, l),
-      /*<<array.ml:418:14>>*/ a =
-        /*<<array.ml:418:14>>*/ caml_make_vect(len, hd),
-      /*<<array.ml:417:16>>*/ i$1 = len - 2 | 0,
-     i = i$1,
-     param = tl;
-    for(;;){
-     if(! param)  /*<<array.ml:419:6>>*/ return a;
-     var tl$0 = param[2], hd$0 = param[1];
-      /*<<array.ml:421:20>>*/ a[1 + i] = hd$0;
-      /*<<array.ml:419:6>>*/ var
-       /*<<array.ml:419:6>>*/ i$0 = i - 1 | 0,
-      i = i$0,
-      param = tl$0;
-    }
-    /*<<array.ml:427:15>>*/ }
-   var
-    Stdlib_Array =
-      [0,
-       init,
-       make_matrix,
-       append,
-       runtime.caml_array_concat,
-       sub,
-       copy,
-       fill,
-       blit,
-       to_list,
-       of_list,
-       iter,
-       iteri,
-       map,
-       mapi,
-       fold_left,
-       fold_left_map,
-       fold_right,
-       iter2,
-       map2,
-       for_all,
-       exists,
-       for_all2,
-       exists2,
-       mem,
-       memq,
-       find_opt,
-       find_map,
-       split,
-       combine,
-       sort,
-       stable_sort,
-       stable_sort,
-       to_seq,
-       to_seqi,
-       of_seq,
-       Floatarray];
-   runtime.caml_register_global(14, Stdlib_Array, "Stdlib__Array");
-   return;
-   /*<<?>>*/ }
-  (globalThis));
-
-//# unitInfo: Provides: Stdlib__Float
-//# unitInfo: Requires: Assert_failure, Stdlib, Stdlib__Array, Stdlib__List, Stdlib__Seq
-(function
-  (globalThis){
-   "use strict";
-   var
-    runtime = globalThis.jsoo_runtime,
-    cst_Float_array_blit$1 = "Float.array.blit",
-    cst_float_ml = "float.ml",
-    caml_array_get = runtime.caml_array_get,
-    caml_array_set = runtime.caml_array_set,
-    caml_float_compare = runtime.caml_float_compare,
-    caml_floatarray_blit = runtime.caml_floatarray_blit,
-    caml_floatarray_create = runtime.caml_floatarray_create,
-    caml_maybe_attach_backtrace = runtime.caml_maybe_attach_backtrace,
-    caml_nextafter_float = runtime.caml_nextafter_float,
-    caml_signbit_float = runtime.caml_signbit_float,
-    caml_wrap_exception = runtime.caml_wrap_exception;
-    /*<<?>>*/ function caml_call1(f, a0){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 1
-            ? f(a0)
-            : runtime.caml_call_gen(f, [a0]);
-   }
-    /*<<?>>*/ function caml_call2(f, a0, a1){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 2
-            ? f(a0, a1)
-            : runtime.caml_call_gen(f, [a0, a1]);
-   }
-    /*<<?>>*/ function caml_call3(f, a0, a1, a2){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 3
-            ? f(a0, a1, a2)
-            : runtime.caml_call_gen(f, [a0, a1, a2]);
-   }
-   var
-    global_data = runtime.caml_get_global_data(),
-    Stdlib_Seq = global_data.Stdlib__Seq,
-    Stdlib_List = global_data.Stdlib__List,
-    Assert_failure = global_data.Assert_failure,
-    Stdlib = global_data.Stdlib,
-    infinity = Stdlib[22],
-    neg_infinity = Stdlib[23],
-    nan = Stdlib[24],
-    _b_ = [0, cst_float_ml, 395, 6],
-    cst_Float_Array_map2_arrays_mu =
-      "Float.Array.map2: arrays must have the same length",
-    cst_Float_Array_iter2_arrays_m =
-      "Float.Array.iter2: arrays must have the same length",
-    cst_Float_array_blit = cst_Float_array_blit$1,
-    cst_Float_array_blit$0 = cst_Float_array_blit$1,
-    cst_Float_Array_fill = "Float.Array.fill",
-    cst_Float_Array_sub = "Float.Array.sub",
-    _a_ = [0, cst_float_ml, 222, 14],
-    cst_Float_Array_concat = "Float.Array.concat",
-    cst_Float_Array_init = "Float.Array.init",
-    cst_Stdlib_Float_Array_Bottom = "Stdlib.Float.Array.Bottom",
-    zero = 0.,
-    one = 1.,
-    minus_one = -1.;
-   function is_finite(x){
-     /*<<float.ml:34:27>>*/ return x - x == 0. ? 1 : 0;
-    /*<<float.ml:34:38>>*/ }
-   function is_infinite(x){
-     /*<<float.ml:35:29>>*/ return 1. / x == 0. ? 1 : 0;
-    /*<<float.ml:35:41>>*/ }
-   function is_nan(x){
-     /*<<float.ml:36:24>>*/ return x != x ? 1 : 0;
-    /*<<float.ml:36:30>>*/ }
-   var
-    max_float = Stdlib[25],
-    min_float = Stdlib[26],
-    epsilon = Stdlib[27],
-    of_string_opt = Stdlib[36],
-    to_string = Stdlib[35],
-    pi = 3.141592653589793;
-   function is_integer(x){
-     /*<<float.ml:111:19>>*/ var
-     _aq_ = x ==  /*<<float.ml:111:23>>*/ runtime.caml_trunc_float(x) ? 1 : 0;
-    return _aq_ ? is_finite(x) : _aq_;
-    /*<<float.ml:111:45>>*/ }
-   function succ(x){
-     /*<<float.ml:116:13>>*/ return  /*<<float.ml:116:13>>*/ caml_nextafter_float
-            (x, infinity);
-    /*<<float.ml:116:34>>*/ }
-   function pred(x){
-     /*<<float.ml:117:13>>*/ return  /*<<float.ml:117:13>>*/ caml_nextafter_float
-            (x, neg_infinity);
-    /*<<float.ml:117:38>>*/ }
-   function equal(x, y){
-     /*<<float.ml:131:16>>*/ return 0 === caml_float_compare(x, y) ? 1 : 0;
-    /*<<float.ml:131:31>>*/ }
-   function min(x, y){
-     /*<<float.ml:134:2>>*/ a:
-    if(! (x < y)){
-      /*<<float.ml:134:34>>*/ if
-      (!
-        /*<<float.ml:134:18>>*/ caml_signbit_float(y)
-       &&  /*<<float.ml:134:34>>*/ caml_signbit_float(x))
-      break a;
-      /*<<float.ml:136:10>>*/ return x != x ? x : y;
-    }
-     /*<<float.ml:135:7>>*/ return y != y ? y : x;
-    /*<<float.ml:136:32>>*/ }
-   function max(x, y){
-     /*<<float.ml:139:2>>*/ a:
-    if(! (x < y)){
-      /*<<float.ml:139:34>>*/ if
-      (!
-        /*<<float.ml:139:18>>*/ caml_signbit_float(y)
-       &&  /*<<float.ml:139:34>>*/ caml_signbit_float(x))
-      break a;
-      /*<<float.ml:141:10>>*/ return y != y ? y : x;
-    }
-     /*<<float.ml:140:7>>*/ return x != x ? x : y;
-    /*<<float.ml:141:32>>*/ }
-   function min_max(x, y){
-     /*<<float.ml:144:2>>*/ if(x == x && y == y){
-     a:
-     if(! (x < y)){
-       /*<<float.ml:145:39>>*/ if
-       (!
-         /*<<float.ml:145:23>>*/ caml_signbit_float(y)
-        &&  /*<<float.ml:145:39>>*/ caml_signbit_float(x))
-       break a;
-       /*<<float.ml:145:68>>*/ return [0, y, x];
-     }
-      /*<<float.ml:145:56>>*/ return [0, x, y];
-    }
-     /*<<float.ml:144:31>>*/ return [0, nan, nan];
-    /*<<float.ml:145:74>>*/ }
-   function min_num(x, y){
-     /*<<float.ml:148:2>>*/ a:
-    if(! (x < y)){
-      /*<<float.ml:148:34>>*/ if
-      (!
-        /*<<float.ml:148:18>>*/ caml_signbit_float(y)
-       &&  /*<<float.ml:148:34>>*/ caml_signbit_float(x))
-      break a;
-      /*<<float.ml:150:10>>*/ return y != y ? x : y;
-    }
-     /*<<float.ml:149:7>>*/ return x != x ? y : x;
-    /*<<float.ml:150:32>>*/ }
-   function max_num(x, y){
-     /*<<float.ml:153:2>>*/ a:
-    if(! (x < y)){
-      /*<<float.ml:153:34>>*/ if
-      (!
-        /*<<float.ml:153:18>>*/ caml_signbit_float(y)
-       &&  /*<<float.ml:153:34>>*/ caml_signbit_float(x))
-      break a;
-      /*<<float.ml:155:10>>*/ return x != x ? y : x;
-    }
-     /*<<float.ml:154:7>>*/ return y != y ? x : y;
-    /*<<float.ml:155:32>>*/ }
-   function min_max_num(x, y){
-     /*<<float.ml:158:2>>*/ if(x != x)
-      /*<<float.ml:158:19>>*/ return [0, y, y];
-     /*<<float.ml:159:10>>*/ if(y != y)
-      /*<<float.ml:159:24>>*/ return [0, x, x];
-    a:
-    if(! (x < y)){
-      /*<<float.ml:160:39>>*/ if
-      (!
-        /*<<float.ml:160:23>>*/ caml_signbit_float(y)
-       &&  /*<<float.ml:160:39>>*/ caml_signbit_float(x))
-      break a;
-      /*<<float.ml:160:67>>*/ return [0, y, x];
-    }
-     /*<<float.ml:160:56>>*/ return [0, x, y];
-    /*<<float.ml:160:72>>*/ }
-   function hash(x){
-     /*<<float.ml:164:13>>*/ return  /*<<float.ml:164:13>>*/ runtime.caml_hash
-            (10, 100, 0, x);
-    /*<<float.ml:164:41>>*/ }
-   function unsafe_fill(a, ofs, len, v){
-     /*<<float.ml:178:4>>*/ var _ao_ = (ofs + len | 0) - 1 | 0;
-    if(_ao_ >= ofs){
-     var i = ofs;
-     for(;;){
-       /*<<float.ml:178:36>>*/ a[1 + i] = v;
-       /*<<float.ml:178:36>>*/  /*<<float.ml:178:36>>*/ var _ap_ = i + 1 | 0;
-      if(_ao_ === i) break;
-      var i = _ap_;
-     }
-    }
-    return 0;
-    /*<<float.ml:178:57>>*/ }
-   function check(a, ofs, len, msg){
-     /*<<float.ml:184:4>>*/ var _ak_ = ofs < 0 ? 1 : 0;
-    if(_ak_)
-     var _al_ = _ak_;
-    else{
-     var _am_ = len < 0 ? 1 : 0;
-     if(_am_)
-      var _al_ = _am_;
-     else
-      var
-       _an_ = (ofs + len | 0) < 0 ? 1 : 0,
-       _al_ = _an_ || (a.length - 1 < (ofs + len | 0) ? 1 : 0);
-    }
-    return _al_ ?  /*<<float.ml:185:6>>*/ caml_call1(Stdlib[1], msg) : _al_;
-    /*<<float.ml:185:21>>*/ }
-   function make(n, v){
-     /*<<float.ml:188:4>>*/  /*<<float.ml:188:17>>*/ var
-     result =  /*<<float.ml:188:17>>*/ caml_floatarray_create(n);
-     /*<<float.ml:189:4>>*/ unsafe_fill(result, 0, n, v);
-     /*<<float.ml:189:4>>*/ return result;
-    /*<<float.ml:190:10>>*/ }
-   function init(l, f){
-     /*<<float.ml:193:4>>*/ if(0 > l)
-      /*<<float.ml:193:18>>*/ return  /*<<float.ml:193:18>>*/ caml_call1
-             (Stdlib[1], cst_Float_Array_init);
-     /*<<float.ml:195:16>>*/ var
-      /*<<float.ml:195:16>>*/ res =
-        /*<<float.ml:195:16>>*/ caml_floatarray_create(l),
-      /*<<float.ml:196:6>>*/ _ai_ = l - 1 | 0,
-      /*<<float.ml:195:16>>*/ _ah_ = 0;
-    if(_ai_ >= 0){
-     var i = _ah_;
-     for(;;){
-       /*<<float.ml:197:8>>*/ res[1 + i] =
-        /*<<float.ml:197:25>>*/ caml_call1(f, i);
-       /*<<float.ml:197:8>>*/  /*<<float.ml:197:8>>*/ var _aj_ = i + 1 | 0;
-      if(_ai_ === i) break;
-      var i = _aj_;
-     }
-    }
-     /*<<float.ml:199:6>>*/ return res;
-    /*<<float.ml:199:9>>*/ }
-   function append(a1, a2){
-     /*<<float.ml:202:4>>*/ var
-     l1 = a1.length - 1,
-      /*<<float.ml:203:4>>*/ l2 = a2.length - 1,
-      /*<<float.ml:204:17>>*/ result =
-        /*<<float.ml:204:17>>*/ caml_floatarray_create(l1 + l2 | 0);
-     /*<<float.ml:205:4>>*/  /*<<float.ml:205:4>>*/ caml_floatarray_blit
-     (a1, 0, result, 0, l1);
-     /*<<float.ml:206:4>>*/  /*<<float.ml:206:4>>*/ caml_floatarray_blit
-     (a2, 0, result, l1, l2);
-     /*<<float.ml:206:4>>*/ return result;
-    /*<<float.ml:207:10>>*/ }
-   function concat(l){
-     /*<<float.ml:218:4>>*/ var acc = 0, param = l;
-    for(;;)
-     if(param)
-      var
-       tl = param[2],
-       hd = param[1],
-       x = hd.length - 1 + acc | 0,
-       acc$0 =
-         acc <= x
-          ? x
-          :  /*<<float.ml:211:26>>*/ caml_call1
-            (Stdlib[1], cst_Float_Array_concat),
-       acc = acc$0,
-       param = tl;
-     else{
-       /*<<float.ml:219:17>>*/ var
-        /*<<float.ml:219:17>>*/ result =
-          /*<<float.ml:219:17>>*/ caml_floatarray_create(acc),
-       l$0 = l,
-       i = 0;
-       /*<<float.ml:221:6>>*/ for(;;){
-       if(! l$0){
-        if(i === acc)  /*<<float.ml:228:4>>*/ return result;
-         /*<<float.ml:222:14>>*/ throw  /*<<float.ml:222:14>>*/ caml_maybe_attach_backtrace
-               ([0, Assert_failure, _a_], 1);
-       }
-        /*<<float.ml:224:8>>*/ var
-        tl$0 = l$0[2],
-        hd$0 = l$0[1],
-         /*<<float.ml:224:8>>*/ hlen = hd$0.length - 1;
-        /*<<float.ml:225:8>>*/  /*<<float.ml:225:8>>*/ caml_floatarray_blit
-        (hd$0, 0, result, i, hlen);
-       var i$0 = i + hlen | 0, l$0 = tl$0, i = i$0;
-      }
-     }
-    /*<<float.ml:229:10>>*/ }
-   function sub(a, ofs, len){
-     /*<<float.ml:232:4>>*/ check(a, ofs, len, cst_Float_Array_sub);
-     /*<<float.ml:233:17>>*/  /*<<float.ml:233:17>>*/ var
-     result =  /*<<float.ml:233:17>>*/ caml_floatarray_create(len);
-     /*<<float.ml:234:4>>*/  /*<<float.ml:234:4>>*/ caml_floatarray_blit
-     (a, ofs, result, 0, len);
-     /*<<float.ml:234:4>>*/ return result;
-    /*<<float.ml:235:10>>*/ }
-   function copy(a){
-     /*<<float.ml:238:4>>*/ var
-     l = a.length - 1,
-      /*<<float.ml:239:17>>*/ result =
-        /*<<float.ml:239:17>>*/ caml_floatarray_create(l);
-     /*<<float.ml:240:4>>*/  /*<<float.ml:240:4>>*/ caml_floatarray_blit
-     (a, 0, result, 0, l);
-     /*<<float.ml:240:4>>*/ return result;
-    /*<<float.ml:241:10>>*/ }
-   function fill(a, ofs, len, v){
-     /*<<float.ml:244:4>>*/ check(a, ofs, len, cst_Float_Array_fill);
-     /*<<float.ml:244:4>>*/ return unsafe_fill(a, ofs, len, v);
-    /*<<float.ml:245:27>>*/ }
-   function blit(src, sofs, dst, dofs, len){
-     /*<<float.ml:248:4>>*/ check(src, sofs, len, cst_Float_array_blit);
-     /*<<float.ml:249:4>>*/ check(dst, dofs, len, cst_Float_array_blit$0);
-     /*<<float.ml:250:4>>*/ return  /*<<float.ml:250:4>>*/ caml_floatarray_blit
-            (src, sofs, dst, dofs, len);
-    /*<<float.ml:250:37>>*/ }
-   function to_list(a){
-     /*<<float.ml:253:25>>*/ function _af_(_ag_){
-      /*<<?>>*/ return a[1 + _ag_];
-    }
-     /*<<float.ml:253:25>>*/ return  /*<<float.ml:253:25>>*/ caml_call2
-            (Stdlib_List[10], a.length - 1, _af_);
-    /*<<float.ml:253:39>>*/ }
-   function of_list(l){
-     /*<<float.ml:256:4>>*/ var
-      /*<<float.ml:256:17>>*/ result =
-        /*<<float.ml:256:17>>*/ caml_floatarray_create
-        ( /*<<float.ml:256:24>>*/ caml_call1(Stdlib_List[1], l)),
-     i = 0,
-     l$0 = l;
-     /*<<float.ml:258:6>>*/ for(;;){
-     if(! l$0)  /*<<float.ml:257:4>>*/ return result;
-     var t = l$0[2], h = l$0[1];
-      /*<<float.ml:260:18>>*/ result[1 + i] = h;
-      /*<<float.ml:257:4>>*/ var
-       /*<<float.ml:257:4>>*/ i$0 = i + 1 | 0,
-      i = i$0,
-      l$0 = t;
-    }
-    /*<<float.ml:262:12>>*/ }
-   function iter(f, a){
-     /*<<float.ml:266:4>>*/ var
-     _ad_ = a.length - 1 - 1 | 0,
-      /*<<float.ml:266:4>>*/ _ac_ = 0;
-    if(_ad_ >= 0){
-     var i = _ac_;
-     for(;;){
-       /*<<float.ml:266:33>>*/  /*<<float.ml:266:33>>*/ caml_call1
-       (f, a[1 + i]);
-       /*<<float.ml:266:33>>*/  /*<<float.ml:266:33>>*/ var _ae_ = i + 1 | 0;
-      if(_ad_ === i) break;
-      var i = _ae_;
-     }
-    }
-    return 0;
-    /*<<float.ml:266:56>>*/ }
-   function iter2(f, a, b){
-     /*<<float.ml:270:4>>*/ if(a.length - 1 !== b.length - 1)
-      /*<<float.ml:271:6>>*/ return  /*<<float.ml:271:6>>*/ caml_call1
-             (Stdlib[1], cst_Float_Array_iter2_arrays_m);
-     /*<<float.ml:273:6>>*/ var
-     _aa_ = a.length - 1 - 1 | 0,
-      /*<<float.ml:273:6>>*/ _$_ = 0;
-    if(_aa_ >= 0){
-     var i = _$_;
-     for(;;){
-       /*<<float.ml:273:35>>*/  /*<<float.ml:273:35>>*/ caml_call2
-       (f, a[1 + i], b[1 + i]);
-       /*<<float.ml:273:35>>*/  /*<<float.ml:273:35>>*/ var _ab_ = i + 1 | 0;
-      if(_aa_ === i) break;
-      var i = _ab_;
-     }
-    }
-    return 0;
-    /*<<float.ml:273:75>>*/ }
-   function map(f, a){
-     /*<<float.ml:276:4>>*/ var
-     l = a.length - 1,
-      /*<<float.ml:277:12>>*/ r =
-        /*<<float.ml:277:12>>*/ caml_floatarray_create(l),
-      /*<<float.ml:278:4>>*/ _Z_ = l - 1 | 0,
-      /*<<float.ml:277:12>>*/ _Y_ = 0;
-    if(_Z_ >= 0){
-     var i = _Y_;
-     for(;;){
-       /*<<float.ml:279:6>>*/ r[1 + i] =
-        /*<<float.ml:279:21>>*/ caml_call1(f, a[1 + i]);
-       /*<<float.ml:279:6>>*/  /*<<float.ml:279:6>>*/ var ___ = i + 1 | 0;
-      if(_Z_ === i) break;
-      var i = ___;
-     }
-    }
-     /*<<float.ml:281:4>>*/ return r;
-    /*<<float.ml:281:5>>*/ }
-   function map2(f, a, b){
-     /*<<float.ml:284:4>>*/ var
-     la = a.length - 1,
-      /*<<float.ml:285:4>>*/ lb = b.length - 1;
-    if(la !== lb)
-      /*<<float.ml:287:6>>*/ return  /*<<float.ml:287:6>>*/ caml_call1
-             (Stdlib[1], cst_Float_Array_map2_arrays_mu);
-     /*<<float.ml:289:14>>*/ var
-      /*<<float.ml:289:14>>*/ r =
-        /*<<float.ml:289:14>>*/ caml_floatarray_create(la),
-      /*<<float.ml:290:6>>*/ _W_ = la - 1 | 0,
-      /*<<float.ml:289:14>>*/ _V_ = 0;
-    if(_W_ >= 0){
-     var i = _V_;
-     for(;;){
-       /*<<float.ml:291:8>>*/ r[1 + i] =
-        /*<<float.ml:291:23>>*/ caml_call2(f, a[1 + i], b[1 + i]);
-       /*<<float.ml:291:8>>*/  /*<<float.ml:291:8>>*/ var _X_ = i + 1 | 0;
-      if(_W_ === i) break;
-      var i = _X_;
-     }
-    }
-     /*<<float.ml:293:6>>*/ return r;
-    /*<<float.ml:294:7>>*/ }
-   function iteri(f, a){
-     /*<<float.ml:298:4>>*/ var
-     _T_ = a.length - 1 - 1 | 0,
-      /*<<float.ml:298:4>>*/ _S_ = 0;
-    if(_T_ >= 0){
-     var i = _S_;
-     for(;;){
-       /*<<float.ml:298:33>>*/  /*<<float.ml:298:33>>*/ caml_call2
-       (f, i, a[1 + i]);
-       /*<<float.ml:298:33>>*/  /*<<float.ml:298:33>>*/ var _U_ = i + 1 | 0;
-      if(_T_ === i) break;
-      var i = _U_;
-     }
-    }
-    return 0;
-    /*<<float.ml:298:58>>*/ }
-   function mapi(f, a){
-     /*<<float.ml:301:4>>*/ var
-     l = a.length - 1,
-      /*<<float.ml:302:12>>*/ r =
-        /*<<float.ml:302:12>>*/ caml_floatarray_create(l),
-      /*<<float.ml:303:4>>*/ _Q_ = l - 1 | 0,
-      /*<<float.ml:302:12>>*/ _P_ = 0;
-    if(_Q_ >= 0){
-     var i = _P_;
-     for(;;){
-       /*<<float.ml:304:6>>*/ r[1 + i] =
-        /*<<float.ml:304:21>>*/ caml_call2(f, i, a[1 + i]);
-       /*<<float.ml:304:6>>*/  /*<<float.ml:304:6>>*/ var _R_ = i + 1 | 0;
-      if(_Q_ === i) break;
-      var i = _R_;
-     }
-    }
-     /*<<float.ml:306:4>>*/ return r;
-    /*<<float.ml:306:5>>*/ }
-   function fold_left(f, x, a){
-     /*<<float.ml:310:4>>*/ var
-      /*<<float.ml:310:12>>*/ r = [0, x],
-     _N_ = a.length - 1 - 1 | 0,
-      /*<<float.ml:310:12>>*/ _M_ = 0;
-    if(_N_ >= 0){
-     var i = _M_;
-     for(;;){
-      r[1] =  /*<<float.ml:312:11>>*/ caml_call2(f, r[1], a[1 + i]);
-       /*<<float.ml:311:4>>*/  /*<<float.ml:311:4>>*/ var _O_ = i + 1 | 0;
-      if(_N_ === i) break;
-      var i = _O_;
-     }
-    }
-    return r[1];
-    /*<<float.ml:314:6>>*/ }
-   function fold_right(f, a, x){
-     /*<<float.ml:318:4>>*/ var
-      /*<<float.ml:318:12>>*/ r = [0, x],
-      /*<<float.ml:319:4>>*/ _K_ = a.length - 1 - 1 | 0;
-    if(_K_ >= 0){
-     var i = _K_;
-     for(;;){
-      r[1] =  /*<<float.ml:320:11>>*/ caml_call2(f, a[1 + i], r[1]);
-       /*<<float.ml:319:4>>*/  /*<<float.ml:319:4>>*/ var _L_ = i - 1 | 0;
-      if(0 === i) break;
-      var i = _L_;
-     }
-    }
-    return r[1];
-    /*<<float.ml:322:6>>*/ }
-   function exists(p, a){
-     /*<<float.ml:326:4>>*/ var n = a.length - 1, i = 0;
-     /*<<float.ml:328:6>>*/ for(;;){
-     if(i === n)  /*<<float.ml:328:20>>*/ return 0;
-      /*<<float.ml:329:14>>*/ if
-      ( /*<<float.ml:329:14>>*/ caml_call1(p, a[1 + i]))
-       /*<<float.ml:329:38>>*/ return 1;
-      /*<<float.ml:330:11>>*/ var
-       /*<<float.ml:330:11>>*/ i$0 = i + 1 | 0,
-      i = i$0;
-    }
-    /*<<float.ml:331:10>>*/ }
-   function for_all(p, a){
-     /*<<float.ml:335:4>>*/ var n = a.length - 1, i = 0;
-     /*<<float.ml:337:6>>*/ for(;;){
-     if(i === n)  /*<<float.ml:337:20>>*/ return 1;
-      /*<<float.ml:338:14>>*/ if
-      (!  /*<<float.ml:338:14>>*/ caml_call1(p, a[1 + i]))
-       /*<<float.ml:339:11>>*/ return 0;
-      /*<<float.ml:338:38>>*/ var
-       /*<<float.ml:338:38>>*/ i$0 = i + 1 | 0,
-      i = i$0;
-    }
-    /*<<float.ml:340:10>>*/ }
-   function mem(x, a){
-     /*<<float.ml:344:4>>*/ var n = a.length - 1, i = 0;
-     /*<<float.ml:346:6>>*/ for(;;){
-     if(i === n)  /*<<float.ml:346:20>>*/ return 0;
-     if(0 ===  /*<<float.ml:347:22>>*/ caml_float_compare(a[1 + i], x))
-       /*<<float.ml:347:50>>*/ return 1;
-      /*<<float.ml:348:11>>*/ var
-       /*<<float.ml:348:11>>*/ i$0 = i + 1 | 0,
-      i = i$0;
-    }
-    /*<<float.ml:350:10>>*/ }
-   function mem_ieee(x, a){
-     /*<<float.ml:354:4>>*/ var n = a.length - 1, i = 0;
-     /*<<float.ml:356:6>>*/ for(;;){
-     if(i === n)  /*<<float.ml:356:20>>*/ return 0;
-     if(x == a[1 + i])  /*<<float.ml:357:40>>*/ return 1;
-      /*<<float.ml:358:11>>*/ var
-       /*<<float.ml:358:11>>*/ i$0 = i + 1 | 0,
-      i = i$0;
-    }
-    /*<<float.ml:360:10>>*/ }
-    /*<<float.ml:363:2>>*/  /*<<float.ml:363:2>>*/ var
-    Bottom = [248, cst_Stdlib_Float_Array_Bottom, runtime.caml_fresh_oo_id(0)];
-   function sort(cmp, a){
-    function maxson(l, i){
-      /*<<float.ml:366:6>>*/ var
-      i31 = ((i + i | 0) + i | 0) + 1 | 0,
-       /*<<float.ml:367:14>>*/ x = [0, i31];
-     if((i31 + 2 | 0) < l){
-      if
-       ( /*<<float.ml:369:11>>*/ caml_call2
-         (cmp,
-           /*<<float.ml:369:15>>*/ caml_array_get(a, i31),
-           /*<<float.ml:369:27>>*/ caml_array_get(a, i31 + 1 | 0))
-        < 0)
-       x[1] = i31 + 1 | 0;
-      if
-       ( /*<<float.ml:370:11>>*/ caml_call2
-         (cmp,
-           /*<<float.ml:370:15>>*/ caml_array_get(a, x[1]),
-           /*<<float.ml:370:26>>*/ caml_array_get(a, i31 + 2 | 0))
-        < 0)
-       x[1] = i31 + 2 | 0;
-      return x[1];
-     }
-      /*<<float.ml:373:24>>*/ if
-      ((i31 + 1 | 0) < l
-       &&
-        0
-        >
-          /*<<float.ml:373:24>>*/ caml_call2
-          (cmp,
-            /*<<float.ml:373:28>>*/ caml_array_get(a, i31),
-            /*<<float.ml:373:40>>*/ caml_array_get(a, i31 + 1 | 0)))
-       /*<<float.ml:374:13>>*/ return i31 + 1 | 0;
-     if(i31 < l)  /*<<float.ml:375:29>>*/ return i31;
-      /*<<float.ml:375:38>>*/ throw  /*<<float.ml:375:38>>*/ caml_maybe_attach_backtrace
-            ([0, Bottom, i], 1);
-     /*<<float.ml:375:54>>*/ }
-    var l = a.length - 1, _E_ = ((l + 1 | 0) / 3 | 0) - 1 | 0;
-    if(_E_ >= 0){
-     var i$6 = _E_;
-     for(;;){
-       /*<<float.ml:404:52>>*/  /*<<float.ml:404:52>>*/ var
-       e$1 =  /*<<float.ml:404:52>>*/ caml_array_get(a, i$6);
-       /*<<float.ml:386:24>>*/ try{
-       var i = i$6;
-        /*<<float.ml:378:6>>*/ for(;;){
-         /*<<float.ml:378:14>>*/  /*<<float.ml:378:14>>*/ var
-         j = maxson(l, i);
-         /*<<float.ml:379:9>>*/ if
-         (0
-          >=
-            /*<<float.ml:379:9>>*/ caml_call2
-            (cmp,  /*<<float.ml:379:13>>*/ caml_array_get(a, j), e$1)){
-          /*<<float.ml:382:15>>*/  /*<<float.ml:382:15>>*/ caml_array_set
-          (a, i, e$1);
-         break;
-        }
-         /*<<float.ml:380:8>>*/  /*<<float.ml:380:8>>*/ caml_array_set
-         (a, i,  /*<<float.ml:380:16>>*/ caml_array_get(a, j));
-        var i = j;
-       }
-      }
-      catch(exn$0){
-       var exn = caml_wrap_exception(exn$0);
-       if(exn[1] !== Bottom) throw caml_maybe_attach_backtrace(exn, 0);
-       var i$0 = exn[2];
-        /*<<float.ml:386:63>>*/  /*<<float.ml:386:63>>*/ caml_array_set
-        (a, i$0, e$1);
-      }
-       /*<<float.ml:404:40>>*/  /*<<float.ml:404:40>>*/ var _J_ = i$6 - 1 | 0;
-      if(0 === i$6) break;
-      var i$6 = _J_;
-     }
-    }
-     /*<<float.ml:405:4>>*/  /*<<float.ml:405:4>>*/ var _F_ = l - 1 | 0;
-    if(_F_ >= 2){
-     var i$4 = _F_;
-     a:
-     for(;;){
-       /*<<float.ml:406:14>>*/  /*<<float.ml:406:14>>*/ var
-       e$0 =  /*<<float.ml:406:14>>*/ caml_array_get(a, i$4);
-       /*<<float.ml:407:6>>*/  /*<<float.ml:407:6>>*/ caml_array_set
-       (a, i$4,  /*<<float.ml:407:14>>*/ caml_array_get(a, 0));
-      var i$5 = 0;
-       /*<<float.ml:392:21>>*/ try{
-       var i$1 = i$5;
-        /*<<float.ml:388:6>>*/ for(;;){
-         /*<<float.ml:388:14>>*/  /*<<float.ml:388:14>>*/ var
-         j$0 = maxson(i$4, i$1);
-         /*<<float.ml:389:6>>*/  /*<<float.ml:389:6>>*/ caml_array_set
-         (a, i$1,  /*<<float.ml:389:14>>*/ caml_array_get(a, j$0));
-        var i$1 = j$0;
-       }
-      }
-      catch(exn){
-       var exn$0 = caml_wrap_exception(exn);
-       if(exn$0[1] !== Bottom) throw caml_maybe_attach_backtrace(exn$0, 0);
-       var i$2 = exn$0[2], i$3 = i$2;
-        /*<<float.ml:394:6>>*/ for(;;){
-        var father = (i$3 - 1 | 0) / 3 | 0;
-        if(i$3 === father)
-          /*<<float.ml:395:6>>*/ throw  /*<<float.ml:395:6>>*/ caml_maybe_attach_backtrace
-                ([0, Assert_failure, _b_], 1);
-         /*<<float.ml:396:9>>*/ if
-         (0
-          <=
-            /*<<float.ml:396:9>>*/ caml_call2
-            (cmp,  /*<<float.ml:396:13>>*/ caml_array_get(a, father), e$0))
-          /*<<float.ml:399:15>>*/  /*<<float.ml:399:15>>*/ caml_array_set
-          (a, i$3, e$0);
-        else{
-          /*<<float.ml:397:8>>*/  /*<<float.ml:397:8>>*/ caml_array_set
-          (a, i$3,  /*<<float.ml:397:16>>*/ caml_array_get(a, father));
-         if(0 < father){var i$3 = father; continue;}
-          /*<<float.ml:398:51>>*/  /*<<float.ml:398:51>>*/ caml_array_set
-          (a, 0, e$0);
-        }
-         /*<<float.ml:405:4>>*/  /*<<float.ml:405:4>>*/ var _I_ = i$4 - 1 | 0;
-        if(2 === i$4) break a;
-        var i$4 = _I_;
-        break;
-       }
-      }
-     }
-    }
-    var _G_ = 1 < l ? 1 : 0;
-    if(_G_){
-      /*<<float.ml:410:27>>*/  /*<<float.ml:410:27>>*/ var
-      e =  /*<<float.ml:410:27>>*/ caml_array_get(a, 1);
-      /*<<float.ml:410:40>>*/  /*<<float.ml:410:40>>*/ caml_array_set
-      (a, 1,  /*<<float.ml:410:48>>*/ caml_array_get(a, 0));
-     var _H_ =  /*<<float.ml:410:59>>*/ caml_array_set(a, 0, e);
-    }
-    else
-     var _H_ = _G_;
-     /*<<float.ml:410:59>>*/ return _H_;
-    /*<<float.ml:410:69>>*/ }
-   function stable_sort(cmp, a){
-    function merge(src1ofs, src1len, src2, src2ofs, src2len, dst, dstofs){
-      /*<<float.ml:416:6>>*/ var
-      src1r = src1ofs + src1len | 0,
-      src2r = src2ofs + src2len | 0,
-       /*<<float.ml:433:46>>*/ s2$1 =
-         /*<<float.ml:433:46>>*/ caml_array_get(src2, src2ofs),
-       /*<<float.ml:433:22>>*/ s1$1 =
-         /*<<float.ml:433:22>>*/ caml_array_get(a, src1ofs),
-      i1 = src1ofs,
-      s1 = s1$1,
-      i2 = src2ofs,
-      s2 = s2$1,
-      d = dstofs;
-      /*<<float.ml:418:8>>*/ for(;;)
-       /*<<float.ml:418:11>>*/ if
-       (0 <  /*<<float.ml:418:11>>*/ caml_call2(cmp, s1, s2)){
-        /*<<float.ml:426:10>>*/  /*<<float.ml:426:10>>*/ caml_array_set
-        (dst, d, s2);
-        /*<<float.ml:426:10>>*/  /*<<float.ml:426:10>>*/ var
-        i2$0 = i2 + 1 | 0;
-       if(i2$0 >= src2r) return blit(a, i1, dst, d + 1 | 0, src1r - i1 | 0);
-        /*<<float.ml:429:12>>*/ var
-         /*<<float.ml:429:12>>*/ d$0 = d + 1 | 0,
-         /*<<float.ml:429:26>>*/ s2$0 =
-           /*<<float.ml:429:26>>*/ caml_array_get(src2, i2$0),
-        i2 = i2$0,
-        s2 = s2$0,
-        d = d$0;
-      }
-      else{
-        /*<<float.ml:419:10>>*/  /*<<float.ml:419:10>>*/ caml_array_set
-        (dst, d, s1);
-        /*<<float.ml:419:10>>*/  /*<<float.ml:419:10>>*/ var
-        i1$0 = i1 + 1 | 0;
-       if(i1$0 >= src1r)
-        return blit(src2, i2, dst, d + 1 | 0, src2r - i2 | 0);
-        /*<<float.ml:422:12>>*/ var
-         /*<<float.ml:422:12>>*/ d$1 = d + 1 | 0,
-         /*<<float.ml:422:20>>*/ s1$0 =
-           /*<<float.ml:422:20>>*/ caml_array_get(a, i1$0),
-        i1 = i1$0,
-        s1 = s1$0,
-        d = d$1;
-      }
-     /*<<float.ml:433:72>>*/ }
-    function isortto(srcofs, dst, dstofs, len){
-      /*<<float.ml:436:6>>*/ var
-      _C_ = len - 1 | 0,
-       /*<<float.ml:436:6>>*/ _B_ = 0;
-     if(_C_ >= 0){
-      var i = _B_;
-      a:
-      for(;;){
-        /*<<float.ml:437:16>>*/ var
-         /*<<float.ml:437:16>>*/ e =
-           /*<<float.ml:437:16>>*/ caml_array_get(a, srcofs + i | 0),
-         /*<<float.ml:438:16>>*/ j = [0, (dstofs + i | 0) - 1 | 0];
-       for(;;){
-         /*<<float.ml:439:31>>*/ if
-         (dstofs <= j[1]
-          &&
-           0
-           <
-             /*<<float.ml:439:31>>*/ caml_call2
-             (cmp,  /*<<float.ml:439:35>>*/ caml_array_get(dst, j[1]), e)){
-          /*<<float.ml:440:10>>*/  /*<<float.ml:440:10>>*/ caml_array_set
-          (dst,
-           j[1] + 1 | 0,
-            /*<<float.ml:440:27>>*/ caml_array_get(dst, j[1]));
-         j[1] += -1;
-         continue;
-        }
-         /*<<float.ml:443:8>>*/  /*<<float.ml:443:8>>*/ caml_array_set
-         (dst, j[1] + 1 | 0, e);
-         /*<<float.ml:436:6>>*/  /*<<float.ml:436:6>>*/ var _D_ = i + 1 | 0;
-        if(_C_ === i) break a;
-        var i = _D_;
-        break;
-       }
-      }
-     }
-     return 0;
-     /*<<float.ml:444:10>>*/ }
-    function sortto(srcofs, dst, dstofs, len){
-      /*<<float.ml:447:6>>*/ if(len <= 5)
-       /*<<float.ml:447:28>>*/ return isortto(srcofs, dst, dstofs, len);
-     var l1 = len / 2 | 0, l2 = len - l1 | 0;
-      /*<<float.ml:450:8>>*/ sortto(srcofs + l1 | 0, dst, dstofs + l1 | 0, l2);
-      /*<<float.ml:451:8>>*/ sortto(srcofs, a, srcofs + l2 | 0, l1);
-      /*<<float.ml:451:8>>*/ return merge
-             (srcofs + l2 | 0, l1, dst, dstofs + l1 | 0, l2, dst, dstofs);
-     /*<<float.ml:453:9>>*/ }
-    var l = a.length - 1;
-    if(l <= 5)  /*<<float.ml:456:24>>*/ return isortto(0, a, 0, l);
-     /*<<float.ml:459:14>>*/ var
-     l1 = l / 2 | 0,
-     l2 = l - l1 | 0,
-      /*<<float.ml:459:14>>*/ t =
-        /*<<float.ml:459:14>>*/ caml_floatarray_create(l2);
-     /*<<float.ml:460:6>>*/ sortto(l1, t, 0, l2);
-     /*<<float.ml:461:6>>*/ sortto(0, a, l2, l1);
-     /*<<float.ml:461:6>>*/ return merge(l2, l1, t, 0, l2, a, 0);
-    /*<<float.ml:463:7>>*/ }
-   function to_seq(a){
-    function aux(i, param){
-      /*<<float.ml:470:6>>*/ if(i >= a.length - 1)
-       /*<<float.ml:474:11>>*/ return 0;
-      /*<<float.ml:472:16>>*/ var
-       /*<<float.ml:472:16>>*/ x = a[1 + i],
-       /*<<float.ml:472:16>>*/ _z_ = i + 1 | 0;
-      /*<<float.ml:473:8>>*/ return [0,
-             x,
-             function(_A_){ /*<<?>>*/ return aux(_z_, _A_);}];
-     /*<<float.ml:474:18>>*/ }
-     /*<<float.ml:476:4>>*/  /*<<float.ml:476:4>>*/ var _x_ = 0;
-     /*<<float.ml:476:4>>*/ return function(_y_){
-      /*<<?>>*/ return aux(_x_, _y_);};
-    /*<<float.ml:476:9>>*/ }
-   function to_seqi(a){
-    function aux(i, param){
-      /*<<float.ml:481:6>>*/ if(i >= a.length - 1)
-       /*<<float.ml:485:11>>*/ return 0;
-      /*<<float.ml:483:16>>*/ var
-       /*<<float.ml:483:16>>*/ x = a[1 + i],
-       /*<<float.ml:483:16>>*/ _v_ = i + 1 | 0;
-      /*<<float.ml:484:8>>*/ return [0,
-             [0, i, x],
-             function(_w_){ /*<<?>>*/ return aux(_v_, _w_);}];
-     /*<<float.ml:485:18>>*/ }
-     /*<<float.ml:487:4>>*/  /*<<float.ml:487:4>>*/ var _t_ = 0;
-     /*<<float.ml:487:4>>*/ return function(_u_){
-      /*<<?>>*/ return aux(_t_, _u_);};
-    /*<<float.ml:487:9>>*/ }
-   function of_seq(i$2){
-     /*<<float.ml:501:4>>*/ var _r_ = 0;
-    function _s_(acc, x){
-      /*<<float.ml:501:40>>*/ return [0, x, acc];
-     /*<<float.ml:501:46>>*/ }
-     /*<<float.ml:501:12>>*/ var
-      /*<<float.ml:501:12>>*/ l =
-        /*<<float.ml:501:12>>*/ caml_call3(Stdlib_Seq[5], _s_, _r_, i$2),
-      /*<<float.ml:491:14>>*/ len =
-        /*<<float.ml:491:14>>*/ caml_call1(Stdlib_List[1], l),
-      /*<<float.ml:492:12>>*/ a =
-        /*<<float.ml:492:12>>*/ caml_floatarray_create(len),
-      /*<<float.ml:491:14>>*/ i$1 = len - 1 | 0,
-     i = i$1,
-     param = l;
-    for(;;){
-     if(! param)  /*<<float.ml:493:4>>*/ return a;
-     var tl = param[2], hd = param[1];
-      /*<<float.ml:495:18>>*/ a[1 + i] = hd;
-      /*<<float.ml:493:4>>*/ var
-       /*<<float.ml:493:4>>*/ i$0 = i - 1 | 0,
-      i = i$0,
-      param = tl;
-    }
-    /*<<float.ml:502:17>>*/ }
-   function map_to_array(f, a){
-     /*<<float.ml:506:4>>*/ var l = a.length - 1;
-     /*<<float.ml:507:4>>*/ if(0 === l)  /*<<float.ml:507:18>>*/ return [0];
-     /*<<float.ml:508:14>>*/ var
-      /*<<float.ml:508:14>>*/ r =
-        /*<<float.ml:508:14>>*/ runtime.caml_make_vect
-        (l,  /*<<float.ml:508:27>>*/ caml_call1(f, a[1])),
-      /*<<float.ml:509:6>>*/ _p_ = l - 1 | 0,
-      /*<<float.ml:508:14>>*/ _o_ = 1;
-    if(_p_ >= 1){
-     var i = _o_;
-     for(;;){
-       /*<<float.ml:510:8>>*/ r[1 + i] =
-        /*<<float.ml:510:29>>*/ caml_call1(f, a[1 + i]);
-       /*<<float.ml:510:8>>*/  /*<<float.ml:510:8>>*/ var _q_ = i + 1 | 0;
-      if(_p_ === i) break;
-      var i = _q_;
-     }
-    }
-     /*<<float.ml:512:6>>*/ return r;
-    /*<<float.ml:513:7>>*/ }
-   function map_from_array(f, a){
-     /*<<float.ml:516:4>>*/ var
-     l = a.length - 1,
-      /*<<float.ml:517:12>>*/ r =
-        /*<<float.ml:517:12>>*/ caml_floatarray_create(l),
-      /*<<float.ml:518:4>>*/ _m_ = l - 1 | 0,
-      /*<<float.ml:517:12>>*/ _l_ = 0;
-    if(_m_ >= 0){
-     var i = _l_;
-     for(;;){
-       /*<<float.ml:519:6>>*/ r[1 + i] =
-        /*<<float.ml:519:21>>*/ caml_call1(f, a[1 + i]);
-       /*<<float.ml:519:6>>*/  /*<<float.ml:519:6>>*/ var _n_ = i + 1 | 0;
-      if(_m_ === i) break;
-      var i = _n_;
-     }
-    }
-     /*<<float.ml:521:4>>*/ return r;
-    /*<<float.ml:521:5>>*/ }
-   var
-    _c_ = caml_floatarray_create,
-    _d_ = caml_array_set,
-    _e_ = caml_array_get,
-    _f_ =
-      [0,
-       function(_k_){ /*<<?>>*/ return _k_.length - 1;},
-       _e_,
-       _d_,
-       make,
-       _c_,
-       init,
-       append,
-       concat,
-       sub,
-       copy,
-       fill,
-       blit,
-       to_list,
-       of_list,
-       iter,
-       iteri,
-       map,
-       mapi,
-       fold_left,
-       fold_right,
-       iter2,
-       map2,
-       for_all,
-       exists,
-       mem,
-       mem_ieee,
-       sort,
-       stable_sort,
-       stable_sort,
-       to_seq,
-       to_seqi,
-       of_seq,
-       map_to_array,
-       map_from_array],
-    _g_ = caml_floatarray_create,
-    _h_ = caml_array_set,
-    _i_ = caml_array_get,
-    Stdlib_Float =
-      [0,
-       zero,
-       one,
-       minus_one,
-       succ,
-       pred,
-       infinity,
-       neg_infinity,
-       nan,
-       pi,
-       max_float,
-       min_float,
-       epsilon,
-       is_finite,
-       is_infinite,
-       is_nan,
-       is_integer,
-       of_string_opt,
-       to_string,
-       caml_float_compare,
-       equal,
-       min,
-       max,
-       min_max,
-       min_num,
-       max_num,
-       min_max_num,
-       hash,
-       [0,
-        function(_j_){ /*<<?>>*/ return _j_.length - 1;},
-        _i_,
-        _h_,
-        make,
-        _g_,
-        init,
-        append,
-        concat,
-        sub,
-        copy,
-        fill,
-        blit,
-        to_list,
-        of_list,
-        iter,
-        iteri,
-        map,
-        mapi,
-        fold_left,
-        fold_right,
-        iter2,
-        map2,
-        for_all,
-        exists,
-        mem,
-        mem_ieee,
-        sort,
-        stable_sort,
-        stable_sort,
-        to_seq,
-        to_seqi,
-        of_seq,
-        map_to_array,
-        map_from_array],
-       _f_];
-   runtime.caml_register_global(22, Stdlib_Float, "Stdlib__Float");
-   return;
-   /*<<?>>*/ }
-  (globalThis));
-
-//# unitInfo: Provides: Stdlib__Int32
-//# unitInfo: Requires: Assert_failure, Stdlib, Stdlib__Sys
-(function
-  (globalThis){
-   "use strict";
-   var
-    runtime = globalThis.jsoo_runtime,
-    caml_greaterequal = runtime.caml_greaterequal,
-    caml_int_compare = runtime.caml_int_compare,
-    caml_maybe_attach_backtrace = runtime.caml_maybe_attach_backtrace,
-    caml_mul = runtime.caml_mul,
-    caml_wrap_exception = runtime.caml_wrap_exception,
-    global_data = runtime.caml_get_global_data(),
-    Stdlib = global_data.Stdlib,
-    Stdlib_Sys = global_data.Stdlib__Sys,
-    Assert_failure = global_data.Assert_failure,
-    _b_ = [0, "int32.ml", 69, 6],
-    zero = 0,
-    one = 1,
-    minus_one = -1;
-   function succ(n){
-     /*<<int32.ml:48:13>>*/ return n + 1 | 0;
-    /*<<int32.ml:48:21>>*/ }
-   function pred(n){
-     /*<<int32.ml:49:13>>*/ return n - 1 | 0;
-    /*<<int32.ml:49:21>>*/ }
-   function abs(n){
-     /*<<int32.ml:50:12>>*/ return  /*<<int32.ml:50:15>>*/ caml_greaterequal
-             (n, 0)
-            ? n
-            : - n | 0;
-    /*<<int32.ml:50:40>>*/ }
-   var min_int = -2147483648, max_int = 2147483647;
-   function lognot(n){
-     /*<<int32.ml:53:15>>*/ return n ^ -1;
-    /*<<int32.ml:53:29>>*/ }
-   var _a_ = Stdlib_Sys[9];
-   if(32 === _a_)
-     /*<<int32.ml:58:6>>*/ var
-      /*<<int32.ml:58:6>>*/ max_int$0 = Stdlib[19],
-     unsigned_to_int =
-       function(n){
-         /*<<int32.ml:60:8>>*/ if
-         (0 >=  /*<<int32.ml:60:11>>*/ caml_int_compare(0, n)
-          && 0 >=  /*<<int32.ml:60:34>>*/ caml_int_compare(n, max_int$0))
-          /*<<int32.ml:61:10>>*/ return [0, n];
-         /*<<int32.ml:63:10>>*/ return 0;
-        /*<<int32.ml:63:14>>*/ };
-   else{
-    if(64 !== _a_)
-      /*<<int32.ml:69:6>>*/ throw  /*<<int32.ml:69:6>>*/ caml_maybe_attach_backtrace
-            ([0, Assert_failure, _b_], 1);
-    var
-     unsigned_to_int =
-       function(n){
-         /*<<int32.ml:67:15>>*/ return [0, n & -1];
-        /*<<int32.ml:67:40>>*/ };
-   }
-   function to_string(n){
-     /*<<int32.ml:72:18>>*/ return  /*<<int32.ml:72:18>>*/ runtime.caml_format_int
-            ("%d", n);
-    /*<<int32.ml:72:31>>*/ }
-   function of_string_opt(s){
-     /*<<int32.ml:78:2>>*/ try{
-      /*<<int32.ml:78:6>>*/  /*<<int32.ml:78:6>>*/ var
-      _d_ = [0,  /*<<int32.ml:78:11>>*/ runtime.caml_int_of_string(s)];
-      /*<<int32.ml:78:6>>*/ return _d_;
-    }
-    catch(_e_){
-     var _c_ = caml_wrap_exception(_e_);
-     if(_c_[1] === Stdlib[7])  /*<<int32.ml:79:20>>*/ return 0;
-     throw caml_maybe_attach_backtrace(_c_, 0);
-    }
-    /*<<int32.ml:79:24>>*/ }
-   var compare = caml_int_compare;
-   function equal(x, y){
-     /*<<int32.ml:84:26>>*/ return 0
-            ===  /*<<int32.ml:84:26>>*/ caml_int_compare(x, y)
-            ? 1
-            : 0;
-    /*<<int32.ml:84:41>>*/ }
-   function unsigned_compare(n, m){
-     /*<<int32.ml:87:2>>*/ return  /*<<int32.ml:87:26>>*/ caml_int_compare
-            (n + 2147483648 | 0, m + 2147483648 | 0);
-    /*<<int32.ml:87:41>>*/ }
-   function min(x, y){
-     /*<<int32.ml:89:18>>*/ return  /*<<int32.ml:89:21>>*/ runtime.caml_lessequal
-             (x, y)
-            ? x
-            : y;
-    /*<<int32.ml:89:41>>*/ }
-   function max(x, y){
-     /*<<int32.ml:90:18>>*/ return  /*<<int32.ml:90:21>>*/ caml_greaterequal
-             (x, y)
-            ? x
-            : y;
-    /*<<int32.ml:90:41>>*/ }
-   function unsigned_div(n, d){
-     /*<<int32.ml:96:2>>*/ if
-     ( /*<<int32.ml:96:5>>*/ runtime.caml_lessthan(d, 0))
-      /*<<int32.ml:97:7>>*/ return 0 <= unsigned_compare(n, d) ? one : zero;
-     /*<<int32.ml:99:12>>*/ var
-      /*<<int32.ml:99:12>>*/ q =
-        /*<<int32.ml:99:23>>*/ runtime.caml_div(n >>> 1 | 0, d) << 1,
-      /*<<int32.ml:100:12>>*/ r =
-       n -  /*<<int32.ml:100:18>>*/ caml_mul(q, d) | 0;
-     /*<<int32.ml:101:7>>*/ return 0 <= unsigned_compare(r, d) ? q + 1 | 0 : q;
-    /*<<int32.ml:101:51>>*/ }
-   function unsigned_rem(n, d){
-     /*<<int32.ml:104:2>>*/ return n
-           -  /*<<int32.ml:104:8>>*/ caml_mul(unsigned_div(n, d), d)
-           | 0;
-    /*<<int32.ml:104:34>>*/ }
-   var
-    Stdlib_Int32 =
-      [0,
-       zero,
-       one,
-       minus_one,
-       unsigned_div,
-       unsigned_rem,
-       succ,
-       pred,
-       abs,
-       max_int,
-       min_int,
-       lognot,
-       unsigned_to_int,
-       of_string_opt,
-       to_string,
-       compare,
-       unsigned_compare,
-       equal,
-       min,
-       max];
-   runtime.caml_register_global(14, Stdlib_Int32, "Stdlib__Int32");
-   return;
-   /*<<?>>*/ }
-  (globalThis));
-
-//# unitInfo: Provides: Stdlib__Int64
-//# unitInfo: Requires: Stdlib
-(function
-  (globalThis){
-   "use strict";
-   var
-    runtime = globalThis.jsoo_runtime,
-    caml_greaterequal = runtime.caml_greaterequal,
-    caml_int64_compare = runtime.caml_int64_compare,
-    caml_int64_mul = runtime.caml_int64_mul,
-    caml_int64_sub = runtime.caml_int64_sub,
-    caml_maybe_attach_backtrace = runtime.caml_maybe_attach_backtrace,
-    caml_wrap_exception = runtime.caml_wrap_exception,
-    global_data = runtime.caml_get_global_data(),
-    zero = runtime.caml_int64_create_lo_mi_hi(0, 0, 0),
-    one = runtime.caml_int64_create_lo_mi_hi(1, 0, 0),
-    minus_one = runtime.caml_int64_create_lo_mi_hi(16777215, 16777215, 65535),
-    min_int = runtime.caml_int64_create_lo_mi_hi(0, 0, 32768),
-    max_int = runtime.caml_int64_create_lo_mi_hi(16777215, 16777215, 32767),
-    Stdlib = global_data.Stdlib,
-    _d_ = runtime.caml_int64_create_lo_mi_hi(16777215, 16777215, 65535),
-    _c_ = runtime.caml_int64_create_lo_mi_hi(0, 0, 0),
-    _b_ = runtime.caml_int64_create_lo_mi_hi(1, 0, 0),
-    _a_ = runtime.caml_int64_create_lo_mi_hi(1, 0, 0);
-   function succ(n){
-     /*<<int64.ml:46:13>>*/ return  /*<<int64.ml:46:13>>*/ runtime.caml_int64_add
-            (n, _a_);
-    /*<<int64.ml:46:21>>*/ }
-   function pred(n){
-     /*<<int64.ml:47:13>>*/ return  /*<<int64.ml:47:13>>*/ caml_int64_sub
-            (n, _b_);
-    /*<<int64.ml:47:21>>*/ }
-   function abs(n){
-     /*<<int64.ml:48:12>>*/ return  /*<<int64.ml:48:15>>*/ caml_greaterequal
-             (n, _c_)
-            ? n
-            :  /*<<int64.ml:48:35>>*/ runtime.caml_int64_neg(n);
-    /*<<int64.ml:48:40>>*/ }
-   function lognot(n){
-     /*<<int64.ml:51:15>>*/ return  /*<<int64.ml:51:15>>*/ runtime.caml_int64_xor
-            (n, _d_);
-    /*<<int64.ml:51:29>>*/ }
-    /*<<int64.ml:54:16>>*/  /*<<int64.ml:54:16>>*/ var
-    max_int$0 =
-       /*<<int64.ml:54:16>>*/ runtime.caml_int64_of_int32(Stdlib[19]);
-   function unsigned_to_int(n){
-     /*<<int64.ml:56:4>>*/ if
-     (0 >=  /*<<int64.ml:56:7>>*/ caml_int64_compare(zero, n)
-      && 0 >=  /*<<int64.ml:56:30>>*/ caml_int64_compare(n, max_int$0))
-      /*<<int64.ml:57:6>>*/ return [0, runtime.caml_int64_to_int32(n)];
-     /*<<int64.ml:59:6>>*/ return 0;
-    /*<<int64.ml:59:10>>*/ }
-   function to_string(n){
-     /*<<int64.ml:62:18>>*/ return  /*<<int64.ml:62:18>>*/ runtime.caml_int64_format
-            ("%d", n);
-    /*<<int64.ml:62:31>>*/ }
-   function of_string_opt(s){
-     /*<<int64.ml:68:2>>*/ try{
-      /*<<int64.ml:68:6>>*/  /*<<int64.ml:68:6>>*/ var
-      _f_ = [0,  /*<<int64.ml:68:11>>*/ runtime.caml_int64_of_string(s)];
-      /*<<int64.ml:68:6>>*/ return _f_;
-    }
-    catch(_g_){
-     var _e_ = caml_wrap_exception(_g_);
-     if(_e_[1] === Stdlib[7])  /*<<int64.ml:69:20>>*/ return 0;
-     throw caml_maybe_attach_backtrace(_e_, 0);
-    }
-    /*<<int64.ml:69:24>>*/ }
-   function compare(x, y){
-     /*<<int64.ml:82:28>>*/ return  /*<<int64.ml:82:28>>*/ caml_int64_compare
-            (x, y);
-    /*<<int64.ml:82:46>>*/ }
-   function equal(x, y){
-     /*<<int64.ml:83:26>>*/ return 0
-            ===  /*<<int64.ml:83:26>>*/ caml_int64_compare(x, y)
-            ? 1
-            : 0;
-    /*<<int64.ml:83:41>>*/ }
-   function unsigned_compare(n, m){
-     /*<<int64.ml:86:2>>*/ return  /*<<int64.ml:86:26>>*/ caml_int64_compare
-            ( /*<<int64.ml:86:10>>*/ caml_int64_sub(n, min_int),
-              /*<<int64.ml:86:26>>*/ caml_int64_sub(m, min_int));
-    /*<<int64.ml:86:41>>*/ }
-   function min(x, y){
-     /*<<int64.ml:88:18>>*/ return  /*<<int64.ml:88:21>>*/ runtime.caml_lessequal
-             (x, y)
-            ? x
-            : y;
-    /*<<int64.ml:88:41>>*/ }
-   function max(x, y){
-     /*<<int64.ml:89:18>>*/ return  /*<<int64.ml:89:21>>*/ caml_greaterequal
-             (x, y)
-            ? x
-            : y;
-    /*<<int64.ml:89:41>>*/ }
-   function unsigned_div(n, d){
-     /*<<int64.ml:95:2>>*/ if
-     ( /*<<int64.ml:95:5>>*/ runtime.caml_lessthan(d, zero))
-      /*<<int64.ml:96:7>>*/ return 0 <= unsigned_compare(n, d) ? one : zero;
-     /*<<int64.ml:98:12>>*/ var
-      /*<<int64.ml:98:12>>*/ q =
-        /*<<int64.ml:98:12>>*/ runtime.caml_int64_shift_left
-        ( /*<<int64.ml:98:23>>*/ runtime.caml_int64_div
-          ( /*<<int64.ml:98:28>>*/ runtime.caml_int64_shift_right_unsigned
-            (n, 1),
-           d),
-         1),
-      /*<<int64.ml:99:12>>*/ r =
-        /*<<int64.ml:99:12>>*/ caml_int64_sub
-        (n,  /*<<int64.ml:99:18>>*/ caml_int64_mul(q, d));
-     /*<<int64.ml:100:7>>*/ return 0 <= unsigned_compare(r, d) ? succ(q) : q;
-    /*<<int64.ml:100:51>>*/ }
-   function unsigned_rem(n, d){
-     /*<<int64.ml:103:2>>*/ return  /*<<int64.ml:103:2>>*/ caml_int64_sub
-            (n,  /*<<int64.ml:103:8>>*/ caml_int64_mul(unsigned_div(n, d), d));
-    /*<<int64.ml:103:34>>*/ }
-   var
-    Stdlib_Int64 =
-      [0,
-       zero,
-       one,
-       minus_one,
-       unsigned_div,
-       unsigned_rem,
-       succ,
-       pred,
-       abs,
-       max_int,
-       min_int,
-       lognot,
-       unsigned_to_int,
-       of_string_opt,
-       to_string,
-       compare,
-       unsigned_compare,
-       equal,
-       min,
-       max];
-   runtime.caml_register_global(11, Stdlib_Int64, "Stdlib__Int64");
-   return;
-   /*<<?>>*/ }
-  (globalThis));
-
-//# unitInfo: Provides: Stdlib__Nativeint
-//# unitInfo: Requires: Stdlib, Stdlib__Sys
-(function
-  (globalThis){
-   "use strict";
-   var
-    runtime = globalThis.jsoo_runtime,
-    caml_greaterequal = runtime.caml_greaterequal,
-    caml_int_compare = runtime.caml_int_compare,
-    caml_maybe_attach_backtrace = runtime.caml_maybe_attach_backtrace,
-    caml_mul = runtime.caml_mul,
-    caml_wrap_exception = runtime.caml_wrap_exception,
-    global_data = runtime.caml_get_global_data(),
-    Stdlib = global_data.Stdlib,
-    Stdlib_Sys = global_data.Stdlib__Sys,
-    zero = 0,
-    one = 1,
-    minus_one = -1;
-   function succ(n){
-     /*<<nativeint.ml:44:13>>*/ return n + 1 | 0;
-    /*<<nativeint.ml:44:21>>*/ }
-   function pred(n){
-     /*<<nativeint.ml:45:13>>*/ return n - 1 | 0;
-    /*<<nativeint.ml:45:21>>*/ }
-   function abs(n){
-     /*<<nativeint.ml:46:12>>*/ return  /*<<nativeint.ml:46:15>>*/ caml_greaterequal
-             (n, 0)
-            ? n
-            : - n | 0;
-    /*<<nativeint.ml:46:40>>*/ }
-    /*<<nativeint.ml:48:14>>*/ var
-    size = Stdlib_Sys[9],
-     /*<<nativeint.ml:48:14>>*/ min_int = 1 << (size - 1 | 0),
-     /*<<nativeint.ml:49:14>>*/ max_int = min_int - 1 | 0;
-   function lognot(n){
-     /*<<nativeint.ml:50:15>>*/ return n ^ -1;
-    /*<<nativeint.ml:50:29>>*/ }
-   var max_int$0 = Stdlib[19];
-   function unsigned_to_int(n){
-     /*<<nativeint.ml:55:4>>*/ if
-     (0 >=  /*<<nativeint.ml:55:7>>*/ caml_int_compare(0, n)
-      && 0 >=  /*<<nativeint.ml:55:30>>*/ caml_int_compare(n, max_int$0))
-      /*<<nativeint.ml:56:6>>*/ return [0, n];
-     /*<<nativeint.ml:58:6>>*/ return 0;
-    /*<<nativeint.ml:58:10>>*/ }
-   function to_string(n){
-     /*<<nativeint.ml:61:18>>*/ return  /*<<nativeint.ml:61:18>>*/ runtime.caml_format_int
-            ("%d", n);
-    /*<<nativeint.ml:61:31>>*/ }
-   function of_string_opt(s){
-     /*<<nativeint.ml:67:2>>*/ try{
-      /*<<nativeint.ml:67:6>>*/  /*<<nativeint.ml:67:6>>*/ var
-      _b_ = [0,  /*<<nativeint.ml:67:11>>*/ runtime.caml_int_of_string(s)];
-      /*<<nativeint.ml:67:6>>*/ return _b_;
-    }
-    catch(_c_){
-     var _a_ = caml_wrap_exception(_c_);
-     if(_a_[1] === Stdlib[7])  /*<<nativeint.ml:68:20>>*/ return 0;
-     throw caml_maybe_attach_backtrace(_a_, 0);
-    }
-    /*<<nativeint.ml:68:24>>*/ }
-   var compare = caml_int_compare;
-   function equal(x, y){
-     /*<<nativeint.ml:73:26>>*/ return 0
-            ===  /*<<nativeint.ml:73:26>>*/ caml_int_compare(x, y)
-            ? 1
-            : 0;
-    /*<<nativeint.ml:73:41>>*/ }
-   function unsigned_compare(n, m){
-     /*<<nativeint.ml:76:2>>*/ return  /*<<nativeint.ml:76:26>>*/ caml_int_compare
-            (n - min_int | 0, m - min_int | 0);
-    /*<<nativeint.ml:76:41>>*/ }
-   function min(x, y){
-     /*<<nativeint.ml:78:18>>*/ return  /*<<nativeint.ml:78:21>>*/ runtime.caml_lessequal
-             (x, y)
-            ? x
-            : y;
-    /*<<nativeint.ml:78:41>>*/ }
-   function max(x, y){
-     /*<<nativeint.ml:79:18>>*/ return  /*<<nativeint.ml:79:21>>*/ caml_greaterequal
-             (x, y)
-            ? x
-            : y;
-    /*<<nativeint.ml:79:41>>*/ }
-   function unsigned_div(n, d){
-     /*<<nativeint.ml:85:2>>*/ if
-     ( /*<<nativeint.ml:85:5>>*/ runtime.caml_lessthan(d, 0))
-      /*<<nativeint.ml:86:7>>*/ return 0 <= unsigned_compare(n, d)
-             ? one
-             : zero;
-     /*<<nativeint.ml:88:12>>*/ var
-      /*<<nativeint.ml:88:12>>*/ q =
-        /*<<nativeint.ml:88:23>>*/ runtime.caml_div(n >>> 1 | 0, d) << 1,
-      /*<<nativeint.ml:89:12>>*/ r =
-       n -  /*<<nativeint.ml:89:18>>*/ caml_mul(q, d) | 0;
-     /*<<nativeint.ml:90:7>>*/ return 0 <= unsigned_compare(r, d)
-            ? q + 1 | 0
-            : q;
-    /*<<nativeint.ml:90:51>>*/ }
-   function unsigned_rem(n, d){
-     /*<<nativeint.ml:93:2>>*/ return n
-           -  /*<<nativeint.ml:93:8>>*/ caml_mul(unsigned_div(n, d), d)
-           | 0;
-    /*<<nativeint.ml:93:34>>*/ }
-   var
-    Stdlib_Nativeint =
-      [0,
-       zero,
-       one,
-       minus_one,
-       unsigned_div,
-       unsigned_rem,
-       succ,
-       pred,
-       abs,
-       size,
-       max_int,
-       min_int,
-       lognot,
-       unsigned_to_int,
-       of_string_opt,
-       to_string,
-       compare,
-       unsigned_compare,
-       equal,
-       min,
-       max];
-   runtime.caml_register_global(12, Stdlib_Nativeint, "Stdlib__Nativeint");
-   return;
-   /*<<?>>*/ }
-  (globalThis));
-
-//# unitInfo: Provides: Stdlib__Lexing
-//# unitInfo: Requires: Stdlib, Stdlib__Bytes, Stdlib__Int, Stdlib__Sys
-(function
-  (globalThis){
-   "use strict";
-   var
-    runtime = globalThis.jsoo_runtime,
-    cst = "",
-    caml_bytes_get = runtime.caml_bytes_get,
-    caml_check_bound = runtime.caml_check_bound,
-    caml_create_bytes = runtime.caml_create_bytes,
-    caml_ml_bytes_length = runtime.caml_ml_bytes_length;
-    /*<<?>>*/ function caml_call1(f, a0){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 1
-            ? f(a0)
-            : runtime.caml_call_gen(f, [a0]);
-   }
-    /*<<?>>*/ function caml_call2(f, a0, a1){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 2
-            ? f(a0, a1)
-            : runtime.caml_call_gen(f, [a0, a1]);
-   }
-    /*<<?>>*/ function caml_call3(f, a0, a1, a2){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 3
-            ? f(a0, a1, a2)
-            : runtime.caml_call_gen(f, [a0, a1, a2]);
-   }
-    /*<<?>>*/ function caml_call4(f, a0, a1, a2, a3){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 4
-            ? f(a0, a1, a2, a3)
-            : runtime.caml_call_gen(f, [a0, a1, a2, a3]);
-   }
-    /*<<?>>*/ function caml_call5(f, a0, a1, a2, a3, a4){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 5
-            ? f(a0, a1, a2, a3, a4)
-            : runtime.caml_call_gen(f, [a0, a1, a2, a3, a4]);
-   }
-   var
-    global_data = runtime.caml_get_global_data(),
-    dummy_pos = [0, cst, 0, 0, -1],
-    zero_pos = [0, cst, 1, 0, 0],
-    Stdlib_Bytes = global_data.Stdlib__Bytes,
-    Stdlib = global_data.Stdlib,
-    Stdlib_Sys = global_data.Stdlib__Sys,
-    Stdlib_Int = global_data.Stdlib__Int,
-    cst_Lexing_lex_refill_cannot_g = "Lexing.lex_refill: cannot grow buffer";
-   function engine(tbl, state, buf){
-     /*<<lexing.ml:65:2>>*/ var
-      /*<<lexing.ml:65:15>>*/ result =
-        /*<<lexing.ml:65:15>>*/ runtime.caml_lex_engine(tbl, state, buf),
-     _F_ = 0 <= result ? 1 : 0,
-     _G_ = _F_ ? buf[12] !== dummy_pos ? 1 : 0 : _F_;
-    if(_G_){
-     buf[11] = buf[12];
-     var _H_ = buf[12];
-     buf[12] = [0, _H_[1], _H_[2], _H_[3], buf[4] + buf[6] | 0];
-    }
-     /*<<lexing.ml:71:2>>*/ return result;
-    /*<<lexing.ml:71:8>>*/ }
-   function new_engine(tbl, state, buf){
-     /*<<lexing.ml:75:2>>*/ var
-      /*<<lexing.ml:75:15>>*/ result =
-        /*<<lexing.ml:75:15>>*/ runtime.caml_new_lex_engine(tbl, state, buf),
-     _C_ = 0 <= result ? 1 : 0,
-     _D_ = _C_ ? buf[12] !== dummy_pos ? 1 : 0 : _C_;
-    if(_D_){
-     buf[11] = buf[12];
-     var _E_ = buf[12];
-     buf[12] = [0, _E_[1], _E_[2], _E_[3], buf[4] + buf[6] | 0];
-    }
-     /*<<lexing.ml:81:2>>*/ return result;
-    /*<<lexing.ml:81:8>>*/ }
-   function from_function(opt, read_fun){
-     /*<<lexing.ml:148:2>>*/ if(opt)
-     var sth = opt[1], with_positions = sth;
-    else
-     var with_positions = 1;
-     /*<<lexing.ml:148:2>>*/ var
-      /*<<lexing.ml:148:2>>*/ _o_ = with_positions ? zero_pos : dummy_pos,
-     _p_ = with_positions ? zero_pos : dummy_pos,
-      /*<<lexing.ml:148:31>>*/ aux_buffer =
-        /*<<lexing.ml:148:31>>*/ caml_create_bytes(512),
-     _q_ = [0],
-      /*<<lexing.ml:156:14>>*/ _r_ = 0,
-     _s_ = 0,
-     _t_ = 0,
-     _u_ = 0,
-     _v_ = 0,
-     _w_ = 0,
-     _x_ = 0,
-      /*<<lexing.ml:149:17>>*/ _y_ =
-        /*<<lexing.ml:149:17>>*/ caml_create_bytes(1024);
-     /*<<lexing.ml:148:2>>*/ return [0,
-            function(lexbuf){
-              /*<<lexing.ml:85:4>>*/ var
-               /*<<lexing.ml:85:4>>*/ read =
-                 /*<<lexing.ml:85:4>>*/ caml_call2
-                 (read_fun, aux_buffer, caml_ml_bytes_length(aux_buffer)),
-               /*<<lexing.ml:86:2>>*/ n = 0 < read ? read : (lexbuf[9] = 1, 0);
-             if(caml_ml_bytes_length(lexbuf[2]) < (lexbuf[3] + n | 0)){
-              if
-               (((lexbuf[3] - lexbuf[5] | 0) + n | 0)
-                <= caml_ml_bytes_length(lexbuf[2]))
-                /*<<lexing.ml:100:9>>*/  /*<<lexing.ml:100:9>>*/ caml_call5
-                (Stdlib_Bytes[11],
-                 lexbuf[2],
-                 lexbuf[5],
-                 lexbuf[2],
-                 0,
-                 lexbuf[3] - lexbuf[5] | 0);
-              else{
-                /*<<lexing.ml:111:8>>*/  /*<<lexing.ml:111:8>>*/ var
-                newlen =
-                   /*<<lexing.ml:111:8>>*/ caml_call2
-                   (Stdlib_Int[10],
-                    2 * caml_ml_bytes_length(lexbuf[2]) | 0,
-                    Stdlib_Sys[12]);
-               if(newlen < ((lexbuf[3] - lexbuf[5] | 0) + n | 0))
-                 /*<<lexing.ml:113:11>>*/  /*<<lexing.ml:113:11>>*/ caml_call1
-                 (Stdlib[2], cst_Lexing_lex_refill_cannot_g);
-                /*<<lexing.ml:114:19>>*/  /*<<lexing.ml:114:19>>*/ var
-                newbuf =  /*<<lexing.ml:114:19>>*/ caml_create_bytes(newlen);
-                /*<<lexing.ml:116:6>>*/  /*<<lexing.ml:116:6>>*/ caml_call5
-                (Stdlib_Bytes[11],
-                 lexbuf[2],
-                 lexbuf[5],
-                 newbuf,
-                 0,
-                 lexbuf[3] - lexbuf[5] | 0);
-               lexbuf[2] = newbuf;
-              }
-              var s = lexbuf[5];
-              lexbuf[4] = lexbuf[4] + s | 0;
-              lexbuf[6] = lexbuf[6] - s | 0;
-              lexbuf[5] = 0;
-              lexbuf[7] = lexbuf[7] - s | 0;
-              lexbuf[3] = lexbuf[3] - s | 0;
-              var t = lexbuf[10], _A_ = t.length - 1 - 1 | 0, _z_ = 0;
-              if(_A_ >= 0){
-               var i = _z_;
-               for(;;){
-                 /*<<lexing.ml:131:14>>*/  /*<<lexing.ml:131:14>>*/ var
-                 v = caml_check_bound(t, i)[1 + i];
-                if(0 <= v)
-                  /*<<lexing.ml:133:8>>*/ caml_check_bound(t, i)[1 + i] = v - s | 0;
-                 /*<<lexing.ml:130:4>>*/  /*<<lexing.ml:130:4>>*/ var
-                 _B_ = i + 1 | 0;
-                if(_A_ === i) break;
-                var i = _B_;
-               }
-              }
-             }
-              /*<<lexing.ml:137:2>>*/  /*<<lexing.ml:137:2>>*/ caml_call5
-              (Stdlib_Bytes[11], aux_buffer, 0, lexbuf[2], lexbuf[3], n);
-             lexbuf[3] = lexbuf[3] + n | 0;
-             return 0;
-            },
-            _y_,
-            _x_,
-            _w_,
-            _v_,
-            _u_,
-            _t_,
-            _s_,
-            _r_,
-            _q_,
-            _p_,
-            _o_];
-    /*<<lexing.ml:160:3>>*/ }
-   function from_channel(with_positions, ic){
-     /*<<lexing.ml:163:2>>*/ return from_function
-            (with_positions,
-             function(buf, n){
-               /*<<lexing.ml:163:46>>*/ return  /*<<lexing.ml:163:46>>*/ caml_call4
-                      (Stdlib[84], ic, buf, 0, n);
-              /*<<lexing.ml:163:62>>*/ });
-    /*<<lexing.ml:163:63>>*/ }
-   function from_string(opt, s){
-     /*<<lexing.ml:166:2>>*/ if(opt)
-     var sth = opt[1], with_positions = sth;
-    else
-     var with_positions = 1;
-     /*<<lexing.ml:166:2>>*/ var
-      /*<<lexing.ml:166:2>>*/ _d_ = with_positions ? zero_pos : dummy_pos,
-     _e_ = with_positions ? zero_pos : dummy_pos,
-     _f_ = [0],
-      /*<<lexing.ml:175:14>>*/ _g_ = 1,
-     _h_ = 0,
-     _i_ = 0,
-     _j_ = 0,
-     _k_ = 0,
-     _l_ = 0,
-     _m_ = runtime.caml_ml_string_length(s),
-      /*<<lexing.ml:167:17>>*/ _n_ =
-        /*<<lexing.ml:167:17>>*/ caml_call1(Stdlib_Bytes[5], s);
-     /*<<lexing.ml:166:2>>*/ return [0,
-            function(lexbuf){
-              /*<<lexing.ml:166:33>>*/ lexbuf[9] = 1;
-             return 0;
-             /*<<lexing.ml:166:63>>*/ },
-            _n_,
-            _m_,
-            _l_,
-            _k_,
-            _j_,
-            _i_,
-            _h_,
-            _g_,
-            _f_,
-            _e_,
-            _d_];
-    /*<<lexing.ml:179:3>>*/ }
-   function set_position(lexbuf, position){
-     /*<<lexing.ml:182:2>>*/ lexbuf[12] =
-     [0, lexbuf[12][1], position[2], position[3], position[4]];
-    lexbuf[4] = position[4];
-    return 0;
-    /*<<lexing.ml:183:41>>*/ }
-   function set_filename(lexbuf, fname){
-     /*<<lexing.ml:186:2>>*/ var _c_ = lexbuf[12];
-    lexbuf[12] = [0, fname, _c_[2], _c_[3], _c_[4]];
-    return 0;
-    /*<<lexing.ml:186:65>>*/ }
-   function with_positions(lexbuf){
-     /*<<lexing.ml:188:28>>*/ return lexbuf[12] !== dummy_pos ? 1 : 0;
-    /*<<lexing.ml:188:58>>*/ }
-   function lexeme(lexbuf){
-     /*<<lexing.ml:191:2>>*/ var len = lexbuf[6] - lexbuf[5] | 0;
-     /*<<lexing.ml:192:2>>*/ return  /*<<lexing.ml:192:2>>*/ caml_call3
-            (Stdlib_Bytes[8], lexbuf[2], lexbuf[5], len);
-    /*<<lexing.ml:192:61>>*/ }
-   function sub_lexeme(lexbuf, i1, i2){
-     /*<<lexing.ml:195:2>>*/ var len = i2 - i1 | 0;
-     /*<<lexing.ml:196:2>>*/ return  /*<<lexing.ml:196:2>>*/ caml_call3
-            (Stdlib_Bytes[8], lexbuf[2], i1, len);
-    /*<<lexing.ml:196:43>>*/ }
-   function sub_lexeme_opt(lexbuf, i1, i2){
-     /*<<lexing.ml:199:2>>*/ if(0 > i1)  /*<<lexing.ml:202:11>>*/ return 0;
-    var len = i2 - i1 | 0;
-     /*<<lexing.ml:201:4>>*/ return [0,
-             /*<<lexing.ml:201:9>>*/ caml_call3
-             (Stdlib_Bytes[8], lexbuf[2], i1, len)];
-    /*<<lexing.ml:204:5>>*/ }
-   function sub_lexeme_char(lexbuf, i){
-     /*<<lexing.ml:206:31>>*/ return  /*<<lexing.ml:206:31>>*/ caml_bytes_get
-            (lexbuf[2], i);
-    /*<<lexing.ml:206:60>>*/ }
-   function sub_lexeme_char_opt(lexbuf, i){
-     /*<<lexing.ml:209:2>>*/ return 0 <= i
-            ? [0,  /*<<lexing.ml:210:9>>*/ caml_bytes_get(lexbuf[2], i)]
-            : 0;
-    /*<<lexing.ml:212:8>>*/ }
-   function lexeme_char(lexbuf, i){
-     /*<<lexing.ml:216:2>>*/ return  /*<<lexing.ml:216:2>>*/ caml_bytes_get
-            (lexbuf[2], lexbuf[5] + i | 0);
-    /*<<lexing.ml:216:56>>*/ }
-   function lexeme_start(lexbuf){
-     /*<<lexing.ml:218:26>>*/ return lexbuf[11][4];
-    /*<<lexing.ml:218:53>>*/ }
-   function lexeme_end(lexbuf){
-     /*<<lexing.ml:219:24>>*/ return lexbuf[12][4];
-    /*<<lexing.ml:219:50>>*/ }
-   function lexeme_start_p(lexbuf){
-     /*<<lexing.ml:221:28>>*/ return lexbuf[11];
-    /*<<lexing.ml:221:46>>*/ }
-   function lexeme_end_p(lexbuf){
-     /*<<lexing.ml:222:26>>*/ return lexbuf[12];
-    /*<<lexing.ml:222:43>>*/ }
-   function new_line(lexbuf){
-     /*<<lexing.ml:225:2>>*/ var
-     lcp = lexbuf[12],
-     _a_ = lcp !== dummy_pos ? 1 : 0,
-     _b_ =
-       _a_
-        ? (lexbuf[12] = [0, lcp[1], lcp[2] + 1 | 0, lcp[4], lcp[4]], 0)
-        : _a_;
-    return _b_;
-    /*<<lexing.ml:231:7>>*/ }
-   function flush_input(lb){
-     /*<<lexing.ml:238:2>>*/ lb[6] = 0;
-    lb[4] = 0;
-    var lcp = lb[12];
-    if(lcp !== dummy_pos)
-     lb[12] = [0, lcp[1], zero_pos[2], zero_pos[3], zero_pos[4]];
-    lb[3] = 0;
-    return 0;
-    /*<<lexing.ml:243:25>>*/ }
-   var
-    Stdlib_Lexing =
-      [0,
-       dummy_pos,
-       from_channel,
-       from_string,
-       from_function,
-       set_position,
-       set_filename,
-       with_positions,
-       lexeme,
-       lexeme_char,
-       lexeme_start,
-       lexeme_end,
-       lexeme_start_p,
-       lexeme_end_p,
-       new_line,
-       flush_input,
-       sub_lexeme,
-       sub_lexeme_opt,
-       sub_lexeme_char,
-       sub_lexeme_char_opt,
-       engine,
-       new_engine];
-   runtime.caml_register_global(7, Stdlib_Lexing, "Stdlib__Lexing");
-   return;
-   /*<<?>>*/ }
-  (globalThis));
-
-//# unitInfo: Provides: Stdlib__Parsing
-//# unitInfo: Requires: Stdlib, Stdlib__Array, Stdlib__Lexing, Stdlib__Obj
-(function
-  (globalThis){
-   "use strict";
-   var
-    runtime = globalThis.jsoo_runtime,
-    caml_check_bound = runtime.caml_check_bound,
-    caml_fresh_oo_id = runtime.caml_fresh_oo_id,
-    caml_make_vect = runtime.caml_make_vect,
-    caml_maybe_attach_backtrace = runtime.caml_maybe_attach_backtrace,
-    caml_wrap_exception = runtime.caml_wrap_exception;
-    /*<<?>>*/ function caml_call1(f, a0){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 1
-            ? f(a0)
-            : runtime.caml_call_gen(f, [a0]);
-   }
-    /*<<?>>*/ function caml_call4(f, a0, a1, a2, a3){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 4
-            ? f(a0, a1, a2, a3)
-            : runtime.caml_call_gen(f, [a0, a1, a2, a3]);
-   }
-    /*<<?>>*/ function caml_call5(f, a0, a1, a2, a3, a4){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 5
-            ? f(a0, a1, a2, a3, a4)
-            : runtime.caml_call_gen(f, [a0, a1, a2, a3, a4]);
-   }
-    /*<<parsing.ml:59:0>>*/ var
-    global_data = runtime.caml_get_global_data(),
-    Stdlib_Obj = global_data.Stdlib__Obj,
-    Stdlib_Array = global_data.Stdlib__Array,
-    Stdlib_Lexing = global_data.Stdlib__Lexing,
-     /*<<parsing.ml:59:0>>*/ YYexit =
-      [248, "Stdlib.Parsing.YYexit", caml_fresh_oo_id(0)],
-     /*<<parsing.ml:60:0>>*/ Parse_error =
-      [248, "Stdlib.Parsing.Parse_error", caml_fresh_oo_id(0)],
-     /*<<parsing.ml:90:2>>*/ env =
-      [0,
-        /*<<parsing.ml:90:14>>*/ caml_make_vect(100, 0),
-        /*<<parsing.ml:91:14>>*/ caml_make_vect(100, 0),
-        /*<<parsing.ml:92:23>>*/ caml_make_vect(100, Stdlib_Lexing[1]),
-        /*<<parsing.ml:93:21>>*/ caml_make_vect(100, Stdlib_Lexing[1]),
-       100,
-       0,
-       0,
-       0,
-       Stdlib_Lexing[1],
-       Stdlib_Lexing[1],
-       0,
-       0,
-       0,
-       0,
-       0,
-       0],
-    cst_syntax_error = "syntax error";
-   function grow_stacks(param){
-     /*<<parsing.ml:108:2>>*/ var
-     oldsize = env[5],
-     newsize = oldsize * 2 | 0,
-      /*<<parsing.ml:110:14>>*/ new_s =
-        /*<<parsing.ml:110:14>>*/ caml_make_vect(newsize, 0),
-      /*<<parsing.ml:111:14>>*/ new_v =
-        /*<<parsing.ml:111:14>>*/ caml_make_vect(newsize, 0),
-      /*<<parsing.ml:112:18>>*/ new_start =
-        /*<<parsing.ml:112:18>>*/ caml_make_vect(newsize, Stdlib_Lexing[1]),
-      /*<<parsing.ml:113:16>>*/ new_end =
-        /*<<parsing.ml:113:16>>*/ caml_make_vect(newsize, Stdlib_Lexing[1]);
-     /*<<parsing.ml:114:4>>*/  /*<<parsing.ml:114:4>>*/ caml_call5
-     (Stdlib_Array[8], env[1], 0, new_s, 0, oldsize);
-    env[1] = new_s;
-     /*<<parsing.ml:116:4>>*/  /*<<parsing.ml:116:4>>*/ caml_call5
-     (Stdlib_Array[8], env[2], 0, new_v, 0, oldsize);
-    env[2] = new_v;
-     /*<<parsing.ml:118:4>>*/  /*<<parsing.ml:118:4>>*/ caml_call5
-     (Stdlib_Array[8], env[3], 0, new_start, 0, oldsize);
-    env[3] = new_start;
-     /*<<parsing.ml:120:4>>*/  /*<<parsing.ml:120:4>>*/ caml_call5
-     (Stdlib_Array[8], env[4], 0, new_end, 0, oldsize);
-    env[4] = new_end;
-    env[5] = newsize;
-    return 0;
-    /*<<parsing.ml:122:28>>*/ }
-   function clear_parser(param){
-     /*<<parsing.ml:125:2>>*/  /*<<parsing.ml:125:2>>*/ caml_call4
-     (Stdlib_Array[7], env[2], 0, env[5], 0);
-    env[8] = 0;
-    return 0;
-    /*<<parsing.ml:126:25>>*/ }
-    /*<<parsing.ml:128:28>>*/  /*<<parsing.ml:128:28>>*/ var
-    current_lookahead_fun =
-      [0,
-       function(param){
-         /*<<parsing.ml:128:52>>*/ return 0;
-        /*<<parsing.ml:128:57>>*/ }];
-   function yyparse(tables, start, lexer, lexbuf){
-     /*<<parsing.ml:131:2>>*/ var
-     init_asp = env[11],
-     init_sp = env[14],
-     init_stackbase = env[6],
-     init_state = env[15],
-     init_curr_char = env[7],
-     init_lval = env[8],
-     init_errflag = env[16];
-    env[6] = env[14] + 1 | 0;
-    env[7] = start;
-    env[10] = lexbuf[12];
-     /*<<parsing.ml:164:2>>*/ try{
-     var cmd = 0, arg = 0;
-      /*<<parsing.ml:132:4>>*/ for(;;)
-      switch
-       ( /*<<parsing.ml:132:10>>*/ runtime.caml_parse_engine
-         (tables, env, cmd, arg)){
-        case 0:
-          /*<<parsing.ml:134:24>>*/  /*<<parsing.ml:134:24>>*/ var
-          arg$0 =  /*<<parsing.ml:134:24>>*/ caml_call1(lexer, lexbuf);
-         env[9] = lexbuf[11];
-         env[10] = lexbuf[12];
-         var cmd = 1, arg = arg$0;
-         break;
-        case 1:
-          /*<<parsing.ml:139:8>>*/ throw  /*<<parsing.ml:139:8>>*/ caml_maybe_attach_backtrace
-                (Parse_error, 1);
-        case 2:
-          /*<<parsing.ml:148:8>>*/ grow_stacks(0);
-         var cmd = 2, arg = 0;
-         break;
-        case 3:
-          /*<<parsing.ml:150:8>>*/ grow_stacks(0);
-         var cmd = 3, arg = 0;
-         break;
-        case 4:
-         try{
-           /*<<parsing.ml:143:39>>*/ var
-           _i_ = env[13],
-            /*<<parsing.ml:143:39>>*/ _j_ =
-              /*<<parsing.ml:143:39>>*/ caml_call1
-              (caml_check_bound(tables[1], _i_)[1 + _i_], env),
-            /*<<parsing.ml:143:39>>*/ _k_ = 4,
-           value = _j_,
-           action = _k_;
-         }
-         catch(_m_){
-          var _h_ = caml_wrap_exception(_m_);
-          if(_h_ !== Parse_error) throw caml_maybe_attach_backtrace(_h_, 0);
-          var value = 0, action = 5;
-         }
-         var cmd = action, arg = value;
-         break;
-        default:
-          /*<<parsing.ml:152:8>>*/  /*<<parsing.ml:152:8>>*/ caml_call1
-          (tables[14], cst_syntax_error);
-         var cmd = 5, arg = 0;
-      }
-    }
-    catch(exn$0){
-      /*<<parsing.ml:167:4>>*/ var
-      exn = caml_wrap_exception(exn$0),
-       /*<<parsing.ml:167:4>>*/ curr_char = env[7];
-     env[11] = init_asp;
-     env[14] = init_sp;
-     env[6] = init_stackbase;
-     env[15] = init_state;
-     env[7] = init_curr_char;
-     env[8] = init_lval;
-     env[16] = init_errflag;
-     if(exn[1] === YYexit){
-      var v = exn[2];
-       /*<<parsing.ml:177:8>>*/ return v;
-     }
-     current_lookahead_fun[1] =
-      function(tok){
-        /*<<parsing.ml:181:12>>*/ if
-        (!  /*<<parsing.ml:181:15>>*/ caml_call1(Stdlib_Obj[1], tok))
-         /*<<parsing.ml:183:17>>*/ return caml_check_bound(tables[2], tok)
-                 [1 + tok]
-                === curr_char
-                ? 1
-                : 0;
-        /*<<parsing.ml:182:38>>*/  /*<<parsing.ml:182:38>>*/ var
-        _l_ =  /*<<parsing.ml:182:38>>*/ runtime.caml_obj_tag(tok);
-        /*<<parsing.ml:182:17>>*/ return caml_check_bound(tables[3], _l_)
-                [1 + _l_]
-               === curr_char
-               ? 1
-               : 0;
-       /*<<parsing.ml:183:64>>*/ };
-      /*<<parsing.ml:184:8>>*/ throw  /*<<parsing.ml:184:8>>*/ caml_maybe_attach_backtrace
-            (exn, 0);
-    }
-    /*<<parsing.ml:184:17>>*/ }
-   function peek_val(env, n){
-     /*<<parsing.ml:187:2>>*/ var _g_ = env[11] - n | 0;
-     /*<<parsing.ml:187:12>>*/ return caml_check_bound(env[2], _g_)[1 + _g_];
-    /*<<parsing.ml:187:37>>*/ }
-   function symbol_start_pos(param){
-     /*<<parsing.ml:190:2>>*/ var i$1 = env[12], i = i$1;
-     /*<<parsing.ml:191:4>>*/ for(;;){
-     if(0 >= i){
-      var _f_ = env[11];
-       /*<<parsing.ml:191:19>>*/ return caml_check_bound(env[4], _f_)[1 + _f_];
-     }
-      /*<<parsing.ml:193:15>>*/ var
-      _d_ = (env[11] - i | 0) + 1 | 0,
-       /*<<parsing.ml:193:15>>*/ st = caml_check_bound(env[3], _d_)[1 + _d_],
-      _e_ = (env[11] - i | 0) + 1 | 0,
-       /*<<parsing.ml:194:15>>*/ en = caml_check_bound(env[4], _e_)[1 + _e_];
-      /*<<parsing.ml:195:9>>*/ if
-      ( /*<<parsing.ml:195:9>>*/ runtime.caml_notequal(st, en))
-       /*<<parsing.ml:195:23>>*/ return st;
-      /*<<parsing.ml:195:31>>*/ var
-       /*<<parsing.ml:195:31>>*/ i$0 = i - 1 | 0,
-      i = i$0;
-    }
-    /*<<parsing.ml:198:19>>*/ }
-   function symbol_end_pos(param){
-     /*<<parsing.ml:200:24>>*/ var _c_ = env[11];
-     /*<<parsing.ml:200:24>>*/ return caml_check_bound(env[4], _c_)[1 + _c_];
-    /*<<parsing.ml:200:52>>*/ }
-   function rhs_start_pos(n){
-     /*<<parsing.ml:201:22>>*/ var _b_ = env[11] - (env[12] - n | 0) | 0;
-     /*<<parsing.ml:201:22>>*/ return caml_check_bound(env[3], _b_)[1 + _b_];
-    /*<<parsing.ml:201:73>>*/ }
-   function rhs_end_pos(n){
-     /*<<parsing.ml:202:20>>*/ var _a_ = env[11] - (env[12] - n | 0) | 0;
-     /*<<parsing.ml:202:20>>*/ return caml_check_bound(env[4], _a_)[1 + _a_];
-    /*<<parsing.ml:202:69>>*/ }
-   function symbol_start(param){
-     /*<<parsing.ml:204:22>>*/ return symbol_start_pos(0)[4];
-    /*<<parsing.ml:204:52>>*/ }
-   function symbol_end(param){
-     /*<<parsing.ml:205:20>>*/ return symbol_end_pos(0)[4];
-    /*<<parsing.ml:205:48>>*/ }
-   function rhs_start(n){
-     /*<<parsing.ml:206:18>>*/ return rhs_start_pos(n)[4];
-    /*<<parsing.ml:206:44>>*/ }
-   function rhs_end(n){
-     /*<<parsing.ml:207:16>>*/ return rhs_end_pos(n)[4];
-    /*<<parsing.ml:207:40>>*/ }
-   function is_current_lookahead(tok){
-     /*<<parsing.ml:210:2>>*/ return  /*<<parsing.ml:210:2>>*/ caml_call1
-            (current_lookahead_fun[1], tok);
-    /*<<parsing.ml:210:40>>*/ }
-   function parse_error(param){
-     /*<<parsing.ml:212:31>>*/ return 0;
-    /*<<parsing.ml:212:33>>*/ }
-   var
-    Stdlib_Parsing =
-      [0,
-       symbol_start,
-       symbol_end,
-       rhs_start,
-       rhs_end,
-       symbol_start_pos,
-       symbol_end_pos,
-       rhs_start_pos,
-       rhs_end_pos,
-       clear_parser,
-       Parse_error,
-       runtime.caml_set_parser_trace,
-       YYexit,
-       yyparse,
-       peek_val,
-       is_current_lookahead,
-       parse_error];
-   runtime.caml_register_global(7, Stdlib_Parsing, "Stdlib__Parsing");
-   return;
-   /*<<?>>*/ }
-  (globalThis));
-
-//# unitInfo: Provides: Stdlib__Set
-//# unitInfo: Requires: Assert_failure, Stdlib, Stdlib__List, Stdlib__Seq
-(function
-  (globalThis){
-   "use strict";
-   var
-    runtime = globalThis.jsoo_runtime,
-    cst_Set_bal$3 = "Set.bal",
-    caml_maybe_attach_backtrace = runtime.caml_maybe_attach_backtrace;
-    /*<<?>>*/ function caml_call1(f, a0){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 1
-            ? f(a0)
-            : runtime.caml_call_gen(f, [a0]);
-   }
-    /*<<?>>*/ function caml_call2(f, a0, a1){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 2
-            ? f(a0, a1)
-            : runtime.caml_call_gen(f, [a0, a1]);
-   }
-    /*<<?>>*/ function caml_call3(f, a0, a1, a2){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 3
-            ? f(a0, a1, a2)
-            : runtime.caml_call_gen(f, [a0, a1, a2]);
-   }
-   var
-    global_data = runtime.caml_get_global_data(),
-    Stdlib = global_data.Stdlib,
-    Stdlib_Seq = global_data.Stdlib__Seq,
-    Stdlib_List = global_data.Stdlib__List,
-    Assert_failure = global_data.Assert_failure,
-    cst_Set_remove_min_elt = "Set.remove_min_elt",
-    _a_ = [0, 0, 0, 0],
-    _b_ = [0, 0, 0],
-    _c_ = [0, "set.ml", 570, 18],
-    cst_Set_bal = cst_Set_bal$3,
-    cst_Set_bal$0 = cst_Set_bal$3,
-    cst_Set_bal$1 = cst_Set_bal$3,
-    cst_Set_bal$2 = cst_Set_bal$3,
-    Stdlib_Set =
-      [0,
-       function(Ord){
-        function height(param){
-          /*<<set.ml:80:17>>*/ if(! param)  /*<<set.ml:81:17>>*/ return 0;
-         var h = param[4];
-          /*<<set.ml:82:20>>*/ return h;
-         /*<<set.ml:82:21>>*/ }
-        function create(l, v, r){
-          /*<<set.ml:90:6>>*/ if(l) var h = l[4], hl = h; else var hl = 0;
-          /*<<set.ml:91:6>>*/ if(r) var h$0 = r[4], hr = h$0; else var hr = 0;
-         var _Z_ = hr <= hl ? hl + 1 | 0 : hr + 1 | 0;
-          /*<<set.ml:92:10>>*/ return [0, l, v, r, _Z_];
-         /*<<set.ml:92:60>>*/ }
-        function bal(l, v, r){
-          /*<<set.ml:100:6>>*/ if(l) var h = l[4], hl = h; else var hl = 0;
-          /*<<set.ml:101:6>>*/ if(r)
-          var h$0 = r[4], hr = h$0;
-         else
-          var hr = 0;
-         if((hr + 2 | 0) < hl){
-          if(! l)
-            /*<<set.ml:104:19>>*/ return  /*<<set.ml:104:19>>*/ caml_call1
-                   (Stdlib[1], cst_Set_bal$0);
-           /*<<set.ml:106:28>>*/ var
-           lr = l[3],
-           lv = l[2],
-           ll = l[1],
-            /*<<set.ml:106:28>>*/ _U_ = height(lr);
-          if(_U_ <= height(ll))
-            /*<<set.ml:107:27>>*/ return create(ll, lv, create(lr, v, r));
-          if(! lr)
-            /*<<set.ml:110:25>>*/ return  /*<<set.ml:110:25>>*/ caml_call1
-                   (Stdlib[1], cst_Set_bal);
-           /*<<set.ml:112:48>>*/ var
-           lrr = lr[3],
-           lrv = lr[2],
-           lrl = lr[1],
-            /*<<set.ml:112:48>>*/ _V_ = create(lrr, v, r);
-           /*<<set.ml:112:48>>*/ return create(create(ll, lv, lrl), lrv, _V_);
-         }
-         if((hl + 2 | 0) >= hr){
-          var _Y_ = hr <= hl ? hl + 1 | 0 : hr + 1 | 0;
-           /*<<set.ml:127:12>>*/ return [0, l, v, r, _Y_];
-         }
-         if(! r)
-           /*<<set.ml:116:19>>*/ return  /*<<set.ml:116:19>>*/ caml_call1
-                  (Stdlib[1], cst_Set_bal$2);
-          /*<<set.ml:118:28>>*/ var
-          rr = r[3],
-          rv = r[2],
-          rl = r[1],
-           /*<<set.ml:118:28>>*/ _W_ = height(rl);
-         if(_W_ <= height(rr))
-           /*<<set.ml:119:14>>*/ return create(create(l, v, rl), rv, rr);
-         if(! rl)
-           /*<<set.ml:122:25>>*/ return  /*<<set.ml:122:25>>*/ caml_call1
-                  (Stdlib[1], cst_Set_bal$1);
-          /*<<set.ml:124:46>>*/ var
-          rlr = rl[3],
-          rlv = rl[2],
-          rll = rl[1],
-           /*<<set.ml:124:46>>*/ _X_ = create(rlr, rv, rr);
-          /*<<set.ml:124:46>>*/ return create(create(l, v, rll), rlv, _X_);
-         /*<<set.ml:127:62>>*/ }
-        function add(x, t){
-          /*<<?>>*/ if(! t)  /*<<set.ml:132:21>>*/ return [0, 0, x, 0, 1];
-          /*<<set.ml:134:18>>*/ var
-          r = t[3],
-          v = t[2],
-          l = t[1],
-           /*<<set.ml:134:18>>*/ c =
-             /*<<set.ml:134:18>>*/ caml_call2(Ord[1], x, v);
-          /*<<set.ml:135:10>>*/ if(0 === c)  /*<<set.ml:135:24>>*/ return t;
-         if(0 <= c){
-           /*<<set.ml:140:21>>*/  /*<<set.ml:140:21>>*/ var rr = add(x, r);
-          return r === rr ? t : bal(l, v, rr);
-         }
-          /*<<set.ml:137:21>>*/  /*<<set.ml:137:21>>*/ var ll = add(x, l);
-         return l === ll ? t : bal(ll, v, r);
-        }
-        function singleton(x){
-          /*<<set.ml:143:22>>*/ return [0, 0, x, 0, 1];
-         /*<<set.ml:143:54>>*/ }
-        function add_min_element(x, param){
-          /*<<?>>*/ if(! param)  /*<<set.ml:153:17>>*/ return singleton(x);
-         var r = param[3], v = param[2], l = param[1];
-          /*<<set.ml:155:8>>*/ return bal(add_min_element(x, l), v, r);
-        }
-        function add_max_element(x, param){
-          /*<<?>>*/ if(! param)  /*<<set.ml:158:17>>*/ return singleton(x);
-         var r = param[3], v = param[2], l = param[1];
-          /*<<set.ml:160:16>>*/ return bal(l, v, add_max_element(x, r));
-        }
-        function join(l, v, r){
-          /*<<set.ml:166:6>>*/ if(! l)
-           /*<<set.ml:167:22>>*/ return add_min_element(v, r);
-         if(! r)  /*<<set.ml:168:22>>*/ return add_max_element(v, l);
-         var
-          rh = r[4],
-          rr = r[3],
-          rv = r[2],
-          rl = r[1],
-          lh = l[4],
-          lr = l[3],
-          lv = l[2],
-          ll = l[1];
-         return (rh + 2 | 0) < lh
-                 ? bal(ll, lv, join(lr, v, r))
-                 : (lh
-                   + 2
-                   | 0)
-                   < rh
-                   ? bal(join(l, v, rl), rv, rr)
-                   : create(l, v, r);
-         /*<<set.ml:172:22>>*/ }
-        function min_elt(param){
-          /*<<set.ml:176:22>>*/ var param$0 = param;
-          /*<<set.ml:176:22>>*/ for(;;){
-          if(! param$0)
-            /*<<set.ml:177:17>>*/ throw  /*<<set.ml:177:17>>*/ caml_maybe_attach_backtrace
-                  (Stdlib[8], 1);
-          var l = param$0[1];
-          if(! l){var v = param$0[2];  /*<<set.ml:178:28>>*/ return v;}
-          var param$0 = l;
-         }
-         /*<<set.ml:179:28>>*/ }
-        function min_elt_opt(param){
-          /*<<set.ml:181:26>>*/ var param$0 = param;
-          /*<<set.ml:181:26>>*/ for(;;){
-          if(! param$0)  /*<<set.ml:182:17>>*/ return 0;
-          var l = param$0[1];
-          if(! l){var v = param$0[2];  /*<<set.ml:183:28>>*/ return [0, v];}
-          var param$0 = l;
-         }
-         /*<<set.ml:184:32>>*/ }
-        function max_elt(param){
-          /*<<set.ml:186:22>>*/ var param$0 = param;
-          /*<<set.ml:186:22>>*/ for(;;){
-          if(! param$0)
-            /*<<set.ml:187:17>>*/ throw  /*<<set.ml:187:17>>*/ caml_maybe_attach_backtrace
-                  (Stdlib[8], 1);
-          if(! param$0[3]){
-           var v = param$0[2];
-            /*<<set.ml:188:28>>*/ return v;
-          }
-          var r = param$0[3], param$0 = r;
-         }
-         /*<<set.ml:189:28>>*/ }
-        function max_elt_opt(param){
-          /*<<set.ml:191:26>>*/ var param$0 = param;
-          /*<<set.ml:191:26>>*/ for(;;){
-          if(! param$0)  /*<<set.ml:192:17>>*/ return 0;
-          if(! param$0[3]){
-           var v = param$0[2];
-            /*<<set.ml:193:28>>*/ return [0, v];
-          }
-          var r = param$0[3], param$0 = r;
-         }
-         /*<<set.ml:194:32>>*/ }
-        function remove_min_elt(param){
-          /*<<set.ml:198:29>>*/ if(! param)
-           /*<<set.ml:199:17>>*/ return  /*<<set.ml:199:17>>*/ caml_call1
-                  (Stdlib[1], cst_Set_remove_min_elt);
-         var l = param[1];
-         if(l){
-          var r = param[3], v = param[2];
-           /*<<set.ml:201:25>>*/ return bal(remove_min_elt(l), v, r);
-         }
-         var r$0 = param[3];
-          /*<<set.ml:200:28>>*/ return r$0;
-         /*<<set.ml:201:51>>*/ }
-        function concat(t1, t2){
-          /*<<set.ml:218:6>>*/ if(! t1)  /*<<set.ml:219:22>>*/ return t2;
-         if(! t2)  /*<<set.ml:220:22>>*/ return t1;
-          /*<<set.ml:221:39>>*/  /*<<set.ml:221:39>>*/ var
-          _T_ = remove_min_elt(t2);
-          /*<<set.ml:221:39>>*/ return join(t1, min_elt(t2), _T_);
-         /*<<set.ml:221:58>>*/ }
-        function split(x, param){
-          /*<<?>>*/ if(! param)  /*<<set.ml:231:10>>*/ return _a_;
-          /*<<set.ml:233:18>>*/ var
-          r = param[3],
-          v = param[2],
-          l = param[1],
-           /*<<set.ml:233:18>>*/ c =
-             /*<<set.ml:233:18>>*/ caml_call2(Ord[1], x, v);
-          /*<<set.ml:234:10>>*/ if(0 === c)
-           /*<<set.ml:234:24>>*/ return [0, l, 1, r];
-         if(0 <= c){
-           /*<<set.ml:238:33>>*/ var
-            /*<<set.ml:238:33>>*/ match = split(x, r),
-           rr = match[3],
-           pres = match[2],
-           lr = match[1];
-           /*<<set.ml:238:46>>*/ return [0, join(l, v, lr), pres, rr];
-         }
-          /*<<set.ml:236:33>>*/ var
-           /*<<set.ml:236:33>>*/ match$0 = split(x, l),
-          rl = match$0[3],
-          pres$0 = match$0[2],
-          ll = match$0[1];
-          /*<<set.ml:236:46>>*/ return [0, ll, pres$0, join(rl, v, r)];
-        }
-        var empty = 0;
-        function is_empty(param){
-          /*<<set.ml:244:19>>*/ return param ? 0 : 1;
-         /*<<set.ml:244:54>>*/ }
-        function mem(x, param){
-         var param$0 = param;
-         for(;;){
-          if(! param$0)  /*<<set.ml:247:17>>*/ return 0;
-           /*<<set.ml:249:18>>*/ var
-           r = param$0[3],
-           v = param$0[2],
-           l = param$0[1],
-            /*<<set.ml:249:18>>*/ c =
-              /*<<set.ml:249:18>>*/ caml_call2(Ord[1], x, v),
-           _S_ = 0 === c ? 1 : 0;
-          if(_S_) return _S_;
-          var r$0 = 0 <= c ? r : l, param$0 = r$0;
-         }
-        }
-        function remove(x, t){
-          /*<<?>>*/ if(! t)  /*<<set.ml:253:17>>*/ return 0;
-          /*<<set.ml:255:18>>*/ var
-          t2 = t[3],
-          v = t[2],
-          t1 = t[1],
-           /*<<set.ml:255:18>>*/ c =
-             /*<<set.ml:255:18>>*/ caml_call2(Ord[1], x, v);
-          /*<<set.ml:256:10>>*/ if(0 === c){
-          if(! t1)  /*<<set.ml:209:22>>*/ return t2;
-          if(! t2)  /*<<set.ml:210:22>>*/ return t1;
-           /*<<set.ml:211:38>>*/  /*<<set.ml:211:38>>*/ var
-           _R_ = remove_min_elt(t2);
-           /*<<set.ml:211:38>>*/ return bal(t1, min_elt(t2), _R_);
-         }
-         if(0 <= c){
-           /*<<set.ml:263:23>>*/  /*<<set.ml:263:23>>*/ var
-           rr = remove(x, t2);
-          return t2 === rr ? t : bal(t1, v, rr);
-         }
-          /*<<set.ml:259:23>>*/  /*<<set.ml:259:23>>*/ var ll = remove(x, t1);
-         return t1 === ll ? t : bal(ll, v, t2);
-        }
-        function union(s1, s2){
-          /*<<set.ml:268:6>>*/ if(! s1)  /*<<set.ml:269:23>>*/ return s2;
-         if(! s2)  /*<<set.ml:270:23>>*/ return s1;
-         var
-          h2 = s2[4],
-          r2 = s2[3],
-          v2 = s2[2],
-          l2 = s2[1],
-          h1 = s1[4],
-          r1 = s1[3],
-          v1 = s1[2],
-          l1 = s1[1];
-         if(h2 <= h1){
-          if(1 === h2)  /*<<set.ml:273:27>>*/ return add(v2, s1);
-           /*<<set.ml:274:32>>*/ var
-            /*<<set.ml:274:32>>*/ match = split(v1, s2),
-           r2$0 = match[3],
-           l2$0 = match[1],
-            /*<<set.ml:275:36>>*/ _P_ = union(r1, r2$0);
-           /*<<set.ml:275:36>>*/ return join(union(l1, l2$0), v1, _P_);
-         }
-         if(1 === h1)  /*<<set.ml:278:27>>*/ return add(v1, s2);
-          /*<<set.ml:279:32>>*/ var
-           /*<<set.ml:279:32>>*/ match$0 = split(v2, s1),
-          r1$0 = match$0[3],
-          l1$0 = match$0[1],
-           /*<<set.ml:280:36>>*/ _Q_ = union(r1$0, r2);
-          /*<<set.ml:280:36>>*/ return join(union(l1$0, l2), v2, _Q_);
-         /*<<set.ml:281:15>>*/ }
-        function inter(s1, s2){
-          /*<<set.ml:284:6>>*/ if(! s1)  /*<<set.ml:285:22>>*/ return 0;
-         if(! s2)  /*<<set.ml:286:22>>*/ return 0;
-          /*<<set.ml:288:16>>*/ var
-          r1 = s1[3],
-          v1 = s1[2],
-          l1 = s1[1],
-           /*<<set.ml:288:16>>*/ _M_ = split(v1, s2),
-          l2 = _M_[1];
-         if(_M_[2]){
-           /*<<set.ml:292:36>>*/ var
-           r2 = _M_[3],
-            /*<<set.ml:292:36>>*/ _N_ = inter(r1, r2);
-           /*<<set.ml:292:36>>*/ return join(inter(l1, l2), v1, _N_);
-         }
-          /*<<set.ml:290:35>>*/ var
-          r2$0 = _M_[3],
-           /*<<set.ml:290:35>>*/ _O_ = inter(r1, r2$0);
-          /*<<set.ml:290:35>>*/ return concat(inter(l1, l2), _O_);
-         /*<<set.ml:292:49>>*/ }
-        function split_bis(x, param){
-          /*<<?>>*/ if(! param)
-           /*<<set.ml:304:10>>*/ return [0,
-                  0,
-                  function(param){
-                    /*<<set.ml:304:38>>*/ return 0;
-                   /*<<set.ml:304:43>>*/ }];
-          /*<<set.ml:306:18>>*/ var
-          r = param[3],
-          v = param[2],
-          l = param[1],
-           /*<<set.ml:306:18>>*/ c =
-             /*<<set.ml:306:18>>*/ caml_call2(Ord[1], x, v);
-          /*<<set.ml:307:10>>*/ if(0 === c)  /*<<set.ml:307:24>>*/ return 0;
-         if(0 <= c){
-           /*<<set.ml:313:18>>*/  /*<<set.ml:313:18>>*/ var
-           match = split_bis(x, r);
-          if(! match)  /*<<set.ml:314:23>>*/ return 0;
-          var rr = match[2], lr = match[1];
-           /*<<set.ml:315:35>>*/ return [0, join(l, v, lr), rr];
-         }
-          /*<<set.ml:309:18>>*/  /*<<set.ml:309:18>>*/ var
-          match$0 = split_bis(x, l);
-         if(! match$0)  /*<<set.ml:310:23>>*/ return 0;
-         var rl = match$0[2], ll = match$0[1];
-          /*<<set.ml:311:35>>*/ return [0,
-                 ll,
-                 function(param){
-                   /*<<set.ml:311:60>>*/ return join(rl(0), v, r);
-                  /*<<set.ml:311:76>>*/ }];
-        }
-        function disjoint(s1, s2){
-          /*<<set.ml:318:6>>*/ var s1$0 = s1, s2$0 = s2;
-          /*<<set.ml:318:6>>*/ for(;;){
-          if(s1$0 && s2$0){
-           var r1 = s1$0[3], v1 = s1$0[2], l1 = s1$0[1];
-           if(s1$0 === s2$0)  /*<<set.ml:321:27>>*/ return 0;
-            /*<<set.ml:322:21>>*/  /*<<set.ml:322:21>>*/ var
-            match = split_bis(v1, s2$0);
-           if(! match)  /*<<set.ml:324:23>>*/ return 0;
-            /*<<set.ml:323:34>>*/ var
-            r2 = match[2],
-            l2 = match[1],
-             /*<<set.ml:323:34>>*/ _L_ = disjoint(l1, l2);
-            /*<<set.ml:323:34>>*/ if(! _L_)  /*<<set.ml:323:34>>*/ return _L_;
-            /*<<set.ml:323:64>>*/ var
-             /*<<set.ml:323:64>>*/ s2$1 = r2(0),
-            s1$0 = r1,
-            s2$0 = s2$1;
-           continue;
-          }
-           /*<<set.ml:319:35>>*/ return 1;
-         }
-         /*<<set.ml:324:28>>*/ }
-        function diff(s1, s2){
-          /*<<set.ml:327:6>>*/ if(! s1)  /*<<set.ml:328:22>>*/ return 0;
-         if(! s2)  /*<<set.ml:329:23>>*/ return s1;
-          /*<<set.ml:331:16>>*/ var
-          r1 = s1[3],
-          v1 = s1[2],
-          l1 = s1[1],
-           /*<<set.ml:331:16>>*/ _I_ = split(v1, s2),
-          l2 = _I_[1];
-         if(_I_[2]){
-           /*<<set.ml:335:34>>*/ var
-           r2 = _I_[3],
-            /*<<set.ml:335:34>>*/ _J_ = diff(r1, r2);
-           /*<<set.ml:335:34>>*/ return concat(diff(l1, l2), _J_);
-         }
-          /*<<set.ml:333:35>>*/ var
-          r2$0 = _I_[3],
-           /*<<set.ml:333:35>>*/ _K_ = diff(r1, r2$0);
-          /*<<set.ml:333:35>>*/ return join(diff(l1, l2), v1, _K_);
-         /*<<set.ml:335:46>>*/ }
-        function cons_enum(s, e){
-          /*<<set.ml:340:6>>*/ var s$0 = s, e$0 = e;
-          /*<<set.ml:340:6>>*/ for(;;){
-          if(! s$0)  /*<<set.ml:341:17>>*/ return e$0;
-           /*<<set.ml:342:37>>*/ var
-           r = s$0[3],
-           v = s$0[2],
-           l = s$0[1],
-            /*<<set.ml:342:37>>*/ e$1 = [0, v, r, e$0],
-           s$0 = l,
-           e$0 = e$1;
-         }
-         /*<<set.ml:342:52>>*/ }
-        function compare(s1, s2){
-          /*<<set.ml:356:6>>*/ var
-           /*<<set.ml:356:37>>*/ e2$2 = cons_enum(s2, 0),
-           /*<<set.ml:356:18>>*/ e1$2 = cons_enum(s1, 0),
-          e1 = e1$2,
-          e2 = e2$2;
-          /*<<set.ml:345:8>>*/ for(;;){
-          if(! e1) return e2 ? -1 : 0;
-          if(! e2)  /*<<set.ml:348:20>>*/ return 1;
-           /*<<set.ml:350:18>>*/ var
-           e2$0 = e2[3],
-           r2 = e2[2],
-           v2 = e2[1],
-           e1$0 = e1[3],
-           r1 = e1[2],
-           v1 = e1[1],
-            /*<<set.ml:350:18>>*/ c =
-              /*<<set.ml:350:18>>*/ caml_call2(Ord[1], v1, v2);
-           /*<<set.ml:351:10>>*/ if(0 !== c)  /*<<set.ml:352:15>>*/ return c;
-           /*<<set.ml:353:45>>*/ var
-            /*<<set.ml:353:45>>*/ e2$1 = cons_enum(r2, e2$0),
-            /*<<set.ml:353:27>>*/ e1$1 = cons_enum(r1, e1$0),
-           e1 = e1$1,
-           e2 = e2$1;
-         }
-         /*<<set.ml:356:55>>*/ }
-        function equal(s1, s2){
-          /*<<set.ml:359:6>>*/ return 0 === compare(s1, s2) ? 1 : 0;
-         /*<<set.ml:359:23>>*/ }
-        function subset(s1, s2){
-          /*<<set.ml:362:6>>*/ var s1$0 = s1, s2$0 = s2;
-          /*<<set.ml:362:6>>*/ for(;;){
-          if(! s1$0)  /*<<set.ml:364:10>>*/ return 1;
-          if(! s2$0)  /*<<set.ml:366:10>>*/ return 0;
-           /*<<set.ml:368:18>>*/ var
-           r2 = s2$0[3],
-           v2 = s2$0[2],
-           l2 = s2$0[1],
-           r1 = s1$0[3],
-           v1 = s1$0[2],
-           l1 = s1$0[1],
-            /*<<set.ml:368:18>>*/ c =
-              /*<<set.ml:368:18>>*/ caml_call2(Ord[1], v1, v2);
-           /*<<set.ml:369:10>>*/ if(0 === c){
-            /*<<set.ml:370:12>>*/  /*<<set.ml:370:12>>*/ var
-            _F_ = subset(l1, l2);
-            /*<<set.ml:370:12>>*/ if(! _F_)  /*<<set.ml:370:12>>*/ return _F_;
-           var s1$0 = r1, s2$0 = r2;
-          }
-          else if(0 <= c){
-            /*<<set.ml:374:12>>*/  /*<<set.ml:374:12>>*/ var
-            _G_ = subset([0, 0, v1, r1, 0], r2);
-            /*<<set.ml:374:12>>*/ if(! _G_)  /*<<set.ml:374:12>>*/ return _G_;
-           var s1$0 = l1;
-          }
-          else{
-            /*<<set.ml:372:12>>*/  /*<<set.ml:372:12>>*/ var
-            _H_ = subset([0, l1, v1, 0, 0], l2);
-            /*<<set.ml:372:12>>*/ if(! _H_)  /*<<set.ml:372:12>>*/ return _H_;
-           var s1$0 = r1;
-          }
-         }
-         /*<<set.ml:374:71>>*/ }
-        function iter(f, param){
-         var param$0 = param;
-         for(;;){
-          if(! param$0)  /*<<set.ml:377:17>>*/ return 0;
-          var r = param$0[3], v = param$0[2], l = param$0[1];
-           /*<<set.ml:378:25>>*/ iter(f, l);
-           /*<<set.ml:378:35>>*/  /*<<set.ml:378:35>>*/ caml_call1(f, v);
-          var param$0 = r;
-         }
-        }
-        function fold(f, s, accu){
-          /*<<set.ml:381:6>>*/ var s$0 = s, accu$0 = accu;
-          /*<<set.ml:381:6>>*/ for(;;){
-          if(! s$0)  /*<<set.ml:382:17>>*/ return accu$0;
-           /*<<set.ml:383:34>>*/ var
-           r = s$0[3],
-           v = s$0[2],
-           l = s$0[1],
-            /*<<set.ml:383:34>>*/ accu$1 =
-              /*<<set.ml:383:34>>*/ caml_call2(f, v, fold(f, l, accu$0)),
-           s$0 = r,
-           accu$0 = accu$1;
-         }
-         /*<<set.ml:383:55>>*/ }
-        function for_all(p, param){
-         var param$0 = param;
-         for(;;){
-          if(! param$0)  /*<<set.ml:386:17>>*/ return 1;
-           /*<<set.ml:387:25>>*/ var
-           r = param$0[3],
-           v = param$0[2],
-           l = param$0[1],
-            /*<<set.ml:387:25>>*/ _C_ =
-              /*<<set.ml:387:25>>*/ caml_call1(p, v);
-           /*<<set.ml:387:25>>*/ if(_C_){
-            /*<<set.ml:387:32>>*/  /*<<set.ml:387:32>>*/ var
-            _D_ = for_all(p, l);
-            /*<<set.ml:387:32>>*/ if(_D_){var param$0 = r; continue;}
-           var _E_ = _D_;
-          }
-          else
-           var _E_ = _C_;
-           /*<<set.ml:387:32>>*/ return _E_;
-         }
-        }
-        function exists(p, param){
-         var param$0 = param;
-         for(;;){
-          if(! param$0)  /*<<set.ml:390:17>>*/ return 0;
-           /*<<set.ml:391:25>>*/ var
-           r = param$0[3],
-           v = param$0[2],
-           l = param$0[1],
-            /*<<set.ml:391:25>>*/ _z_ =
-              /*<<set.ml:391:25>>*/ caml_call1(p, v);
-           /*<<set.ml:391:25>>*/ if(_z_)
-           var _A_ = _z_;
-          else{
-            /*<<set.ml:391:32>>*/  /*<<set.ml:391:32>>*/ var
-            _B_ = exists(p, l);
-            /*<<set.ml:391:32>>*/ if(! _B_){var param$0 = r; continue;}
-           var _A_ = _B_;
-          }
-           /*<<set.ml:391:25>>*/ return _A_;
-         }
-        }
-        function filter(p, t){
-          /*<<?>>*/ if(! t)  /*<<set.ml:394:17>>*/ return 0;
-          /*<<set.ml:397:19>>*/ var
-          r = t[3],
-          v = t[2],
-          l = t[1],
-           /*<<set.ml:397:19>>*/ l$0 = filter(p, l),
-           /*<<set.ml:398:19>>*/ pv =  /*<<set.ml:398:19>>*/ caml_call1(p, v),
-           /*<<set.ml:399:19>>*/ r$0 = filter(p, r);
-          /*<<set.ml:400:10>>*/ if(! pv)
-           /*<<set.ml:402:15>>*/ return concat(l$0, r$0);
-         if(l === l$0 && r === r$0)  /*<<set.ml:401:35>>*/ return t;
-          /*<<set.ml:401:42>>*/ return join(l$0, v, r$0);
-        }
-        function partition(p, param){
-          /*<<?>>*/ if(! param)  /*<<set.ml:405:17>>*/ return _b_;
-          /*<<set.ml:408:25>>*/ var
-          r = param[3],
-          v = param[2],
-          l = param[1],
-           /*<<set.ml:408:25>>*/ match = partition(p, l),
-          lf = match[2],
-          lt = match[1],
-           /*<<set.ml:409:19>>*/ pv =  /*<<set.ml:409:19>>*/ caml_call1(p, v),
-           /*<<set.ml:410:25>>*/ match$0 = partition(p, r),
-          rf = match$0[2],
-          rt = match$0[1];
-          /*<<set.ml:411:10>>*/ if(pv){
-           /*<<set.ml:412:30>>*/  /*<<set.ml:412:30>>*/ var
-           _x_ = concat(lf, rf);
-           /*<<set.ml:412:15>>*/ return [0, join(lt, v, rt), _x_];
-         }
-          /*<<set.ml:413:30>>*/  /*<<set.ml:413:30>>*/ var
-          _y_ = join(lf, v, rf);
-          /*<<set.ml:413:15>>*/ return [0, concat(lt, rt), _y_];
-        }
-        function cardinal(param){
-          /*<<set.ml:415:23>>*/ if(! param)  /*<<set.ml:416:17>>*/ return 0;
-          /*<<set.ml:417:39>>*/ var
-          r = param[3],
-          l = param[1],
-           /*<<set.ml:417:39>>*/ _w_ = cardinal(r);
-         return (cardinal(l) + 1 | 0) + _w_ | 0;
-         /*<<set.ml:417:49>>*/ }
-        function elements_aux(accu, param){
-         var accu$0 = accu, param$0 = param;
-         for(;;){
-          if(! param$0)  /*<<set.ml:420:17>>*/ return accu$0;
-           /*<<set.ml:421:38>>*/ var
-           r = param$0[3],
-           v = param$0[2],
-           l = param$0[1],
-            /*<<set.ml:421:38>>*/ accu$1 = [0, v, elements_aux(accu$0, r)],
-           accu$0 = accu$1,
-           param$0 = l;
-         }
-        }
-        function elements(s){
-          /*<<set.ml:424:6>>*/ return elements_aux(0, s);
-         /*<<set.ml:424:23>>*/ }
-        function find(x, param){
-         var param$0 = param;
-         for(;;){
-          if(! param$0)
-            /*<<set.ml:431:17>>*/ throw  /*<<set.ml:431:17>>*/ caml_maybe_attach_backtrace
-                  (Stdlib[8], 1);
-           /*<<set.ml:433:18>>*/ var
-           r = param$0[3],
-           v = param$0[2],
-           l = param$0[1],
-            /*<<set.ml:433:18>>*/ c =
-              /*<<set.ml:433:18>>*/ caml_call2(Ord[1], x, v);
-           /*<<set.ml:434:10>>*/ if(0 === c)  /*<<set.ml:434:24>>*/ return v;
-          var r$0 = 0 <= c ? r : l, param$0 = r$0;
-         }
-        }
-        function find_first(f, param$0){
-         var param$1 = param$0;
-         for(;;){
-          if(! param$1)
-            /*<<set.ml:448:10>>*/ throw  /*<<set.ml:448:10>>*/ caml_maybe_attach_backtrace
-                  (Stdlib[8], 1);
-          var r$0 = param$1[3], v0$1 = param$1[2], l$0 = param$1[1];
-           /*<<set.ml:450:13>>*/ if
-           ( /*<<set.ml:450:13>>*/ caml_call1(f, v0$1)){
-           var v0 = v0$1, param = l$0;
-           for(;;){
-            if(! param)  /*<<set.ml:439:10>>*/ return v0;
-            var r = param[3], v0$0 = param[2], l = param[1];
-             /*<<set.ml:441:13>>*/ if
-             ( /*<<set.ml:441:13>>*/ caml_call1(f, v0$0))
-             var v0 = v0$0, param = l;
-            else
-             var param = r;
-           }
-          }
-          else
-           var param$1 = r$0;
-         }
-        }
-        function find_first_opt(f, param$0){
-         var param$1 = param$0;
-         for(;;){
-          if(! param$1)  /*<<set.ml:466:10>>*/ return 0;
-          var r$0 = param$1[3], v0$1 = param$1[2], l$0 = param$1[1];
-           /*<<set.ml:468:13>>*/ if
-           ( /*<<set.ml:468:13>>*/ caml_call1(f, v0$1)){
-           var v0 = v0$1, param = l$0;
-           for(;;){
-            if(! param)  /*<<set.ml:457:10>>*/ return [0, v0];
-            var r = param[3], v0$0 = param[2], l = param[1];
-             /*<<set.ml:459:13>>*/ if
-             ( /*<<set.ml:459:13>>*/ caml_call1(f, v0$0))
-             var v0 = v0$0, param = l;
-            else
-             var param = r;
-           }
-          }
-          else
-           var param$1 = r$0;
-         }
-        }
-        function find_last(f, param$0){
-         var param$1 = param$0;
-         for(;;){
-          if(! param$1)
-            /*<<set.ml:484:10>>*/ throw  /*<<set.ml:484:10>>*/ caml_maybe_attach_backtrace
-                  (Stdlib[8], 1);
-          var r$0 = param$1[3], v0$1 = param$1[2], l$0 = param$1[1];
-           /*<<set.ml:486:13>>*/ if
-           ( /*<<set.ml:486:13>>*/ caml_call1(f, v0$1)){
-           var v0 = v0$1, param = r$0;
-           for(;;){
-            if(! param)  /*<<set.ml:475:10>>*/ return v0;
-            var r = param[3], v0$0 = param[2], l = param[1];
-             /*<<set.ml:477:13>>*/ if
-             ( /*<<set.ml:477:13>>*/ caml_call1(f, v0$0))
-             var v0 = v0$0, param = r;
-            else
-             var param = l;
-           }
-          }
-          else
-           var param$1 = l$0;
-         }
-        }
-        function find_last_opt(f, param$0){
-         var param$1 = param$0;
-         for(;;){
-          if(! param$1)  /*<<set.ml:502:10>>*/ return 0;
-          var r$0 = param$1[3], v0$1 = param$1[2], l$0 = param$1[1];
-           /*<<set.ml:504:13>>*/ if
-           ( /*<<set.ml:504:13>>*/ caml_call1(f, v0$1)){
-           var v0 = v0$1, param = r$0;
-           for(;;){
-            if(! param)  /*<<set.ml:493:10>>*/ return [0, v0];
-            var r = param[3], v0$0 = param[2], l = param[1];
-             /*<<set.ml:495:13>>*/ if
-             ( /*<<set.ml:495:13>>*/ caml_call1(f, v0$0))
-             var v0 = v0$0, param = r;
-            else
-             var param = l;
-           }
-          }
-          else
-           var param$1 = l$0;
-         }
-        }
-        function find_opt(x, param){
-         var param$0 = param;
-         for(;;){
-          if(! param$0)  /*<<set.ml:510:17>>*/ return 0;
-           /*<<set.ml:512:18>>*/ var
-           r = param$0[3],
-           v = param$0[2],
-           l = param$0[1],
-            /*<<set.ml:512:18>>*/ c =
-              /*<<set.ml:512:18>>*/ caml_call2(Ord[1], x, v);
-           /*<<set.ml:513:10>>*/ if(0 === c)
-            /*<<set.ml:513:24>>*/ return [0, v];
-          var r$0 = 0 <= c ? r : l, param$0 = r$0;
-         }
-        }
-        function try_join(l, v, r){
-          /*<<set.ml:520:6>>*/ a:
-         {
-          if(0 !== l){
-            /*<<set.ml:520:35>>*/  /*<<set.ml:520:35>>*/ var _v_ = max_elt(l);
-            /*<<set.ml:520:23>>*/ if
-            (0 <=  /*<<set.ml:520:23>>*/ caml_call2(Ord[1], _v_, v))
-            break a;
-          }
-          if(0 !== r){
-            /*<<set.ml:521:37>>*/  /*<<set.ml:521:37>>*/ var _u_ = min_elt(r);
-            /*<<set.ml:521:23>>*/ if
-            (0 <=  /*<<set.ml:521:23>>*/ caml_call2(Ord[1], v, _u_))
-            break a;
-          }
-           /*<<set.ml:522:11>>*/ return join(l, v, r);
-         }
-          /*<<set.ml:523:19>>*/ return union(l, add(v, r));
-         /*<<set.ml:523:28>>*/ }
-        function map(f, t){
-          /*<<?>>*/ if(! t)  /*<<set.ml:526:17>>*/ return 0;
-          /*<<set.ml:529:18>>*/ var
-          r = t[3],
-          v = t[2],
-          l = t[1],
-           /*<<set.ml:529:18>>*/ l$0 = map(f, l),
-           /*<<set.ml:530:18>>*/ v$0 =  /*<<set.ml:530:18>>*/ caml_call1(f, v),
-           /*<<set.ml:531:18>>*/ r$0 = map(f, r);
-         if(l === l$0 && v === v$0 && r === r$0)
-           /*<<set.ml:532:47>>*/ return t;
-          /*<<set.ml:533:14>>*/ return try_join(l$0, v$0, r$0);
-        }
-        function filter_map(f, t){
-          /*<<?>>*/ if(! t)  /*<<set.ml:542:17>>*/ return 0;
-          /*<<set.ml:545:18>>*/ var
-          r = t[3],
-          v = t[2],
-          l = t[1],
-           /*<<set.ml:545:18>>*/ t1 = filter_map(f, l),
-           /*<<set.ml:546:18>>*/ v$0 =  /*<<set.ml:546:18>>*/ caml_call1(f, v),
-           /*<<set.ml:547:18>>*/ t2 = filter_map(f, r);
-          /*<<set.ml:548:9>>*/ if(v$0){
-          var v$1 = v$0[1];
-          if(l === t1 && v === v$1 && r === t2)
-            /*<<set.ml:550:52>>*/ return t;
-           /*<<set.ml:551:19>>*/ return try_join(t1, v$1, t2);
-         }
-         if(! t1)  /*<<set.ml:537:22>>*/ return t2;
-         if(! t2)  /*<<set.ml:538:22>>*/ return t1;
-          /*<<set.ml:539:43>>*/  /*<<set.ml:539:43>>*/ var
-          _t_ = remove_min_elt(t2);
-          /*<<set.ml:539:43>>*/ return try_join(t1, min_elt(t2), _t_);
-        }
-        function of_list(l){
-          /*<<set.ml:578:6>>*/ if(! l) return empty;
-         var _o_ = l[2], x0 = l[1];
-         if(! _o_)  /*<<set.ml:580:16>>*/ return singleton(x0);
-         var _p_ = _o_[2], x1 = _o_[1];
-         if(! _p_)  /*<<set.ml:581:27>>*/ return add(x1, singleton(x0));
-         var _q_ = _p_[2], x2 = _p_[1];
-         if(! _q_)
-           /*<<set.ml:582:31>>*/ return add(x2, add(x1, singleton(x0)));
-         var _r_ = _q_[2], x3 = _q_[1];
-         if(! _r_)
-           /*<<set.ml:583:35>>*/ return add
-                  (x3, add(x2, add(x1, singleton(x0))));
-         if(_r_[2]){
-           /*<<set.ml:585:28>>*/ var
-            /*<<set.ml:585:28>>*/ l$0 =
-              /*<<set.ml:585:28>>*/ caml_call2(Stdlib_List[59], Ord[1], l),
-           sub =
-             function(n, l){
-               /*<<set.ml:558:8>>*/ if(3 >= n >>> 0)
-               switch(n){
-                 case 0:
-                   /*<<set.ml:559:18>>*/ return [0, 0, l];
-                 case 1:
-                  if(l){
-                   var l$3 = l[2], x0 = l[1];
-                    /*<<set.ml:560:24>>*/ return [0, [0, 0, x0, 0, 1], l$3];
-                  }
-                  break;
-                 case 2:
-                  if(l){
-                   var match$1 = l[2];
-                   if(match$1){
-                    var l$4 = match$1[2], x1 = match$1[1], x0$0 = l[1];
-                     /*<<set.ml:562:12>>*/ return [0,
-                            [0, [0, 0, x0$0, 0, 1], x1, 0, 2],
-                            l$4];
-                   }
-                  }
-                  break;
-                 default:
-                  if(l){
-                   var _s_ = l[2];
-                   if(_s_){
-                    var match$2 = _s_[2];
-                    if(match$2){
-                     var
-                      l$5 = match$2[2],
-                      x2 = match$2[1],
-                      x1$0 = _s_[1],
-                      x0$1 = l[1];
-                      /*<<set.ml:564:12>>*/ return [0,
-                             [0, [0, 0, x0$1, 0, 1], x1$0, [0, 0, x2, 0, 1], 2],
-                             l$5];
-                    }
-                   }
-                  }
-               }
-               /*<<set.ml:568:24>>*/ var
-               nl = n / 2 | 0,
-                /*<<set.ml:568:24>>*/ match = sub(nl, l),
-               l$0 = match[2],
-               left = match[1];
-               /*<<set.ml:569:10>>*/ if(! l$0)
-                /*<<set.ml:570:18>>*/ throw  /*<<set.ml:570:18>>*/ caml_maybe_attach_backtrace
-                      ([0, Assert_failure, _c_], 1);
-               /*<<set.ml:572:27>>*/ var
-               l$1 = l$0[2],
-               mid = l$0[1],
-                /*<<set.ml:572:27>>*/ match$0 = sub((n - nl | 0) - 1 | 0, l$1),
-               l$2 = match$0[2],
-               right = match$0[1];
-               /*<<set.ml:573:12>>*/ return [0, create(left, mid, right), l$2];
-              /*<<set.ml:573:36>>*/ };
-           /*<<set.ml:575:10>>*/ return sub
-                   ( /*<<set.ml:575:15>>*/ caml_call1(Stdlib_List[1], l$0),
-                    l$0)
-                  [1];
-         }
-         var x4 = _r_[1];
-          /*<<set.ml:584:39>>*/ return add
-                 (x4, add(x3, add(x2, add(x1, singleton(x0)))));
-         /*<<set.ml:585:58>>*/ }
-        function add_seq(i, m){
-         function _n_(s, x){
-           /*<<set.ml:588:32>>*/ return add(x, s);
-          /*<<set.ml:588:39>>*/ }
-          /*<<set.ml:588:6>>*/ return  /*<<set.ml:588:6>>*/ caml_call3
-                 (Stdlib_Seq[5], _n_, m, i);
-         /*<<set.ml:588:44>>*/ }
-        function of_seq(i){
-          /*<<set.ml:590:19>>*/ return add_seq(i, empty);
-         /*<<set.ml:590:34>>*/ }
-        function seq_of_enum(c, param){
-          /*<<set.ml:592:32>>*/ if(! c)  /*<<set.ml:593:15>>*/ return 0;
-          /*<<set.ml:594:55>>*/ var
-          rest = c[3],
-          t = c[2],
-          x = c[1],
-           /*<<set.ml:594:55>>*/ _l_ = cons_enum(t, rest);
-          /*<<set.ml:594:29>>*/ return [0,
-                 x,
-                 function(_m_){ /*<<?>>*/ return seq_of_enum(_l_, _m_);}];
-         /*<<set.ml:594:74>>*/ }
-        function to_seq(c){
-          /*<<set.ml:596:19>>*/  /*<<set.ml:596:32>>*/ var
-          _j_ = cons_enum(c, 0);
-          /*<<set.ml:596:32>>*/ return function(_k_){
-           /*<<?>>*/ return seq_of_enum(_j_, _k_);};
-         /*<<set.ml:596:49>>*/ }
-        function snoc_enum(s, e){
-          /*<<set.ml:599:6>>*/ var s$0 = s, e$0 = e;
-          /*<<set.ml:599:6>>*/ for(;;){
-          if(! s$0)  /*<<set.ml:600:17>>*/ return e$0;
-           /*<<set.ml:601:37>>*/ var
-           r = s$0[3],
-           v = s$0[2],
-           l = s$0[1],
-            /*<<set.ml:601:37>>*/ e$1 = [0, v, l, e$0],
-           s$0 = r,
-           e$0 = e$1;
-         }
-         /*<<set.ml:601:52>>*/ }
-        function rev_seq_of_enum(c, param){
-          /*<<set.ml:603:36>>*/ if(! c)  /*<<set.ml:604:15>>*/ return 0;
-          /*<<set.ml:605:59>>*/ var
-          rest = c[3],
-          t = c[2],
-          x = c[1],
-           /*<<set.ml:605:59>>*/ _h_ = snoc_enum(t, rest);
-          /*<<set.ml:605:29>>*/ return [0,
-                 x,
-                 function(_i_){ /*<<?>>*/ return rev_seq_of_enum(_h_, _i_);}];
-         /*<<set.ml:605:78>>*/ }
-        function to_rev_seq(c){
-          /*<<set.ml:607:23>>*/  /*<<set.ml:607:40>>*/ var
-          _f_ = snoc_enum(c, 0);
-          /*<<set.ml:607:40>>*/ return function(_g_){
-           /*<<?>>*/ return rev_seq_of_enum(_f_, _g_);};
-         /*<<set.ml:607:57>>*/ }
-        function to_seq_from(low, s){
-          /*<<set.ml:610:6>>*/ var s$0 = s, c = 0;
-          /*<<set.ml:610:28>>*/ for(;;){
-          if(s$0){
-            /*<<set.ml:613:24>>*/ var
-            r = s$0[3],
-            v = s$0[2],
-            l = s$0[1],
-             /*<<set.ml:613:24>>*/ n =
-               /*<<set.ml:613:24>>*/ caml_call2(Ord[1], v, low);
-           if(0 !== n){
-            if(0 <= n){
-              /*<<set.ml:616:31>>*/ var
-               /*<<set.ml:616:31>>*/ c$0 = [0, v, r, c],
-              s$0 = l,
-              c = c$0;
-             continue;
-            }
-            var s$0 = r;
-            continue;
-           }
-           var _d_ = [0, v, r, c];
-          }
-          else
-           var _d_ = c;
-           /*<<set.ml:619:19>>*/ return function(_e_){
-            /*<<?>>*/ return seq_of_enum(_d_, _e_);};
-         }
-         /*<<set.ml:619:34>>*/ }
-        return [0,
-                empty,
-                is_empty,
-                mem,
-                add,
-                singleton,
-                remove,
-                union,
-                inter,
-                disjoint,
-                diff,
-                compare,
-                equal,
-                subset,
-                iter,
-                map,
-                fold,
-                for_all,
-                exists,
-                filter,
-                filter_map,
-                partition,
-                cardinal,
-                elements,
-                min_elt,
-                min_elt_opt,
-                max_elt,
-                max_elt_opt,
-                min_elt,
-                min_elt_opt,
-                split,
-                find,
-                find_opt,
-                find_first,
-                find_first_opt,
-                find_last,
-                find_last_opt,
-                of_list,
-                to_seq_from,
-                to_seq,
-                to_rev_seq,
-                add_seq,
-                of_seq];
-       }];
-   runtime.caml_register_global(12, Stdlib_Set, "Stdlib__Set");
-   return;
-   /*<<?>>*/ }
-  (globalThis));
-
-//# unitInfo: Provides: Stdlib__Map
-//# unitInfo: Requires: Assert_failure, Stdlib, Stdlib__Seq
-(function
-  (globalThis){
-   "use strict";
-   var
-    runtime = globalThis.jsoo_runtime,
-    cst_Map_bal$3 = "Map.bal",
-    caml_maybe_attach_backtrace = runtime.caml_maybe_attach_backtrace;
-    /*<<?>>*/ function caml_call1(f, a0){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 1
-            ? f(a0)
-            : runtime.caml_call_gen(f, [a0]);
-   }
-    /*<<?>>*/ function caml_call2(f, a0, a1){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 2
-            ? f(a0, a1)
-            : runtime.caml_call_gen(f, [a0, a1]);
-   }
-    /*<<?>>*/ function caml_call3(f, a0, a1, a2){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 3
-            ? f(a0, a1, a2)
-            : runtime.caml_call_gen(f, [a0, a1, a2]);
-   }
-   var
-    global_data = runtime.caml_get_global_data(),
-    Stdlib = global_data.Stdlib,
-    Assert_failure = global_data.Assert_failure,
-    Stdlib_Seq = global_data.Stdlib__Seq,
-    cst_Map_remove_min_elt = "Map.remove_min_elt",
-    _a_ = [0, 0, 0, 0],
-    _b_ = [0, "map.ml", 400, 10],
-    _c_ = [0, 0, 0],
-    cst_Map_bal = cst_Map_bal$3,
-    cst_Map_bal$0 = cst_Map_bal$3,
-    cst_Map_bal$1 = cst_Map_bal$3,
-    cst_Map_bal$2 = cst_Map_bal$3,
-    Stdlib_Map =
-      [0,
-       function(Ord){
-        function height(param){
-          /*<<map.ml:77:17>>*/ if(! param)  /*<<map.ml:78:17>>*/ return 0;
-         var h = param[5];
-          /*<<map.ml:79:20>>*/ return h;
-         /*<<map.ml:79:21>>*/ }
-        function create(l, x, d, r){
-          /*<<map.ml:82:6>>*/ var
-           /*<<map.ml:82:15>>*/ hl = height(l),
-           /*<<map.ml:82:33>>*/ hr = height(r),
-          _L_ = hr <= hl ? hl + 1 | 0 : hr + 1 | 0;
-          /*<<map.ml:83:10>>*/ return [0, l, x, d, r, _L_];
-         /*<<map.ml:83:65>>*/ }
-        function singleton(x, d){
-          /*<<map.ml:85:24>>*/ return [0, 0, x, d, 0, 1];
-         /*<<map.ml:85:59>>*/ }
-        function bal(l, x, d, r){
-          /*<<map.ml:88:6>>*/ if(l) var h = l[5], hl = h; else var hl = 0;
-          /*<<map.ml:89:6>>*/ if(r) var h$0 = r[5], hr = h$0; else var hr = 0;
-         if((hr + 2 | 0) < hl){
-          if(! l)
-            /*<<map.ml:92:19>>*/ return  /*<<map.ml:92:19>>*/ caml_call1
-                   (Stdlib[1], cst_Map_bal$0);
-           /*<<map.ml:94:28>>*/ var
-           lr = l[4],
-           ld = l[3],
-           lv = l[2],
-           ll = l[1],
-            /*<<map.ml:94:28>>*/ _G_ = height(lr);
-          if(_G_ <= height(ll))
-            /*<<map.ml:95:30>>*/ return create
-                   (ll, lv, ld, create(lr, x, d, r));
-          if(! lr)
-            /*<<map.ml:98:25>>*/ return  /*<<map.ml:98:25>>*/ caml_call1
-                   (Stdlib[1], cst_Map_bal);
-           /*<<map.ml:100:55>>*/ var
-           lrr = lr[4],
-           lrd = lr[3],
-           lrv = lr[2],
-           lrl = lr[1],
-            /*<<map.ml:100:55>>*/ _H_ = create(lrr, x, d, r);
-           /*<<map.ml:100:55>>*/ return create
-                  (create(ll, lv, ld, lrl), lrv, lrd, _H_);
-         }
-         if((hl + 2 | 0) >= hr){
-          var _K_ = hr <= hl ? hl + 1 | 0 : hr + 1 | 0;
-           /*<<map.ml:115:12>>*/ return [0, l, x, d, r, _K_];
-         }
-         if(! r)
-           /*<<map.ml:104:19>>*/ return  /*<<map.ml:104:19>>*/ caml_call1
-                  (Stdlib[1], cst_Map_bal$2);
-          /*<<map.ml:106:28>>*/ var
-          rr = r[4],
-          rd = r[3],
-          rv = r[2],
-          rl = r[1],
-           /*<<map.ml:106:28>>*/ _I_ = height(rl);
-         if(_I_ <= height(rr))
-           /*<<map.ml:107:14>>*/ return create
-                  (create(l, x, d, rl), rv, rd, rr);
-         if(! rl)
-           /*<<map.ml:110:25>>*/ return  /*<<map.ml:110:25>>*/ caml_call1
-                  (Stdlib[1], cst_Map_bal$1);
-          /*<<map.ml:112:52>>*/ var
-          rlr = rl[4],
-          rld = rl[3],
-          rlv = rl[2],
-          rll = rl[1],
-           /*<<map.ml:112:52>>*/ _J_ = create(rlr, rv, rd, rr);
-          /*<<map.ml:112:52>>*/ return create
-                 (create(l, x, d, rll), rlv, rld, _J_);
-         /*<<map.ml:115:67>>*/ }
-        var empty = 0;
-        function is_empty(param){
-          /*<<map.ml:119:19>>*/ return param ? 0 : 1;
-         /*<<map.ml:119:54>>*/ }
-        function add(x, data, m){
-          /*<<?>>*/ if(! m)
-           /*<<map.ml:123:14>>*/ return [0, 0, x, data, 0, 1];
-          /*<<map.ml:125:18>>*/ var
-          h = m[5],
-          r = m[4],
-          d = m[3],
-          v = m[2],
-          l = m[1],
-           /*<<map.ml:125:18>>*/ c =
-             /*<<map.ml:125:18>>*/ caml_call2(Ord[1], x, v);
-          /*<<map.ml:126:10>>*/ if(0 === c)
-          return d === data ? m : [0, l, x, data, r, h];
-         if(0 <= c){
-           /*<<map.ml:132:21>>*/  /*<<map.ml:132:21>>*/ var
-           rr = add(x, data, r);
-          return r === rr ? m : bal(l, v, d, rr);
-         }
-          /*<<map.ml:129:21>>*/  /*<<map.ml:129:21>>*/ var
-          ll = add(x, data, l);
-         return l === ll ? m : bal(ll, v, d, r);
-        }
-        function find(x, param){
-         var param$0 = param;
-         for(;;){
-          if(! param$0)
-            /*<<map.ml:137:10>>*/ throw  /*<<map.ml:137:10>>*/ caml_maybe_attach_backtrace
-                  (Stdlib[8], 1);
-           /*<<map.ml:139:18>>*/ var
-           r = param$0[4],
-           d = param$0[3],
-           v = param$0[2],
-           l = param$0[1],
-            /*<<map.ml:139:18>>*/ c =
-              /*<<map.ml:139:18>>*/ caml_call2(Ord[1], x, v);
-           /*<<map.ml:140:10>>*/ if(0 === c)  /*<<map.ml:140:24>>*/ return d;
-          var r$0 = 0 <= c ? r : l, param$0 = r$0;
-         }
-        }
-        function find_first(f, param$0){
-         var param$1 = param$0;
-         for(;;){
-          if(! param$1)
-            /*<<map.ml:154:10>>*/ throw  /*<<map.ml:154:10>>*/ caml_maybe_attach_backtrace
-                  (Stdlib[8], 1);
-          var
-           r$0 = param$1[4],
-           d0$1 = param$1[3],
-           v0$1 = param$1[2],
-           l$0 = param$1[1];
-           /*<<map.ml:156:13>>*/ if
-           ( /*<<map.ml:156:13>>*/ caml_call1(f, v0$1)){
-           var v0 = v0$1, d0 = d0$1, param = l$0;
-           for(;;){
-            if(! param)  /*<<map.ml:145:10>>*/ return [0, v0, d0];
-            var r = param[4], d0$0 = param[3], v0$0 = param[2], l = param[1];
-             /*<<map.ml:147:13>>*/ if
-             ( /*<<map.ml:147:13>>*/ caml_call1(f, v0$0))
-             var v0 = v0$0, d0 = d0$0, param = l;
-            else
-             var param = r;
-           }
-          }
-          else
-           var param$1 = r$0;
-         }
-        }
-        function find_first_opt(f, param$0){
-         var param$1 = param$0;
-         for(;;){
-          if(! param$1)  /*<<map.ml:172:10>>*/ return 0;
-          var
-           r$0 = param$1[4],
-           d0$1 = param$1[3],
-           v0$1 = param$1[2],
-           l$0 = param$1[1];
-           /*<<map.ml:174:13>>*/ if
-           ( /*<<map.ml:174:13>>*/ caml_call1(f, v0$1)){
-           var v0 = v0$1, d0 = d0$1, param = l$0;
-           for(;;){
-            if(! param)  /*<<map.ml:163:10>>*/ return [0, [0, v0, d0]];
-            var r = param[4], d0$0 = param[3], v0$0 = param[2], l = param[1];
-             /*<<map.ml:165:13>>*/ if
-             ( /*<<map.ml:165:13>>*/ caml_call1(f, v0$0))
-             var v0 = v0$0, d0 = d0$0, param = l;
-            else
-             var param = r;
-           }
-          }
-          else
-           var param$1 = r$0;
-         }
-        }
-        function find_last(f, param$0){
-         var param$1 = param$0;
-         for(;;){
-          if(! param$1)
-            /*<<map.ml:190:10>>*/ throw  /*<<map.ml:190:10>>*/ caml_maybe_attach_backtrace
-                  (Stdlib[8], 1);
-          var
-           r$0 = param$1[4],
-           d0$1 = param$1[3],
-           v0$1 = param$1[2],
-           l$0 = param$1[1];
-           /*<<map.ml:192:13>>*/ if
-           ( /*<<map.ml:192:13>>*/ caml_call1(f, v0$1)){
-           var v0 = v0$1, d0 = d0$1, param = r$0;
-           for(;;){
-            if(! param)  /*<<map.ml:181:10>>*/ return [0, v0, d0];
-            var r = param[4], d0$0 = param[3], v0$0 = param[2], l = param[1];
-             /*<<map.ml:183:13>>*/ if
-             ( /*<<map.ml:183:13>>*/ caml_call1(f, v0$0))
-             var v0 = v0$0, d0 = d0$0, param = r;
-            else
-             var param = l;
-           }
-          }
-          else
-           var param$1 = l$0;
-         }
-        }
-        function find_last_opt(f, param$0){
-         var param$1 = param$0;
-         for(;;){
-          if(! param$1)  /*<<map.ml:208:10>>*/ return 0;
-          var
-           r$0 = param$1[4],
-           d0$1 = param$1[3],
-           v0$1 = param$1[2],
-           l$0 = param$1[1];
-           /*<<map.ml:210:13>>*/ if
-           ( /*<<map.ml:210:13>>*/ caml_call1(f, v0$1)){
-           var v0 = v0$1, d0 = d0$1, param = r$0;
-           for(;;){
-            if(! param)  /*<<map.ml:199:10>>*/ return [0, [0, v0, d0]];
-            var r = param[4], d0$0 = param[3], v0$0 = param[2], l = param[1];
-             /*<<map.ml:201:13>>*/ if
-             ( /*<<map.ml:201:13>>*/ caml_call1(f, v0$0))
-             var v0 = v0$0, d0 = d0$0, param = r;
-            else
-             var param = l;
-           }
-          }
-          else
-           var param$1 = l$0;
-         }
-        }
-        function find_opt(x, param){
-         var param$0 = param;
-         for(;;){
-          if(! param$0)  /*<<map.ml:217:10>>*/ return 0;
-           /*<<map.ml:219:18>>*/ var
-           r = param$0[4],
-           d = param$0[3],
-           v = param$0[2],
-           l = param$0[1],
-            /*<<map.ml:219:18>>*/ c =
-              /*<<map.ml:219:18>>*/ caml_call2(Ord[1], x, v);
-           /*<<map.ml:220:10>>*/ if(0 === c)
-            /*<<map.ml:220:24>>*/ return [0, d];
-          var r$0 = 0 <= c ? r : l, param$0 = r$0;
-         }
-        }
-        function mem(x, param){
-         var param$0 = param;
-         for(;;){
-          if(! param$0)  /*<<map.ml:225:10>>*/ return 0;
-           /*<<map.ml:227:18>>*/ var
-           r = param$0[4],
-           v = param$0[2],
-           l = param$0[1],
-            /*<<map.ml:227:18>>*/ c =
-              /*<<map.ml:227:18>>*/ caml_call2(Ord[1], x, v),
-           _F_ = 0 === c ? 1 : 0;
-          if(_F_) return _F_;
-          var r$0 = 0 <= c ? r : l, param$0 = r$0;
-         }
-        }
-        function min_binding(param){
-          /*<<map.ml:230:26>>*/ var param$0 = param;
-          /*<<map.ml:230:26>>*/ for(;;){
-          if(! param$0)
-            /*<<map.ml:231:17>>*/ throw  /*<<map.ml:231:17>>*/ caml_maybe_attach_backtrace
-                  (Stdlib[8], 1);
-          var l = param$0[1];
-          if(! l){
-           var d = param$0[3], v = param$0[2];
-            /*<<map.ml:232:32>>*/ return [0, v, d];
-          }
-          var param$0 = l;
-         }
-         /*<<map.ml:233:33>>*/ }
-        function min_binding_opt(param){
-          /*<<map.ml:235:30>>*/ var param$0 = param;
-          /*<<map.ml:235:30>>*/ for(;;){
-          if(! param$0)  /*<<map.ml:236:17>>*/ return 0;
-          var l = param$0[1];
-          if(! l){
-           var d = param$0[3], v = param$0[2];
-            /*<<map.ml:237:32>>*/ return [0, [0, v, d]];
-          }
-          var param$0 = l;
-         }
-         /*<<map.ml:238:36>>*/ }
-        function max_binding(param){
-          /*<<map.ml:240:26>>*/ var param$0 = param;
-          /*<<map.ml:240:26>>*/ for(;;){
-          if(! param$0)
-            /*<<map.ml:241:17>>*/ throw  /*<<map.ml:241:17>>*/ caml_maybe_attach_backtrace
-                  (Stdlib[8], 1);
-          if(! param$0[4]){
-           var d = param$0[3], v = param$0[2];
-            /*<<map.ml:242:32>>*/ return [0, v, d];
-          }
-          var r = param$0[4], param$0 = r;
-         }
-         /*<<map.ml:243:33>>*/ }
-        function max_binding_opt(param){
-          /*<<map.ml:245:30>>*/ var param$0 = param;
-          /*<<map.ml:245:30>>*/ for(;;){
-          if(! param$0)  /*<<map.ml:246:17>>*/ return 0;
-          if(! param$0[4]){
-           var d = param$0[3], v = param$0[2];
-            /*<<map.ml:247:32>>*/ return [0, [0, v, d]];
-          }
-          var r = param$0[4], param$0 = r;
-         }
-         /*<<map.ml:248:37>>*/ }
-        function remove_min_binding(param){
-          /*<<map.ml:250:33>>*/ if(! param)
-           /*<<map.ml:251:17>>*/ return  /*<<map.ml:251:17>>*/ caml_call1
-                  (Stdlib[1], cst_Map_remove_min_elt);
-         var l = param[1];
-         if(l){
-          var r = param[4], d = param[3], v = param[2];
-           /*<<map.ml:253:29>>*/ return bal(remove_min_binding(l), v, d, r);
-         }
-         var r$0 = param[4];
-          /*<<map.ml:252:29>>*/ return r$0;
-         /*<<map.ml:253:61>>*/ }
-        function _d_(t1, t2){
-          /*<<map.ml:256:6>>*/ if(! t1)  /*<<map.ml:257:22>>*/ return t2;
-         if(! t2)  /*<<map.ml:258:22>>*/ return t1;
-          /*<<map.ml:260:23>>*/ var
-           /*<<map.ml:260:23>>*/ match = min_binding(t2),
-          d = match[2],
-          x = match[1];
-          /*<<map.ml:261:21>>*/ return bal(t1, x, d, remove_min_binding(t2));
-         /*<<map.ml:261:44>>*/ }
-        function remove(x, m){
-          /*<<?>>*/ if(! m)  /*<<map.ml:265:10>>*/ return 0;
-          /*<<map.ml:267:18>>*/ var
-          r = m[4],
-          d = m[3],
-          v = m[2],
-          l = m[1],
-           /*<<map.ml:267:18>>*/ c =
-             /*<<map.ml:267:18>>*/ caml_call2(Ord[1], x, v);
-          /*<<map.ml:268:10>>*/ if(0 === c)
-           /*<<map.ml:268:24>>*/ return _d_(l, r);
-         if(0 <= c){
-           /*<<map.ml:272:21>>*/  /*<<map.ml:272:21>>*/ var rr = remove(x, r);
-          return r === rr ? m : bal(l, v, d, rr);
-         }
-          /*<<map.ml:270:21>>*/  /*<<map.ml:270:21>>*/ var ll = remove(x, l);
-         return l === ll ? m : bal(ll, v, d, r);
-        }
-        function update(x, f, m){
-          /*<<?>>*/ if(! m){
-           /*<<map.ml:276:22>>*/  /*<<map.ml:276:22>>*/ var
-           match$0 =  /*<<map.ml:276:22>>*/ caml_call1(f, 0);
-          if(! match$0)  /*<<map.ml:277:20>>*/ return 0;
-          var data$0 = match$0[1];
-           /*<<map.ml:278:29>>*/ return [0, 0, x, data$0, 0, 1];
-         }
-          /*<<map.ml:281:18>>*/ var
-          h = m[5],
-          r = m[4],
-          d = m[3],
-          v = m[2],
-          l = m[1],
-           /*<<map.ml:281:18>>*/ c =
-             /*<<map.ml:281:18>>*/ caml_call2(Ord[1], x, v);
-          /*<<map.ml:282:10>>*/ if(0 === c){
-           /*<<map.ml:283:18>>*/  /*<<map.ml:283:18>>*/ var
-           match =  /*<<map.ml:283:18>>*/ caml_call1(f, [0, d]);
-          if(! match)  /*<<map.ml:284:22>>*/ return _d_(l, r);
-          var data = match[1];
-          return d === data ? m : [0, l, x, data, r, h];
-         }
-         if(0 <= c){
-           /*<<map.ml:291:21>>*/  /*<<map.ml:291:21>>*/ var
-           rr = update(x, f, r);
-          return r === rr ? m : bal(l, v, d, rr);
-         }
-          /*<<map.ml:288:21>>*/  /*<<map.ml:288:21>>*/ var
-          ll = update(x, f, l);
-         return l === ll ? m : bal(ll, v, d, r);
-        }
-        function iter(f, param){
-         var param$0 = param;
-         for(;;){
-          if(! param$0)  /*<<map.ml:295:17>>*/ return 0;
-          var r = param$0[4], d = param$0[3], v = param$0[2], l = param$0[1];
-           /*<<map.ml:297:10>>*/ iter(f, l);
-           /*<<map.ml:297:20>>*/  /*<<map.ml:297:20>>*/ caml_call2(f, v, d);
-          var param$0 = r;
-         }
-        }
-        function map(f, param){
-          /*<<?>>*/ if(! param)  /*<<map.ml:301:10>>*/ return 0;
-          /*<<map.ml:303:19>>*/ var
-          h = param[5],
-          r = param[4],
-          d = param[3],
-          v = param[2],
-          l = param[1],
-           /*<<map.ml:303:19>>*/ l$0 = map(f, l),
-           /*<<map.ml:304:19>>*/ d$0 =  /*<<map.ml:304:19>>*/ caml_call1(f, d),
-           /*<<map.ml:305:19>>*/ r$0 = map(f, r);
-          /*<<map.ml:306:14>>*/ return [0, l$0, v, d$0, r$0, h];
-        }
-        function mapi(f, param){
-          /*<<?>>*/ if(! param)  /*<<map.ml:310:10>>*/ return 0;
-          /*<<map.ml:312:19>>*/ var
-          h = param[5],
-          r = param[4],
-          d = param[3],
-          v = param[2],
-          l = param[1],
-           /*<<map.ml:312:19>>*/ l$0 = mapi(f, l),
-           /*<<map.ml:313:19>>*/ d$0 =
-             /*<<map.ml:313:19>>*/ caml_call2(f, v, d),
-           /*<<map.ml:314:19>>*/ r$0 = mapi(f, r);
-          /*<<map.ml:315:14>>*/ return [0, l$0, v, d$0, r$0, h];
-        }
-        function fold(f, m, accu){
-          /*<<map.ml:318:6>>*/ var m$0 = m, accu$0 = accu;
-          /*<<map.ml:318:6>>*/ for(;;){
-          if(! m$0)  /*<<map.ml:319:17>>*/ return accu$0;
-           /*<<map.ml:321:19>>*/ var
-           r = m$0[4],
-           d = m$0[3],
-           v = m$0[2],
-           l = m$0[1],
-            /*<<map.ml:321:19>>*/ accu$1 =
-              /*<<map.ml:321:19>>*/ caml_call3(f, v, d, fold(f, l, accu$0)),
-           m$0 = r,
-           accu$0 = accu$1;
-         }
-         /*<<map.ml:321:42>>*/ }
-        function for_all(p, param){
-         var param$0 = param;
-         for(;;){
-          if(! param$0)  /*<<map.ml:324:17>>*/ return 1;
-           /*<<map.ml:325:29>>*/ var
-           r = param$0[4],
-           d = param$0[3],
-           v = param$0[2],
-           l = param$0[1],
-            /*<<map.ml:325:29>>*/ _C_ =
-              /*<<map.ml:325:29>>*/ caml_call2(p, v, d);
-           /*<<map.ml:325:29>>*/ if(_C_){
-            /*<<map.ml:325:38>>*/  /*<<map.ml:325:38>>*/ var
-            _D_ = for_all(p, l);
-            /*<<map.ml:325:38>>*/ if(_D_){var param$0 = r; continue;}
-           var _E_ = _D_;
-          }
-          else
-           var _E_ = _C_;
-           /*<<map.ml:325:38>>*/ return _E_;
-         }
-        }
-        function exists(p, param){
-         var param$0 = param;
-         for(;;){
-          if(! param$0)  /*<<map.ml:328:17>>*/ return 0;
-           /*<<map.ml:329:29>>*/ var
-           r = param$0[4],
-           d = param$0[3],
-           v = param$0[2],
-           l = param$0[1],
-            /*<<map.ml:329:29>>*/ _z_ =
-              /*<<map.ml:329:29>>*/ caml_call2(p, v, d);
-           /*<<map.ml:329:29>>*/ if(_z_)
-           var _A_ = _z_;
-          else{
-            /*<<map.ml:329:38>>*/  /*<<map.ml:329:38>>*/ var
-            _B_ = exists(p, l);
-            /*<<map.ml:329:38>>*/ if(! _B_){var param$0 = r; continue;}
-           var _A_ = _B_;
-          }
-           /*<<map.ml:329:29>>*/ return _A_;
-         }
-        }
-        function add_min_binding(k, x, param){
-          /*<<?>>*/ if(! param)  /*<<map.ml:340:17>>*/ return singleton(k, x);
-         var r = param[4], d = param[3], v = param[2], l = param[1];
-          /*<<map.ml:342:8>>*/ return bal(add_min_binding(k, x, l), v, d, r);
-        }
-        function add_max_binding(k, x, param){
-          /*<<?>>*/ if(! param)  /*<<map.ml:345:17>>*/ return singleton(k, x);
-         var r = param[4], d = param[3], v = param[2], l = param[1];
-          /*<<map.ml:347:18>>*/ return bal(l, v, d, add_max_binding(k, x, r));
-        }
-        function join(l, v, d, r){
-          /*<<map.ml:353:6>>*/ if(! l)
-           /*<<map.ml:354:22>>*/ return add_min_binding(v, d, r);
-         if(! r)  /*<<map.ml:355:22>>*/ return add_max_binding(v, d, l);
-         var
-          rh = r[5],
-          rr = r[4],
-          rd = r[3],
-          rv = r[2],
-          rl = r[1],
-          lh = l[5],
-          lr = l[4],
-          ld = l[3],
-          lv = l[2],
-          ll = l[1];
-         return (rh + 2 | 0) < lh
-                 ? bal(ll, lv, ld, join(lr, v, d, r))
-                 : (lh
-                   + 2
-                   | 0)
-                   < rh
-                   ? bal(join(l, v, d, rl), rv, rd, rr)
-                   : create(l, v, d, r);
-         /*<<map.ml:360:24>>*/ }
-        function concat(t1, t2){
-          /*<<map.ml:367:6>>*/ if(! t1)  /*<<map.ml:368:22>>*/ return t2;
-         if(! t2)  /*<<map.ml:369:22>>*/ return t1;
-          /*<<map.ml:371:23>>*/ var
-           /*<<map.ml:371:23>>*/ match = min_binding(t2),
-          d = match[2],
-          x = match[1];
-          /*<<map.ml:372:22>>*/ return join(t1, x, d, remove_min_binding(t2));
-         /*<<map.ml:372:45>>*/ }
-        function concat_or_join(t1, v, d, t2){
-          /*<<map.ml:375:6>>*/ if(! d)
-           /*<<map.ml:377:16>>*/ return concat(t1, t2);
-         var d$0 = d[1];
-          /*<<map.ml:376:18>>*/ return join(t1, v, d$0, t2);
-         /*<<map.ml:377:28>>*/ }
-        function split(x, param){
-          /*<<?>>*/ if(! param)  /*<<map.ml:381:10>>*/ return _a_;
-          /*<<map.ml:383:18>>*/ var
-          r = param[4],
-          d = param[3],
-          v = param[2],
-          l = param[1],
-           /*<<map.ml:383:18>>*/ c =
-             /*<<map.ml:383:18>>*/ caml_call2(Ord[1], x, v);
-          /*<<map.ml:384:10>>*/ if(0 === c)
-           /*<<map.ml:384:24>>*/ return [0, l, [0, d], r];
-         if(0 <= c){
-           /*<<map.ml:388:33>>*/ var
-            /*<<map.ml:388:33>>*/ match = split(x, r),
-           rr = match[3],
-           pres = match[2],
-           lr = match[1];
-           /*<<map.ml:388:46>>*/ return [0, join(l, v, d, lr), pres, rr];
-         }
-          /*<<map.ml:386:33>>*/ var
-           /*<<map.ml:386:33>>*/ match$0 = split(x, l),
-          rl = match$0[3],
-          pres$0 = match$0[2],
-          ll = match$0[1];
-          /*<<map.ml:386:46>>*/ return [0, ll, pres$0, join(rl, v, d, r)];
-        }
-        function merge(f, s1, s2){
-          /*<<map.ml:391:6>>*/ if(s1){
-          var h1 = s1[5], r1 = s1[4], d1 = s1[3], v1 = s1[2], l1 = s1[1];
-          if(height(s2) <= h1){
-            /*<<map.ml:394:29>>*/ var
-             /*<<map.ml:394:29>>*/ match = split(v1, s2),
-            r2 = match[3],
-            d2 = match[2],
-            l2 = match[1],
-             /*<<map.ml:395:64>>*/ _v_ = merge(f, r1, r2),
-             /*<<map.ml:395:44>>*/ _w_ =
-               /*<<map.ml:395:44>>*/ caml_call3(f, v1, [0, d1], d2);
-            /*<<map.ml:395:64>>*/ return concat_or_join
-                   (merge(f, l1, l2), v1, _w_, _v_);
-          }
-         }
-         else if(! s2)  /*<<map.ml:392:26>>*/ return 0;
-         if(! s2)
-           /*<<map.ml:400:10>>*/ throw  /*<<map.ml:400:10>>*/ caml_maybe_attach_backtrace
-                 ([0, Assert_failure, _b_], 1);
-          /*<<map.ml:397:29>>*/ var
-          r2$0 = s2[4],
-          d2$0 = s2[3],
-          v2 = s2[2],
-          l2$0 = s2[1],
-           /*<<map.ml:397:29>>*/ match$0 = split(v2, s1),
-          r1$0 = match$0[3],
-          d1$0 = match$0[2],
-          l1$0 = match$0[1],
-           /*<<map.ml:398:64>>*/ _x_ = merge(f, r1$0, r2$0),
-           /*<<map.ml:398:44>>*/ _y_ =
-             /*<<map.ml:398:44>>*/ caml_call3(f, v2, d1$0, [0, d2$0]);
-          /*<<map.ml:398:64>>*/ return concat_or_join
-                 (merge(f, l1$0, l2$0), v2, _y_, _x_);
-         /*<<map.ml:400:22>>*/ }
-        function union(f, s1, s2){
-          /*<<map.ml:403:6>>*/ if(s1){
-          if(s2){
-           var
-            h2 = s2[5],
-            r2 = s2[4],
-            d2 = s2[3],
-            v2 = s2[2],
-            l2 = s2[1],
-            h1 = s1[5],
-            r1 = s1[4],
-            d1 = s1[3],
-            v1 = s1[2],
-            l1 = s1[1];
-           if(h2 <= h1){
-             /*<<map.ml:408:31>>*/ var
-              /*<<map.ml:408:31>>*/ match = split(v1, s2),
-             r2$0 = match[3],
-             d2$0 = match[2],
-             l2$0 = match[1],
-              /*<<map.ml:409:20>>*/ l = union(f, l1, l2$0),
-              /*<<map.ml:409:42>>*/ r = union(f, r1, r2$0);
-             /*<<map.ml:410:12>>*/ if(! d2$0)
-              /*<<map.ml:411:22>>*/ return join(l, v1, d1, r);
-            var d2$1 = d2$0[1];
-             /*<<map.ml:412:25>>*/ return concat_or_join
-                    (l,
-                     v1,
-                      /*<<map.ml:412:45>>*/ caml_call3(f, v1, d1, d2$1),
-                     r);
-           }
-            /*<<map.ml:414:31>>*/ var
-             /*<<map.ml:414:31>>*/ match$0 = split(v2, s1),
-            r1$0 = match$0[3],
-            d1$0 = match$0[2],
-            l1$0 = match$0[1],
-             /*<<map.ml:415:20>>*/ l$0 = union(f, l1$0, l2),
-             /*<<map.ml:415:42>>*/ r$0 = union(f, r1$0, r2);
-            /*<<map.ml:416:12>>*/ if(! d1$0)
-             /*<<map.ml:417:22>>*/ return join(l$0, v2, d2, r$0);
-           var d1$1 = d1$0[1];
-            /*<<map.ml:418:25>>*/ return concat_or_join
-                   (l$0,
-                    v2,
-                     /*<<map.ml:418:45>>*/ caml_call3(f, v2, d1$1, d2),
-                    r$0);
-          }
-          var s = s1;
-         }
-         else
-          var s = s2;
-          /*<<map.ml:404:35>>*/ return s;
-         /*<<map.ml:418:59>>*/ }
-        function filter(p, m){
-          /*<<?>>*/ if(! m)  /*<<map.ml:421:17>>*/ return 0;
-          /*<<map.ml:424:19>>*/ var
-          r = m[4],
-          d = m[3],
-          v = m[2],
-          l = m[1],
-           /*<<map.ml:424:19>>*/ l$0 = filter(p, l),
-           /*<<map.ml:425:20>>*/ pvd =
-             /*<<map.ml:425:20>>*/ caml_call2(p, v, d),
-           /*<<map.ml:426:19>>*/ r$0 = filter(p, r);
-          /*<<map.ml:427:10>>*/ if(! pvd)
-           /*<<map.ml:428:15>>*/ return concat(l$0, r$0);
-         if(l === l$0 && r === r$0)  /*<<map.ml:427:45>>*/ return m;
-          /*<<map.ml:427:52>>*/ return join(l$0, v, d, r$0);
-        }
-        function filter_map(f, param){
-          /*<<?>>*/ if(! param)  /*<<map.ml:431:17>>*/ return 0;
-          /*<<map.ml:434:19>>*/ var
-          r = param[4],
-          d = param[3],
-          v = param[2],
-          l = param[1],
-           /*<<map.ml:434:19>>*/ l$0 = filter_map(f, l),
-           /*<<map.ml:435:20>>*/ fvd =
-             /*<<map.ml:435:20>>*/ caml_call2(f, v, d),
-           /*<<map.ml:436:19>>*/ r$0 = filter_map(f, r);
-          /*<<map.ml:437:10>>*/ if(! fvd)
-           /*<<map.ml:439:22>>*/ return concat(l$0, r$0);
-         var d$0 = fvd[1];
-          /*<<map.ml:438:25>>*/ return join(l$0, v, d$0, r$0);
-        }
-        function partition(p, param){
-          /*<<?>>*/ if(! param)  /*<<map.ml:443:17>>*/ return _c_;
-          /*<<map.ml:446:25>>*/ var
-          r = param[4],
-          d = param[3],
-          v = param[2],
-          l = param[1],
-           /*<<map.ml:446:25>>*/ match = partition(p, l),
-          lf = match[2],
-          lt = match[1],
-           /*<<map.ml:447:20>>*/ pvd =
-             /*<<map.ml:447:20>>*/ caml_call2(p, v, d),
-           /*<<map.ml:448:25>>*/ match$0 = partition(p, r),
-          rf = match$0[2],
-          rt = match$0[1];
-          /*<<map.ml:449:10>>*/ if(pvd){
-           /*<<map.ml:450:32>>*/  /*<<map.ml:450:32>>*/ var
-           _t_ = concat(lf, rf);
-           /*<<map.ml:450:15>>*/ return [0, join(lt, v, d, rt), _t_];
-         }
-          /*<<map.ml:451:30>>*/  /*<<map.ml:451:30>>*/ var
-          _u_ = join(lf, v, d, rf);
-          /*<<map.ml:451:15>>*/ return [0, concat(lt, rt), _u_];
-        }
-        function cons_enum(m, e){
-          /*<<map.ml:456:6>>*/ var m$0 = m, e$0 = e;
-          /*<<map.ml:456:6>>*/ for(;;){
-          if(! m$0)  /*<<map.ml:457:17>>*/ return e$0;
-           /*<<map.ml:458:41>>*/ var
-           r = m$0[4],
-           d = m$0[3],
-           v = m$0[2],
-           l = m$0[1],
-            /*<<map.ml:458:41>>*/ e$1 = [0, v, d, r, e$0],
-           m$0 = l,
-           e$0 = e$1;
-         }
-         /*<<map.ml:458:59>>*/ }
-        function compare(cmp, m1, m2){
-          /*<<map.ml:461:6>>*/ var
-           /*<<map.ml:472:40>>*/ e2$2 = cons_enum(m2, 0),
-           /*<<map.ml:472:21>>*/ e1$2 = cons_enum(m1, 0),
-          e1 = e1$2,
-          e2 = e2$2;
-          /*<<map.ml:462:10>>*/ for(;;){
-          if(! e1) return e2 ? -1 : 0;
-          if(! e2)  /*<<map.ml:465:22>>*/ return 1;
-           /*<<map.ml:467:20>>*/ var
-           e2$0 = e2[4],
-           r2 = e2[3],
-           d2 = e2[2],
-           v2 = e2[1],
-           e1$0 = e1[4],
-           r1 = e1[3],
-           d1 = e1[2],
-           v1 = e1[1],
-            /*<<map.ml:467:20>>*/ c =
-              /*<<map.ml:467:20>>*/ caml_call2(Ord[1], v1, v2);
-           /*<<map.ml:468:12>>*/ if(0 !== c)  /*<<map.ml:468:27>>*/ return c;
-           /*<<map.ml:469:20>>*/  /*<<map.ml:469:20>>*/ var
-           c$0 =  /*<<map.ml:469:20>>*/ caml_call2(cmp, d1, d2);
-           /*<<map.ml:470:12>>*/ if(0 !== c$0)
-            /*<<map.ml:470:27>>*/ return c$0;
-           /*<<map.ml:471:42>>*/ var
-            /*<<map.ml:471:42>>*/ e2$1 = cons_enum(r2, e2$0),
-            /*<<map.ml:471:24>>*/ e1$1 = cons_enum(r1, e1$0),
-           e1 = e1$1,
-           e2 = e2$1;
-         }
-         /*<<map.ml:472:58>>*/ }
-        function equal(cmp, m1, m2){
-          /*<<map.ml:475:6>>*/ var
-           /*<<map.ml:483:38>>*/ e2$2 = cons_enum(m2, 0),
-           /*<<map.ml:483:19>>*/ e1$2 = cons_enum(m1, 0),
-          e1 = e1$2,
-          e2 = e2$2;
-          /*<<map.ml:476:10>>*/ for(;;){
-          if(! e1) return e2 ? 0 : 1;
-          if(! e2)  /*<<map.ml:479:22>>*/ return 0;
-          var
-           e2$0 = e2[4],
-           r2 = e2[3],
-           d2 = e2[2],
-           v2 = e2[1],
-           e1$0 = e1[4],
-           r1 = e1[3],
-           d1 = e1[2],
-           v1 = e1[1],
-           _q_ =
-             0 ===  /*<<map.ml:481:12>>*/ caml_call2(Ord[1], v1, v2) ? 1 : 0;
-          if(_q_){
-            /*<<map.ml:481:37>>*/  /*<<map.ml:481:37>>*/ var
-            _r_ =  /*<<map.ml:481:37>>*/ caml_call2(cmp, d1, d2);
-            /*<<map.ml:481:37>>*/ if(_r_){
-             /*<<map.ml:482:40>>*/ var
-              /*<<map.ml:482:40>>*/ e2$1 = cons_enum(r2, e2$0),
-              /*<<map.ml:482:22>>*/ e1$1 = cons_enum(r1, e1$0),
-             e1 = e1$1,
-             e2 = e2$1;
-            continue;
-           }
-           var _s_ = _r_;
-          }
-          else
-           var _s_ = _q_;
-           /*<<map.ml:481:37>>*/ return _s_;
-         }
-         /*<<map.ml:483:56>>*/ }
-        function cardinal(param){
-          /*<<map.ml:485:23>>*/ if(! param)  /*<<map.ml:486:17>>*/ return 0;
-          /*<<map.ml:487:40>>*/ var
-          r = param[4],
-          l = param[1],
-           /*<<map.ml:487:40>>*/ _p_ = cardinal(r);
-         return (cardinal(l) + 1 | 0) + _p_ | 0;
-         /*<<map.ml:487:50>>*/ }
-        function bindings_aux(accu, param){
-         var accu$0 = accu, param$0 = param;
-         for(;;){
-          if(! param$0)  /*<<map.ml:490:17>>*/ return accu$0;
-           /*<<map.ml:491:42>>*/ var
-           r = param$0[4],
-           d = param$0[3],
-           v = param$0[2],
-           l = param$0[1],
-            /*<<map.ml:491:42>>*/ accu$1 =
-             [0, [0, v, d], bindings_aux(accu$0, r)],
-           accu$0 = accu$1,
-           param$0 = l;
-         }
-        }
-        function bindings(s){
-          /*<<map.ml:494:6>>*/ return bindings_aux(0, s);
-         /*<<map.ml:494:23>>*/ }
-        function add_seq(i, m){
-         function _o_(m, param){
-           /*<<map.ml:501:20>>*/ var v = param[2], k = param[1];
-           /*<<map.ml:501:36>>*/ return add(k, v, m);
-          /*<<map.ml:501:46>>*/ }
-          /*<<map.ml:501:6>>*/ return  /*<<map.ml:501:6>>*/ caml_call3
-                 (Stdlib_Seq[5], _o_, m, i);
-         /*<<map.ml:501:50>>*/ }
-        function of_seq(i){
-          /*<<map.ml:503:19>>*/ return add_seq(i, empty);
-         /*<<map.ml:503:34>>*/ }
-        function seq_of_enum(c, param){
-          /*<<map.ml:505:32>>*/ if(! c)  /*<<map.ml:506:15>>*/ return 0;
-          /*<<map.ml:507:59>>*/ var
-          rest = c[4],
-          t = c[3],
-          v = c[2],
-          k = c[1],
-           /*<<map.ml:507:59>>*/ _m_ = cons_enum(t, rest);
-          /*<<map.ml:507:29>>*/ return [0,
-                 [0, k, v],
-                 function(_n_){ /*<<?>>*/ return seq_of_enum(_m_, _n_);}];
-         /*<<map.ml:507:78>>*/ }
-        function to_seq(m){
-          /*<<map.ml:510:6>>*/  /*<<map.ml:510:19>>*/ var
-          _k_ = cons_enum(m, 0);
-          /*<<map.ml:510:19>>*/ return function(_l_){
-           /*<<?>>*/ return seq_of_enum(_k_, _l_);};
-         /*<<map.ml:510:36>>*/ }
-        function snoc_enum(s, e){
-          /*<<map.ml:513:6>>*/ var s$0 = s, e$0 = e;
-          /*<<map.ml:513:6>>*/ for(;;){
-          if(! s$0)  /*<<map.ml:514:17>>*/ return e$0;
-           /*<<map.ml:515:40>>*/ var
-           r = s$0[4],
-           d = s$0[3],
-           v = s$0[2],
-           l = s$0[1],
-            /*<<map.ml:515:40>>*/ e$1 = [0, v, d, l, e$0],
-           s$0 = r,
-           e$0 = e$1;
-         }
-         /*<<map.ml:515:58>>*/ }
-        function rev_seq_of_enum(c, param){
-          /*<<map.ml:517:36>>*/ if(! c)  /*<<map.ml:518:15>>*/ return 0;
-          /*<<map.ml:520:44>>*/ var
-          rest = c[4],
-          t = c[3],
-          v = c[2],
-          k = c[1],
-           /*<<map.ml:520:44>>*/ _i_ = snoc_enum(t, rest);
-          /*<<map.ml:520:10>>*/ return [0,
-                 [0, k, v],
-                 function(_j_){ /*<<?>>*/ return rev_seq_of_enum(_i_, _j_);}];
-         /*<<map.ml:520:63>>*/ }
-        function to_rev_seq(c){
-          /*<<map.ml:523:6>>*/  /*<<map.ml:523:23>>*/ var
-          _g_ = snoc_enum(c, 0);
-          /*<<map.ml:523:23>>*/ return function(_h_){
-           /*<<?>>*/ return rev_seq_of_enum(_g_, _h_);};
-         /*<<map.ml:523:40>>*/ }
-        function to_seq_from(low, m){
-          /*<<map.ml:526:6>>*/ var m$0 = m, c = 0;
-          /*<<map.ml:526:28>>*/ for(;;){
-          if(m$0){
-            /*<<map.ml:529:24>>*/ var
-            r = m$0[4],
-            d = m$0[3],
-            v = m$0[2],
-            l = m$0[1],
-             /*<<map.ml:529:24>>*/ n =
-               /*<<map.ml:529:24>>*/ caml_call2(Ord[1], v, low);
-           if(0 !== n){
-            if(0 <= n){
-              /*<<map.ml:532:31>>*/ var
-               /*<<map.ml:532:31>>*/ c$0 = [0, v, d, r, c],
-              m$0 = l,
-              c = c$0;
-             continue;
-            }
-            var m$0 = r;
-            continue;
-           }
-           var _e_ = [0, v, d, r, c];
-          }
-          else
-           var _e_ = c;
-           /*<<map.ml:535:19>>*/ return function(_f_){
-            /*<<?>>*/ return seq_of_enum(_e_, _f_);};
-         }
-         /*<<map.ml:535:34>>*/ }
-        return [0,
-                empty,
-                is_empty,
-                mem,
-                add,
-                update,
-                singleton,
-                remove,
-                merge,
-                union,
-                compare,
-                equal,
-                iter,
-                fold,
-                for_all,
-                exists,
-                filter,
-                filter_map,
-                partition,
-                cardinal,
-                bindings,
-                min_binding,
-                min_binding_opt,
-                max_binding,
-                max_binding_opt,
-                min_binding,
-                min_binding_opt,
-                split,
-                find,
-                find_opt,
-                find_first,
-                find_first_opt,
-                find_last,
-                find_last_opt,
-                map,
-                mapi,
-                to_seq,
-                to_rev_seq,
-                to_seq_from,
-                add_seq,
-                of_seq];
-       }];
-   runtime.caml_register_global(11, Stdlib_Map, "Stdlib__Map");
-   return;
-   /*<<?>>*/ }
-  (globalThis));
-
-//# unitInfo: Provides: Stdlib__Stack
-//# unitInfo: Requires: Stdlib__List, Stdlib__Seq
-(function
-  (globalThis){
-   "use strict";
-   var
-    runtime = globalThis.jsoo_runtime,
-    caml_maybe_attach_backtrace = runtime.caml_maybe_attach_backtrace;
-    /*<<?>>*/ function caml_call1(f, a0){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 1
-            ? f(a0)
-            : runtime.caml_call_gen(f, [a0]);
-   }
-    /*<<?>>*/ function caml_call2(f, a0, a1){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 2
-            ? f(a0, a1)
-            : runtime.caml_call_gen(f, [a0, a1]);
-   }
-    /*<<?>>*/ function caml_call3(f, a0, a1, a2){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 3
-            ? f(a0, a1, a2)
-            : runtime.caml_call_gen(f, [a0, a1, a2]);
-   }
-    /*<<stack.ml:18:0>>*/ var
-    global_data = runtime.caml_get_global_data(),
-    Stdlib_Seq = global_data.Stdlib__Seq,
-    Stdlib_List = global_data.Stdlib__List,
-     /*<<stack.ml:18:0>>*/ Empty =
-      [248, "Stdlib.Stack.Empty", runtime.caml_fresh_oo_id(0)];
-   function create(param){
-     /*<<stack.ml:20:16>>*/ return [0, 0, 0];
-    /*<<stack.ml:20:36>>*/ }
-   function clear(s){
-     /*<<stack.ml:22:14>>*/ s[1] = 0;
-    s[2] = 0;
-    return 0;
-    /*<<stack.ml:22:35>>*/ }
-   function copy(s){
-     /*<<stack.ml:24:13>>*/ return [0, s[1], s[2]];
-    /*<<stack.ml:24:38>>*/ }
-   function push(x, s){
-     /*<<stack.ml:26:15>>*/ s[1] = [0, x, s[1]];
-    s[2] = s[2] + 1 | 0;
-    return 0;
-    /*<<stack.ml:26:50>>*/ }
-   function pop(s){
-     /*<<stack.ml:29:2>>*/ var match = s[1];
-    if(! match)
-      /*<<stack.ml:31:14>>*/ throw  /*<<stack.ml:31:14>>*/ caml_maybe_attach_backtrace
-            (Empty, 1);
-    var tl = match[2], hd = match[1];
-    s[1] = tl;
-    s[2] = s[2] - 1 | 0;
-     /*<<stack.ml:30:45>>*/ return hd;
-    /*<<stack.ml:31:25>>*/ }
-   function pop_opt(s){
-     /*<<stack.ml:34:2>>*/ var match = s[1];
-    if(! match)  /*<<stack.ml:36:14>>*/ return 0;
-    var tl = match[2], hd = match[1];
-    s[1] = tl;
-    s[2] = s[2] - 1 | 0;
-     /*<<stack.ml:35:45>>*/ return [0, hd];
-    /*<<stack.ml:36:18>>*/ }
-   function top(s){
-     /*<<stack.ml:39:2>>*/ var match = s[1];
-    if(! match)
-      /*<<stack.ml:41:13>>*/ throw  /*<<stack.ml:41:13>>*/ caml_maybe_attach_backtrace
-            (Empty, 1);
-    var hd = match[1];
-     /*<<stack.ml:40:13>>*/ return hd;
-    /*<<stack.ml:41:24>>*/ }
-   function top_opt(s){
-     /*<<stack.ml:44:2>>*/ var match = s[1];
-    if(! match)  /*<<stack.ml:46:13>>*/ return 0;
-    var hd = match[1];
-     /*<<stack.ml:45:13>>*/ return [0, hd];
-    /*<<stack.ml:46:17>>*/ }
-   function is_empty(s){
-     /*<<stack.ml:48:17>>*/ return 0 === s[1] ? 1 : 0;
-    /*<<stack.ml:48:27>>*/ }
-   function length(s){
-     /*<<stack.ml:50:15>>*/ return s[2];
-    /*<<stack.ml:50:20>>*/ }
-   function iter(f, s){
-     /*<<stack.ml:52:15>>*/ return caml_call2(Stdlib_List[17], f, s[1]);
-    /*<<stack.ml:52:30>>*/ }
-   function fold(f, acc, s){
-     /*<<stack.ml:54:19>>*/ return caml_call3(Stdlib_List[25], f, acc, s[1]);
-    /*<<stack.ml:54:43>>*/ }
-   function to_seq(s){
-     /*<<stack.ml:58:15>>*/ return caml_call1(Stdlib_List[61], s[1]);
-    /*<<stack.ml:58:30>>*/ }
-   function add_seq(q, i){
-    function _a_(x){
-      /*<<stack.ml:60:37>>*/ return push(x, q);
-     /*<<stack.ml:60:45>>*/ }
-     /*<<stack.ml:60:18>>*/ return  /*<<stack.ml:60:18>>*/ caml_call2
-            (Stdlib_Seq[4], _a_, i);
-    /*<<stack.ml:60:48>>*/ }
-   function of_seq(g){
-     /*<<stack.ml:63:2>>*/  /*<<stack.ml:63:10>>*/ var s = create(0);
-     /*<<stack.ml:64:2>>*/ add_seq(s, g);
-     /*<<stack.ml:64:2>>*/ return s;
-    /*<<stack.ml:65:3>>*/ }
-   var
-    Stdlib_Stack =
-      [0,
-       Empty,
-       create,
-       push,
-       pop,
-       pop_opt,
-       top,
-       top_opt,
-       clear,
-       copy,
-       is_empty,
-       length,
-       iter,
-       fold,
-       to_seq,
-       add_seq,
-       of_seq];
-   runtime.caml_register_global(3, Stdlib_Stack, "Stdlib__Stack");
-   return;
-   /*<<?>>*/ }
-  (globalThis));
-
-//# unitInfo: Provides: Stdlib__Queue
-//# unitInfo: Requires: Stdlib__Seq
-(function
-  (globalThis){
-   "use strict";
-   var
-    runtime = globalThis.jsoo_runtime,
-    caml_maybe_attach_backtrace = runtime.caml_maybe_attach_backtrace;
-    /*<<?>>*/ function caml_call1(f, a0){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 1
-            ? f(a0)
-            : runtime.caml_call_gen(f, [a0]);
-   }
-    /*<<?>>*/ function caml_call2(f, a0, a1){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 2
-            ? f(a0, a1)
-            : runtime.caml_call_gen(f, [a0, a1]);
-   }
-    /*<<queue.ml:17:0>>*/ var
-    global_data = runtime.caml_get_global_data(),
-    Stdlib_Seq = global_data.Stdlib__Seq,
-     /*<<queue.ml:17:0>>*/ Empty =
-      [248, "Stdlib.Queue.Empty", runtime.caml_fresh_oo_id(0)];
-   function create(param){
-     /*<<queue.ml:29:16>>*/ return [0, 0, 0, 0];
-    /*<<queue.ml:33:1>>*/ }
-   function clear(q){
-     /*<<queue.ml:36:2>>*/ q[1] = 0;
-    q[2] = 0;
-    q[3] = 0;
-    return 0;
-    /*<<queue.ml:38:15>>*/ }
-   function add(x, q){
-     /*<<queue.ml:41:2>>*/ var
-      /*<<queue.ml:41:18>>*/ cell = [0, x, 0],
-      /*<<queue.ml:45:2>>*/ match = q[3];
-    return match
-            ? (q[1] = q[1] + 1 | 0, match[2] = cell, q[3] = cell, 0)
-            : (q[1] = 1, q[2] = cell, q[3] = cell, 0);
-    /*<<queue.ml:53:18>>*/ }
-   function peek(q){
-     /*<<queue.ml:59:2>>*/ var match = q[2];
-    if(! match)
-      /*<<queue.ml:60:11>>*/ throw  /*<<queue.ml:60:11>>*/ caml_maybe_attach_backtrace
-            (Empty, 1);
-    var content = match[1];
-     /*<<queue.ml:61:24>>*/ return content;
-    /*<<queue.ml:61:31>>*/ }
-   function peek_opt(q){
-     /*<<queue.ml:64:2>>*/ var match = q[2];
-    if(! match)  /*<<queue.ml:65:11>>*/ return 0;
-    var content = match[1];
-     /*<<queue.ml:66:24>>*/ return [0, content];
-    /*<<queue.ml:66:36>>*/ }
-   function take(q){
-     /*<<queue.ml:72:2>>*/ var _g_ = q[2];
-    if(! _g_)
-      /*<<queue.ml:73:11>>*/ throw  /*<<queue.ml:73:11>>*/ caml_maybe_attach_backtrace
-            (Empty, 1);
-    var content = _g_[1];
-    if(_g_[2]){
-     var next = _g_[2];
-     q[1] = q[1] - 1 | 0;
-     q[2] = next;
-      /*<<queue.ml:80:4>>*/ return content;
-    }
-     /*<<queue.ml:75:4>>*/ clear(q);
-     /*<<queue.ml:75:4>>*/ return content;
-    /*<<queue.ml:80:11>>*/ }
-   function take_opt(q){
-     /*<<queue.ml:83:2>>*/ var _f_ = q[2];
-    if(! _f_)  /*<<queue.ml:84:11>>*/ return 0;
-    var content = _f_[1];
-    if(_f_[2]){
-     var next = _f_[2];
-     q[1] = q[1] - 1 | 0;
-     q[2] = next;
-      /*<<queue.ml:91:4>>*/ return [0, content];
-    }
-     /*<<queue.ml:86:4>>*/ clear(q);
-     /*<<queue.ml:87:4>>*/ return [0, content];
-    /*<<queue.ml:91:16>>*/ }
-   function copy(q){
-     /*<<queue.ml:108:11>>*/ var
-     cell$0 = q[2],
-      /*<<queue.ml:108:16>>*/ q_res = [0, q[1], 0, 0],
-     prev = 0,
-     cell = cell$0;
-     /*<<queue.ml:98:4>>*/ for(;;){
-     if(! cell){q_res[3] = prev;  /*<<queue.ml:99:33>>*/ return q_res;}
-      /*<<queue.ml:101:21>>*/ var
-      content = cell[1],
-      next = cell[2],
-       /*<<queue.ml:101:21>>*/ prev$0 = [0, content, 0];
-      /*<<queue.ml:102:6>>*/ if(prev)
-      prev[2] = prev$0;
-     else
-      q_res[2] = prev$0;
-     var prev = prev$0, cell = next;
-    }
-    /*<<queue.ml:108:74>>*/ }
-   function is_empty(q){
-     /*<<queue.ml:111:2>>*/ return 0 === q[1] ? 1 : 0;
-    /*<<queue.ml:111:14>>*/ }
-   function length(q){
-     /*<<queue.ml:114:2>>*/ return q[1];
-    /*<<queue.ml:114:10>>*/ }
-   function iter(f, q){
-     /*<<queue.ml:124:13>>*/ var cell$0 = q[2], cell = cell$0;
-     /*<<queue.ml:118:4>>*/ for(;;){
-     if(! cell)  /*<<queue.ml:119:13>>*/ return 0;
-     var content = cell[1], next = cell[2];
-      /*<<queue.ml:121:6>>*/  /*<<queue.ml:121:6>>*/ caml_call1(f, content);
-     var cell = next;
-    }
-    /*<<queue.ml:124:27>>*/ }
-   function fold(f, accu$1, q){
-     /*<<queue.ml:134:18>>*/ var cell$0 = q[2], accu = accu$1, cell = cell$0;
-     /*<<queue.ml:128:4>>*/ for(;;){
-     if(! cell)  /*<<queue.ml:129:13>>*/ return accu;
-      /*<<queue.ml:131:17>>*/ var
-      content = cell[1],
-      next = cell[2],
-       /*<<queue.ml:131:17>>*/ accu$0 =
-         /*<<queue.ml:131:17>>*/ caml_call2(f, accu, content),
-      accu = accu$0,
-      cell = next;
-    }
-    /*<<queue.ml:134:37>>*/ }
-   function transfer(q1, q2){
-     /*<<queue.ml:137:2>>*/ var _e_ = 0 < q1[1] ? 1 : 0;
-    if(! _e_) return _e_;
-    var match = q2[3];
-    return match
-            ? (q2
-               [1]
-              = q2[1] + q1[1] | 0,
-              match[2] = q1[2],
-              q2[3] = q1[3],
-              clear(q1))
-            : (q2[1] = q1[1], q2[2] = q1[2], q2[3] = q1[3], clear(q1));
-    /*<<queue.ml:148:14>>*/ }
-   function to_seq(q){
-     /*<<queue.ml:153:2>>*/ function aux(c, param){
-      /*<<queue.ml:153:21>>*/ if(! c)  /*<<queue.ml:154:13>>*/ return 0;
-     var x = c[1], next = c[2];
-      /*<<queue.ml:155:35>>*/ return [0,
-             x,
-             function(_d_){ /*<<?>>*/ return aux(next, _d_);}];
-     /*<<queue.ml:155:57>>*/ }
-    var _b_ = q[2];
-     /*<<queue.ml:153:2>>*/ return function(_c_){
-      /*<<?>>*/ return aux(_b_, _c_);};
-    /*<<queue.ml:157:13>>*/ }
-   function add_seq(q, i){
-    function _a_(x){
-      /*<<queue.ml:159:37>>*/ return add(x, q);
-     /*<<queue.ml:159:45>>*/ }
-     /*<<queue.ml:159:18>>*/ return  /*<<queue.ml:159:18>>*/ caml_call2
-            (Stdlib_Seq[4], _a_, i);
-    /*<<queue.ml:159:48>>*/ }
-   function of_seq(g){
-     /*<<queue.ml:162:2>>*/  /*<<queue.ml:162:10>>*/ var q = create(0);
-     /*<<queue.ml:163:2>>*/ add_seq(q, g);
-     /*<<queue.ml:163:2>>*/ return q;
-    /*<<queue.ml:164:3>>*/ }
-   var
-    Stdlib_Queue =
-      [0,
-       Empty,
-       create,
-       add,
-       add,
-       take,
-       take_opt,
-       take,
-       peek,
-       peek_opt,
-       peek,
-       clear,
-       copy,
-       is_empty,
-       length,
-       iter,
-       fold,
-       transfer,
-       to_seq,
-       add_seq,
-       of_seq];
-   runtime.caml_register_global(2, Stdlib_Queue, "Stdlib__Queue");
-   return;
-   /*<<?>>*/ }
-  (globalThis));
-
-//# unitInfo: Provides: Stdlib__Buffer
-//# unitInfo: Requires: Assert_failure, Stdlib, Stdlib__Bytes, Stdlib__Seq, Stdlib__String, Stdlib__Sys
-(function
-  (globalThis){
-   "use strict";
-   var
-    runtime = globalThis.jsoo_runtime,
-    caml_blit_string = runtime.caml_blit_string,
-    caml_bswap16 = runtime.caml_bswap16,
-    caml_bytes_get = runtime.caml_bytes_get,
-    caml_bytes_set = runtime.caml_bytes_set,
-    caml_bytes_set16 = runtime.caml_bytes_set16,
-    caml_bytes_set32 = runtime.caml_bytes_set32,
-    caml_bytes_set64 = runtime.caml_bytes_set64,
-    caml_bytes_unsafe_set = runtime.caml_bytes_unsafe_set,
-    caml_create_bytes = runtime.caml_create_bytes,
-    caml_int32_bswap = runtime.caml_int32_bswap,
-    caml_int64_bswap = runtime.caml_int64_bswap,
-    caml_maybe_attach_backtrace = runtime.caml_maybe_attach_backtrace,
-    caml_ml_bytes_length = runtime.caml_ml_bytes_length,
-    caml_ml_string_length = runtime.caml_ml_string_length,
-    caml_string_get = runtime.caml_string_get;
-    /*<<?>>*/ function caml_call1(f, a0){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 1
-            ? f(a0)
-            : runtime.caml_call_gen(f, [a0]);
-   }
-    /*<<?>>*/ function caml_call2(f, a0, a1){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 2
-            ? f(a0, a1)
-            : runtime.caml_call_gen(f, [a0, a1]);
-   }
-    /*<<?>>*/ function caml_call3(f, a0, a1, a2){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 3
-            ? f(a0, a1, a2)
-            : runtime.caml_call_gen(f, [a0, a1, a2]);
-   }
-    /*<<?>>*/ function caml_call4(f, a0, a1, a2, a3){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 4
-            ? f(a0, a1, a2, a3)
-            : runtime.caml_call_gen(f, [a0, a1, a2, a3]);
-   }
-    /*<<?>>*/ function caml_call5(f, a0, a1, a2, a3, a4){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 5
-            ? f(a0, a1, a2, a3, a4)
-            : runtime.caml_call_gen(f, [a0, a1, a2, a3, a4]);
-   }
-   var
-    global_data = runtime.caml_get_global_data(),
-    Stdlib_Bytes = global_data.Stdlib__Bytes,
-    Stdlib_Sys = global_data.Stdlib__Sys,
-    Stdlib_Seq = global_data.Stdlib__Seq,
-    Stdlib = global_data.Stdlib,
-    Stdlib_String = global_data.Stdlib__String,
-    Assert_failure = global_data.Assert_failure,
-    cst_Buffer_truncate = "Buffer.truncate",
-    _a_ = [0, "buffer.ml", 220, 9],
-    cst_Buffer_add_channel = "Buffer.add_channel",
-    cst_Buffer_add_substring_add_s = "Buffer.add_substring/add_subbytes",
-    cst_Buffer_add_cannot_grow_buf = "Buffer.add: cannot grow buffer",
-    cst_Buffer_nth = "Buffer.nth",
-    cst_Buffer_blit = "Buffer.blit",
-    cst_Buffer_sub = "Buffer.sub";
-   function create(n){
-     /*<<buffer.ml:41:1>>*/ var
-     n$0 = 1 <= n ? n : 1,
-     n$1 = Stdlib_Sys[12] < n$0 ? Stdlib_Sys[12] : n$0,
-      /*<<buffer.ml:43:9>>*/ s =
-        /*<<buffer.ml:43:9>>*/ caml_create_bytes(n$1);
-     /*<<buffer.ml:44:1>>*/ return [0, [0, s, n$1], 0, s];
-    /*<<buffer.ml:44:71>>*/ }
-   function contents(b){
-     /*<<buffer.ml:46:17>>*/ return caml_call3
-            (Stdlib_Bytes[8], b[1][1], 0, b[2]);
-    /*<<buffer.ml:46:61>>*/ }
-   function to_bytes(b){
-     /*<<buffer.ml:47:17>>*/ return caml_call3
-            (Stdlib_Bytes[7], b[1][1], 0, b[2]);
-    /*<<buffer.ml:47:54>>*/ }
-   function sub(b, ofs, len){
-     /*<<buffer.ml:50:2>>*/ if
-     (0 <= ofs && 0 <= len && (b[2] - len | 0) >= ofs)
-      /*<<buffer.ml:52:7>>*/ return  /*<<buffer.ml:52:7>>*/ caml_call3
-             (Stdlib_Bytes[8], b[1][1], ofs, len);
-     /*<<buffer.ml:51:7>>*/ return  /*<<buffer.ml:51:7>>*/ caml_call1
-            (Stdlib[1], cst_Buffer_sub);
-    /*<<buffer.ml:52:46>>*/ }
-   function blit(src, srcoff, dst, dstoff, len){
-     /*<<buffer.ml:56:2>>*/ if
-     (0 <= len
-      &&
-       0 <= srcoff
-       &&
-        (src[2] - len | 0) >= srcoff
-        && 0 <= dstoff && (caml_ml_bytes_length(dst) - len | 0) >= dstoff)
-      /*<<buffer.ml:60:4>>*/ return  /*<<buffer.ml:60:4>>*/ caml_call5
-             (Stdlib_Bytes[11], src[1][1], srcoff, dst, dstoff, len);
-     /*<<buffer.ml:58:7>>*/ return  /*<<buffer.ml:58:7>>*/ caml_call1
-            (Stdlib[1], cst_Buffer_blit);
-    /*<<buffer.ml:60:53>>*/ }
-   function nth(b, ofs){
-     /*<<buffer.ml:64:2>>*/ var
-     position = b[2],
-      /*<<buffer.ml:65:2>>*/ match = b[1],
-     length = match[2],
-     buffer = match[1];
-    if(0 <= ofs && position > ofs && length >= position)
-     return runtime.caml_bytes_unsafe_get(buffer, ofs);
-     /*<<buffer.ml:67:3>>*/ return  /*<<buffer.ml:67:3>>*/ caml_call1
-            (Stdlib[1], cst_Buffer_nth);
-    /*<<buffer.ml:68:34>>*/ }
-   function length(b){
-     /*<<buffer.ml:71:15>>*/ return b[2];
-    /*<<buffer.ml:71:25>>*/ }
-   function clear(b){
-     /*<<buffer.ml:73:14>>*/ b[2] = 0;
-    return 0;
-    /*<<buffer.ml:73:29>>*/ }
-   function reset(b){
-     /*<<buffer.ml:76:2>>*/ b[2] = 0;
-     /*<<buffer.ml:78:4>>*/  /*<<buffer.ml:78:4>>*/ var
-     inner = [0, b[3], caml_ml_bytes_length(b[3])];
-    b[1] = inner;
-    return 0;
-    /*<<buffer.ml:80:18>>*/ }
-   function resize(b, more){
-     /*<<buffer.ml:87:2>>*/ var
-     old_pos = b[2],
-     old_len = b[1][2],
-      /*<<buffer.ml:89:16>>*/ new_len = [0, old_len];
-    for(;;){
-     if(new_len[1] >= (old_pos + more | 0)){
-      if(Stdlib_Sys[12] < new_len[1])
-       if((old_pos + more | 0) <= Stdlib_Sys[12])
-        new_len[1] = Stdlib_Sys[12];
-       else
-         /*<<buffer.ml:94:9>>*/  /*<<buffer.ml:94:9>>*/ caml_call1
-         (Stdlib[2], cst_Buffer_add_cannot_grow_buf);
-       /*<<buffer.ml:96:19>>*/  /*<<buffer.ml:96:19>>*/ var
-       new_buffer =  /*<<buffer.ml:96:19>>*/ caml_create_bytes(new_len[1]);
-       /*<<buffer.ml:99:2>>*/  /*<<buffer.ml:99:2>>*/ caml_call5
-       (Stdlib_Bytes[11], b[1][1], 0, new_buffer, 0, b[2]);
-      b[1] = [0, new_buffer, new_len[1]];
-      return 0;
-     }
-     new_len[1] = 2 * new_len[1] | 0;
-    }
-    /*<<buffer.ml:100:55>>*/ }
-   function add_char(b, c){
-     /*<<buffer.ml:113:2>>*/ var
-     pos = b[2],
-      /*<<buffer.ml:114:2>>*/ match = b[1],
-     length = match[2],
-     buffer = match[1];
-    if(length <= pos){
-      /*<<buffer.ml:116:4>>*/ resize(b, 1);
-      /*<<buffer.ml:117:4>>*/  /*<<buffer.ml:117:4>>*/ caml_bytes_set
-      (b[1][1], b[2], c);
-    }
-    else
-     caml_bytes_unsafe_set(buffer, pos, c);
-    b[2] = pos + 1 | 0;
-    return 0;
-    /*<<buffer.ml:120:23>>*/ }
-   var uchar_utf_8_byte_length_max = 4, uchar_utf_16_byte_length_max = 4;
-   function add_utf_8_uchar(b, u){
-     /*<<buffer.ml:126:2>>*/ for(;;){
-     var pos = b[2];
-     if(b[1][2] <= pos)
-       /*<<buffer.ml:127:32>>*/ resize(b, uchar_utf_8_byte_length_max);
-      /*<<buffer.ml:128:10>>*/  /*<<buffer.ml:128:10>>*/ var
-      n =
-         /*<<buffer.ml:128:10>>*/ caml_call3
-         (Stdlib_Bytes[51], b[1][1], pos, u);
-      /*<<buffer.ml:129:2>>*/ if(0 !== n){b[2] = pos + n | 0; return 0;}
-      /*<<buffer.ml:130:8>>*/ resize(b, uchar_utf_8_byte_length_max);
-    }
-    /*<<buffer.ml:131:30>>*/ }
-   function add_utf_16be_uchar(b, u){
-     /*<<buffer.ml:134:2>>*/ for(;;){
-     var pos = b[2];
-     if(b[1][2] <= pos)
-       /*<<buffer.ml:135:32>>*/ resize(b, uchar_utf_16_byte_length_max);
-      /*<<buffer.ml:136:10>>*/  /*<<buffer.ml:136:10>>*/ var
-      n =
-         /*<<buffer.ml:136:10>>*/ caml_call3
-         (Stdlib_Bytes[54], b[1][1], pos, u);
-      /*<<buffer.ml:137:2>>*/ if(0 !== n){b[2] = pos + n | 0; return 0;}
-      /*<<buffer.ml:138:8>>*/ resize(b, uchar_utf_16_byte_length_max);
-    }
-    /*<<buffer.ml:139:30>>*/ }
-   function add_utf_16le_uchar(b, u){
-     /*<<buffer.ml:142:2>>*/ for(;;){
-     var pos = b[2];
-     if(b[1][2] <= pos)
-       /*<<buffer.ml:143:32>>*/ resize(b, uchar_utf_16_byte_length_max);
-      /*<<buffer.ml:144:10>>*/  /*<<buffer.ml:144:10>>*/ var
-      n =
-         /*<<buffer.ml:144:10>>*/ caml_call3
-         (Stdlib_Bytes[57], b[1][1], pos, u);
-      /*<<buffer.ml:145:2>>*/ if(0 !== n){b[2] = pos + n | 0; return 0;}
-      /*<<buffer.ml:146:8>>*/ resize(b, uchar_utf_16_byte_length_max);
-    }
-    /*<<buffer.ml:147:30>>*/ }
-   function add_substring(b, s, offset, len){
-     /*<<buffer.ml:150:2>>*/ var _r_ = offset < 0 ? 1 : 0;
-    if(_r_)
-     var _s_ = _r_;
-    else
-     var
-      _t_ = len < 0 ? 1 : 0,
-      _s_ = _t_ || ((caml_ml_string_length(s) - len | 0) < offset ? 1 : 0);
-    if(_s_)
-      /*<<buffer.ml:151:7>>*/  /*<<buffer.ml:151:7>>*/ caml_call1
-      (Stdlib[1], cst_Buffer_add_substring_add_s);
-     /*<<buffer.ml:153:2>>*/ var
-     position = b[2],
-      /*<<buffer.ml:153:2>>*/ match = b[1],
-     length = match[2],
-     buffer = match[1],
-     new_position = position + len | 0;
-    if(length < new_position){
-      /*<<buffer.ml:156:4>>*/ resize(b, len);
-      /*<<buffer.ml:157:4>>*/  /*<<buffer.ml:157:4>>*/ caml_call5
-      (Stdlib_Bytes[12], s, offset, b[1][1], b[2], len);
-    }
-    else
-      /*<<buffer.ml:159:4>>*/  /*<<buffer.ml:159:4>>*/ caml_blit_string
-      (s, offset, buffer, position, len);
-    b[2] = new_position;
-    return 0;
-    /*<<buffer.ml:160:28>>*/ }
-   function add_subbytes(b, s, offset, len){
-     /*<<buffer.ml:163:2>>*/ return add_substring
-            (b,
-              /*<<buffer.ml:163:18>>*/ caml_call1(Stdlib_Bytes[44], s),
-             offset,
-             len);
-    /*<<buffer.ml:163:55>>*/ }
-   function add_string(b, s){
-     /*<<buffer.ml:166:2>>*/ var
-     len = caml_ml_string_length(s),
-      /*<<buffer.ml:167:2>>*/ position = b[2],
-      /*<<buffer.ml:168:2>>*/ match = b[1],
-     length = match[2],
-     buffer = match[1],
-     new_position = b[2] + len | 0;
-    if(length < new_position){
-      /*<<buffer.ml:171:4>>*/ resize(b, len);
-      /*<<buffer.ml:172:4>>*/  /*<<buffer.ml:172:4>>*/ caml_call5
-      (Stdlib_Bytes[12], s, 0, b[1][1], b[2], len);
-    }
-    else
-      /*<<buffer.ml:174:4>>*/  /*<<buffer.ml:174:4>>*/ caml_blit_string
-      (s, 0, buffer, position, len);
-    b[2] = new_position;
-    return 0;
-    /*<<buffer.ml:175:28>>*/ }
-   function add_bytes(b, s){
-     /*<<buffer.ml:177:20>>*/ return add_string
-            (b,  /*<<buffer.ml:177:33>>*/ caml_call1(Stdlib_Bytes[44], s));
-    /*<<buffer.ml:177:59>>*/ }
-   function add_buffer(b, bs){
-     /*<<buffer.ml:180:2>>*/ return add_subbytes(b, bs[1][1], 0, bs[2]);
-    /*<<buffer.ml:180:46>>*/ }
-   function add_channel(b, ic, to_read$1){
-     /*<<buffer.ml:206:2>>*/ var
-     _p_ = to_read$1 < 0 ? 1 : 0,
-     _q_ = _p_ || (Stdlib_Sys[12] < to_read$1 ? 1 : 0);
-    if(_q_)
-      /*<<buffer.ml:207:4>>*/  /*<<buffer.ml:207:4>>*/ caml_call1
-      (Stdlib[1], cst_Buffer_add_channel);
-    if(b[1][2] < (b[2] + to_read$1 | 0))
-      /*<<buffer.ml:200:44>>*/ resize(b, to_read$1);
-    var
-     ofs$1 = b[2],
-     buf = b[1][1],
-     already_read = 0,
-     ofs = ofs$1,
-     to_read = to_read$1;
-     /*<<buffer.ml:185:4>>*/ for(;;){
-     if(0 !== to_read){
-       /*<<buffer.ml:187:14>>*/  /*<<buffer.ml:187:14>>*/ var
-       r =
-          /*<<buffer.ml:187:14>>*/ caml_call4
-          (Stdlib[84], ic, buf, ofs, to_read);
-       /*<<buffer.ml:188:6>>*/ if(0 !== r){
-       var
-        already_read$0 = already_read + r | 0,
-        ofs$0 = ofs + r | 0,
-        to_read$0 = to_read - r | 0,
-        already_read = already_read$0,
-        ofs = ofs$0,
-        to_read = to_read$0;
-       continue;
-      }
-     }
-     b[2] = b[2] + already_read | 0;
-     if(already_read < to_read$1)
-       /*<<buffer.ml:211:18>>*/ throw  /*<<buffer.ml:211:18>>*/ caml_maybe_attach_backtrace
-             (Stdlib[12], 1);
-      /*<<buffer.ml:212:2>>*/ return 0;
-    }
-    /*<<buffer.ml:212:4>>*/ }
-   function output_buffer(oc, b){
-     /*<<buffer.ml:215:2>>*/ return caml_call4
-            (Stdlib[68], oc, b[1][1], 0, b[2]);
-    /*<<buffer.ml:215:39>>*/ }
-   function add_substitute(b, f, s){
-     /*<<buffer.ml:260:2>>*/ var
-     lim$1 = caml_ml_string_length(s),
-     previous = 32,
-     i$4 = 0;
-     /*<<buffer.ml:262:4>>*/ for(;;){
-     if(i$4 >= lim$1){
-      var _o_ = 92 === previous ? 1 : 0;
-      return _o_ ? add_char(b, previous) : _o_;
-     }
-      /*<<buffer.ml:263:12>>*/  /*<<buffer.ml:263:12>>*/ var
-      previous$0 =  /*<<buffer.ml:263:12>>*/ caml_string_get(s, i$4);
-     if(36 === previous$0)
-      if(92 === previous){
-        /*<<buffer.ml:265:9>>*/ add_char(b, previous$0);
-        /*<<buffer.ml:265:9>>*/ var
-         /*<<buffer.ml:265:9>>*/ i$5 = i$4 + 1 | 0,
-        previous = 32,
-        i$4 = i$5;
-      }
-      else{
-        /*<<buffer.ml:268:9>>*/  /*<<buffer.ml:268:9>>*/ var
-        start$0 = i$4 + 1 | 0;
-       if(lim$1 <= start$0)
-         /*<<buffer.ml:245:23>>*/ throw  /*<<buffer.ml:245:23>>*/ caml_maybe_attach_backtrace
-               (Stdlib[8], 1);
-        /*<<buffer.ml:246:8>>*/  /*<<buffer.ml:246:8>>*/ var
-        opening =  /*<<buffer.ml:246:8>>*/ caml_string_get(s, start$0);
-       a:
-       {
-        if(40 !== opening && 123 !== opening){
-          /*<<buffer.ml:254:5>>*/ var
-           /*<<buffer.ml:254:5>>*/ start = start$0 + 1 | 0,
-          lim$0 = caml_ml_string_length(s),
-          i$2 = start;
-          /*<<buffer.ml:237:4>>*/ for(;;){
-          b:
-          {
-           if(lim$0 > i$2){
-             /*<<buffer.ml:238:10>>*/  /*<<buffer.ml:238:10>>*/ var
-             match =  /*<<buffer.ml:238:10>>*/ caml_string_get(s, i$2);
-            c:
-            {
-             if(91 <= match){
-              if(97 <= match){
-               if(123 > match) break c;
-              }
-              else if(95 === match) break c;
-             }
-             else
-              if(58 <= match){
-               if(65 <= match) break c;
-              }
-              else if(48 <= match) break c;
-             var stop$0 = i$2;
-             break b;
-            }
-            var i$3 = i$2 + 1 | 0, i$2 = i$3;
-            continue;
-           }
-           var stop$0 = lim$0;
-          }
-          var
-           match$0 =
-             [0,
-               /*<<buffer.ml:255:5>>*/ caml_call3
-               (Stdlib_String[15], s, start$0, stop$0 - start$0 | 0),
-              stop$0];
-          break a;
-         }
-        }
-         /*<<buffer.ml:249:5>>*/ var
-          /*<<buffer.ml:249:5>>*/ new_start = start$0 + 1 | 0,
-         k$2 = 0;
-        if(40 === opening)
-         var closing = 41;
-        else{
-         if(123 !== opening)
-           /*<<buffer.ml:220:9>>*/ throw  /*<<buffer.ml:220:9>>*/ caml_maybe_attach_backtrace
-                 ([0, Assert_failure, _a_], 1);
-         var closing = 125;
-        }
-        var lim = caml_ml_string_length(s), k = k$2, stop = new_start;
-         /*<<buffer.ml:228:4>>*/ for(;;){
-         if(lim <= stop)
-           /*<<buffer.ml:228:21>>*/ throw  /*<<buffer.ml:228:21>>*/ caml_maybe_attach_backtrace
-                 (Stdlib[8], 1);
-         if( /*<<buffer.ml:229:7>>*/ caml_string_get(s, stop) === opening)
-          var i = stop + 1 | 0, k$0 = k + 1 | 0, k = k$0, stop = i;
-         else if
-          ( /*<<buffer.ml:230:7>>*/ caml_string_get(s, stop) === closing){
-          if(0 === k){
-           var
-            match$0 =
-              [0,
-                /*<<buffer.ml:251:5>>*/ caml_call3
-                (Stdlib_String[15],
-                 s,
-                 new_start,
-                 (stop - start$0 | 0) - 1 | 0),
-               stop + 1 | 0];
-           break;
-          }
-          var i$0 = stop + 1 | 0, k$1 = k - 1 | 0, k = k$1, stop = i$0;
-         }
-         else
-          var i$1 = stop + 1 | 0, stop = i$1;
-        }
-       }
-       var next_i = match$0[2], ident = match$0[1];
-        /*<<buffer.ml:270:9>>*/ add_string
-        (b,  /*<<buffer.ml:270:22>>*/ caml_call1(f, ident));
-       var previous = 32, i$4 = next_i;
-      }
-     else if(92 === previous){
-       /*<<buffer.ml:273:9>>*/ add_char(b, 92);
-       /*<<buffer.ml:274:9>>*/ add_char(b, previous$0);
-       /*<<buffer.ml:274:9>>*/ var
-        /*<<buffer.ml:274:9>>*/ i$6 = i$4 + 1 | 0,
-       previous = 32,
-       i$4 = i$6;
-     }
-     else if(92 === previous$0)
-       /*<<buffer.ml:277:9>>*/ var
-        /*<<buffer.ml:277:9>>*/ i$7 = i$4 + 1 | 0,
-       previous = previous$0,
-       i$4 = i$7;
-     else{
-       /*<<buffer.ml:279:9>>*/ add_char(b, previous$0);
-       /*<<buffer.ml:279:9>>*/ var
-        /*<<buffer.ml:279:9>>*/ i$8 = i$4 + 1 | 0,
-       previous = previous$0,
-       i$4 = i$8;
-     }
-    }
-    /*<<buffer.ml:283:13>>*/ }
-   function truncate(b, len){
-     /*<<buffer.ml:286:4>>*/ if(0 <= len && b[2] >= len){b[2] = len; return 0;}
-     /*<<buffer.ml:287:6>>*/ return  /*<<buffer.ml:287:6>>*/ caml_call1
-            (Stdlib[1], cst_Buffer_truncate);
-    /*<<buffer.ml:289:23>>*/ }
-   function to_seq(b){
-    function aux(i, param){
-      /*<<buffer.ml:296:4>>*/ if(b[2] <= i)
-       /*<<buffer.ml:296:28>>*/ return 0;
-      /*<<buffer.ml:298:14>>*/ var
-       /*<<buffer.ml:298:14>>*/ x =
-         /*<<buffer.ml:298:14>>*/ caml_bytes_get(b[1][1], i),
-       /*<<buffer.ml:298:14>>*/ _m_ = i + 1 | 0;
-      /*<<buffer.ml:299:6>>*/ return [0,
-             x,
-             function(_n_){ /*<<?>>*/ return aux(_m_, _n_);}];
-     /*<<buffer.ml:299:29>>*/ }
-     /*<<buffer.ml:301:2>>*/  /*<<buffer.ml:301:2>>*/ var _k_ = 0;
-     /*<<buffer.ml:301:2>>*/ return function(_l_){
-      /*<<?>>*/ return aux(_k_, _l_);};
-    /*<<buffer.ml:301:7>>*/ }
-   function to_seqi(b){
-    function aux(i, param){
-      /*<<buffer.ml:306:4>>*/ if(b[2] <= i)
-       /*<<buffer.ml:306:28>>*/ return 0;
-      /*<<buffer.ml:308:14>>*/ var
-       /*<<buffer.ml:308:14>>*/ x =
-         /*<<buffer.ml:308:14>>*/ caml_bytes_get(b[1][1], i),
-       /*<<buffer.ml:308:14>>*/ _i_ = i + 1 | 0;
-      /*<<buffer.ml:309:6>>*/ return [0,
-             [0, i, x],
-             function(_j_){ /*<<?>>*/ return aux(_i_, _j_);}];
-     /*<<buffer.ml:309:33>>*/ }
-     /*<<buffer.ml:311:2>>*/  /*<<buffer.ml:311:2>>*/ var _g_ = 0;
-     /*<<buffer.ml:311:2>>*/ return function(_h_){
-      /*<<?>>*/ return aux(_g_, _h_);};
-    /*<<buffer.ml:311:7>>*/ }
-   function add_seq(b, seq){
-     /*<<buffer.ml:313:29>>*/ function _e_(_f_){
-      /*<<?>>*/ return add_char(b, _f_);
-    }
-     /*<<buffer.ml:313:20>>*/ return  /*<<buffer.ml:313:20>>*/ caml_call2
-            (Stdlib_Seq[4], _e_, seq);
-    /*<<buffer.ml:313:45>>*/ }
-   function of_seq(i){
-     /*<<buffer.ml:316:2>>*/  /*<<buffer.ml:316:10>>*/ var b = create(32);
-     /*<<buffer.ml:317:2>>*/ add_seq(b, i);
-     /*<<buffer.ml:317:2>>*/ return b;
-    /*<<buffer.ml:318:3>>*/ }
-   function add_int8(b, x){
-     /*<<buffer.ml:337:2>>*/ var
-     position = b[2],
-      /*<<buffer.ml:338:2>>*/ match = b[1],
-     length = match[2],
-     buffer = match[1],
-      /*<<buffer.ml:339:2>>*/ new_position = position + 1 | 0;
-    if(length < new_position){
-      /*<<buffer.ml:341:4>>*/ resize(b, 1);
-      /*<<buffer.ml:342:4>>*/  /*<<buffer.ml:342:4>>*/ caml_bytes_set
-      (b[1][1], b[2], x);
-    }
-    else
-     caml_bytes_unsafe_set(buffer, position, x);
-    b[2] = new_position;
-    return 0;
-    /*<<buffer.ml:345:28>>*/ }
-   function add_int16_ne(b, x){
-     /*<<buffer.ml:348:2>>*/ var
-     position = b[2],
-      /*<<buffer.ml:349:2>>*/ match = b[1],
-     length = match[2],
-     buffer = match[1],
-      /*<<buffer.ml:350:2>>*/ new_position = position + 2 | 0;
-    if(length < new_position){
-      /*<<buffer.ml:352:4>>*/ resize(b, 2);
-      /*<<buffer.ml:353:4>>*/  /*<<buffer.ml:353:4>>*/ caml_bytes_set16
-      (b[1][1], b[2], x);
-    }
-    else
-      /*<<buffer.ml:355:4>>*/  /*<<buffer.ml:355:4>>*/ caml_bytes_set16
-      (buffer, position, x);
-    b[2] = new_position;
-    return 0;
-    /*<<buffer.ml:356:28>>*/ }
-   function add_int32_ne(b, x){
-     /*<<buffer.ml:359:2>>*/ var
-     position = b[2],
-      /*<<buffer.ml:360:2>>*/ match = b[1],
-     length = match[2],
-     buffer = match[1],
-      /*<<buffer.ml:361:2>>*/ new_position = position + 4 | 0;
-    if(length < new_position){
-      /*<<buffer.ml:363:4>>*/ resize(b, 4);
-      /*<<buffer.ml:364:4>>*/  /*<<buffer.ml:364:4>>*/ caml_bytes_set32
-      (b[1][1], b[2], x);
-    }
-    else
-      /*<<buffer.ml:366:4>>*/  /*<<buffer.ml:366:4>>*/ caml_bytes_set32
-      (buffer, position, x);
-    b[2] = new_position;
-    return 0;
-    /*<<buffer.ml:367:28>>*/ }
-   function add_int64_ne(b, x){
-     /*<<buffer.ml:370:2>>*/ var
-     position = b[2],
-      /*<<buffer.ml:371:2>>*/ match = b[1],
-     length = match[2],
-     buffer = match[1],
-      /*<<buffer.ml:372:2>>*/ new_position = position + 8 | 0;
-    if(length < new_position){
-      /*<<buffer.ml:374:4>>*/ resize(b, 8);
-      /*<<buffer.ml:375:4>>*/  /*<<buffer.ml:375:4>>*/ caml_bytes_set64
-      (b[1][1], b[2], x);
-    }
-    else
-      /*<<buffer.ml:377:4>>*/  /*<<buffer.ml:377:4>>*/ caml_bytes_set64
-      (buffer, position, x);
-    b[2] = new_position;
-    return 0;
-    /*<<buffer.ml:378:28>>*/ }
-   function add_int16_le(b, x){
-     /*<<buffer.ml:381:2>>*/ var _d_ = Stdlib_Sys[11] ? caml_bswap16(x) : x;
-    return add_int16_ne(b, _d_);
-    /*<<buffer.ml:381:57>>*/ }
-   function add_int16_be(b, x){
-     /*<<buffer.ml:384:2>>*/ var x$0 = Stdlib_Sys[11] ? x : caml_bswap16(x);
-     /*<<buffer.ml:384:41>>*/ return add_int16_ne(b, x$0);
-    /*<<buffer.ml:384:57>>*/ }
-   function add_int32_le(b, x){
-     /*<<buffer.ml:387:2>>*/ var
-     _c_ = Stdlib_Sys[11] ?  /*<<buffer.ml:387:41>>*/ caml_int32_bswap(x) : x;
-     /*<<buffer.ml:387:41>>*/ return add_int32_ne(b, _c_);
-    /*<<buffer.ml:387:57>>*/ }
-   function add_int32_be(b, x){
-     /*<<buffer.ml:390:2>>*/ var
-     x$0 = Stdlib_Sys[11] ? x :  /*<<buffer.ml:390:48>>*/ caml_int32_bswap(x);
-     /*<<buffer.ml:390:48>>*/ return add_int32_ne(b, x$0);
-    /*<<buffer.ml:390:57>>*/ }
-   function add_int64_le(b, x){
-     /*<<buffer.ml:393:2>>*/ var
-     _b_ = Stdlib_Sys[11] ?  /*<<buffer.ml:393:41>>*/ caml_int64_bswap(x) : x;
-     /*<<buffer.ml:393:41>>*/ return add_int64_ne(b, _b_);
-    /*<<buffer.ml:393:57>>*/ }
-   function add_int64_be(b, x){
-     /*<<buffer.ml:396:2>>*/ var
-     x$0 = Stdlib_Sys[11] ? x :  /*<<buffer.ml:396:48>>*/ caml_int64_bswap(x);
-     /*<<buffer.ml:396:48>>*/ return add_int64_ne(b, x$0);
-    /*<<buffer.ml:396:57>>*/ }
-   var
-    Stdlib_Buffer =
-      [0,
-       create,
-       contents,
-       to_bytes,
-       sub,
-       blit,
-       nth,
-       length,
-       clear,
-       reset,
-       output_buffer,
-       truncate,
-       add_char,
-       add_utf_8_uchar,
-       add_utf_16le_uchar,
-       add_utf_16be_uchar,
-       add_string,
-       add_bytes,
-       add_substring,
-       add_subbytes,
-       add_substitute,
-       add_buffer,
-       add_channel,
-       to_seq,
-       to_seqi,
-       add_seq,
-       of_seq,
-       add_int8,
-       add_int8,
-       add_int16_ne,
-       add_int16_be,
-       add_int16_le,
-       add_int16_ne,
-       add_int16_be,
-       add_int16_le,
-       add_int32_ne,
-       add_int32_be,
-       add_int32_le,
-       add_int64_ne,
-       add_int64_be,
-       add_int64_le];
-   runtime.caml_register_global(14, Stdlib_Buffer, "Stdlib__Buffer");
-   return;
-   /*<<?>>*/ }
-  (globalThis));
-
-//# unitInfo: Provides: Stdlib__Mutex
-(function(globalThis){
-   "use strict";
-   var
-    runtime = globalThis.jsoo_runtime,
-    Stdlib_Mutex =
-      [0,
-       runtime.caml_ml_mutex_new,
-       runtime.caml_ml_mutex_lock,
-       runtime.caml_ml_mutex_try_lock,
-       runtime.caml_ml_mutex_unlock];
-   runtime.caml_register_global(0, Stdlib_Mutex, "Stdlib__Mutex");
-   return;
-   /*<<?>>*/ }
-  (globalThis));
-
-//# unitInfo: Provides: Stdlib__Condition
-(function(globalThis){
-   "use strict";
-   var
-    runtime = globalThis.jsoo_runtime,
-    Stdlib_Condition =
-      [0,
-       runtime.caml_ml_condition_new,
-       runtime.caml_ml_condition_wait,
-       runtime.caml_ml_condition_signal,
-       runtime.caml_ml_condition_broadcast];
-   runtime.caml_register_global(0, Stdlib_Condition, "Stdlib__Condition");
-   return;
-   /*<<?>>*/ }
-  (globalThis));
-
-//# unitInfo: Provides: Stdlib__Semaphore
-//# unitInfo: Requires: Stdlib, Stdlib__Condition, Stdlib__Mutex
-(function
-  (globalThis){
-   "use strict";
-   var
-    runtime = globalThis.jsoo_runtime,
-    caml_maybe_attach_backtrace = runtime.caml_maybe_attach_backtrace;
-    /*<<?>>*/ function caml_call1(f, a0){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 1
-            ? f(a0)
-            : runtime.caml_call_gen(f, [a0]);
-   }
-    /*<<?>>*/ function caml_call2(f, a0, a1){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 2
-            ? f(a0, a1)
-            : runtime.caml_call_gen(f, [a0, a1]);
-   }
-   var
-    global_data = runtime.caml_get_global_data(),
-    Stdlib_Mutex = global_data.Stdlib__Mutex,
-    Stdlib_Condition = global_data.Stdlib__Condition,
-    Stdlib = global_data.Stdlib,
-    cst_Semaphore_Counting_release = "Semaphore.Counting.release: overflow",
-    cst_Semaphore_Counting_init_wr =
-      "Semaphore.Counting.init: wrong initial value";
-   function make(v){
-     /*<<semaphore.ml:29:2>>*/ if(v < 0)
-      /*<<semaphore.ml:29:16>>*/  /*<<semaphore.ml:29:16>>*/ caml_call1
-      (Stdlib[1], cst_Semaphore_Counting_init_wr);
-     /*<<semaphore.ml:30:39>>*/  /*<<semaphore.ml:30:39>>*/ var
-     _c_ =  /*<<semaphore.ml:30:39>>*/ caml_call1(Stdlib_Condition[1], 0);
-     /*<<semaphore.ml:30:2>>*/ return [0,
-             /*<<semaphore.ml:30:10>>*/ caml_call1(Stdlib_Mutex[1], 0),
-            v,
-            _c_];
-    /*<<semaphore.ml:30:59>>*/ }
-   function release(s){
-     /*<<semaphore.ml:33:2>>*/  /*<<semaphore.ml:33:2>>*/ caml_call1
-     (Stdlib_Mutex[2], s[1]);
-    if(s[2] < Stdlib[19]){
-     s[2] = s[2] + 1 | 0;
-      /*<<semaphore.ml:36:4>>*/  /*<<semaphore.ml:36:4>>*/ caml_call1
-      (Stdlib_Condition[3], s[3]);
-     return caml_call1(Stdlib_Mutex[4], s[1]);
-    }
-     /*<<semaphore.ml:39:4>>*/  /*<<semaphore.ml:39:4>>*/ caml_call1
-     (Stdlib_Mutex[4], s[1]);
-     /*<<semaphore.ml:40:4>>*/ throw  /*<<semaphore.ml:40:4>>*/ caml_maybe_attach_backtrace
-           ([0, Stdlib[11], cst_Semaphore_Counting_release], 1);
-    /*<<semaphore.ml:41:5>>*/ }
-   function acquire(s){
-     /*<<semaphore.ml:44:2>>*/  /*<<semaphore.ml:44:2>>*/ caml_call1
-     (Stdlib_Mutex[2], s[1]);
-     /*<<semaphore.ml:45:19>>*/ for(;;){
-     if(0 !== s[2]){
-      s[2] = s[2] - 1 | 0;
-      return caml_call1(Stdlib_Mutex[4], s[1]);
-     }
-      /*<<semaphore.ml:45:19>>*/  /*<<semaphore.ml:45:19>>*/ caml_call2
-      (Stdlib_Condition[2], s[3], s[1]);
-    }
-    /*<<semaphore.ml:47:20>>*/ }
-   function try_acquire(s){
-     /*<<semaphore.ml:50:2>>*/  /*<<semaphore.ml:50:2>>*/ caml_call1
-     (Stdlib_Mutex[2], s[1]);
-    var ret = 0 === s[2] ? 0 : (s[2] = s[2] - 1 | 0, 1);
-     /*<<semaphore.ml:52:2>>*/  /*<<semaphore.ml:52:2>>*/ caml_call1
-     (Stdlib_Mutex[4], s[1]);
-     /*<<semaphore.ml:52:2>>*/ return ret;
-    /*<<semaphore.ml:53:5>>*/ }
-   function get_value(s){
-     /*<<semaphore.ml:55:18>>*/ return s[2];
-    /*<<semaphore.ml:55:21>>*/ }
-    /*<<semaphore.ml:24:18>>*/  /*<<semaphore.ml:24:18>>*/ var
-    Counting = [0, make, release, acquire, try_acquire, get_value];
-   function make$0(b){
-     /*<<semaphore.ml:64:2>>*/ var
-      /*<<semaphore.ml:66:14>>*/ _a_ =
-        /*<<semaphore.ml:66:14>>*/ caml_call1(Stdlib_Condition[1], 0),
-     _b_ = b ? 1 : 0;
-     /*<<semaphore.ml:64:2>>*/ return [0,
-             /*<<semaphore.ml:64:10>>*/ caml_call1(Stdlib_Mutex[1], 0),
-            _b_,
-            _a_];
-    /*<<semaphore.ml:66:34>>*/ }
-   function release$0(s){
-     /*<<semaphore.ml:69:2>>*/  /*<<semaphore.ml:69:2>>*/ caml_call1
-     (Stdlib_Mutex[2], s[1]);
-    s[2] = 1;
-     /*<<semaphore.ml:71:2>>*/  /*<<semaphore.ml:71:2>>*/ caml_call1
-     (Stdlib_Condition[3], s[3]);
-    return caml_call1(Stdlib_Mutex[4], s[1]);
-    /*<<semaphore.ml:72:20>>*/ }
-   function acquire$0(s){
-     /*<<semaphore.ml:75:2>>*/  /*<<semaphore.ml:75:2>>*/ caml_call1
-     (Stdlib_Mutex[2], s[1]);
-     /*<<semaphore.ml:76:19>>*/ for(;;){
-     if(0 !== s[2]){s[2] = 0; return caml_call1(Stdlib_Mutex[4], s[1]);}
-      /*<<semaphore.ml:76:19>>*/  /*<<semaphore.ml:76:19>>*/ caml_call2
-      (Stdlib_Condition[2], s[3], s[1]);
-    }
-    /*<<semaphore.ml:78:20>>*/ }
-   function try_acquire$0(s){
-     /*<<semaphore.ml:81:2>>*/  /*<<semaphore.ml:81:2>>*/ caml_call1
-     (Stdlib_Mutex[2], s[1]);
-    var ret = 0 === s[2] ? 0 : (s[2] = 0, 1);
-     /*<<semaphore.ml:83:2>>*/  /*<<semaphore.ml:83:2>>*/ caml_call1
-     (Stdlib_Mutex[4], s[1]);
-     /*<<semaphore.ml:83:2>>*/ return ret;
-    /*<<semaphore.ml:84:5>>*/ }
-    /*<<semaphore.ml:59:16>>*/ var
-     /*<<semaphore.ml:59:16>>*/ Binary =
-      [0, make$0, release$0, acquire$0, try_acquire$0],
-    Stdlib_Semaphore = [0, Counting, Binary];
-   runtime.caml_register_global(5, Stdlib_Semaphore, "Stdlib__Semaphore");
-   return;
-   /*<<?>>*/ }
-  (globalThis));
-
-//# unitInfo: Provides: Stdlib__Domain
-//# unitInfo: Requires: Stdlib, Stdlib__Array, Stdlib__Atomic, Stdlib__Condition, Stdlib__List, Stdlib__Mutex
-(function
-  (globalThis){
-   "use strict";
-   var
-    runtime = globalThis.jsoo_runtime,
-    caml_check_bound = runtime.caml_check_bound,
-    caml_domain_dls_set = runtime.caml_domain_dls_set,
-    caml_make_vect = runtime.caml_make_vect,
-    caml_maybe_attach_backtrace = runtime.caml_maybe_attach_backtrace,
-    caml_ml_domain_id = runtime.caml_ml_domain_id,
-    caml_wrap_exception = runtime.caml_wrap_exception;
-    /*<<?>>*/ function caml_call1(f, a0){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 1
-            ? f(a0)
-            : runtime.caml_call_gen(f, [a0]);
-   }
-    /*<<?>>*/ function caml_call2(f, a0, a1){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 2
-            ? f(a0, a1)
-            : runtime.caml_call_gen(f, [a0, a1]);
-   }
-    /*<<?>>*/ function caml_call3(f, a0, a1, a2){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 3
-            ? f(a0, a1, a2)
-            : runtime.caml_call_gen(f, [a0, a1, a2]);
-   }
-    /*<<?>>*/ function caml_call5(f, a0, a1, a2, a3, a4){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 5
-            ? f(a0, a1, a2, a3, a4)
-            : runtime.caml_call_gen(f, [a0, a1, a2, a3, a4]);
-   }
-   var
-    global_data = runtime.caml_get_global_data(),
-    Stdlib_Mutex = global_data.Stdlib__Mutex,
-    Stdlib_Condition = global_data.Stdlib__Condition,
-    Stdlib = global_data.Stdlib,
-    Stdlib_Atomic = global_data.Stdlib__Atomic,
-    Stdlib_List = global_data.Stdlib__List,
-    Stdlib_Array = global_data.Stdlib__Array,
-    cst_internal_error_Am_I_alread = "internal error: Am I already finished?",
-    cst_first_domain_already_spawn = "first domain already spawned";
-   function cpu_relax(param){
-     /*<<domain.ml:32:19>>*/ return  /*<<domain.ml:32:19>>*/ runtime.caml_ml_domain_cpu_relax
-            (0);
-    /*<<domain.ml:32:35>>*/ }
-    /*<<domain.ml:51:30>>*/  /*<<domain.ml:51:30>>*/ var
-    unique_value = [0, 0];
-   function create_dls(param){
-     /*<<domain.ml:59:4>>*/  /*<<domain.ml:59:13>>*/ var
-     st =  /*<<domain.ml:59:13>>*/ caml_make_vect(8, unique_value);
-     /*<<domain.ml:60:4>>*/ return  /*<<domain.ml:60:4>>*/ caml_domain_dls_set
-            (st);
-    /*<<domain.ml:60:20>>*/ }
-    /*<<domain.ml:62:10>>*/ create_dls(0);
-    /*<<domain.ml:66:20>>*/ var
-     /*<<domain.ml:66:20>>*/ key_counter =
-       /*<<domain.ml:66:20>>*/ caml_call1(Stdlib_Atomic[1], 0),
-     /*<<domain.ml:71:20>>*/ parent_keys =
-       /*<<domain.ml:71:20>>*/ caml_call1(Stdlib_Atomic[1], 0);
-   function new_key(split_from_parent, init_orphan){
-     /*<<domain.ml:79:4>>*/ var
-      /*<<domain.ml:79:14>>*/ idx =
-        /*<<domain.ml:79:14>>*/ caml_call2(Stdlib_Atomic[6], key_counter, 1),
-      /*<<domain.ml:80:12>>*/ k = [0, idx, init_orphan];
-     /*<<domain.ml:81:4>>*/ if(split_from_parent){
-      /*<<domain.ml:83:35>>*/ var
-      split = split_from_parent[1],
-       /*<<domain.ml:83:35>>*/ ki = [0, k, split];
-      /*<<domain.ml:74:4>>*/ for(;;){
-       /*<<domain.ml:74:12>>*/  /*<<domain.ml:74:12>>*/ var
-       l =  /*<<domain.ml:74:12>>*/ caml_call1(Stdlib_Atomic[2], parent_keys);
-      if
-       (!
-        (1
-        -
-          /*<<domain.ml:75:11>>*/ caml_call3
-          (Stdlib_Atomic[5], parent_keys, l, [0, ki, l])))
-       break;
-     }
-    }
-     /*<<domain.ml:85:4>>*/ return k;
-    /*<<domain.ml:85:5>>*/ }
-   function maybe_grow(idx){
-     /*<<domain.ml:90:4>>*/ var
-     st = runtime.caml_domain_dls_get(0),
-      /*<<domain.ml:91:4>>*/ sz = st.length - 1;
-    if(idx < sz)  /*<<domain.ml:92:21>>*/ return st;
-    var new_sz = sz;
-     /*<<domain.ml:95:8>>*/ for(;;){
-     if(idx < new_sz){
-       /*<<domain.ml:98:19>>*/  /*<<domain.ml:98:19>>*/ var
-       new_st =  /*<<domain.ml:98:19>>*/ caml_make_vect(new_sz, unique_value);
-       /*<<domain.ml:99:6>>*/  /*<<domain.ml:99:6>>*/ caml_call5
-       (Stdlib_Array[8], st, 0, new_st, 0, sz);
-       /*<<domain.ml:100:6>>*/  /*<<domain.ml:100:6>>*/ caml_domain_dls_set
-       (new_st);
-       /*<<domain.ml:100:6>>*/ return new_st;
-     }
-     var s = 2 * new_sz | 0, new_sz = s;
-    }
-    /*<<domain.ml:102:7>>*/ }
-   function set(param, x){
-     /*<<domain.ml:105:13>>*/ var
-     idx = param[1],
-      /*<<domain.ml:105:13>>*/ st = maybe_grow(idx);
-     /*<<domain.ml:109:4>>*/ caml_check_bound(st, idx)[1 + idx] = x;
-     /*<<domain.ml:109:4>>*/ return 0;
-   }
-   function get(param){
-     /*<<domain.ml:112:13>>*/ var
-     init = param[2],
-     idx = param[1],
-      /*<<domain.ml:112:13>>*/ st = maybe_grow(idx),
-      /*<<domain.ml:113:12>>*/ v = caml_check_bound(st, idx)[1 + idx];
-    if(v !== unique_value)  /*<<domain.ml:118:9>>*/ return v;
-     /*<<domain.ml:115:24>>*/  /*<<domain.ml:115:24>>*/ var
-     v$0 =  /*<<domain.ml:115:24>>*/ caml_call1(init, 0);
-     /*<<domain.ml:116:6>>*/ caml_check_bound(st, idx)[1 + idx] = v$0;
-     /*<<domain.ml:116:6>>*/ return v$0;
-   }
-   function get_id(param){
-    var domain = param[1];
-     /*<<domain.ml:136:27>>*/ return domain;
-   }
-   function self(param){
-     /*<<domain.ml:138:14>>*/ return  /*<<domain.ml:138:14>>*/ caml_ml_domain_id
-            (0);
-    /*<<domain.ml:138:25>>*/ }
-   function is_main_domain(param){
-     /*<<domain.ml:140:24>>*/ return 0
-            ===  /*<<domain.ml:140:25>>*/ caml_ml_domain_id(0)
-            ? 1
-            : 0;
-    /*<<domain.ml:140:44>>*/ }
-    /*<<domain.ml:145:27>>*/ var
-     /*<<domain.ml:145:27>>*/ first_domain_spawned =
-       /*<<domain.ml:145:27>>*/ caml_call1(Stdlib_Atomic[1], 0),
-     /*<<domain.ml:147:27>>*/ first_spawn_function =
-      [0,
-       function(param){
-         /*<<domain.ml:147:42>>*/ return 0;
-        /*<<domain.ml:147:44>>*/ }];
-   function before_first_spawn(f){
-     /*<<domain.ml:150:2>>*/ if
-     ( /*<<domain.ml:150:5>>*/ caml_call1
-       (Stdlib_Atomic[2], first_domain_spawned))
-      /*<<domain.ml:151:4>>*/ throw  /*<<domain.ml:151:4>>*/ caml_maybe_attach_backtrace
-            ([0, Stdlib[6], cst_first_domain_already_spawn], 1);
-    var old_f = first_spawn_function[1];
-    function new_f(param){
-      /*<<domain.ml:154:19>>*/  /*<<domain.ml:154:19>>*/ caml_call1(old_f, 0);
-      /*<<domain.ml:154:19>>*/ return  /*<<domain.ml:154:19>>*/ caml_call1
-             (f, 0);
-     /*<<domain.ml:154:33>>*/ }
-    first_spawn_function[1] = new_f;
-    return 0;
-    /*<<domain.ml:156:5>>*/ }
-    /*<<domain.ml:166:18>>*/  /*<<domain.ml:166:18>>*/ var
-    at_exit_key =
-      new_key
-       (0,
-        function(param, _e_){
-          /*<<domain.ml:166:52>>*/ return 0;
-         /*<<domain.ml:166:54>>*/ });
-   function at_exit(f){
-     /*<<domain.ml:169:2>>*/  /*<<domain.ml:169:32>>*/ var
-     old_exit = get(at_exit_key);
-    function new_exit(param){
-      /*<<domain.ml:175:4>>*/  /*<<domain.ml:175:4>>*/ caml_call1(f, 0);
-      /*<<domain.ml:175:4>>*/ return  /*<<domain.ml:175:4>>*/ caml_call1
-             (old_exit, 0);
-     /*<<domain.ml:175:21>>*/ }
-     /*<<domain.ml:177:2>>*/ return set(at_exit_key, new_exit);
-    /*<<domain.ml:177:30>>*/ }
-   function do_at_exit(param){
-     /*<<domain.ml:180:2>>*/  /*<<domain.ml:180:25>>*/ var
-     f = get(at_exit_key);
-     /*<<domain.ml:181:2>>*/ return  /*<<domain.ml:181:2>>*/ caml_call1(f, 0);
-    /*<<domain.ml:181:6>>*/ }
-   Stdlib[104][1] = do_at_exit;
-   function spawn(f){
-     /*<<domain.ml:188:2>>*/ if
-     (1
-      -
-        /*<<domain.ml:159:9>>*/ caml_call1
-        (Stdlib_Atomic[2], first_domain_spawned)){
-      /*<<domain.ml:160:4>>*/  /*<<domain.ml:160:4>>*/ caml_call2
-      (Stdlib_Atomic[3], first_domain_spawned, 1);
-      /*<<domain.ml:161:4>>*/  /*<<domain.ml:161:4>>*/ caml_call1
-      (first_spawn_function[1], 0);
-     first_spawn_function[1] =
-      function(param){
-        /*<<domain.ml:163:39>>*/ return 0;
-       /*<<domain.ml:163:41>>*/ };
-    }
-     /*<<domain.ml:124:6>>*/  /*<<domain.ml:124:6>>*/ var
-     _a_ =  /*<<domain.ml:124:6>>*/ caml_call1(Stdlib_Atomic[2], parent_keys);
-    function _b_(param){
-      /*<<domain.ml:122:6>>*/ var split = param[2], k = param[1], idx = k[1];
-      /*<<domain.ml:123:11>>*/ return [0,
-             idx,
-              /*<<domain.ml:123:26>>*/ caml_call1(split, get(k))];
-     /*<<domain.ml:123:43>>*/ }
-     /*<<domain.ml:124:6>>*/ var
-      /*<<domain.ml:124:6>>*/ pk =
-        /*<<domain.ml:124:6>>*/ caml_call2(Stdlib_List[19], _b_, _a_),
-      /*<<domain.ml:193:19>>*/ term_mutex =
-        /*<<domain.ml:193:19>>*/ caml_call1(Stdlib_Mutex[1], 0),
-      /*<<domain.ml:194:23>>*/ term_condition =
-        /*<<domain.ml:194:23>>*/ caml_call1(Stdlib_Condition[1], 0),
-      /*<<domain.ml:195:19>>*/ term_state = [0, 0];
-    function body(param){
-      /*<<domain.ml:198:4>>*/ a:
-     {
-       /*<<domain.ml:198:4>>*/ try{
-        /*<<domain.ml:200:8>>*/ create_dls(0);
-       var
-        _c_ =
-          function(param){
-            /*<<domain.ml:128:6>>*/ var
-            v = param[2],
-            idx = param[1],
-             /*<<domain.ml:129:17>>*/ st = maybe_grow(idx);
-            /*<<domain.ml:129:35>>*/ caml_check_bound(st, idx)[1 + idx] = v;
-            /*<<domain.ml:129:35>>*/ return 0;
-           /*<<domain.ml:129:49>>*/ };
-        /*<<domain.ml:127:4>>*/  /*<<domain.ml:127:4>>*/ caml_call2
-        (Stdlib_List[17], _c_, pk);
-        /*<<domain.ml:202:18>>*/  /*<<domain.ml:202:18>>*/ var
-        res =  /*<<domain.ml:202:18>>*/ caml_call1(f, 0);
-      }
-      catch(ex$0){
-       var ex = caml_wrap_exception(ex$0), result = [1, ex];
-       break a;
-      }
-      var result = [0, res];
-     }
-      /*<<domain.ml:209:4>>*/ try{
-       /*<<domain.ml:212:12>>*/ do_at_exit(0);
-      var result$0 = result;
-     }
-     catch(ex){
-       /*<<domain.ml:215:10>>*/ var
-       ex$0 = caml_wrap_exception(ex),
-        /*<<domain.ml:215:10>>*/ _d_ = 0 === result[0] ? [1, ex$0] : result,
-       result$0 = _d_;
-     }
-      /*<<domain.ml:230:4>>*/  /*<<domain.ml:230:4>>*/ caml_call1
-      (Stdlib_Mutex[2], term_mutex);
-     return term_state[1]
-             ?  /*<<domain.ml:236:8>>*/ caml_call1
-               (Stdlib[2], cst_internal_error_Am_I_alread)
-             : (term_state
-                [1]
-               = [0, result$0],
-                /*<<domain.ml:197:2>>*/ caml_call1
-                (Stdlib_Condition[4], term_condition));
-     /*<<domain.ml:236:57>>*/ }
-     /*<<domain.ml:240:2>>*/ return [0,
-             /*<<domain.ml:240:13>>*/ runtime.caml_domain_spawn
-             (body, term_mutex),
-            term_mutex,
-            term_condition,
-            term_state];
-    /*<<domain.ml:243:16>>*/ }
-   function join(param){
-    var
-     term_state = param[4],
-     term_condition = param[3],
-     term_mutex = param[2];
-     /*<<domain.ml:246:2>>*/  /*<<domain.ml:246:2>>*/ caml_call1
-     (Stdlib_Mutex[2], term_mutex);
-     /*<<domain.ml:248:4>>*/ for(;;){
-     var match = term_state[1];
-     if(match){
-      var res = match[1];
-       /*<<domain.ml:253:8>>*/  /*<<domain.ml:253:8>>*/ caml_call1
-       (Stdlib_Mutex[4], term_mutex);
-      if(0 === res[0]){var x = res[1];  /*<<domain.ml:257:12>>*/ return x;}
-      var ex = res[1];
-       /*<<domain.ml:258:16>>*/ throw  /*<<domain.ml:258:16>>*/ caml_maybe_attach_backtrace
-             (ex, 1);
-     }
-      /*<<domain.ml:250:8>>*/  /*<<domain.ml:250:8>>*/ caml_call2
-      (Stdlib_Condition[2], term_condition, term_mutex);
-    }
-   }
-   var
-    recommended_domain_count = runtime.caml_recommended_domain_count,
-    Stdlib_Domain =
-      [0,
-       spawn,
-       join,
-       get_id,
-       self,
-       before_first_spawn,
-       at_exit,
-       cpu_relax,
-       is_main_domain,
-       recommended_domain_count,
-       [0, new_key, get, set]];
-   runtime.caml_register_global(8, Stdlib_Domain, "Stdlib__Domain");
-   return;
-   /*<<?>>*/ }
-  (globalThis));
-
-//# unitInfo: Provides: CamlinternalFormat
-//# unitInfo: Requires: Assert_failure, CamlinternalFormatBasics, Stdlib, Stdlib__Buffer, Stdlib__Bytes, Stdlib__Char, Stdlib__Int, Stdlib__String, Stdlib__Sys
-(function
-  (globalThis){
-   "use strict";
-   var
-    runtime = globalThis.jsoo_runtime,
-    cst$43 = "",
-    cst_and = " and ",
-    cst_Li$3 = "%Li",
-    cst_i$3 = "%i",
-    cst_li$3 = "%li",
-    cst_ni$3 = "%ni",
-    cst_u$0 = "%u",
-    cst$42 = "' '",
-    cst$41 = "'#'",
-    cst$39 = "'*'",
-    cst$40 = "'+'",
-    cst$44 = ", ",
-    cst_0$3 = "0",
-    cst_at_character_number = ": at character number ",
-    cst$38 = "@[",
-    cst$37 = "@{",
-    cst_bad_input_format_type_mism =
-      "bad input: format type mismatch between ",
-    cst_bad_input_format_type_mism$0 =
-      "bad input: format type mismatch between %S and %S",
-    cst_camlinternalFormat_ml = "camlinternalFormat.ml",
-    cst_invalid_format = "invalid format ",
-    cst_precision$3 = "precision",
-    caml_blit_string = runtime.caml_blit_string,
-    caml_bytes_set = runtime.caml_bytes_set,
-    caml_create_bytes = runtime.caml_create_bytes,
-    caml_format_float = runtime.caml_format_float,
-    caml_format_int = runtime.caml_format_int,
-    caml_maybe_attach_backtrace = runtime.caml_maybe_attach_backtrace,
-    caml_ml_string_length = runtime.caml_ml_string_length,
-    caml_notequal = runtime.caml_notequal,
-    caml_string_get = runtime.caml_string_get,
-    caml_string_notequal = runtime.caml_string_notequal,
-    caml_string_unsafe_get = runtime.caml_string_unsafe_get,
-    caml_trampoline = runtime.caml_trampoline,
-    caml_trampoline_return = runtime.caml_trampoline_return,
-    caml_wrap_exception = runtime.caml_wrap_exception;
-    /*<<?>>*/ function caml_call1(f, a0){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 1
-            ? f(a0)
-            : runtime.caml_call_gen(f, [a0]);
-   }
-    /*<<?>>*/ function caml_call2(f, a0, a1){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 2
-            ? f(a0, a1)
-            : runtime.caml_call_gen(f, [a0, a1]);
-   }
-    /*<<?>>*/ function caml_call3(f, a0, a1, a2){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 3
-            ? f(a0, a1, a2)
-            : runtime.caml_call_gen(f, [a0, a1, a2]);
-   }
-    /*<<?>>*/ function caml_call4(f, a0, a1, a2, a3){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 4
-            ? f(a0, a1, a2, a3)
-            : runtime.caml_call_gen(f, [a0, a1, a2, a3]);
-   }
-    /*<<?>>*/ function caml_call5(f, a0, a1, a2, a3, a4){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 5
-            ? f(a0, a1, a2, a3, a4)
-            : runtime.caml_call_gen(f, [a0, a1, a2, a3, a4]);
-   }
-   var
-    global_data = runtime.caml_get_global_data(),
-    cst$9 = "%{",
-    cst$10 = "%}",
-    cst$11 = "%(",
-    cst$12 = "%)",
-    cst$13 = "%?",
-    cst$18 = cst$37,
-    cst$19 = cst$38,
-    cst$20 = cst$37,
-    cst$21 = cst$38,
-    cst$22 = cst$37,
-    cst$23 = cst$38,
-    cst$26 = cst$39,
-    cst$24 = "'-'",
-    cst$25 = cst$39,
-    cst$27 = cst$40,
-    cst$28 = cst$41,
-    cst$29 = cst$42,
-    cst$30 = cst$40,
-    cst$31 = "'_'",
-    sub_format = [0, 0, cst$43],
-    formatting_lit = [0, "@;", 1, 0],
-    cst$35 = cst$41,
-    cst$32 = cst$40,
-    cst$33 = cst$40,
-    cst$34 = cst$42,
-    cst$36 = cst$40,
-    cst$17 = ".",
-    cst$14 = "%!",
-    cst$15 = cst$37,
-    cst$16 = cst$38,
-    cst$8 = "%%",
-    cst$0 = "@]",
-    cst$1 = "@}",
-    cst$2 = "@?",
-    cst$3 = "@\n",
-    cst$4 = "@.",
-    cst$5 = "@@",
-    cst$6 = "@%",
-    cst$7 = "@",
-    cst = ".*",
-    Assert_failure = global_data.Assert_failure,
-    CamlinternalFormatBasics = global_data.CamlinternalFormatBasics,
-    Stdlib = global_data.Stdlib,
-    Stdlib_Buffer = global_data.Stdlib__Buffer,
-    Stdlib_String = global_data.Stdlib__String,
-    Stdlib_Sys = global_data.Stdlib__Sys,
-    Stdlib_Char = global_data.Stdlib__Char,
-    Stdlib_Bytes = global_data.Stdlib__Bytes,
-    Stdlib_Int = global_data.Stdlib__Int,
-    cst_c = "%c",
-    cst_s = "%s",
-    cst_i = cst_i$3,
-    cst_li = cst_li$3,
-    cst_ni = cst_ni$3,
-    cst_Li = cst_Li$3,
-    cst_f = "%f",
-    cst_B = "%B",
-    cst_a = "%a",
-    cst_t = "%t",
-    cst_r = "%r",
-    cst_r$0 = "%_r",
-    _b_ = [0, cst_camlinternalFormat_ml, 850, 23],
-    _m_ = [0, cst_camlinternalFormat_ml, 814, 21],
-    _e_ = [0, cst_camlinternalFormat_ml, 815, 21],
-    _n_ = [0, cst_camlinternalFormat_ml, 818, 21],
-    _f_ = [0, cst_camlinternalFormat_ml, 819, 21],
-    _o_ = [0, cst_camlinternalFormat_ml, 822, 19],
-    _g_ = [0, cst_camlinternalFormat_ml, 823, 19],
-    _p_ = [0, cst_camlinternalFormat_ml, 826, 22],
-    _h_ = [0, cst_camlinternalFormat_ml, 827, 22],
-    _q_ = [0, cst_camlinternalFormat_ml, 831, 30],
-    _i_ = [0, cst_camlinternalFormat_ml, 832, 30],
-    _k_ = [0, cst_camlinternalFormat_ml, 836, 26],
-    _c_ = [0, cst_camlinternalFormat_ml, 837, 26],
-    _l_ = [0, cst_camlinternalFormat_ml, 846, 28],
-    _d_ = [0, cst_camlinternalFormat_ml, 847, 28],
-    _j_ = [0, cst_camlinternalFormat_ml, 851, 23],
-    _s_ = [0, cst_camlinternalFormat_ml, 1558, 4],
-    cst_Printf_bad_conversion = "Printf: bad conversion %[",
-    _t_ = [0, cst_camlinternalFormat_ml, 1626, 39],
-    _u_ = [0, cst_camlinternalFormat_ml, 1649, 31],
-    _v_ = [0, cst_camlinternalFormat_ml, 1650, 31],
-    cst_Printf_bad_conversion$0 = "Printf: bad conversion %_",
-    _w_ = [0, cst_camlinternalFormat_ml, 1830, 8],
-    ___ =
-      [0,
-       [11, cst_bad_input_format_type_mism, [3, 0, [11, cst_and, [3, 0, 0]]]],
-       cst_bad_input_format_type_mism$0],
-    _Z_ =
-      [0,
-       [11, cst_bad_input_format_type_mism, [3, 0, [11, cst_and, [3, 0, 0]]]],
-       cst_bad_input_format_type_mism$0],
-    _C_ =
-      [0,
-       [11,
-        cst_invalid_format,
-        [3,
-         0,
-         [11,
-          cst_at_character_number,
-          [4, 0, 0, 0, [11, ", duplicate flag ", [1, 0]]]]]],
-       "invalid format %S: at character number %d, duplicate flag %C"],
-    cst_0 = cst_0$3,
-    cst_padding = "padding",
-    _D_ = [0, 1, 0],
-    _E_ = [0, 0],
-    cst_precision = cst_precision$3,
-    _F_ = [1, 0],
-    _G_ = [1, 1],
-    cst_0$2 = "'0'",
-    cst_0$0 = cst_0$3,
-    _I_ = [1, 1],
-    cst_0$1 = cst_0$3,
-    cst_precision$0 = cst_precision$3,
-    _H_ = [1, 1],
-    cst_precision$1 = cst_precision$3,
-    _M_ =
-      [0,
-       [11,
-        cst_invalid_format,
-        [3,
-         0,
-         [11,
-          cst_at_character_number,
-          [4,
-           0,
-           0,
-           0,
-           [11,
-            ", flag ",
-            [1,
-             [11,
-              " is only allowed after the '",
-              [12, 37, [11, "', before padding and precision", 0]]]]]]]]],
-       "invalid format %S: at character number %d, flag %C is only allowed after the '%%', before padding and precision"],
-    _J_ =
-      [0,
-       [11,
-        cst_invalid_format,
-        [3,
-         0,
-         [11,
-          cst_at_character_number,
-          [4,
-           0,
-           0,
-           0,
-           [11, ', invalid conversion "', [12, 37, [0, [12, 34, 0]]]]]]]],
-       'invalid format %S: at character number %d, invalid conversion "%%%c"'],
-    _K_ = [0, 0],
-    cst_padding$0 = "`padding'",
-    _L_ = [0, 0],
-    cst_precision$2 = "`precision'",
-    _N_ = [0, [12, 64, 0]],
-    _O_ = [0, "@ ", 1, 0],
-    _P_ = [0, "@,", 0, 0],
-    _Q_ = [2, 60],
-    _R_ =
-      [0,
-       [11,
-        cst_invalid_format,
-        [3,
-         0,
-         [11,
-          ": '",
-          [12,
-           37,
-           [11,
-            "' alone is not accepted in character sets, use ",
-            [12,
-             37,
-             [12,
-              37,
-              [11, " instead at position ", [4, 0, 0, 0, [12, 46, 0]]]]]]]]]],
-       "invalid format %S: '%%' alone is not accepted in character sets, use %%%% instead at position %d."],
-    _S_ =
-      [0,
-       [11,
-        cst_invalid_format,
-        [3,
-         0,
-         [11,
-          ": integer ",
-          [4, 0, 0, 0, [11, " is greater than the limit ", [4, 0, 0, 0, 0]]]]]],
-       "invalid format %S: integer %d is greater than the limit %d"],
-    cst_digit = "digit",
-    _T_ = [0, cst_camlinternalFormat_ml, 2837, 11],
-    _U_ =
-      [0,
-       [11,
-        cst_invalid_format,
-        [3,
-         0,
-         [11,
-          ': unclosed sub-format, expected "',
-          [12, 37, [0, [11, '" at character number ', [4, 0, 0, 0, 0]]]]]]],
-       'invalid format %S: unclosed sub-format, expected "%%%c" at character number %d'],
-    cst_character = "character ')'",
-    cst_character$0 = "character '}'",
-    _V_ = [0, cst_camlinternalFormat_ml, 2899, 34],
-    _W_ = [0, cst_camlinternalFormat_ml, 2935, 28],
-    _X_ = [0, cst_camlinternalFormat_ml, 2957, 11],
-    _Y_ =
-      [0,
-       [11,
-        cst_invalid_format,
-        [3,
-         0,
-         [11,
-          cst_at_character_number,
-          [4,
-           0,
-           0,
-           0,
-           [11,
-            cst$44,
-            [2,
-             0,
-             [11,
-              " is incompatible with '",
-              [0, [11, "' in sub-format ", [3, 0, 0]]]]]]]]]],
-       "invalid format %S: at character number %d, %s is incompatible with '%c' in sub-format %S"],
-    _B_ =
-      [0,
-       [11,
-        cst_invalid_format,
-        [3,
-         0,
-         [11,
-          cst_at_character_number,
-          [4, 0, 0, 0, [11, cst$44, [2, 0, [11, " expected, read ", [1, 0]]]]]]]],
-       "invalid format %S: at character number %d, %s expected, read %C"],
-    _A_ =
-      [0,
-       [11,
-        cst_invalid_format,
-        [3,
-         0,
-         [11,
-          cst_at_character_number,
-          [4, 0, 0, 0, [11, ", '", [0, [11, "' without ", [2, 0, 0]]]]]]]],
-       "invalid format %S: at character number %d, '%c' without %s"],
-    cst_non_zero_widths_are_unsupp =
-      "non-zero widths are unsupported for %c conversions",
-    cst_unexpected_end_of_format = "unexpected end of format",
-    _z_ =
-      [0,
-       [11,
-        cst_invalid_format,
-        [3,
-         0,
-         [11, cst_at_character_number, [4, 0, 0, 0, [11, cst$44, [2, 0, 0]]]]]],
-       "invalid format %S: at character number %d, %s"],
-    _y_ =
-      [0,
-       [11, "invalid box description ", [3, 0, 0]],
-       "invalid box description %S"],
-    _x_ = [0, 0, 4],
-    cst_nan = "nan",
-    cst_neg_infinity = "neg_infinity",
-    cst_infinity = "infinity",
-    _r_ = [0, 103],
-    cst_nd$0 = "%+nd",
-    cst_nd$1 = "% nd",
-    cst_ni$1 = "%+ni",
-    cst_ni$2 = "% ni",
-    cst_nx = "%nx",
-    cst_nx$0 = "%#nx",
-    cst_nX = "%nX",
-    cst_nX$0 = "%#nX",
-    cst_no = "%no",
-    cst_no$0 = "%#no",
-    cst_nd = "%nd",
-    cst_ni$0 = cst_ni$3,
-    cst_nu = "%nu",
-    cst_ld$0 = "%+ld",
-    cst_ld$1 = "% ld",
-    cst_li$1 = "%+li",
-    cst_li$2 = "% li",
-    cst_lx = "%lx",
-    cst_lx$0 = "%#lx",
-    cst_lX = "%lX",
-    cst_lX$0 = "%#lX",
-    cst_lo = "%lo",
-    cst_lo$0 = "%#lo",
-    cst_ld = "%ld",
-    cst_li$0 = cst_li$3,
-    cst_lu = "%lu",
-    cst_Ld$0 = "%+Ld",
-    cst_Ld$1 = "% Ld",
-    cst_Li$1 = "%+Li",
-    cst_Li$2 = "% Li",
-    cst_Lx = "%Lx",
-    cst_Lx$0 = "%#Lx",
-    cst_LX = "%LX",
-    cst_LX$0 = "%#LX",
-    cst_Lo = "%Lo",
-    cst_Lo$0 = "%#Lo",
-    cst_Ld = "%Ld",
-    cst_Li$0 = cst_Li$3,
-    cst_Lu = "%Lu",
-    cst_d$0 = "%+d",
-    cst_d$1 = "% d",
-    cst_i$1 = "%+i",
-    cst_i$2 = "% i",
-    cst_x = "%x",
-    cst_x$0 = "%#x",
-    cst_X = "%X",
-    cst_X$0 = "%#X",
-    cst_o = "%o",
-    cst_o$0 = "%#o",
-    cst_d = "%d",
-    cst_i$0 = cst_i$3,
-    cst_u = cst_u$0,
-    cst_0c = "0c",
-    _a_ = [0, 0, 0],
-    cst_CamlinternalFormat_Type_mi = "CamlinternalFormat.Type_mismatch";
-   function create_char_set(param){
-     /*<<camlinternalFormat.ml:24:25>>*/ return  /*<<camlinternalFormat.ml:24:25>>*/ caml_call2
-            (Stdlib_Bytes[1], 32, 0);
-    /*<<camlinternalFormat.ml:24:45>>*/ }
-   function add_in_char_set(char_set, c){
-     /*<<camlinternalFormat.ml:28:2>>*/ var
-     str_ind = c >>> 3 | 0,
-     mask = 1 << (c & 7),
-      /*<<camlinternalFormat.ml:31:30>>*/ _dU_ =
-        /*<<camlinternalFormat.ml:31:30>>*/ runtime.caml_bytes_get
-        (char_set, str_ind)
-       | mask;
-     /*<<camlinternalFormat.ml:30:2>>*/ return  /*<<camlinternalFormat.ml:30:2>>*/ caml_bytes_set
-            (char_set,
-             str_ind,
-              /*<<camlinternalFormat.ml:31:4>>*/ caml_call1(Stdlib[29], _dU_));
-    /*<<camlinternalFormat.ml:31:69>>*/ }
-   function freeze_char_set(char_set){
-     /*<<camlinternalFormat.ml:34:2>>*/ return  /*<<camlinternalFormat.ml:34:2>>*/ caml_call1
-            (Stdlib_Bytes[6], char_set);
-    /*<<camlinternalFormat.ml:34:26>>*/ }
-   function rev_char_set(char_set){
-     /*<<camlinternalFormat.ml:38:2>>*/ var
-      /*<<camlinternalFormat.ml:38:18>>*/ char_set$0 = create_char_set(0),
-     i = 0;
-    for(;;){
-      /*<<camlinternalFormat.ml:41:32>>*/  /*<<camlinternalFormat.ml:41:32>>*/ var
-      _dS_ =
-         /*<<camlinternalFormat.ml:41:32>>*/ caml_string_get(char_set, i)
-        ^ 255;
-      /*<<camlinternalFormat.ml:40:4>>*/  /*<<camlinternalFormat.ml:40:4>>*/ caml_bytes_set
-      (char_set$0,
-       i,
-        /*<<camlinternalFormat.ml:41:6>>*/ caml_call1(Stdlib[29], _dS_));
-      /*<<camlinternalFormat.ml:40:4>>*/  /*<<camlinternalFormat.ml:40:4>>*/ var
-      _dT_ = i + 1 | 0;
-     if(31 === i)
-       /*<<camlinternalFormat.ml:43:2>>*/ return  /*<<camlinternalFormat.ml:43:2>>*/ caml_call1
-              (Stdlib_Bytes[44], char_set$0);
-     var i = _dT_;
-    }
-    /*<<camlinternalFormat.ml:43:34>>*/ }
-   function is_in_char_set(char_set, c){
-     /*<<camlinternalFormat.ml:47:2>>*/ var
-     str_ind = c >>> 3 | 0,
-     mask = 1 << (c & 7);
-    return 0
-            !==
-             ( /*<<camlinternalFormat.ml:49:15>>*/ caml_string_get
-              (char_set, str_ind)
-             & mask)
-            ? 1
-            : 0;
-    /*<<camlinternalFormat.ml:49:60>>*/ }
-   function pad_of_pad_opt(pad_opt){
-     /*<<camlinternalFormat.ml:62:29>>*/ if(! pad_opt)
-      /*<<camlinternalFormat.ml:63:12>>*/ return 0;
-    var width = pad_opt[1];
-     /*<<camlinternalFormat.ml:64:18>>*/ return [0, 1, width];
-    /*<<camlinternalFormat.ml:64:44>>*/ }
-   function param_format_of_ignored_format(ign, fmt){
-     /*<<camlinternalFormat.ml:76:15>>*/ if(typeof ign === "number")
-     switch(ign){
-       case 0:
-         /*<<camlinternalFormat.ml:78:4>>*/ return [0, [0, fmt]];
-       case 1:
-         /*<<camlinternalFormat.ml:80:4>>*/ return [0, [1, fmt]];
-       case 2:
-         /*<<camlinternalFormat.ml:108:4>>*/ return [0, [19, fmt]];
-       default:  /*<<camlinternalFormat.ml:114:4>>*/ return [0, [22, fmt]];
-     }
-    switch(ign[0]){
-      case 0:
-       var pad_opt = ign[1];
-        /*<<camlinternalFormat.ml:82:4>>*/ return [0,
-               [2, pad_of_pad_opt(pad_opt), fmt]];
-      case 1:
-       var pad_opt$0 = ign[1];
-        /*<<camlinternalFormat.ml:84:4>>*/ return [0,
-               [3, pad_of_pad_opt(pad_opt$0), fmt]];
-      case 2:
-       var pad_opt$1 = ign[2], iconv = ign[1];
-        /*<<camlinternalFormat.ml:86:4>>*/ return [0,
-               [4, iconv, pad_of_pad_opt(pad_opt$1), 0, fmt]];
-      case 3:
-       var pad_opt$2 = ign[2], iconv$0 = ign[1];
-        /*<<camlinternalFormat.ml:88:4>>*/ return [0,
-               [5, iconv$0, pad_of_pad_opt(pad_opt$2), 0, fmt]];
-      case 4:
-       var pad_opt$3 = ign[2], iconv$1 = ign[1];
-        /*<<camlinternalFormat.ml:91:4>>*/ return [0,
-               [6, iconv$1, pad_of_pad_opt(pad_opt$3), 0, fmt]];
-      case 5:
-       var pad_opt$4 = ign[2], iconv$2 = ign[1];
-        /*<<camlinternalFormat.ml:94:4>>*/ return [0,
-               [7, iconv$2, pad_of_pad_opt(pad_opt$4), 0, fmt]];
-      case 6:
-       var prec_opt = ign[2], pad_opt$5 = ign[1];
-       if(prec_opt)
-        var ndec = prec_opt[1], _dR_ = [0, ndec];
-       else
-        var _dR_ = 0;
-        /*<<camlinternalFormat.ml:97:4>>*/ return [0,
-               [8, _a_, pad_of_pad_opt(pad_opt$5), _dR_, fmt]];
-      case 7:
-       var pad_opt$6 = ign[1];
-        /*<<camlinternalFormat.ml:101:4>>*/ return [0,
-               [9, pad_of_pad_opt(pad_opt$6), fmt]];
-      case 8:
-       var fmtty = ign[2], pad_opt$7 = ign[1];
-        /*<<camlinternalFormat.ml:103:4>>*/ return [0,
-               [13, pad_opt$7, fmtty, fmt]];
-      case 9:
-       var fmtty$0 = ign[2], pad_opt$8 = ign[1];
-        /*<<camlinternalFormat.ml:105:4>>*/ return [0,
-               [14, pad_opt$8, fmtty$0, fmt]];
-      case 10:
-       var char_set = ign[2], width_opt = ign[1];
-        /*<<camlinternalFormat.ml:110:4>>*/ return [0,
-               [20, width_opt, char_set, fmt]];
-      default:
-       var counter = ign[1];
-        /*<<camlinternalFormat.ml:112:4>>*/ return [0, [21, counter, fmt]];
-    }
-    /*<<camlinternalFormat.ml:114:41>>*/ }
-   function default_float_precision(fconv){
-     /*<<camlinternalFormat.ml:221:2>>*/ return 5 === fconv[2] ? 12 : -6;
-    /*<<camlinternalFormat.ml:227:17>>*/ }
-   function buffer_create(init_size){
-     /*<<camlinternalFormat.ml:256:30>>*/ return [0,
-            0,
-             /*<<camlinternalFormat.ml:256:49>>*/ caml_create_bytes(init_size)];
-    /*<<camlinternalFormat.ml:256:73>>*/ }
-   function buffer_check_size(buf, overhead){
-     /*<<camlinternalFormat.ml:260:2>>*/ var
-     len = runtime.caml_ml_bytes_length(buf[2]),
-     min_len = buf[1] + overhead | 0,
-     _dP_ = len < min_len ? 1 : 0;
-    if(_dP_){
-      /*<<camlinternalFormat.ml:263:18>>*/ var
-       /*<<camlinternalFormat.ml:263:18>>*/ new_len =
-         /*<<camlinternalFormat.ml:263:18>>*/ caml_call2
-         (Stdlib_Int[11], len * 2 | 0, min_len),
-       /*<<camlinternalFormat.ml:264:18>>*/ new_str =
-         /*<<camlinternalFormat.ml:264:18>>*/ caml_create_bytes(new_len);
-      /*<<camlinternalFormat.ml:265:4>>*/  /*<<camlinternalFormat.ml:265:4>>*/ caml_call5
-      (Stdlib_Bytes[11], buf[2], 0, new_str, 0, len);
-     buf[2] = new_str;
-     var _dQ_ = 0;
-    }
-    else
-     var _dQ_ = _dP_;
-    return _dQ_;
-    /*<<camlinternalFormat.ml:267:3>>*/ }
-   function buffer_add_char(buf, c){
-     /*<<camlinternalFormat.ml:271:2>>*/ buffer_check_size(buf, 1);
-     /*<<camlinternalFormat.ml:272:2>>*/  /*<<camlinternalFormat.ml:272:2>>*/ caml_bytes_set
-     (buf[2], buf[1], c);
-    buf[1] = buf[1] + 1 | 0;
-    return 0;
-    /*<<camlinternalFormat.ml:273:24>>*/ }
-   function buffer_add_string(buf, s){
-     /*<<camlinternalFormat.ml:277:2>>*/ var
-     str_len = caml_ml_string_length(s);
-     /*<<camlinternalFormat.ml:278:2>>*/ buffer_check_size(buf, str_len);
-     /*<<camlinternalFormat.ml:279:2>>*/  /*<<camlinternalFormat.ml:279:2>>*/ caml_call5
-     (Stdlib_String[48], s, 0, buf[2], buf[1], str_len);
-    buf[1] = buf[1] + str_len | 0;
-    return 0;
-    /*<<camlinternalFormat.ml:280:30>>*/ }
-   function buffer_contents(buf){
-     /*<<camlinternalFormat.ml:284:2>>*/ return caml_call3
-            (Stdlib_Bytes[8], buf[2], 0, buf[1]);
-    /*<<camlinternalFormat.ml:284:38>>*/ }
-   function char_of_iconv(iconv){
-     /*<<camlinternalFormat.ml:289:26>>*/ switch(iconv){
-      case 6:
-      case 7:
-        /*<<camlinternalFormat.ml:291:38>>*/ return 120;
-      case 8:
-      case 9:
-        /*<<camlinternalFormat.ml:291:62>>*/ return 88;
-      case 10:
-      case 11:
-        /*<<camlinternalFormat.ml:292:14>>*/ return 111;
-      case 12:
-      case 15:
-        /*<<camlinternalFormat.ml:292:38>>*/ return 117;
-      case 0:
-      case 1:
-      case 2:
-      case 13:
-        /*<<camlinternalFormat.ml:290:40>>*/ return 100;
-      default:  /*<<camlinternalFormat.ml:291:14>>*/ return 105;
-    }
-    /*<<camlinternalFormat.ml:292:41>>*/ }
-   function char_of_fconv(opt, fconv){
-     /*<<camlinternalFormat.ml:296:36>>*/ if(opt)
-     var sth = opt[1], cF = sth;
-    else
-     var cF = 70;
-    switch(fconv[2]){
-      case 0:
-        /*<<camlinternalFormat.ml:297:15>>*/ return 102;
-      case 1:
-        /*<<camlinternalFormat.ml:297:32>>*/ return 101;
-      case 2:
-        /*<<camlinternalFormat.ml:298:15>>*/ return 69;
-      case 3:
-        /*<<camlinternalFormat.ml:298:32>>*/ return 103;
-      case 4:
-        /*<<camlinternalFormat.ml:299:15>>*/ return 71;
-      case 5:
-        /*<<camlinternalFormat.ml:299:32>>*/ return cF;
-      case 6:
-        /*<<camlinternalFormat.ml:300:15>>*/ return 104;
-      case 7:
-        /*<<camlinternalFormat.ml:300:32>>*/ return 72;
-      default:  /*<<camlinternalFormat.ml:301:16>>*/ return 70;
-    }
-    /*<<camlinternalFormat.ml:301:19>>*/ }
-   function bprint_padty(buf, padty){
-     /*<<camlinternalFormat.ml:374:29>>*/ switch(padty){
-      case 0:
-        /*<<camlinternalFormat.ml:375:13>>*/ return buffer_add_char(buf, 45);
-      case 1:
-        /*<<camlinternalFormat.ml:376:13>>*/ return 0;
-      default:
-        /*<<camlinternalFormat.ml:377:13>>*/ return buffer_add_char(buf, 48);
-    }
-    /*<<camlinternalFormat.ml:377:36>>*/ }
-   function bprint_ignored_flag(buf, ign_flag){
-     /*<<camlinternalFormat.ml:381:2>>*/ return ign_flag
-            ? buffer_add_char(buf, 95)
-            : ign_flag;
-    /*<<camlinternalFormat.ml:381:42>>*/ }
-   function bprint_pad_opt(buf, pad_opt){
-     /*<<camlinternalFormat.ml:385:33>>*/ if(! pad_opt)
-      /*<<camlinternalFormat.ml:386:12>>*/ return 0;
-    var width = pad_opt[1];
-     /*<<camlinternalFormat.ml:387:40>>*/ return buffer_add_string
-            (buf,
-              /*<<camlinternalFormat.ml:387:40>>*/ caml_call1
-              (Stdlib_Int[12], width));
-    /*<<camlinternalFormat.ml:387:61>>*/ }
-   function bprint_padding(buf, pad){
-     /*<<camlinternalFormat.ml:393:15>>*/ if(typeof pad === "number")
-      /*<<camlinternalFormat.ml:394:18>>*/ return 0;
-    if(0 === pad[0]){
-     var n = pad[2], padty = pad[1];
-      /*<<camlinternalFormat.ml:396:4>>*/ bprint_padty(buf, padty);
-      /*<<camlinternalFormat.ml:397:26>>*/ return buffer_add_string
-             (buf,
-               /*<<camlinternalFormat.ml:397:26>>*/ caml_call1
-               (Stdlib_Int[12], n));
-    }
-    var padty$0 = pad[1];
-     /*<<camlinternalFormat.ml:399:4>>*/ bprint_padty(buf, padty$0);
-     /*<<camlinternalFormat.ml:399:4>>*/ return buffer_add_char(buf, 42);
-    /*<<camlinternalFormat.ml:400:27>>*/ }
-   function bprint_precision(buf, prec){
-     /*<<camlinternalFormat.ml:404:18>>*/ if(typeof prec === "number")
-     return prec ? buffer_add_string(buf, cst) : 0;
-    var n = prec[1];
-     /*<<camlinternalFormat.ml:407:4>>*/ buffer_add_char(buf, 46);
-     /*<<camlinternalFormat.ml:408:26>>*/ return buffer_add_string
-            (buf,
-              /*<<camlinternalFormat.ml:408:26>>*/ caml_call1
-              (Stdlib_Int[12], n));
-    /*<<camlinternalFormat.ml:410:30>>*/ }
-   function bprint_iconv_flag(buf, iconv){
-     /*<<camlinternalFormat.ml:415:34>>*/ switch(iconv){
-      case 1:
-      case 4:
-        /*<<camlinternalFormat.ml:416:23>>*/ return buffer_add_char(buf, 43);
-      case 2:
-      case 5:
-        /*<<camlinternalFormat.ml:417:23>>*/ return buffer_add_char(buf, 32);
-      case 7:
-      case 9:
-      case 11:
-      case 13:
-      case 14:
-      case 15:
-        /*<<camlinternalFormat.ml:419:6>>*/ return buffer_add_char(buf, 35);
-      default:  /*<<camlinternalFormat.ml:420:53>>*/ return 0;
-    }
-    /*<<camlinternalFormat.ml:420:55>>*/ }
-   function bprint_altint_fmt(buf, ign_flag, iconv, pad, prec, c){
-     /*<<camlinternalFormat.ml:433:2>>*/ buffer_add_char(buf, 37);
-     /*<<camlinternalFormat.ml:434:2>>*/ bprint_ignored_flag(buf, ign_flag);
-     /*<<camlinternalFormat.ml:435:2>>*/ bprint_iconv_flag(buf, iconv);
-     /*<<camlinternalFormat.ml:436:2>>*/ bprint_padding(buf, pad);
-     /*<<camlinternalFormat.ml:437:2>>*/ bprint_precision(buf, prec);
-     /*<<camlinternalFormat.ml:438:2>>*/ buffer_add_char(buf, c);
-     /*<<camlinternalFormat.ml:439:22>>*/ return buffer_add_char
-            (buf, char_of_iconv(iconv));
-    /*<<camlinternalFormat.ml:439:43>>*/ }
-   function bprint_fconv_flag(buf, fconv){
-     /*<<camlinternalFormat.ml:445:2>>*/ switch(fconv[1]){
-      case 0: break;
-      case 1:
-        /*<<camlinternalFormat.ml:446:20>>*/ buffer_add_char(buf, 43); break;
-      default:  /*<<camlinternalFormat.ml:447:20>>*/ buffer_add_char(buf, 32);
-    }
-    return 8 <= fconv[2] ? buffer_add_char(buf, 35) : 0;
-    /*<<camlinternalFormat.ml:452:37>>*/ }
-   function string_of_formatting_lit(formatting_lit){
-     /*<<camlinternalFormat.ml:465:46>>*/ if
-     (typeof formatting_lit === "number")
-     switch(formatting_lit){
-       case 0:
-         /*<<camlinternalFormat.ml:466:28>>*/ return cst$0;
-       case 1:
-         /*<<camlinternalFormat.ml:467:28>>*/ return cst$1;
-       case 2:
-         /*<<camlinternalFormat.ml:469:28>>*/ return cst$2;
-       case 3:
-         /*<<camlinternalFormat.ml:470:28>>*/ return cst$3;
-       case 4:
-         /*<<camlinternalFormat.ml:471:28>>*/ return cst$4;
-       case 5:
-         /*<<camlinternalFormat.ml:473:28>>*/ return cst$5;
-       default:  /*<<camlinternalFormat.ml:474:28>>*/ return cst$6;
-     }
-    switch(formatting_lit[0]){
-      case 0:
-       var str = formatting_lit[1];
-        /*<<camlinternalFormat.ml:468:28>>*/ return str;
-      case 1:
-       var str$0 = formatting_lit[1];
-        /*<<camlinternalFormat.ml:472:28>>*/ return str$0;
-      default:
-        /*<<camlinternalFormat.ml:475:26>>*/ var
-        c = formatting_lit[1],
-         /*<<camlinternalFormat.ml:475:26>>*/ _dO_ =
-           /*<<camlinternalFormat.ml:475:26>>*/ caml_call2
-           (Stdlib_String[1], 1, c);
-        /*<<camlinternalFormat.ml:475:26>>*/ return  /*<<camlinternalFormat.ml:475:26>>*/ caml_call2
-               (Stdlib[28], cst$7, _dO_);
-    }
-    /*<<camlinternalFormat.ml:475:43>>*/ }
-   function bprint_char_literal(buf, chr){
-     /*<<camlinternalFormat.ml:480:34>>*/ return 37 === chr
-            ? buffer_add_string(buf, cst$8)
-            : buffer_add_char(buf, chr);
-    /*<<camlinternalFormat.ml:482:32>>*/ }
-   function bprint_string_literal(buf, str){
-     /*<<camlinternalFormat.ml:486:2>>*/ var
-     _dM_ = caml_ml_string_length(str) - 1 | 0,
-      /*<<camlinternalFormat.ml:486:2>>*/ _dL_ = 0;
-    if(_dM_ >= 0){
-     var i = _dL_;
-     for(;;){
-       /*<<camlinternalFormat.ml:487:4>>*/ bprint_char_literal
-       (buf,  /*<<camlinternalFormat.ml:487:28>>*/ caml_string_get(str, i));
-       /*<<camlinternalFormat.ml:487:4>>*/  /*<<camlinternalFormat.ml:487:4>>*/ var
-       _dN_ = i + 1 | 0;
-      if(_dM_ === i) break;
-      var i = _dN_;
-     }
-    }
-    return 0;
-    /*<<camlinternalFormat.ml:488:6>>*/ }
-   function bprint_fmtty(buf, fmtty){
-     /*<<camlinternalFormat.ml:496:17>>*/ var fmtty$0 = fmtty;
-     /*<<camlinternalFormat.ml:496:17>>*/ for(;;){
-     if(typeof fmtty$0 === "number")
-       /*<<camlinternalFormat.ml:521:20>>*/ return 0;
-     switch(fmtty$0[0]){
-       case 0:
-        var fmtty$1 = fmtty$0[1];
-         /*<<camlinternalFormat.ml:497:25>>*/ buffer_add_string(buf, cst_c);
-        var fmtty$0 = fmtty$1;
-        break;
-       case 1:
-        var fmtty$2 = fmtty$0[1];
-         /*<<camlinternalFormat.ml:498:25>>*/ buffer_add_string(buf, cst_s);
-        var fmtty$0 = fmtty$2;
-        break;
-       case 2:
-        var fmtty$3 = fmtty$0[1];
-         /*<<camlinternalFormat.ml:499:25>>*/ buffer_add_string(buf, cst_i);
-        var fmtty$0 = fmtty$3;
-        break;
-       case 3:
-        var fmtty$4 = fmtty$0[1];
-         /*<<camlinternalFormat.ml:500:25>>*/ buffer_add_string(buf, cst_li);
-        var fmtty$0 = fmtty$4;
-        break;
-       case 4:
-        var fmtty$5 = fmtty$0[1];
-         /*<<camlinternalFormat.ml:501:25>>*/ buffer_add_string(buf, cst_ni);
-        var fmtty$0 = fmtty$5;
-        break;
-       case 5:
-        var fmtty$6 = fmtty$0[1];
-         /*<<camlinternalFormat.ml:502:25>>*/ buffer_add_string(buf, cst_Li);
-        var fmtty$0 = fmtty$6;
-        break;
-       case 6:
-        var fmtty$7 = fmtty$0[1];
-         /*<<camlinternalFormat.ml:503:25>>*/ buffer_add_string(buf, cst_f);
-        var fmtty$0 = fmtty$7;
-        break;
-       case 7:
-        var fmtty$8 = fmtty$0[1];
-         /*<<camlinternalFormat.ml:504:25>>*/ buffer_add_string(buf, cst_B);
-        var fmtty$0 = fmtty$8;
-        break;
-       case 8:
-        var fmtty$9 = fmtty$0[2], sub_fmtty = fmtty$0[1];
-         /*<<camlinternalFormat.ml:515:4>>*/ buffer_add_string(buf, cst$9);
-         /*<<camlinternalFormat.ml:515:32>>*/ bprint_fmtty(buf, sub_fmtty);
-         /*<<camlinternalFormat.ml:516:4>>*/ buffer_add_string(buf, cst$10);
-        var fmtty$0 = fmtty$9;
-        break;
-       case 9:
-        var fmtty$10 = fmtty$0[3], sub_fmtty$0 = fmtty$0[1];
-         /*<<camlinternalFormat.ml:518:4>>*/ buffer_add_string(buf, cst$11);
-         /*<<camlinternalFormat.ml:518:32>>*/ bprint_fmtty(buf, sub_fmtty$0);
-         /*<<camlinternalFormat.ml:519:4>>*/ buffer_add_string(buf, cst$12);
-        var fmtty$0 = fmtty$10;
-        break;
-       case 10:
-        var fmtty$11 = fmtty$0[1];
-         /*<<camlinternalFormat.ml:505:25>>*/ buffer_add_string(buf, cst_a);
-        var fmtty$0 = fmtty$11;
-        break;
-       case 11:
-        var fmtty$12 = fmtty$0[1];
-         /*<<camlinternalFormat.ml:506:25>>*/ buffer_add_string(buf, cst_t);
-        var fmtty$0 = fmtty$12;
-        break;
-       case 12:
-        var fmtty$13 = fmtty$0[1];
-         /*<<camlinternalFormat.ml:507:25>>*/ buffer_add_string(buf, cst$13);
-        var fmtty$0 = fmtty$13;
-        break;
-       case 13:
-        var fmtty$14 = fmtty$0[1];
-         /*<<camlinternalFormat.ml:508:25>>*/ buffer_add_string(buf, cst_r);
-        var fmtty$0 = fmtty$14;
-        break;
-       default:
-        var fmtty$15 = fmtty$0[1];
-         /*<<camlinternalFormat.ml:511:4>>*/ buffer_add_string(buf, cst_r$0);
-        var fmtty$0 = fmtty$15;
-     }
-    }
-    /*<<camlinternalFormat.ml:521:22>>*/ }
-   function int_of_custom_arity(param){
-     /*<<camlinternalFormat.ml:525:8>>*/ if(! param)
-      /*<<camlinternalFormat.ml:528:19>>*/ return 0;
-    var x = param[1];
-    return 1 + int_of_custom_arity(x) | 0;
-    /*<<camlinternalFormat.ml:529:46>>*/ }
-   function string_of_fmt(fmt){
-     /*<<camlinternalFormat.ml:644:2>>*/  /*<<camlinternalFormat.ml:644:12>>*/ var
-     buf = buffer_create(16);
-    function fmtiter(fmt, ign_flag){
-      /*<<camlinternalFormat.ml:535:22>>*/ var
-      fmt$0 = fmt,
-      ign_flag$0 = ign_flag;
-      /*<<camlinternalFormat.ml:535:22>>*/ for(;;){
-      if(typeof fmt$0 === "number")
-        /*<<camlinternalFormat.ml:636:23>>*/ return 0;
-      switch(fmt$0[0]){
-        case 0:
-         var rest = fmt$0[1];
-          /*<<camlinternalFormat.ml:562:6>>*/ buffer_add_char(buf, 37);
-          /*<<camlinternalFormat.ml:562:31>>*/ bprint_ignored_flag
-          (buf, ign_flag$0);
-          /*<<camlinternalFormat.ml:563:6>>*/ buffer_add_char(buf, 99);
-         var fmt$0 = rest, ign_flag$0 = 0;
-         break;
-        case 1:
-         var rest$0 = fmt$0[1];
-          /*<<camlinternalFormat.ml:565:6>>*/ buffer_add_char(buf, 37);
-          /*<<camlinternalFormat.ml:565:31>>*/ bprint_ignored_flag
-          (buf, ign_flag$0);
-          /*<<camlinternalFormat.ml:566:6>>*/ buffer_add_char(buf, 67);
-         var fmt$0 = rest$0, ign_flag$0 = 0;
-         break;
-        case 2:
-         var rest$1 = fmt$0[2], pad = fmt$0[1];
-          /*<<camlinternalFormat.ml:537:6>>*/ buffer_add_char(buf, 37);
-          /*<<camlinternalFormat.ml:537:31>>*/ bprint_ignored_flag
-          (buf, ign_flag$0);
-          /*<<camlinternalFormat.ml:538:6>>*/ bprint_padding(buf, pad);
-          /*<<camlinternalFormat.ml:538:30>>*/ buffer_add_char(buf, 115);
-         var fmt$0 = rest$1, ign_flag$0 = 0;
-         break;
-        case 3:
-         var rest$2 = fmt$0[2], pad$0 = fmt$0[1];
-          /*<<camlinternalFormat.ml:541:6>>*/ buffer_add_char(buf, 37);
-          /*<<camlinternalFormat.ml:541:31>>*/ bprint_ignored_flag
-          (buf, ign_flag$0);
-          /*<<camlinternalFormat.ml:542:6>>*/ bprint_padding(buf, pad$0);
-          /*<<camlinternalFormat.ml:542:30>>*/ buffer_add_char(buf, 83);
-         var fmt$0 = rest$2, ign_flag$0 = 0;
-         break;
-        case 4:
-         var
-          rest$3 = fmt$0[4],
-          prec = fmt$0[3],
-          pad$1 = fmt$0[2],
-          iconv = fmt$0[1];
-          /*<<camlinternalFormat.ml:424:2>>*/ buffer_add_char(buf, 37);
-          /*<<camlinternalFormat.ml:425:2>>*/ bprint_ignored_flag
-          (buf, ign_flag$0);
-          /*<<camlinternalFormat.ml:426:2>>*/ bprint_iconv_flag(buf, iconv);
-          /*<<camlinternalFormat.ml:427:2>>*/ bprint_padding(buf, pad$1);
-          /*<<camlinternalFormat.ml:428:2>>*/ bprint_precision(buf, prec);
-          /*<<camlinternalFormat.ml:429:22>>*/ buffer_add_char
-          (buf, char_of_iconv(iconv));
-         var fmt$0 = rest$3, ign_flag$0 = 0;
-         break;
-        case 5:
-         var
-          rest$4 = fmt$0[4],
-          prec$0 = fmt$0[3],
-          pad$2 = fmt$0[2],
-          iconv$0 = fmt$0[1];
-          /*<<camlinternalFormat.ml:549:6>>*/ bprint_altint_fmt
-          (buf, ign_flag$0, iconv$0, pad$2, prec$0, 108);
-         var fmt$0 = rest$4, ign_flag$0 = 0;
-         break;
-        case 6:
-         var
-          rest$5 = fmt$0[4],
-          prec$1 = fmt$0[3],
-          pad$3 = fmt$0[2],
-          iconv$1 = fmt$0[1];
-          /*<<camlinternalFormat.ml:552:6>>*/ bprint_altint_fmt
-          (buf, ign_flag$0, iconv$1, pad$3, prec$1, 110);
-         var fmt$0 = rest$5, ign_flag$0 = 0;
-         break;
-        case 7:
-         var
-          rest$6 = fmt$0[4],
-          prec$2 = fmt$0[3],
-          pad$4 = fmt$0[2],
-          iconv$2 = fmt$0[1];
-          /*<<camlinternalFormat.ml:555:6>>*/ bprint_altint_fmt
-          (buf, ign_flag$0, iconv$2, pad$4, prec$2, 76);
-         var fmt$0 = rest$6, ign_flag$0 = 0;
-         break;
-        case 8:
-         var
-          rest$7 = fmt$0[4],
-          prec$3 = fmt$0[3],
-          pad$5 = fmt$0[2],
-          fconv = fmt$0[1];
-          /*<<camlinternalFormat.ml:456:2>>*/ buffer_add_char(buf, 37);
-          /*<<camlinternalFormat.ml:457:2>>*/ bprint_ignored_flag
-          (buf, ign_flag$0);
-          /*<<camlinternalFormat.ml:458:2>>*/ bprint_fconv_flag(buf, fconv);
-          /*<<camlinternalFormat.ml:459:2>>*/ bprint_padding(buf, pad$5);
-          /*<<camlinternalFormat.ml:460:2>>*/ bprint_precision(buf, prec$3);
-          /*<<camlinternalFormat.ml:461:22>>*/ buffer_add_char
-          (buf, char_of_fconv(0, fconv));
-         var fmt$0 = rest$7, ign_flag$0 = 0;
-         break;
-        case 9:
-         var rest$8 = fmt$0[2], pad$6 = fmt$0[1];
-          /*<<camlinternalFormat.ml:568:6>>*/ buffer_add_char(buf, 37);
-          /*<<camlinternalFormat.ml:568:31>>*/ bprint_ignored_flag
-          (buf, ign_flag$0);
-          /*<<camlinternalFormat.ml:569:6>>*/ bprint_padding(buf, pad$6);
-          /*<<camlinternalFormat.ml:569:30>>*/ buffer_add_char(buf, 66);
-         var fmt$0 = rest$8, ign_flag$0 = 0;
-         break;
-        case 10:
-         var rest$9 = fmt$0[1];
-          /*<<camlinternalFormat.ml:587:6>>*/ buffer_add_string(buf, cst$14);
-         var fmt$0 = rest$9;
-         break;
-        case 11:
-         var rest$10 = fmt$0[2], str = fmt$0[1];
-          /*<<camlinternalFormat.ml:591:6>>*/ bprint_string_literal(buf, str);
-         var fmt$0 = rest$10;
-         break;
-        case 12:
-         var rest$11 = fmt$0[2], chr = fmt$0[1];
-          /*<<camlinternalFormat.ml:594:6>>*/ bprint_char_literal(buf, chr);
-         var fmt$0 = rest$11;
-         break;
-        case 13:
-         var rest$12 = fmt$0[3], fmtty = fmt$0[2], pad_opt = fmt$0[1];
-          /*<<camlinternalFormat.ml:598:6>>*/ buffer_add_char(buf, 37);
-          /*<<camlinternalFormat.ml:598:31>>*/ bprint_ignored_flag
-          (buf, ign_flag$0);
-          /*<<camlinternalFormat.ml:599:6>>*/ bprint_pad_opt(buf, pad_opt);
-          /*<<camlinternalFormat.ml:599:34>>*/ buffer_add_char(buf, 123);
-          /*<<camlinternalFormat.ml:600:6>>*/ bprint_fmtty(buf, fmtty);
-          /*<<camlinternalFormat.ml:600:30>>*/ buffer_add_char(buf, 37);
-          /*<<camlinternalFormat.ml:600:55>>*/ buffer_add_char(buf, 125);
-         var fmt$0 = rest$12, ign_flag$0 = 0;
-         break;
-        case 14:
-         var rest$13 = fmt$0[3], fmtty$0 = fmt$0[2], pad_opt$0 = fmt$0[1];
-          /*<<camlinternalFormat.ml:603:6>>*/ buffer_add_char(buf, 37);
-          /*<<camlinternalFormat.ml:603:31>>*/ bprint_ignored_flag
-          (buf, ign_flag$0);
-          /*<<camlinternalFormat.ml:604:6>>*/ bprint_pad_opt(buf, pad_opt$0);
-          /*<<camlinternalFormat.ml:604:34>>*/ buffer_add_char(buf, 40);
-          /*<<camlinternalFormat.ml:605:6>>*/ bprint_fmtty(buf, fmtty$0);
-          /*<<camlinternalFormat.ml:605:30>>*/ buffer_add_char(buf, 37);
-          /*<<camlinternalFormat.ml:605:55>>*/ buffer_add_char(buf, 41);
-         var fmt$0 = rest$13, ign_flag$0 = 0;
-         break;
-        case 15:
-         var rest$14 = fmt$0[1];
-          /*<<camlinternalFormat.ml:572:6>>*/ buffer_add_char(buf, 37);
-          /*<<camlinternalFormat.ml:572:31>>*/ bprint_ignored_flag
-          (buf, ign_flag$0);
-          /*<<camlinternalFormat.ml:573:6>>*/ buffer_add_char(buf, 97);
-         var fmt$0 = rest$14, ign_flag$0 = 0;
-         break;
-        case 16:
-         var rest$15 = fmt$0[1];
-          /*<<camlinternalFormat.ml:575:6>>*/ buffer_add_char(buf, 37);
-          /*<<camlinternalFormat.ml:575:31>>*/ bprint_ignored_flag
-          (buf, ign_flag$0);
-          /*<<camlinternalFormat.ml:576:6>>*/ buffer_add_char(buf, 116);
-         var fmt$0 = rest$15, ign_flag$0 = 0;
-         break;
-        case 17:
-         var rest$16 = fmt$0[2], fmting_lit = fmt$0[1];
-          /*<<camlinternalFormat.ml:625:6>>*/ bprint_string_literal
-          (buf, string_of_formatting_lit(fmting_lit));
-         var fmt$0 = rest$16;
-         break;
-        case 18:
-         var rest$17 = fmt$0[2], fmting_gen = fmt$0[1];
-          /*<<camlinternalFormat.ml:628:6>>*/ if(0 === fmting_gen[0]){
-          var str$0 = fmting_gen[1][2];
-           /*<<camlinternalFormat.ml:630:8>>*/ buffer_add_string(buf, cst$15);
-           /*<<camlinternalFormat.ml:630:36>>*/ buffer_add_string(buf, str$0);
-         }
-         else{
-          var str$1 = fmting_gen[1][2];
-           /*<<camlinternalFormat.ml:632:8>>*/ buffer_add_string(buf, cst$16);
-           /*<<camlinternalFormat.ml:632:36>>*/ buffer_add_string(buf, str$1);
-         }
-         var fmt$0 = rest$17;
-         break;
-        case 19:
-         var rest$18 = fmt$0[1];
-          /*<<camlinternalFormat.ml:584:6>>*/ buffer_add_char(buf, 37);
-          /*<<camlinternalFormat.ml:584:31>>*/ bprint_ignored_flag
-          (buf, ign_flag$0);
-          /*<<camlinternalFormat.ml:585:6>>*/ buffer_add_char(buf, 114);
-         var fmt$0 = rest$18, ign_flag$0 = 0;
-         break;
-        case 20:
-         var rest$19 = fmt$0[3], char_set = fmt$0[2], width_opt = fmt$0[1];
-          /*<<camlinternalFormat.ml:609:6>>*/ buffer_add_char(buf, 37);
-          /*<<camlinternalFormat.ml:609:31>>*/ bprint_ignored_flag
-          (buf, ign_flag$0);
-          /*<<camlinternalFormat.ml:610:6>>*/ bprint_pad_opt(buf, width_opt);
-         var
-          print_char =
-            function(buf, i){
-              /*<<camlinternalFormat.ml:358:25>>*/  /*<<camlinternalFormat.ml:358:31>>*/ var
-              c =
-                 /*<<camlinternalFormat.ml:358:31>>*/ caml_call1
-                 (Stdlib[29], i);
-             return 37 === c
-                     ? (buffer_add_char(buf, 37), buffer_add_char(buf, 37))
-                     : 64
-                       === c
-                       ? (buffer_add_char(buf, 37), buffer_add_char(buf, 64))
-                       : buffer_add_char(buf, c);
-             /*<<camlinternalFormat.ml:361:35>>*/ };
-          /*<<camlinternalFormat.ml:363:2>>*/ buffer_add_char(buf, 91);
-          /*<<camlinternalFormat.ml:365:7>>*/ var
-           /*<<camlinternalFormat.ml:365:7>>*/ set =
-            is_in_char_set(char_set, 0)
-             ? (buffer_add_char(buf, 94), rev_char_set(char_set))
-             : char_set,
-          is_alone$0 =
-            function(set){
-             function is_alone(c){
-               /*<<camlinternalFormat.ml:316:6>>*/ var
-                /*<<camlinternalFormat.ml:316:50>>*/ after =
-                  /*<<camlinternalFormat.ml:316:50>>*/ caml_call1
-                  (Stdlib_Char[1], c + 1 | 0),
-                /*<<camlinternalFormat.ml:316:32>>*/ before =
-                  /*<<camlinternalFormat.ml:316:32>>*/ caml_call1
-                  (Stdlib_Char[1], c - 1 | 0),
-                /*<<camlinternalFormat.ml:317:6>>*/ _dH_ =
-                 is_in_char_set(set, c);
-               /*<<camlinternalFormat.ml:317:6>>*/ if(_dH_)
-                /*<<camlinternalFormat.ml:318:14>>*/ var
-                 /*<<camlinternalFormat.ml:318:14>>*/ _dI_ =
-                  is_in_char_set(set, before),
-                 /*<<camlinternalFormat.ml:318:14>>*/ _dJ_ =
-                  _dI_ ? is_in_char_set(set, after) : _dI_,
-                _dK_ = 1 - _dJ_;
-              else
-               var _dK_ = _dH_;
-               /*<<camlinternalFormat.ml:318:43>>*/ return _dK_;
-              /*<<camlinternalFormat.ml:318:68>>*/ }
-             return is_alone;
-            },
-          is_alone = is_alone$0(set);
-          /*<<camlinternalFormat.ml:319:7>>*/ if(is_alone(93))
-           /*<<camlinternalFormat.ml:319:25>>*/ buffer_add_char(buf, 93);
-         var i = 1;
-         a:
-          /*<<camlinternalFormat.ml:323:4>>*/ for(;;){
-          b:
-          if(i < 256){
-            /*<<camlinternalFormat.ml:324:9>>*/ if
-            (!
-             is_in_char_set
-              (set,
-                /*<<camlinternalFormat.ml:324:28>>*/ caml_call1(Stdlib[29], i))){
-             /*<<camlinternalFormat.ml:325:11>>*/ var
-              /*<<camlinternalFormat.ml:325:11>>*/ i$0 = i + 1 | 0,
-             i = i$0;
-            continue;
-           }
-            /*<<camlinternalFormat.ml:327:10>>*/  /*<<camlinternalFormat.ml:327:10>>*/ var
-            switcher =
-               /*<<camlinternalFormat.ml:327:10>>*/ caml_call1(Stdlib[29], i)
-              - 45
-              | 0;
-           if(48 < switcher >>> 0){
-            if(210 <= switcher){
-              /*<<camlinternalFormat.ml:328:16>>*/ print_char(buf, 255);
-             break b;
-            }
-           }
-           else if(46 < switcher - 1 >>> 0){
-             /*<<camlinternalFormat.ml:329:19>>*/ var
-              /*<<camlinternalFormat.ml:329:19>>*/ i$2 = i + 1 | 0,
-             i = i$2;
-            continue;
-           }
-            /*<<camlinternalFormat.ml:330:11>>*/  /*<<camlinternalFormat.ml:330:11>>*/ var
-            i$1 = i + 1 | 0;
-            /*<<camlinternalFormat.ml:332:7>>*/ if
-            (!
-             is_in_char_set
-              (set,
-                /*<<camlinternalFormat.ml:332:26>>*/ caml_call1
-                (Stdlib[29], i$1))){
-             /*<<camlinternalFormat.ml:347:6>>*/ print_char(buf, i$1 - 1 | 0);
-             /*<<camlinternalFormat.ml:347:6>>*/ var
-              /*<<camlinternalFormat.ml:347:6>>*/ i$6 = i$1 + 1 | 0,
-             i = i$6;
-            continue;
-           }
-            /*<<camlinternalFormat.ml:333:12>>*/  /*<<camlinternalFormat.ml:333:12>>*/ var
-            switcher$0 =
-               /*<<camlinternalFormat.ml:333:12>>*/ caml_call1
-               (Stdlib[29], i$1)
-              - 45
-              | 0;
-           if(48 < switcher$0 >>> 0){
-            if(210 <= switcher$0){
-              /*<<camlinternalFormat.ml:335:8>>*/ print_char(buf, 254);
-              /*<<camlinternalFormat.ml:335:8>>*/ print_char(buf, 255);
-             break b;
-            }
-           }
-           else if
-            (46 < switcher$0 - 1 >>> 0
-             &&
-              !
-              is_in_char_set
-               (set,
-                 /*<<camlinternalFormat.ml:337:47>>*/ caml_call1
-                 (Stdlib[29], i$1 + 1 | 0))){
-             /*<<camlinternalFormat.ml:338:8>>*/ print_char(buf, i$1 - 1 | 0);
-             /*<<camlinternalFormat.ml:338:8>>*/ var
-              /*<<camlinternalFormat.ml:338:8>>*/ i$5 = i$1 + 1 | 0,
-             i = i$5;
-            continue;
-           }
-            /*<<camlinternalFormat.ml:340:19>>*/ if
-            (!
-             is_in_char_set
-              (set,
-                /*<<camlinternalFormat.ml:340:39>>*/ caml_call1
-                (Stdlib[29], i$1 + 1 | 0))){
-             /*<<camlinternalFormat.ml:341:8>>*/ print_char(buf, i$1 - 1 | 0);
-             /*<<camlinternalFormat.ml:342:8>>*/ print_char(buf, i$1);
-             /*<<camlinternalFormat.ml:342:8>>*/ var
-              /*<<camlinternalFormat.ml:342:8>>*/ i$4 = i$1 + 2 | 0,
-             i = i$4;
-            continue;
-           }
-            /*<<camlinternalFormat.ml:345:8>>*/ var
-             /*<<camlinternalFormat.ml:345:8>>*/ j = i$1 + 2 | 0,
-            i$3 = i$1 - 1 | 0,
-            j$0 = j;
-            /*<<camlinternalFormat.ml:351:4>>*/ for(;;){
-             /*<<camlinternalFormat.ml:351:22>>*/ if
-             (256 !== j$0
-              &&
-               is_in_char_set
-                (set,
-                  /*<<camlinternalFormat.ml:351:42>>*/ caml_call1
-                  (Stdlib[29], j$0))){
-              /*<<camlinternalFormat.ml:357:6>>*/ var
-               /*<<camlinternalFormat.ml:357:6>>*/ j$1 = j$0 + 1 | 0,
-              j$0 = j$1;
-             continue;
-            }
-             /*<<camlinternalFormat.ml:352:6>>*/ print_char(buf, i$3);
-             /*<<camlinternalFormat.ml:353:6>>*/ print_char(buf, 45);
-             /*<<camlinternalFormat.ml:354:6>>*/ print_char(buf, j$0 - 1 | 0);
-            if(j$0 >= 256) break;
-             /*<<camlinternalFormat.ml:355:22>>*/ var
-              /*<<camlinternalFormat.ml:355:22>>*/ i$7 = j$0 + 1 | 0,
-             i = i$7;
-            continue a;
-           }
-          }
-           /*<<camlinternalFormat.ml:321:7>>*/ if(is_alone(45))
-            /*<<camlinternalFormat.ml:321:25>>*/ buffer_add_char(buf, 45);
-           /*<<camlinternalFormat.ml:364:2>>*/ buffer_add_char(buf, 93);
-          var fmt$0 = rest$19, ign_flag$0 = 0;
-          break;
-         }
-         break;
-        case 21:
-         var rest$20 = fmt$0[2], counter = fmt$0[1];
-          /*<<camlinternalFormat.ml:613:6>>*/ buffer_add_char(buf, 37);
-          /*<<camlinternalFormat.ml:613:31>>*/ bprint_ignored_flag
-          (buf, ign_flag$0);
-         switch(counter){
-           case 0:
-            var _dD_ = 108; break;
-           case 1:
-            var _dD_ = 110; break;
-           default: var _dD_ = 78;
-         }
-          /*<<camlinternalFormat.ml:614:6>>*/ buffer_add_char(buf, _dD_);
-         var fmt$0 = rest$20, ign_flag$0 = 0;
-         break;
-        case 22:
-         var rest$21 = fmt$0[1];
-          /*<<camlinternalFormat.ml:617:6>>*/ buffer_add_char(buf, 37);
-          /*<<camlinternalFormat.ml:617:31>>*/ bprint_ignored_flag
-          (buf, ign_flag$0);
-          /*<<camlinternalFormat.ml:618:6>>*/ bprint_string_literal
-          (buf, cst_0c);
-         var fmt$0 = rest$21, ign_flag$0 = 0;
-         break;
-        case 23:
-         var
-          rest$22 = fmt$0[2],
-          ign = fmt$0[1],
-          fmt$1 = param_format_of_ignored_format(ign, rest$22)[1],
-          fmt$0 = fmt$1,
-          ign_flag$0 = 1;
-         break;
-        default:
-          /*<<camlinternalFormat.ml:578:20>>*/ var
-          rest$23 = fmt$0[3],
-          arity = fmt$0[1],
-           /*<<camlinternalFormat.ml:578:20>>*/ _dF_ =
-            int_of_custom_arity(arity),
-          _dE_ = 1;
-         if(_dF_ >= 1){
-          var i$8 = _dE_;
-          for(;;){
-            /*<<camlinternalFormat.ml:579:8>>*/ buffer_add_char(buf, 37);
-            /*<<camlinternalFormat.ml:579:33>>*/ bprint_ignored_flag
-            (buf, ign_flag$0);
-            /*<<camlinternalFormat.ml:580:8>>*/ buffer_add_char(buf, 63);
-            /*<<camlinternalFormat.ml:580:8>>*/  /*<<camlinternalFormat.ml:580:8>>*/ var
-            _dG_ = i$8 + 1 | 0;
-           if(_dF_ === i$8) break;
-           var i$8 = _dG_;
-          }
-         }
-         var fmt$0 = rest$23, ign_flag$0 = 0;
-      }
-     }
-     /*<<camlinternalFormat.ml:636:25>>*/ }
-     /*<<camlinternalFormat.ml:638:5>>*/ fmtiter(fmt, 0);
-     /*<<camlinternalFormat.ml:645:2>>*/ return buffer_contents(buf);
-    /*<<camlinternalFormat.ml:646:21>>*/ }
-   function symm(param){
-     /*<<camlinternalFormat.ml:657:8>>*/ if(typeof param === "number")
-      /*<<camlinternalFormat.ml:680:20>>*/ return 0;
-    switch(param[0]){
-      case 0:
-       var rest = param[1];
-        /*<<camlinternalFormat.ml:663:20>>*/ return [0, symm(rest)];
-      case 1:
-       var rest$0 = param[1];
-        /*<<camlinternalFormat.ml:670:22>>*/ return [1, symm(rest$0)];
-      case 2:
-       var rest$1 = param[1];
-        /*<<camlinternalFormat.ml:664:19>>*/ return [2, symm(rest$1)];
-      case 3:
-       var rest$2 = param[1];
-        /*<<camlinternalFormat.ml:665:21>>*/ return [3, symm(rest$2)];
-      case 4:
-       var rest$3 = param[1];
-        /*<<camlinternalFormat.ml:667:25>>*/ return [4, symm(rest$3)];
-      case 5:
-       var rest$4 = param[1];
-        /*<<camlinternalFormat.ml:666:21>>*/ return [5, symm(rest$4)];
-      case 6:
-       var rest$5 = param[1];
-        /*<<camlinternalFormat.ml:668:21>>*/ return [6, symm(rest$5)];
-      case 7:
-       var rest$6 = param[1];
-        /*<<camlinternalFormat.ml:669:20>>*/ return [7, symm(rest$6)];
-      case 8:
-       var rest$7 = param[2], ty = param[1];
-        /*<<camlinternalFormat.ml:677:4>>*/ return [8, ty, symm(rest$7)];
-      case 9:
-       var rest$8 = param[3], ty2 = param[2], ty1 = param[1];
-        /*<<camlinternalFormat.ml:679:4>>*/ return [9, ty2, ty1, symm(rest$8)];
-      case 10:
-       var rest$9 = param[1];
-        /*<<camlinternalFormat.ml:672:21>>*/ return [10, symm(rest$9)];
-      case 11:
-       var rest$10 = param[1];
-        /*<<camlinternalFormat.ml:671:21>>*/ return [11, symm(rest$10)];
-      case 12:
-       var rest$11 = param[1];
-        /*<<camlinternalFormat.ml:673:19>>*/ return [12, symm(rest$11)];
-      case 13:
-       var rest$12 = param[1];
-        /*<<camlinternalFormat.ml:674:22>>*/ return [13, symm(rest$12)];
-      default:
-       var rest$13 = param[1];
-        /*<<camlinternalFormat.ml:675:30>>*/ return [14, symm(rest$13)];
-    }
-    /*<<camlinternalFormat.ml:680:32>>*/ }
-   function fmtty_rel_det(param){
-     /*<<camlinternalFormat.ml:682:8>>*/ if(typeof param !== "number")
-     switch(param[0]){
-       case 0:
-         /*<<camlinternalFormat.ml:696:25>>*/ var
-         rest = param[1],
-          /*<<camlinternalFormat.ml:696:25>>*/ match = fmtty_rel_det(rest),
-         de = match[4],
-         ed = match[3],
-         af = match[2],
-         fa = match[1],
-         _di_ =
-           function(param){
-             /*<<camlinternalFormat.ml:698:17>>*/ af(0);
-             /*<<camlinternalFormat.ml:698:39>>*/ return 0;
-            /*<<camlinternalFormat.ml:698:43>>*/ };
-         /*<<camlinternalFormat.ml:697:4>>*/ return [0,
-                function(param){
-                  /*<<camlinternalFormat.ml:697:17>>*/ fa(0);
-                  /*<<camlinternalFormat.ml:697:39>>*/ return 0;
-                 /*<<camlinternalFormat.ml:697:43>>*/ },
-                _di_,
-                ed,
-                de];
-       case 1:
-         /*<<camlinternalFormat.ml:701:25>>*/ var
-         rest$0 = param[1],
-          /*<<camlinternalFormat.ml:701:25>>*/ match$0 = fmtty_rel_det(rest$0),
-         de$0 = match$0[4],
-         ed$0 = match$0[3],
-         af$0 = match$0[2],
-         fa$0 = match$0[1],
-         _dj_ =
-           function(param){
-             /*<<camlinternalFormat.ml:703:17>>*/ af$0(0);
-             /*<<camlinternalFormat.ml:703:39>>*/ return 0;
-            /*<<camlinternalFormat.ml:703:43>>*/ };
-         /*<<camlinternalFormat.ml:702:4>>*/ return [0,
-                function(param){
-                  /*<<camlinternalFormat.ml:702:17>>*/ fa$0(0);
-                  /*<<camlinternalFormat.ml:702:39>>*/ return 0;
-                 /*<<camlinternalFormat.ml:702:43>>*/ },
-                _dj_,
-                ed$0,
-                de$0];
-       case 2:
-         /*<<camlinternalFormat.ml:706:25>>*/ var
-         rest$1 = param[1],
-          /*<<camlinternalFormat.ml:706:25>>*/ match$1 = fmtty_rel_det(rest$1),
-         de$1 = match$1[4],
-         ed$1 = match$1[3],
-         af$1 = match$1[2],
-         fa$1 = match$1[1],
-         _dk_ =
-           function(param){
-             /*<<camlinternalFormat.ml:708:17>>*/ af$1(0);
-             /*<<camlinternalFormat.ml:708:39>>*/ return 0;
-            /*<<camlinternalFormat.ml:708:43>>*/ };
-         /*<<camlinternalFormat.ml:707:4>>*/ return [0,
-                function(param){
-                  /*<<camlinternalFormat.ml:707:17>>*/ fa$1(0);
-                  /*<<camlinternalFormat.ml:707:39>>*/ return 0;
-                 /*<<camlinternalFormat.ml:707:43>>*/ },
-                _dk_,
-                ed$1,
-                de$1];
-       case 3:
-         /*<<camlinternalFormat.ml:711:25>>*/ var
-         rest$2 = param[1],
-          /*<<camlinternalFormat.ml:711:25>>*/ match$2 = fmtty_rel_det(rest$2),
-         de$2 = match$2[4],
-         ed$2 = match$2[3],
-         af$2 = match$2[2],
-         fa$2 = match$2[1],
-         _dl_ =
-           function(param){
-             /*<<camlinternalFormat.ml:713:17>>*/ af$2(0);
-             /*<<camlinternalFormat.ml:713:39>>*/ return 0;
-            /*<<camlinternalFormat.ml:713:43>>*/ };
-         /*<<camlinternalFormat.ml:712:4>>*/ return [0,
-                function(param){
-                  /*<<camlinternalFormat.ml:712:17>>*/ fa$2(0);
-                  /*<<camlinternalFormat.ml:712:39>>*/ return 0;
-                 /*<<camlinternalFormat.ml:712:43>>*/ },
-                _dl_,
-                ed$2,
-                de$2];
-       case 4:
-         /*<<camlinternalFormat.ml:721:25>>*/ var
-         rest$3 = param[1],
-          /*<<camlinternalFormat.ml:721:25>>*/ match$3 = fmtty_rel_det(rest$3),
-         de$3 = match$3[4],
-         ed$3 = match$3[3],
-         af$3 = match$3[2],
-         fa$3 = match$3[1],
-         _dm_ =
-           function(param){
-             /*<<camlinternalFormat.ml:723:17>>*/ af$3(0);
-             /*<<camlinternalFormat.ml:723:39>>*/ return 0;
-            /*<<camlinternalFormat.ml:723:43>>*/ };
-         /*<<camlinternalFormat.ml:722:4>>*/ return [0,
-                function(param){
-                  /*<<camlinternalFormat.ml:722:17>>*/ fa$3(0);
-                  /*<<camlinternalFormat.ml:722:39>>*/ return 0;
-                 /*<<camlinternalFormat.ml:722:43>>*/ },
-                _dm_,
-                ed$3,
-                de$3];
-       case 5:
-         /*<<camlinternalFormat.ml:716:25>>*/ var
-         rest$4 = param[1],
-          /*<<camlinternalFormat.ml:716:25>>*/ match$4 = fmtty_rel_det(rest$4),
-         de$4 = match$4[4],
-         ed$4 = match$4[3],
-         af$4 = match$4[2],
-         fa$4 = match$4[1],
-         _dn_ =
-           function(param){
-             /*<<camlinternalFormat.ml:718:17>>*/ af$4(0);
-             /*<<camlinternalFormat.ml:718:39>>*/ return 0;
-            /*<<camlinternalFormat.ml:718:43>>*/ };
-         /*<<camlinternalFormat.ml:717:4>>*/ return [0,
-                function(param){
-                  /*<<camlinternalFormat.ml:717:17>>*/ fa$4(0);
-                  /*<<camlinternalFormat.ml:717:39>>*/ return 0;
-                 /*<<camlinternalFormat.ml:717:43>>*/ },
-                _dn_,
-                ed$4,
-                de$4];
-       case 6:
-         /*<<camlinternalFormat.ml:726:25>>*/ var
-         rest$5 = param[1],
-          /*<<camlinternalFormat.ml:726:25>>*/ match$5 = fmtty_rel_det(rest$5),
-         de$5 = match$5[4],
-         ed$5 = match$5[3],
-         af$5 = match$5[2],
-         fa$5 = match$5[1],
-         _do_ =
-           function(param){
-             /*<<camlinternalFormat.ml:728:17>>*/ af$5(0);
-             /*<<camlinternalFormat.ml:728:39>>*/ return 0;
-            /*<<camlinternalFormat.ml:728:43>>*/ };
-         /*<<camlinternalFormat.ml:727:4>>*/ return [0,
-                function(param){
-                  /*<<camlinternalFormat.ml:727:17>>*/ fa$5(0);
-                  /*<<camlinternalFormat.ml:727:39>>*/ return 0;
-                 /*<<camlinternalFormat.ml:727:43>>*/ },
-                _do_,
-                ed$5,
-                de$5];
-       case 7:
-         /*<<camlinternalFormat.ml:731:25>>*/ var
-         rest$6 = param[1],
-          /*<<camlinternalFormat.ml:731:25>>*/ match$6 = fmtty_rel_det(rest$6),
-         de$6 = match$6[4],
-         ed$6 = match$6[3],
-         af$6 = match$6[2],
-         fa$6 = match$6[1],
-         _dp_ =
-           function(param){
-             /*<<camlinternalFormat.ml:733:17>>*/ af$6(0);
-             /*<<camlinternalFormat.ml:733:39>>*/ return 0;
-            /*<<camlinternalFormat.ml:733:43>>*/ };
-         /*<<camlinternalFormat.ml:732:4>>*/ return [0,
-                function(param){
-                  /*<<camlinternalFormat.ml:732:17>>*/ fa$6(0);
-                  /*<<camlinternalFormat.ml:732:39>>*/ return 0;
-                 /*<<camlinternalFormat.ml:732:43>>*/ },
-                _dp_,
-                ed$6,
-                de$6];
-       case 8:
-         /*<<camlinternalFormat.ml:764:25>>*/ var
-         rest$7 = param[2],
-          /*<<camlinternalFormat.ml:764:25>>*/ match$7 = fmtty_rel_det(rest$7),
-         de$7 = match$7[4],
-         ed$7 = match$7[3],
-         af$7 = match$7[2],
-         fa$7 = match$7[1],
-         _dq_ =
-           function(param){
-             /*<<camlinternalFormat.ml:766:17>>*/ af$7(0);
-             /*<<camlinternalFormat.ml:766:39>>*/ return 0;
-            /*<<camlinternalFormat.ml:766:43>>*/ };
-         /*<<camlinternalFormat.ml:765:4>>*/ return [0,
-                function(param){
-                  /*<<camlinternalFormat.ml:765:17>>*/ fa$7(0);
-                  /*<<camlinternalFormat.ml:765:39>>*/ return 0;
-                 /*<<camlinternalFormat.ml:765:43>>*/ },
-                _dq_,
-                ed$7,
-                de$7];
-       case 9:
-         /*<<camlinternalFormat.ml:769:25>>*/ var
-         rest$8 = param[3],
-         ty2 = param[2],
-         ty1 = param[1],
-          /*<<camlinternalFormat.ml:769:25>>*/ match$8 = fmtty_rel_det(rest$8),
-         de$8 = match$8[4],
-         ed$8 = match$8[3],
-         af$8 = match$8[2],
-         fa$8 = match$8[1],
-          /*<<camlinternalFormat.ml:770:13>>*/ ty = trans(symm(ty1), ty2),
-          /*<<camlinternalFormat.ml:771:25>>*/ match$9 = fmtty_rel_det(ty),
-         jd = match$9[4],
-         dj = match$9[3],
-         ga = match$9[2],
-         ag = match$9[1],
-         _dr_ =
-           function(param){
-             /*<<camlinternalFormat.ml:775:17>>*/ jd(0);
-             /*<<camlinternalFormat.ml:775:50>>*/ de$8(0);
-             /*<<camlinternalFormat.ml:775:61>>*/ return 0;
-            /*<<camlinternalFormat.ml:775:65>>*/ },
-         _ds_ =
-           function(param){
-             /*<<camlinternalFormat.ml:774:17>>*/ ed$8(0);
-             /*<<camlinternalFormat.ml:774:50>>*/ dj(0);
-             /*<<camlinternalFormat.ml:774:61>>*/ return 0;
-            /*<<camlinternalFormat.ml:774:65>>*/ },
-         _dt_ =
-           function(param){
-             /*<<camlinternalFormat.ml:773:17>>*/ ga(0);
-             /*<<camlinternalFormat.ml:773:50>>*/ af$8(0);
-             /*<<camlinternalFormat.ml:773:61>>*/ return 0;
-            /*<<camlinternalFormat.ml:773:65>>*/ };
-         /*<<camlinternalFormat.ml:772:4>>*/ return [0,
-                function(param){
-                  /*<<camlinternalFormat.ml:772:17>>*/ fa$8(0);
-                  /*<<camlinternalFormat.ml:772:50>>*/ ag(0);
-                  /*<<camlinternalFormat.ml:772:61>>*/ return 0;
-                 /*<<camlinternalFormat.ml:772:65>>*/ },
-                _dt_,
-                _ds_,
-                _dr_];
-       case 10:
-         /*<<camlinternalFormat.ml:742:25>>*/ var
-         rest$9 = param[1],
-          /*<<camlinternalFormat.ml:742:25>>*/ match$10 =
-           fmtty_rel_det(rest$9),
-         de$9 = match$10[4],
-         ed$9 = match$10[3],
-         af$9 = match$10[2],
-         fa$9 = match$10[1],
-         _du_ =
-           function(param){
-             /*<<camlinternalFormat.ml:744:17>>*/ af$9(0);
-             /*<<camlinternalFormat.ml:744:39>>*/ return 0;
-            /*<<camlinternalFormat.ml:744:43>>*/ };
-         /*<<camlinternalFormat.ml:743:4>>*/ return [0,
-                function(param){
-                  /*<<camlinternalFormat.ml:743:17>>*/ fa$9(0);
-                  /*<<camlinternalFormat.ml:743:39>>*/ return 0;
-                 /*<<camlinternalFormat.ml:743:43>>*/ },
-                _du_,
-                ed$9,
-                de$9];
-       case 11:
-         /*<<camlinternalFormat.ml:737:25>>*/ var
-         rest$10 = param[1],
-          /*<<camlinternalFormat.ml:737:25>>*/ match$11 =
-           fmtty_rel_det(rest$10),
-         de$10 = match$11[4],
-         ed$10 = match$11[3],
-         af$10 = match$11[2],
-         fa$10 = match$11[1],
-         _dv_ =
-           function(param){
-             /*<<camlinternalFormat.ml:739:17>>*/ af$10(0);
-             /*<<camlinternalFormat.ml:739:39>>*/ return 0;
-            /*<<camlinternalFormat.ml:739:43>>*/ };
-         /*<<camlinternalFormat.ml:738:4>>*/ return [0,
-                function(param){
-                  /*<<camlinternalFormat.ml:738:17>>*/ fa$10(0);
-                  /*<<camlinternalFormat.ml:738:39>>*/ return 0;
-                 /*<<camlinternalFormat.ml:738:43>>*/ },
-                _dv_,
-                ed$10,
-                de$10];
-       case 12:
-         /*<<camlinternalFormat.ml:747:25>>*/ var
-         rest$11 = param[1],
-          /*<<camlinternalFormat.ml:747:25>>*/ match$12 =
-           fmtty_rel_det(rest$11),
-         de$11 = match$12[4],
-         ed$11 = match$12[3],
-         af$11 = match$12[2],
-         fa$11 = match$12[1],
-         _dw_ =
-           function(param){
-             /*<<camlinternalFormat.ml:749:17>>*/ af$11(0);
-             /*<<camlinternalFormat.ml:749:39>>*/ return 0;
-            /*<<camlinternalFormat.ml:749:43>>*/ };
-         /*<<camlinternalFormat.ml:748:4>>*/ return [0,
-                function(param){
-                  /*<<camlinternalFormat.ml:748:17>>*/ fa$11(0);
-                  /*<<camlinternalFormat.ml:748:39>>*/ return 0;
-                 /*<<camlinternalFormat.ml:748:43>>*/ },
-                _dw_,
-                ed$11,
-                de$11];
-       case 13:
-         /*<<camlinternalFormat.ml:752:25>>*/ var
-         rest$12 = param[1],
-          /*<<camlinternalFormat.ml:752:25>>*/ match$13 =
-           fmtty_rel_det(rest$12),
-         de$12 = match$13[4],
-         ed$12 = match$13[3],
-         af$12 = match$13[2],
-         fa$12 = match$13[1],
-          /*<<camlinternalFormat.ml:753:4>>*/ _dx_ =
-           function(param){
-             /*<<camlinternalFormat.ml:756:17>>*/ de$12(0);
-             /*<<camlinternalFormat.ml:756:39>>*/ return 0;
-            /*<<camlinternalFormat.ml:756:43>>*/ },
-         _dy_ =
-           function(param){
-             /*<<camlinternalFormat.ml:755:17>>*/ ed$12(0);
-             /*<<camlinternalFormat.ml:755:39>>*/ return 0;
-            /*<<camlinternalFormat.ml:755:43>>*/ },
-         _dz_ =
-           function(param){
-             /*<<camlinternalFormat.ml:754:17>>*/ af$12(0);
-             /*<<camlinternalFormat.ml:754:39>>*/ return 0;
-            /*<<camlinternalFormat.ml:754:43>>*/ };
-         /*<<camlinternalFormat.ml:753:4>>*/ return [0,
-                function(param){
-                  /*<<camlinternalFormat.ml:753:17>>*/ fa$12(0);
-                  /*<<camlinternalFormat.ml:753:39>>*/ return 0;
-                 /*<<camlinternalFormat.ml:753:43>>*/ },
-                _dz_,
-                _dy_,
-                _dx_];
-       default:
-         /*<<camlinternalFormat.ml:758:25>>*/ var
-         rest$13 = param[1],
-          /*<<camlinternalFormat.ml:758:25>>*/ match$14 =
-           fmtty_rel_det(rest$13),
-         de$13 = match$14[4],
-         ed$13 = match$14[3],
-         af$13 = match$14[2],
-         fa$13 = match$14[1],
-          /*<<camlinternalFormat.ml:759:4>>*/ _dA_ =
-           function(param){
-             /*<<camlinternalFormat.ml:762:17>>*/ de$13(0);
-             /*<<camlinternalFormat.ml:762:39>>*/ return 0;
-            /*<<camlinternalFormat.ml:762:43>>*/ },
-         _dB_ =
-           function(param){
-             /*<<camlinternalFormat.ml:761:17>>*/ ed$13(0);
-             /*<<camlinternalFormat.ml:761:39>>*/ return 0;
-            /*<<camlinternalFormat.ml:761:43>>*/ },
-         _dC_ =
-           function(param){
-             /*<<camlinternalFormat.ml:760:17>>*/ af$13(0);
-             /*<<camlinternalFormat.ml:760:39>>*/ return 0;
-            /*<<camlinternalFormat.ml:760:43>>*/ };
-         /*<<camlinternalFormat.ml:759:4>>*/ return [0,
-                function(param){
-                  /*<<camlinternalFormat.ml:759:17>>*/ fa$13(0);
-                  /*<<camlinternalFormat.ml:759:39>>*/ return 0;
-                 /*<<camlinternalFormat.ml:759:43>>*/ },
-                _dC_,
-                _dB_,
-                _dA_];
-     }
-     /*<<camlinternalFormat.ml:691:4>>*/ function _df_(param){
-      /*<<camlinternalFormat.ml:694:17>>*/ return 0;
-     /*<<camlinternalFormat.ml:694:21>>*/ }
-    function _dg_(param){
-      /*<<camlinternalFormat.ml:693:17>>*/ return 0;
-     /*<<camlinternalFormat.ml:693:21>>*/ }
-    function _dh_(param){
-      /*<<camlinternalFormat.ml:692:17>>*/ return 0;
-     /*<<camlinternalFormat.ml:692:21>>*/ }
-     /*<<camlinternalFormat.ml:691:4>>*/ return [0,
-            function(param){
-              /*<<camlinternalFormat.ml:691:17>>*/ return 0;
-             /*<<camlinternalFormat.ml:691:21>>*/ },
-            _dh_,
-            _dg_,
-            _df_];
-    /*<<camlinternalFormat.ml:775:66>>*/ }
-   function trans(ty1, ty2){
-     /*<<camlinternalFormat.ml:803:17>>*/ a:
-    {
-     b:
-     {
-      c:
-      {
-       d:
-       {
-        e:
-        {
-         f:
-         {
-          g:
-          {
-           if(typeof ty1 !== "number"){
-            switch(ty1[0]){
-              case 0:
-               var rest1 = ty1[1];
-               if(typeof ty2 !== "number")
-                switch(ty2[0]){
-                  case 0:
-                   var rest2 = ty2[1];
-                    /*<<camlinternalFormat.ml:804:36>>*/ return [0,
-                           trans(rest1, rest2)];
-                  case 8:
-                   break f;
-                  case 9:
-                   break g;
-                  case 10:
-                   break a;
-                  case 11:
-                   break b;
-                  case 12:
-                   break c;
-                  case 13:
-                   break d;
-                  case 14:
-                   break e;
-                }
-               break;
-              case 1:
-               var rest1$0 = ty1[1];
-               if(typeof ty2 !== "number")
-                switch(ty2[0]){
-                  case 1:
-                   var rest2$0 = ty2[1];
-                    /*<<camlinternalFormat.ml:805:40>>*/ return [1,
-                           trans(rest1$0, rest2$0)];
-                  case 8:
-                   break f;
-                  case 9:
-                   break g;
-                  case 10:
-                   break a;
-                  case 11:
-                   break b;
-                  case 12:
-                   break c;
-                  case 13:
-                   break d;
-                  case 14:
-                   break e;
-                }
-               break;
-              case 2:
-               var rest1$1 = ty1[1];
-               if(typeof ty2 !== "number")
-                switch(ty2[0]){
-                  case 2:
-                   var rest2$1 = ty2[1];
-                    /*<<camlinternalFormat.ml:807:34>>*/ return [2,
-                           trans(rest1$1, rest2$1)];
-                  case 8:
-                   break f;
-                  case 9:
-                   break g;
-                  case 10:
-                   break a;
-                  case 11:
-                   break b;
-                  case 12:
-                   break c;
-                  case 13:
-                   break d;
-                  case 14:
-                   break e;
-                }
-               break;
-              case 3:
-               var rest1$2 = ty1[1];
-               if(typeof ty2 !== "number")
-                switch(ty2[0]){
-                  case 3:
-                   var rest2$2 = ty2[1];
-                    /*<<camlinternalFormat.ml:808:38>>*/ return [3,
-                           trans(rest1$2, rest2$2)];
-                  case 8:
-                   break f;
-                  case 9:
-                   break g;
-                  case 10:
-                   break a;
-                  case 11:
-                   break b;
-                  case 12:
-                   break c;
-                  case 13:
-                   break d;
-                  case 14:
-                   break e;
-                }
-               break;
-              case 4:
-               var rest1$3 = ty1[1];
-               if(typeof ty2 !== "number")
-                switch(ty2[0]){
-                  case 4:
-                   var rest2$3 = ty2[1];
-                    /*<<camlinternalFormat.ml:810:46>>*/ return [4,
-                           trans(rest1$3, rest2$3)];
-                  case 8:
-                   break f;
-                  case 9:
-                   break g;
-                  case 10:
-                   break a;
-                  case 11:
-                   break b;
-                  case 12:
-                   break c;
-                  case 13:
-                   break d;
-                  case 14:
-                   break e;
-                }
-               break;
-              case 5:
-               var rest1$4 = ty1[1];
-               if(typeof ty2 !== "number")
-                switch(ty2[0]){
-                  case 5:
-                   var rest2$4 = ty2[1];
-                    /*<<camlinternalFormat.ml:809:38>>*/ return [5,
-                           trans(rest1$4, rest2$4)];
-                  case 8:
-                   break f;
-                  case 9:
-                   break g;
-                  case 10:
-                   break a;
-                  case 11:
-                   break b;
-                  case 12:
-                   break c;
-                  case 13:
-                   break d;
-                  case 14:
-                   break e;
-                }
-               break;
-              case 6:
-               var rest1$5 = ty1[1];
-               if(typeof ty2 !== "number")
-                switch(ty2[0]){
-                  case 6:
-                   var rest2$5 = ty2[1];
-                    /*<<camlinternalFormat.ml:811:38>>*/ return [6,
-                           trans(rest1$5, rest2$5)];
-                  case 8:
-                   break f;
-                  case 9:
-                   break g;
-                  case 10:
-                   break a;
-                  case 11:
-                   break b;
-                  case 12:
-                   break c;
-                  case 13:
-                   break d;
-                  case 14:
-                   break e;
-                }
-               break;
-              case 7:
-               var rest1$6 = ty1[1];
-               if(typeof ty2 !== "number")
-                switch(ty2[0]){
-                  case 7:
-                   var rest2$6 = ty2[1];
-                    /*<<camlinternalFormat.ml:806:36>>*/ return [7,
-                           trans(rest1$6, rest2$6)];
-                  case 8:
-                   break f;
-                  case 9:
-                   break g;
-                  case 10:
-                   break a;
-                  case 11:
-                   break b;
-                  case 12:
-                   break c;
-                  case 13:
-                   break d;
-                  case 14:
-                   break e;
-                }
-               break;
-              case 8:
-               var rest1$7 = ty1[2], ty1$0 = ty1[1];
-               if(typeof ty2 !== "number")
-                switch(ty2[0]){
-                  case 8:
-                    /*<<camlinternalFormat.ml:835:34>>*/ var
-                    rest2$7 = ty2[2],
-                    ty2$0 = ty2[1],
-                     /*<<camlinternalFormat.ml:835:34>>*/ _de_ =
-                      trans(rest1$7, rest2$7);
-                    /*<<camlinternalFormat.ml:835:4>>*/ return [8,
-                           trans(ty1$0, ty2$0),
-                           _de_];
-                  case 10:
-                   break a;
-                  case 11:
-                   break b;
-                  case 12:
-                   break c;
-                  case 13:
-                   break d;
-                  case 14:
-                   break e;
-                }
-                /*<<camlinternalFormat.ml:836:26>>*/ throw  /*<<camlinternalFormat.ml:836:26>>*/ caml_maybe_attach_backtrace
-                      ([0, Assert_failure, _k_], 1);
-              case 9:
-               var rest1$8 = ty1[3], ty12 = ty1[2], ty11 = ty1[1];
-               if(typeof ty2 !== "number")
-                switch(ty2[0]){
-                  case 8:
-                   break f;
-                  case 9:
-                    /*<<camlinternalFormat.ml:841:13>>*/ var
-                    rest2$8 = ty2[3],
-                    ty22 = ty2[2],
-                    ty21 = ty2[1],
-                     /*<<camlinternalFormat.ml:841:13>>*/ ty =
-                      trans(symm(ty12), ty21),
-                     /*<<camlinternalFormat.ml:842:23>>*/ match =
-                      fmtty_rel_det(ty),
-                    f4 = match[4],
-                    f2 = match[2];
-                    /*<<camlinternalFormat.ml:843:15>>*/ f2(0);
-                    /*<<camlinternalFormat.ml:844:15>>*/ f4(0);
-                    /*<<camlinternalFormat.ml:845:4>>*/ return [9,
-                           ty11,
-                           ty22,
-                           trans(rest1$8, rest2$8)];
-                  case 10:
-                   break a;
-                  case 11:
-                   break b;
-                  case 12:
-                   break c;
-                  case 13:
-                   break d;
-                  case 14:
-                   break e;
-                }
-                /*<<camlinternalFormat.ml:846:28>>*/ throw  /*<<camlinternalFormat.ml:846:28>>*/ caml_maybe_attach_backtrace
-                      ([0, Assert_failure, _l_], 1);
-              case 10:
-               var rest1$9 = ty1[1];
-               if(typeof ty2 !== "number" && 10 === ty2[0]){
-                var rest2$9 = ty2[1];
-                 /*<<camlinternalFormat.ml:813:38>>*/ return [10,
-                        trans(rest1$9, rest2$9)];
-               }
-                /*<<camlinternalFormat.ml:814:21>>*/ throw  /*<<camlinternalFormat.ml:814:21>>*/ caml_maybe_attach_backtrace
-                      ([0, Assert_failure, _m_], 1);
-              case 11:
-               var rest1$10 = ty1[1];
-               if(typeof ty2 !== "number")
-                switch(ty2[0]){
-                  case 10:
-                   break a;
-                  case 11:
-                   var rest2$10 = ty2[1];
-                    /*<<camlinternalFormat.ml:817:38>>*/ return [11,
-                           trans(rest1$10, rest2$10)];
-                }
-                /*<<camlinternalFormat.ml:818:21>>*/ throw  /*<<camlinternalFormat.ml:818:21>>*/ caml_maybe_attach_backtrace
-                      ([0, Assert_failure, _n_], 1);
-              case 12:
-               var rest1$11 = ty1[1];
-               if(typeof ty2 !== "number")
-                switch(ty2[0]){
-                  case 10:
-                   break a;
-                  case 11:
-                   break b;
-                  case 12:
-                   var rest2$11 = ty2[1];
-                    /*<<camlinternalFormat.ml:821:34>>*/ return [12,
-                           trans(rest1$11, rest2$11)];
-                }
-                /*<<camlinternalFormat.ml:822:19>>*/ throw  /*<<camlinternalFormat.ml:822:19>>*/ caml_maybe_attach_backtrace
-                      ([0, Assert_failure, _o_], 1);
-              case 13:
-               var rest1$12 = ty1[1];
-               if(typeof ty2 !== "number")
-                switch(ty2[0]){
-                  case 10:
-                   break a;
-                  case 11:
-                   break b;
-                  case 12:
-                   break c;
-                  case 13:
-                   var rest2$12 = ty2[1];
-                    /*<<camlinternalFormat.ml:825:40>>*/ return [13,
-                           trans(rest1$12, rest2$12)];
-                }
-                /*<<camlinternalFormat.ml:826:22>>*/ throw  /*<<camlinternalFormat.ml:826:22>>*/ caml_maybe_attach_backtrace
-                      ([0, Assert_failure, _p_], 1);
-              default:
-               var rest1$13 = ty1[1];
-               if(typeof ty2 !== "number")
-                switch(ty2[0]){
-                  case 10:
-                   break a;
-                  case 11:
-                   break b;
-                  case 12:
-                   break c;
-                  case 13:
-                   break d;
-                  case 14:
-                   var rest2$13 = ty2[1];
-                    /*<<camlinternalFormat.ml:830:4>>*/ return [14,
-                           trans(rest1$13, rest2$13)];
-                }
-                /*<<camlinternalFormat.ml:831:30>>*/ throw  /*<<camlinternalFormat.ml:831:30>>*/ caml_maybe_attach_backtrace
-                      ([0, Assert_failure, _q_], 1);
-            }
-             /*<<camlinternalFormat.ml:851:23>>*/ throw  /*<<camlinternalFormat.ml:851:23>>*/ caml_maybe_attach_backtrace
-                   ([0, Assert_failure, _j_], 1);
-           }
-           if(typeof ty2 === "number")
-             /*<<camlinternalFormat.ml:849:34>>*/ return 0;
-           switch(ty2[0]){
-             case 10:
-              break a;
-             case 11:
-              break b;
-             case 12:
-              break c;
-             case 13:
-              break d;
-             case 14:
-              break e;
-             case 8:
-              break f;
-             case 9: break;
-             default:
-               /*<<camlinternalFormat.ml:850:23>>*/ throw  /*<<camlinternalFormat.ml:850:23>>*/ caml_maybe_attach_backtrace
-                     ([0, Assert_failure, _b_], 1);
-           }
-          }
-           /*<<camlinternalFormat.ml:847:28>>*/ throw  /*<<camlinternalFormat.ml:847:28>>*/ caml_maybe_attach_backtrace
-                 ([0, Assert_failure, _d_], 1);
-         }
-          /*<<camlinternalFormat.ml:837:26>>*/ throw  /*<<camlinternalFormat.ml:837:26>>*/ caml_maybe_attach_backtrace
-                ([0, Assert_failure, _c_], 1);
-        }
-         /*<<camlinternalFormat.ml:832:30>>*/ throw  /*<<camlinternalFormat.ml:832:30>>*/ caml_maybe_attach_backtrace
-               ([0, Assert_failure, _i_], 1);
-       }
-        /*<<camlinternalFormat.ml:827:22>>*/ throw  /*<<camlinternalFormat.ml:827:22>>*/ caml_maybe_attach_backtrace
-              ([0, Assert_failure, _h_], 1);
-      }
-       /*<<camlinternalFormat.ml:823:19>>*/ throw  /*<<camlinternalFormat.ml:823:19>>*/ caml_maybe_attach_backtrace
-             ([0, Assert_failure, _g_], 1);
-     }
-      /*<<camlinternalFormat.ml:819:21>>*/ throw  /*<<camlinternalFormat.ml:819:21>>*/ caml_maybe_attach_backtrace
-            ([0, Assert_failure, _f_], 1);
-    }
-     /*<<camlinternalFormat.ml:815:21>>*/ throw  /*<<camlinternalFormat.ml:815:21>>*/ caml_maybe_attach_backtrace
-           ([0, Assert_failure, _e_], 1);
-    /*<<camlinternalFormat.ml:851:35>>*/ }
-   function fmtty_of_padding_fmtty(pad, fmtty){
-     /*<<camlinternalFormat.ml:952:19>>*/ return typeof pad === "number"
-            ? fmtty
-            : 0 === pad[0] ? fmtty : [2, fmtty];
-    /*<<camlinternalFormat.ml:955:35>>*/ }
-   function fmtty_of_custom(arity, fmtty){
-     /*<<camlinternalFormat.ml:921:19>>*/ if(! arity)
-      /*<<camlinternalFormat.ml:922:19>>*/ return fmtty;
-    var arity$0 = arity[1];
-     /*<<camlinternalFormat.ml:923:25>>*/ return [12,
-            fmtty_of_custom(arity$0, fmtty)];
-    /*<<camlinternalFormat.ml:923:61>>*/ }
-   function fmtty_of_fmt(fmtty){
-     /*<<camlinternalFormat.ml:863:13>>*/ var fmtty$0 = fmtty;
-     /*<<camlinternalFormat.ml:863:13>>*/ for(;;){
-     if(typeof fmtty$0 === "number")
-       /*<<camlinternalFormat.ml:916:34>>*/ return 0;
-     switch(fmtty$0[0]){
-       case 0:
-        var rest = fmtty$0[1];
-         /*<<camlinternalFormat.ml:890:34>>*/ return [0, fmtty_of_fmt(rest)];
-       case 1:
-        var rest$0 = fmtty$0[1];
-         /*<<camlinternalFormat.ml:891:34>>*/ return [0, fmtty_of_fmt(rest$0)];
-       case 2:
-        var rest$1 = fmtty$0[2], pad = fmtty$0[1];
-         /*<<camlinternalFormat.ml:865:31>>*/ return fmtty_of_padding_fmtty
-                (pad, [1, fmtty_of_fmt(rest$1)]);
-       case 3:
-        var rest$2 = fmtty$0[2], pad$0 = fmtty$0[1];
-         /*<<camlinternalFormat.ml:867:31>>*/ return fmtty_of_padding_fmtty
-                (pad$0, [1, fmtty_of_fmt(rest$2)]);
-       case 4:
-         /*<<camlinternalFormat.ml:870:18>>*/ var
-         rest$3 = fmtty$0[4],
-         prec = fmtty$0[3],
-         pad$1 = fmtty$0[2],
-          /*<<camlinternalFormat.ml:870:18>>*/ ty_rest = fmtty_of_fmt(rest$3),
-          /*<<camlinternalFormat.ml:871:18>>*/ prec_ty =
-           fmtty_of_precision_fmtty(prec, [2, ty_rest]);
-         /*<<camlinternalFormat.ml:872:4>>*/ return fmtty_of_padding_fmtty
-                (pad$1, prec_ty);
-       case 5:
-         /*<<camlinternalFormat.ml:874:18>>*/ var
-         rest$4 = fmtty$0[4],
-         prec$0 = fmtty$0[3],
-         pad$2 = fmtty$0[2],
-          /*<<camlinternalFormat.ml:874:18>>*/ ty_rest$0 =
-           fmtty_of_fmt(rest$4),
-          /*<<camlinternalFormat.ml:875:18>>*/ prec_ty$0 =
-           fmtty_of_precision_fmtty(prec$0, [3, ty_rest$0]);
-         /*<<camlinternalFormat.ml:876:4>>*/ return fmtty_of_padding_fmtty
-                (pad$2, prec_ty$0);
-       case 6:
-         /*<<camlinternalFormat.ml:878:18>>*/ var
-         rest$5 = fmtty$0[4],
-         prec$1 = fmtty$0[3],
-         pad$3 = fmtty$0[2],
-          /*<<camlinternalFormat.ml:878:18>>*/ ty_rest$1 =
-           fmtty_of_fmt(rest$5),
-          /*<<camlinternalFormat.ml:879:18>>*/ prec_ty$1 =
-           fmtty_of_precision_fmtty(prec$1, [4, ty_rest$1]);
-         /*<<camlinternalFormat.ml:880:4>>*/ return fmtty_of_padding_fmtty
-                (pad$3, prec_ty$1);
-       case 7:
-         /*<<camlinternalFormat.ml:882:18>>*/ var
-         rest$6 = fmtty$0[4],
-         prec$2 = fmtty$0[3],
-         pad$4 = fmtty$0[2],
-          /*<<camlinternalFormat.ml:882:18>>*/ ty_rest$2 =
-           fmtty_of_fmt(rest$6),
-          /*<<camlinternalFormat.ml:883:18>>*/ prec_ty$2 =
-           fmtty_of_precision_fmtty(prec$2, [5, ty_rest$2]);
-         /*<<camlinternalFormat.ml:884:4>>*/ return fmtty_of_padding_fmtty
-                (pad$4, prec_ty$2);
-       case 8:
-         /*<<camlinternalFormat.ml:886:18>>*/ var
-         rest$7 = fmtty$0[4],
-         prec$3 = fmtty$0[3],
-         pad$5 = fmtty$0[2],
-          /*<<camlinternalFormat.ml:886:18>>*/ ty_rest$3 =
-           fmtty_of_fmt(rest$7),
-          /*<<camlinternalFormat.ml:887:18>>*/ prec_ty$3 =
-           fmtty_of_precision_fmtty(prec$3, [6, ty_rest$3]);
-         /*<<camlinternalFormat.ml:888:4>>*/ return fmtty_of_padding_fmtty
-                (pad$5, prec_ty$3);
-       case 9:
-        var rest$8 = fmtty$0[2], pad$6 = fmtty$0[1];
-         /*<<camlinternalFormat.ml:893:33>>*/ return fmtty_of_padding_fmtty
-                (pad$6, [7, fmtty_of_fmt(rest$8)]);
-       case 10:
-        var fmtty$1 = fmtty$0[1], fmtty$0 = fmtty$1; break;
-       case 11:
-        var fmtty$2 = fmtty$0[2], fmtty$0 = fmtty$2; break;
-       case 12:
-        var fmtty$3 = fmtty$0[2], fmtty$0 = fmtty$3; break;
-       case 13:
-        var rest$9 = fmtty$0[3], ty = fmtty$0[2];
-         /*<<camlinternalFormat.ml:900:4>>*/ return [8,
-                ty,
-                fmtty_of_fmt(rest$9)];
-       case 14:
-        var rest$10 = fmtty$0[3], ty$0 = fmtty$0[2];
-         /*<<camlinternalFormat.ml:902:4>>*/ return [9,
-                ty$0,
-                ty$0,
-                fmtty_of_fmt(rest$10)];
-       case 15:
-        var rest$11 = fmtty$0[1];
-         /*<<camlinternalFormat.ml:894:34>>*/ return [10,
-                fmtty_of_fmt(rest$11)];
-       case 16:
-        var rest$12 = fmtty$0[1];
-         /*<<camlinternalFormat.ml:895:34>>*/ return [11,
-                fmtty_of_fmt(rest$12)];
-       case 17:
-        var fmtty$4 = fmtty$0[2], fmtty$0 = fmtty$4; break;
-       case 18:
-         /*<<camlinternalFormat.ml:914:54>>*/ var
-         rest$13 = fmtty$0[2],
-         formatting_gen = fmtty$0[1],
-          /*<<camlinternalFormat.ml:914:54>>*/ _db_ = fmtty_of_fmt(rest$13);
-        if(0 === formatting_gen[0])
-         var fmt = formatting_gen[1][1], _dc_ = fmtty_of_fmt(fmt);
-        else
-         var fmt$0 = formatting_gen[1][1], _dc_ = fmtty_of_fmt(fmt$0);
-         /*<<camlinternalFormat.ml:914:54>>*/ return  /*<<camlinternalFormat.ml:914:54>>*/ caml_call2
-                (CamlinternalFormatBasics[1], _dc_, _db_);
-       case 19:
-        var rest$14 = fmtty$0[1];
-         /*<<camlinternalFormat.ml:897:34>>*/ return [13,
-                fmtty_of_fmt(rest$14)];
-       case 20:
-        var rest$15 = fmtty$0[3];
-         /*<<camlinternalFormat.ml:908:34>>*/ return [1,
-                fmtty_of_fmt(rest$15)];
-       case 21:
-        var rest$16 = fmtty$0[2];
-         /*<<camlinternalFormat.ml:909:34>>*/ return [2,
-                fmtty_of_fmt(rest$16)];
-       case 22:
-        var rest$17 = fmtty$0[1];
-         /*<<camlinternalFormat.ml:910:34>>*/ return [0,
-                fmtty_of_fmt(rest$17)];
-       case 23:
-        var fmtty$5 = fmtty$0[2], ign = fmtty$0[1];
-        if(typeof ign === "number")
-         switch(ign){
-           case 0:
-            var fmtty$0 = fmtty$5; break;
-           case 1:
-            var fmtty$0 = fmtty$5; break;
-           case 2:
-             /*<<camlinternalFormat.ml:944:39>>*/ return [14,
-                    fmtty_of_fmt(fmtty$5)];
-           default: var fmtty$0 = fmtty$5;
-         }
-        else
-         switch(ign[0]){
-           case 0:
-            var fmtty$0 = fmtty$5; break;
-           case 1:
-            var fmtty$0 = fmtty$5; break;
-           case 2:
-            var fmtty$0 = fmtty$5; break;
-           case 3:
-            var fmtty$0 = fmtty$5; break;
-           case 4:
-            var fmtty$0 = fmtty$5; break;
-           case 5:
-            var fmtty$0 = fmtty$5; break;
-           case 6:
-            var fmtty$0 = fmtty$5; break;
-           case 7:
-            var fmtty$0 = fmtty$5; break;
-           case 8:
-            var fmtty$0 = fmtty$5; break;
-           case 9:
-             /*<<camlinternalFormat.ml:943:58>>*/ var
-             fmtty$6 = ign[2],
-              /*<<camlinternalFormat.ml:943:58>>*/ _dd_ =
-               fmtty_of_fmt(fmtty$5);
-             /*<<camlinternalFormat.ml:943:58>>*/ return  /*<<camlinternalFormat.ml:943:58>>*/ caml_call2
-                    (CamlinternalFormatBasics[1], fmtty$6, _dd_);
-           case 10:
-            var fmtty$0 = fmtty$5; break;
-           default: var fmtty$0 = fmtty$5;
-         }
-        break;
-       default:
-        var rest$18 = fmtty$0[3], arity = fmtty$0[1];
-         /*<<camlinternalFormat.ml:896:56>>*/ return fmtty_of_custom
-                (arity, fmtty_of_fmt(rest$18));
-     }
-    }
-    /*<<camlinternalFormat.ml:916:46>>*/ }
-   function fmtty_of_precision_fmtty(prec, fmtty){
-     /*<<camlinternalFormat.ml:960:20>>*/ return typeof prec === "number"
-            ? prec ? [2, fmtty] : fmtty
-            : fmtty;
-    /*<<camlinternalFormat.ml:963:37>>*/ }
-    /*<<camlinternalFormat.ml:969:0>>*/  /*<<camlinternalFormat.ml:969:0>>*/ var
-    Type_mismatch =
-      [248, cst_CamlinternalFormat_Type_mi, runtime.caml_fresh_oo_id(0)];
-   function type_padding(pad, fmtty){
-     /*<<camlinternalFormat.ml:977:17>>*/ if(typeof pad === "number")
-      /*<<camlinternalFormat.ml:978:21>>*/ return [0, 0, fmtty];
-    if(0 === pad[0]){
-     var w = pad[2], padty = pad[1];
-      /*<<camlinternalFormat.ml:979:33>>*/ return [0, [0, padty, w], fmtty];
-    }
-    if(typeof fmtty !== "number" && 2 === fmtty[0]){
-     var rest = fmtty[1], padty$0 = pad[1];
-      /*<<camlinternalFormat.ml:980:38>>*/ return [0, [1, padty$0], rest];
-    }
-     /*<<camlinternalFormat.ml:981:9>>*/ throw  /*<<camlinternalFormat.ml:981:9>>*/ caml_maybe_attach_backtrace
-           (Type_mismatch, 1);
-    /*<<camlinternalFormat.ml:981:28>>*/ }
-   function type_padprec(pad, prec, fmtty){
-     /*<<camlinternalFormat.ml:989:22>>*/  /*<<camlinternalFormat.ml:989:34>>*/ var
-     match = type_padding(pad, fmtty);
-    if(typeof prec !== "number"){
-     var rest$1 = match[2], pad$2 = match[1], p = prec[1];
-      /*<<camlinternalFormat.ml:993:4>>*/ return [0, pad$2, [0, p], rest$1];
-    }
-    if(! prec){
-     var rest$0 = match[2], pad$1 = match[1];
-      /*<<camlinternalFormat.ml:991:4>>*/ return [0, pad$1, 0, rest$0];
-    }
-    var match$0 = match[2];
-    if(typeof match$0 !== "number" && 2 === match$0[0]){
-     var rest = match$0[1], pad$0 = match[1];
-      /*<<camlinternalFormat.ml:995:4>>*/ return [0, pad$0, 1, rest];
-    }
-     /*<<camlinternalFormat.ml:996:35>>*/ throw  /*<<camlinternalFormat.ml:996:35>>*/ caml_maybe_attach_backtrace
-           (Type_mismatch, 1);
-    /*<<camlinternalFormat.ml:996:54>>*/ }
-   function type_format(fmt, fmtty){
-     /*<<camlinternalFormat.ml:1008:19>>*/  /*<<camlinternalFormat.ml:1008:25>>*/ var
-     _da_ = type_format_gen(fmt, fmtty);
-    if(typeof _da_[2] !== "number")
-      /*<<camlinternalFormat.ml:1010:9>>*/ throw  /*<<camlinternalFormat.ml:1010:9>>*/ caml_maybe_attach_backtrace
-            (Type_mismatch, 1);
-    var fmt$0 = _da_[1];
-     /*<<camlinternalFormat.ml:1009:42>>*/ return fmt$0;
-    /*<<camlinternalFormat.ml:1010:28>>*/ }
-   function type_ignored_param_one(ign, fmt, fmtty){
-     /*<<camlinternalFormat.ml:1194:2>>*/ var
-      /*<<camlinternalFormat.ml:1194:37>>*/ match =
-       type_format_gen(fmt, fmtty),
-     fmtty$0 = match[2],
-     fmt$0 = match[1];
-     /*<<camlinternalFormat.ml:1195:2>>*/ return [0,
-            [23, ign, fmt$0],
-            fmtty$0];
-    /*<<camlinternalFormat.ml:1195:51>>*/ }
-   function type_format_gen(fmt, fmtty0){
-     /*<<camlinternalFormat.ml:1018:19>>*/ if(typeof fmt === "number")
-      /*<<camlinternalFormat.ml:1133:33>>*/ return [0, 0, fmtty0];
-    switch(fmt[0]){
-      case 0:
-       if(typeof fmtty0 !== "number" && 0 === fmtty0[0]){
-         /*<<camlinternalFormat.ml:1020:39>>*/ var
-         fmtty_rest = fmtty0[1],
-         fmt_rest = fmt[1],
-          /*<<camlinternalFormat.ml:1020:39>>*/ match =
-           type_format_gen(fmt_rest, fmtty_rest),
-         fmtty = match[2],
-         fmt$0 = match[1];
-         /*<<camlinternalFormat.ml:1021:4>>*/ return [0, [0, fmt$0], fmtty];
-       }
-       break;
-      case 1:
-       if(typeof fmtty0 !== "number" && 0 === fmtty0[0]){
-         /*<<camlinternalFormat.ml:1023:39>>*/ var
-         fmtty_rest$0 = fmtty0[1],
-         fmt_rest$0 = fmt[1],
-          /*<<camlinternalFormat.ml:1023:39>>*/ match$0 =
-           type_format_gen(fmt_rest$0, fmtty_rest$0),
-         fmtty$0 = match$0[2],
-         fmt$1 = match$0[1];
-         /*<<camlinternalFormat.ml:1024:4>>*/ return [0, [1, fmt$1], fmtty$0];
-       }
-       break;
-      case 2:
-        /*<<camlinternalFormat.ml:1026:10>>*/ var
-        fmt_rest$1 = fmt[2],
-        pad = fmt[1],
-         /*<<camlinternalFormat.ml:1026:10>>*/ match$1 =
-          type_padding(pad, fmtty0),
-        pad$0 = match$1[1],
-        match$2 = match$1[2];
-       if(typeof match$2 !== "number" && 1 === match$2[0]){
-         /*<<camlinternalFormat.ml:1028:41>>*/ var
-         fmtty_rest$1 = match$2[1],
-          /*<<camlinternalFormat.ml:1028:41>>*/ match$3 =
-           type_format_gen(fmt_rest$1, fmtty_rest$1),
-         fmtty$1 = match$3[2],
-         fmt$2 = match$3[1];
-         /*<<camlinternalFormat.ml:1029:6>>*/ return [0,
-                [2, pad$0, fmt$2],
-                fmtty$1];
-       }
-        /*<<camlinternalFormat.ml:1030:34>>*/ throw  /*<<camlinternalFormat.ml:1030:34>>*/ caml_maybe_attach_backtrace
-              (Type_mismatch, 1);
-      case 3:
-        /*<<camlinternalFormat.ml:1033:10>>*/ var
-        fmt_rest$2 = fmt[2],
-        pad$1 = fmt[1],
-         /*<<camlinternalFormat.ml:1033:10>>*/ match$4 =
-          type_padding(pad$1, fmtty0),
-        pad$2 = match$4[1],
-        match$5 = match$4[2];
-       if(typeof match$5 !== "number" && 1 === match$5[0]){
-         /*<<camlinternalFormat.ml:1035:41>>*/ var
-         fmtty_rest$2 = match$5[1],
-          /*<<camlinternalFormat.ml:1035:41>>*/ match$6 =
-           type_format_gen(fmt_rest$2, fmtty_rest$2),
-         fmtty$2 = match$6[2],
-         fmt$3 = match$6[1];
-         /*<<camlinternalFormat.ml:1036:6>>*/ return [0,
-                [3, pad$2, fmt$3],
-                fmtty$2];
-       }
-        /*<<camlinternalFormat.ml:1037:34>>*/ throw  /*<<camlinternalFormat.ml:1037:34>>*/ caml_maybe_attach_backtrace
-              (Type_mismatch, 1);
-      case 4:
-        /*<<camlinternalFormat.ml:1040:10>>*/ var
-        fmt_rest$3 = fmt[4],
-        prec = fmt[3],
-        pad$3 = fmt[2],
-        iconv = fmt[1],
-         /*<<camlinternalFormat.ml:1040:10>>*/ match$7 =
-          type_padprec(pad$3, prec, fmtty0),
-        pad$4 = match$7[1],
-        match$8 = match$7[3];
-       if(typeof match$8 !== "number" && 2 === match$8[0]){
-         /*<<camlinternalFormat.ml:1042:41>>*/ var
-         fmtty_rest$3 = match$8[1],
-         prec$0 = match$7[2],
-          /*<<camlinternalFormat.ml:1042:41>>*/ match$9 =
-           type_format_gen(fmt_rest$3, fmtty_rest$3),
-         fmtty$3 = match$9[2],
-         fmt$4 = match$9[1];
-         /*<<camlinternalFormat.ml:1043:6>>*/ return [0,
-                [4, iconv, pad$4, prec$0, fmt$4],
-                fmtty$3];
-       }
-        /*<<camlinternalFormat.ml:1044:37>>*/ throw  /*<<camlinternalFormat.ml:1044:37>>*/ caml_maybe_attach_backtrace
-              (Type_mismatch, 1);
-      case 5:
-        /*<<camlinternalFormat.ml:1047:10>>*/ var
-        fmt_rest$4 = fmt[4],
-        prec$1 = fmt[3],
-        pad$5 = fmt[2],
-        iconv$0 = fmt[1],
-         /*<<camlinternalFormat.ml:1047:10>>*/ match$10 =
-          type_padprec(pad$5, prec$1, fmtty0),
-        pad$6 = match$10[1],
-        match$11 = match$10[3];
-       if(typeof match$11 !== "number" && 3 === match$11[0]){
-         /*<<camlinternalFormat.ml:1049:41>>*/ var
-         fmtty_rest$4 = match$11[1],
-         prec$2 = match$10[2],
-          /*<<camlinternalFormat.ml:1049:41>>*/ match$12 =
-           type_format_gen(fmt_rest$4, fmtty_rest$4),
-         fmtty$4 = match$12[2],
-         fmt$5 = match$12[1];
-         /*<<camlinternalFormat.ml:1050:6>>*/ return [0,
-                [5, iconv$0, pad$6, prec$2, fmt$5],
-                fmtty$4];
-       }
-        /*<<camlinternalFormat.ml:1051:37>>*/ throw  /*<<camlinternalFormat.ml:1051:37>>*/ caml_maybe_attach_backtrace
-              (Type_mismatch, 1);
-      case 6:
-        /*<<camlinternalFormat.ml:1054:10>>*/ var
-        fmt_rest$5 = fmt[4],
-        prec$3 = fmt[3],
-        pad$7 = fmt[2],
-        iconv$1 = fmt[1],
-         /*<<camlinternalFormat.ml:1054:10>>*/ match$13 =
-          type_padprec(pad$7, prec$3, fmtty0),
-        pad$8 = match$13[1],
-        match$14 = match$13[3];
-       if(typeof match$14 !== "number" && 4 === match$14[0]){
-         /*<<camlinternalFormat.ml:1056:41>>*/ var
-         fmtty_rest$5 = match$14[1],
-         prec$4 = match$13[2],
-          /*<<camlinternalFormat.ml:1056:41>>*/ match$15 =
-           type_format_gen(fmt_rest$5, fmtty_rest$5),
-         fmtty$5 = match$15[2],
-         fmt$6 = match$15[1];
-         /*<<camlinternalFormat.ml:1057:6>>*/ return [0,
-                [6, iconv$1, pad$8, prec$4, fmt$6],
-                fmtty$5];
-       }
-        /*<<camlinternalFormat.ml:1058:37>>*/ throw  /*<<camlinternalFormat.ml:1058:37>>*/ caml_maybe_attach_backtrace
-              (Type_mismatch, 1);
-      case 7:
-        /*<<camlinternalFormat.ml:1061:10>>*/ var
-        fmt_rest$6 = fmt[4],
-        prec$5 = fmt[3],
-        pad$9 = fmt[2],
-        iconv$2 = fmt[1],
-         /*<<camlinternalFormat.ml:1061:10>>*/ match$16 =
-          type_padprec(pad$9, prec$5, fmtty0),
-        pad$10 = match$16[1],
-        match$17 = match$16[3];
-       if(typeof match$17 !== "number" && 5 === match$17[0]){
-         /*<<camlinternalFormat.ml:1063:41>>*/ var
-         fmtty_rest$6 = match$17[1],
-         prec$6 = match$16[2],
-          /*<<camlinternalFormat.ml:1063:41>>*/ match$18 =
-           type_format_gen(fmt_rest$6, fmtty_rest$6),
-         fmtty$6 = match$18[2],
-         fmt$7 = match$18[1];
-         /*<<camlinternalFormat.ml:1064:6>>*/ return [0,
-                [7, iconv$2, pad$10, prec$6, fmt$7],
-                fmtty$6];
-       }
-        /*<<camlinternalFormat.ml:1065:37>>*/ throw  /*<<camlinternalFormat.ml:1065:37>>*/ caml_maybe_attach_backtrace
-              (Type_mismatch, 1);
-      case 8:
-        /*<<camlinternalFormat.ml:1068:10>>*/ var
-        fmt_rest$7 = fmt[4],
-        prec$7 = fmt[3],
-        pad$11 = fmt[2],
-        fconv = fmt[1],
-         /*<<camlinternalFormat.ml:1068:10>>*/ match$19 =
-          type_padprec(pad$11, prec$7, fmtty0),
-        pad$12 = match$19[1],
-        match$20 = match$19[3];
-       if(typeof match$20 !== "number" && 6 === match$20[0]){
-         /*<<camlinternalFormat.ml:1070:41>>*/ var
-         fmtty_rest$7 = match$20[1],
-         prec$8 = match$19[2],
-          /*<<camlinternalFormat.ml:1070:41>>*/ match$21 =
-           type_format_gen(fmt_rest$7, fmtty_rest$7),
-         fmtty$7 = match$21[2],
-         fmt$8 = match$21[1];
-         /*<<camlinternalFormat.ml:1071:6>>*/ return [0,
-                [8, fconv, pad$12, prec$8, fmt$8],
-                fmtty$7];
-       }
-        /*<<camlinternalFormat.ml:1072:37>>*/ throw  /*<<camlinternalFormat.ml:1072:37>>*/ caml_maybe_attach_backtrace
-              (Type_mismatch, 1);
-      case 9:
-        /*<<camlinternalFormat.ml:1075:10>>*/ var
-        fmt_rest$8 = fmt[2],
-        pad$13 = fmt[1],
-         /*<<camlinternalFormat.ml:1075:10>>*/ match$22 =
-          type_padding(pad$13, fmtty0),
-        pad$14 = match$22[1],
-        match$23 = match$22[2];
-       if(typeof match$23 !== "number" && 7 === match$23[0]){
-         /*<<camlinternalFormat.ml:1077:41>>*/ var
-         fmtty_rest$8 = match$23[1],
-          /*<<camlinternalFormat.ml:1077:41>>*/ match$24 =
-           type_format_gen(fmt_rest$8, fmtty_rest$8),
-         fmtty$8 = match$24[2],
-         fmt$9 = match$24[1];
-         /*<<camlinternalFormat.ml:1078:6>>*/ return [0,
-                [9, pad$14, fmt$9],
-                fmtty$8];
-       }
-        /*<<camlinternalFormat.ml:1079:34>>*/ throw  /*<<camlinternalFormat.ml:1079:34>>*/ caml_maybe_attach_backtrace
-              (Type_mismatch, 1);
-      case 10:
-        /*<<camlinternalFormat.ml:1082:39>>*/ var
-        fmt_rest$9 = fmt[1],
-         /*<<camlinternalFormat.ml:1082:39>>*/ match$25 =
-          type_format_gen(fmt_rest$9, fmtty0),
-        fmtty$9 = match$25[2],
-        fmt$10 = match$25[1];
-        /*<<camlinternalFormat.ml:1083:4>>*/ return [0, [10, fmt$10], fmtty$9];
-      case 11:
-        /*<<camlinternalFormat.ml:1086:39>>*/ var
-        fmt_rest$10 = fmt[2],
-        str = fmt[1],
-         /*<<camlinternalFormat.ml:1086:39>>*/ match$26 =
-          type_format_gen(fmt_rest$10, fmtty0),
-        fmtty$10 = match$26[2],
-        fmt$11 = match$26[1];
-        /*<<camlinternalFormat.ml:1087:4>>*/ return [0,
-               [11, str, fmt$11],
-               fmtty$10];
-      case 12:
-        /*<<camlinternalFormat.ml:1089:39>>*/ var
-        fmt_rest$11 = fmt[2],
-        chr = fmt[1],
-         /*<<camlinternalFormat.ml:1089:39>>*/ match$27 =
-          type_format_gen(fmt_rest$11, fmtty0),
-        fmtty$11 = match$27[2],
-        fmt$12 = match$27[1];
-        /*<<camlinternalFormat.ml:1090:4>>*/ return [0,
-               [12, chr, fmt$12],
-               fmtty$11];
-      case 13:
-       if(typeof fmtty0 !== "number" && 8 === fmtty0[0]){
-        var
-         fmtty_rest$9 = fmtty0[2],
-         sub_fmtty = fmtty0[1],
-         fmt_rest$12 = fmt[3],
-         sub_fmtty$0 = fmt[2],
-         pad_opt = fmt[1];
-         /*<<camlinternalFormat.ml:1094:7>>*/ if
-         ( /*<<camlinternalFormat.ml:1094:7>>*/ caml_notequal
-           ([0, sub_fmtty$0], [0, sub_fmtty]))
-          /*<<camlinternalFormat.ml:1094:56>>*/ throw  /*<<camlinternalFormat.ml:1094:56>>*/ caml_maybe_attach_backtrace
-                (Type_mismatch, 1);
-         /*<<camlinternalFormat.ml:1095:39>>*/ var
-          /*<<camlinternalFormat.ml:1095:39>>*/ match$28 =
-           type_format_gen(fmt_rest$12, fmtty_rest$9),
-         fmtty$12 = match$28[2],
-         fmt$13 = match$28[1];
-         /*<<camlinternalFormat.ml:1096:4>>*/ return [0,
-                [13, pad_opt, sub_fmtty, fmt$13],
-                fmtty$12];
-       }
-       break;
-      case 14:
-       if(typeof fmtty0 !== "number" && 9 === fmtty0[0]){
-         /*<<camlinternalFormat.ml:1099:42>>*/ var
-         fmtty_rest$10 = fmtty0[3],
-         sub_fmtty1 = fmtty0[1],
-         fmt_rest$13 = fmt[3],
-         sub_fmtty$1 = fmt[2],
-         pad_opt$0 = fmt[1],
-          /*<<camlinternalFormat.ml:1099:42>>*/ _c__ =
-           [0,
-             /*<<camlinternalFormat.ml:1099:52>>*/ caml_call1
-             (CamlinternalFormatBasics[2], sub_fmtty1)];
-         /*<<camlinternalFormat.ml:1099:7>>*/ if
-         ( /*<<camlinternalFormat.ml:1099:7>>*/ caml_notequal
-           ([0,
-              /*<<camlinternalFormat.ml:1099:17>>*/ caml_call1
-              (CamlinternalFormatBasics[2], sub_fmtty$1)],
-            _c__))
-          /*<<camlinternalFormat.ml:1100:6>>*/ throw  /*<<camlinternalFormat.ml:1100:6>>*/ caml_maybe_attach_backtrace
-                (Type_mismatch, 1);
-         /*<<camlinternalFormat.ml:1102:6>>*/ var
-          /*<<camlinternalFormat.ml:1102:6>>*/ match$29 =
-           type_format_gen
-            (fmt_rest$13,
-              /*<<camlinternalFormat.ml:1102:31>>*/ caml_call1
-              (CamlinternalFormatBasics[2], fmtty_rest$10)),
-         fmtty$13 = match$29[2],
-         fmt$14 = match$29[1];
-         /*<<camlinternalFormat.ml:1104:4>>*/ return [0,
-                [14, pad_opt$0, sub_fmtty1, fmt$14],
-                fmtty$13];
-       }
-       break;
-      case 15:
-       if(typeof fmtty0 !== "number" && 10 === fmtty0[0]){
-         /*<<camlinternalFormat.ml:1107:39>>*/ var
-         fmtty_rest$11 = fmtty0[1],
-         fmt_rest$14 = fmt[1],
-          /*<<camlinternalFormat.ml:1107:39>>*/ match$30 =
-           type_format_gen(fmt_rest$14, fmtty_rest$11),
-         fmtty$14 = match$30[2],
-         fmt$15 = match$30[1];
-         /*<<camlinternalFormat.ml:1108:4>>*/ return [0,
-                [15, fmt$15],
-                fmtty$14];
-       }
-       break;
-      case 16:
-       if(typeof fmtty0 !== "number" && 11 === fmtty0[0]){
-         /*<<camlinternalFormat.ml:1110:39>>*/ var
-         fmtty_rest$12 = fmtty0[1],
-         fmt_rest$15 = fmt[1],
-          /*<<camlinternalFormat.ml:1110:39>>*/ match$31 =
-           type_format_gen(fmt_rest$15, fmtty_rest$12),
-         fmtty$15 = match$31[2],
-         fmt$16 = match$31[1];
-         /*<<camlinternalFormat.ml:1111:4>>*/ return [0,
-                [16, fmt$16],
-                fmtty$15];
-       }
-       break;
-      case 17:
-        /*<<camlinternalFormat.ml:1115:39>>*/ var
-        fmt_rest$16 = fmt[2],
-        formatting_lit = fmt[1],
-         /*<<camlinternalFormat.ml:1115:39>>*/ match$32 =
-          type_format_gen(fmt_rest$16, fmtty0),
-        fmtty$16 = match$32[2],
-        fmt$17 = match$32[1];
-        /*<<camlinternalFormat.ml:1116:4>>*/ return [0,
-               [17, formatting_lit, fmt$17],
-               fmtty$16];
-      case 18:
-       var fmt_rest$17 = fmt[2], formatting_gen = fmt[1];
-       if(0 === formatting_gen[0]){
-         /*<<camlinternalFormat.ml:1144:39>>*/ var
-         match$36 = formatting_gen[1],
-         str$0 = match$36[2],
-         fmt1 = match$36[1],
-          /*<<camlinternalFormat.ml:1144:39>>*/ match$37 =
-           type_format_gen(fmt1, fmtty0),
-         fmtty2 = match$37[2],
-         fmt2 = match$37[1],
-          /*<<camlinternalFormat.ml:1145:39>>*/ match$38 =
-           type_format_gen(fmt_rest$17, fmtty2),
-         fmtty3 = match$38[2],
-         fmt3 = match$38[1];
-         /*<<camlinternalFormat.ml:1146:4>>*/ return [0,
-                [18, [0, [0, fmt2, str$0]], fmt3],
-                fmtty3];
-       }
-        /*<<camlinternalFormat.ml:1148:39>>*/ var
-        match$39 = formatting_gen[1],
-        str$1 = match$39[2],
-        fmt1$0 = match$39[1],
-         /*<<camlinternalFormat.ml:1148:39>>*/ match$40 =
-          type_format_gen(fmt1$0, fmtty0),
-        fmtty2$0 = match$40[2],
-        fmt2$0 = match$40[1],
-         /*<<camlinternalFormat.ml:1149:39>>*/ match$41 =
-          type_format_gen(fmt_rest$17, fmtty2$0),
-        fmtty3$0 = match$41[2],
-        fmt3$0 = match$41[1];
-        /*<<camlinternalFormat.ml:1150:4>>*/ return [0,
-               [18, [1, [0, fmt2$0, str$1]], fmt3$0],
-               fmtty3$0];
-      case 19:
-       if(typeof fmtty0 !== "number" && 13 === fmtty0[0]){
-         /*<<camlinternalFormat.ml:1122:39>>*/ var
-         fmtty_rest$13 = fmtty0[1],
-         fmt_rest$18 = fmt[1],
-          /*<<camlinternalFormat.ml:1122:39>>*/ match$33 =
-           type_format_gen(fmt_rest$18, fmtty_rest$13),
-         fmtty$17 = match$33[2],
-         fmt$18 = match$33[1];
-         /*<<camlinternalFormat.ml:1123:4>>*/ return [0,
-                [19, fmt$18],
-                fmtty$17];
-       }
-       break;
-      case 20:
-       if(typeof fmtty0 !== "number" && 1 === fmtty0[0]){
-         /*<<camlinternalFormat.ml:1125:39>>*/ var
-         fmtty_rest$14 = fmtty0[1],
-         fmt_rest$19 = fmt[3],
-         char_set = fmt[2],
-         width_opt = fmt[1],
-          /*<<camlinternalFormat.ml:1125:39>>*/ match$34 =
-           type_format_gen(fmt_rest$19, fmtty_rest$14),
-         fmtty$18 = match$34[2],
-         fmt$19 = match$34[1];
-         /*<<camlinternalFormat.ml:1126:4>>*/ return [0,
-                [20, width_opt, char_set, fmt$19],
-                fmtty$18];
-       }
-       break;
-      case 21:
-       if(typeof fmtty0 !== "number" && 2 === fmtty0[0]){
-         /*<<camlinternalFormat.ml:1128:39>>*/ var
-         fmtty_rest$15 = fmtty0[1],
-         fmt_rest$20 = fmt[2],
-         counter = fmt[1],
-          /*<<camlinternalFormat.ml:1128:39>>*/ match$35 =
-           type_format_gen(fmt_rest$20, fmtty_rest$15),
-         fmtty$19 = match$35[2],
-         fmt$20 = match$35[1];
-         /*<<camlinternalFormat.ml:1129:4>>*/ return [0,
-                [21, counter, fmt$20],
-                fmtty$19];
-       }
-       break;
-      case 23:
-       var rest = fmt[2], ign = fmt[1];
-       if(typeof ign !== "number")
-        switch(ign[0]){
-          case 0:
-            /*<<camlinternalFormat.ml:1161:42>>*/ return type_ignored_param_one
-                   (ign, rest, fmtty0);
-          case 1:
-            /*<<camlinternalFormat.ml:1162:42>>*/ return type_ignored_param_one
-                   (ign, rest, fmtty0);
-          case 2:
-            /*<<camlinternalFormat.ml:1163:42>>*/ return type_ignored_param_one
-                   (ign, rest, fmtty0);
-          case 3:
-            /*<<camlinternalFormat.ml:1164:42>>*/ return type_ignored_param_one
-                   (ign, rest, fmtty0);
-          case 4:
-            /*<<camlinternalFormat.ml:1165:42>>*/ return type_ignored_param_one
-                   (ign, rest, fmtty0);
-          case 5:
-            /*<<camlinternalFormat.ml:1166:42>>*/ return type_ignored_param_one
-                   (ign, rest, fmtty0);
-          case 6:
-            /*<<camlinternalFormat.ml:1167:42>>*/ return type_ignored_param_one
-                   (ign, rest, fmtty0);
-          case 7:
-            /*<<camlinternalFormat.ml:1168:42>>*/ return type_ignored_param_one
-                   (ign, rest, fmtty0);
-          case 8:
-           var sub_fmtty$2 = ign[2], pad_opt$1 = ign[1];
-            /*<<camlinternalFormat.ml:1173:4>>*/ return type_ignored_param_one
-                   ([8, pad_opt$1, sub_fmtty$2], rest, fmtty0);
-          case 9:
-            /*<<camlinternalFormat.ml:1176:6>>*/ var
-            sub_fmtty$3 = ign[2],
-            pad_opt$2 = ign[1],
-             /*<<camlinternalFormat.ml:1176:6>>*/ _c$_ =
-              type_ignored_format_substituti(sub_fmtty$3, rest, fmtty0),
-            match$43 = _c$_[2],
-            fmtty$21 = match$43[2],
-            fmt$22 = match$43[1],
-            sub_fmtty$4 = _c$_[1];
-            /*<<camlinternalFormat.ml:1177:4>>*/ return [0,
-                   [23, [9, pad_opt$2, sub_fmtty$4], fmt$22],
-                   fmtty$21];
-          case 10:
-            /*<<camlinternalFormat.ml:1169:42>>*/ return type_ignored_param_one
-                   (ign, rest, fmtty0);
-          default:
-            /*<<camlinternalFormat.ml:1170:42>>*/ return type_ignored_param_one
-                   (ign, rest, fmtty0);
-        }
-       switch(ign){
-         case 0:
-           /*<<camlinternalFormat.ml:1159:42>>*/ return type_ignored_param_one
-                  (ign, rest, fmtty0);
-         case 1:
-           /*<<camlinternalFormat.ml:1160:42>>*/ return type_ignored_param_one
-                  (ign, rest, fmtty0);
-         case 2:
-          if(typeof fmtty0 !== "number" && 14 === fmtty0[0]){
-            /*<<camlinternalFormat.ml:1183:41>>*/ var
-            fmtty_rest$16 = fmtty0[1],
-             /*<<camlinternalFormat.ml:1183:41>>*/ match$42 =
-              type_format_gen(rest, fmtty_rest$16),
-            fmtty$20 = match$42[2],
-            fmt$21 = match$42[1];
-            /*<<camlinternalFormat.ml:1184:6>>*/ return [0,
-                   [23, 2, fmt$21],
-                   fmtty$20];
-          }
-           /*<<camlinternalFormat.ml:1185:11>>*/ throw  /*<<camlinternalFormat.ml:1185:11>>*/ caml_maybe_attach_backtrace
-                 (Type_mismatch, 1);
-         default:
-           /*<<camlinternalFormat.ml:1171:42>>*/ return type_ignored_param_one
-                  (ign, rest, fmtty0);
-       }
-    }
-     /*<<camlinternalFormat.ml:1135:9>>*/ throw  /*<<camlinternalFormat.ml:1135:9>>*/ caml_maybe_attach_backtrace
-           (Type_mismatch, 1);
-    /*<<camlinternalFormat.ml:1135:28>>*/ }
-   function type_ignored_format_substituti(sub_fmtty, fmt, fmtty){
-     /*<<camlinternalFormat.ml:1202:27>>*/ if(typeof sub_fmtty === "number")
-      /*<<camlinternalFormat.ml:1276:4>>*/ return [0,
-             0,
-             type_format_gen(fmt, fmtty)];
-    switch(sub_fmtty[0]){
-      case 0:
-       if(typeof fmtty !== "number" && 0 === fmtty[0]){
-         /*<<camlinternalFormat.ml:1205:6>>*/ var
-         fmtty_rest = fmtty[1],
-         sub_fmtty_rest = sub_fmtty[1],
-          /*<<camlinternalFormat.ml:1205:6>>*/ match =
-           type_ignored_format_substituti(sub_fmtty_rest, fmt, fmtty_rest),
-         fmt$0 = match[2],
-         sub_fmtty_rest$0 = match[1];
-         /*<<camlinternalFormat.ml:1206:4>>*/ return [0,
-                [0, sub_fmtty_rest$0],
-                fmt$0];
-       }
-       break;
-      case 1:
-       if(typeof fmtty !== "number" && 1 === fmtty[0]){
-         /*<<camlinternalFormat.ml:1209:6>>*/ var
-         fmtty_rest$0 = fmtty[1],
-         sub_fmtty_rest$1 = sub_fmtty[1],
-          /*<<camlinternalFormat.ml:1209:6>>*/ match$0 =
-           type_ignored_format_substituti(sub_fmtty_rest$1, fmt, fmtty_rest$0),
-         fmt$1 = match$0[2],
-         sub_fmtty_rest$2 = match$0[1];
-         /*<<camlinternalFormat.ml:1210:4>>*/ return [0,
-                [1, sub_fmtty_rest$2],
-                fmt$1];
-       }
-       break;
-      case 2:
-       if(typeof fmtty !== "number" && 2 === fmtty[0]){
-         /*<<camlinternalFormat.ml:1213:6>>*/ var
-         fmtty_rest$1 = fmtty[1],
-         sub_fmtty_rest$3 = sub_fmtty[1],
-          /*<<camlinternalFormat.ml:1213:6>>*/ match$1 =
-           type_ignored_format_substituti(sub_fmtty_rest$3, fmt, fmtty_rest$1),
-         fmt$2 = match$1[2],
-         sub_fmtty_rest$4 = match$1[1];
-         /*<<camlinternalFormat.ml:1214:4>>*/ return [0,
-                [2, sub_fmtty_rest$4],
-                fmt$2];
-       }
-       break;
-      case 3:
-       if(typeof fmtty !== "number" && 3 === fmtty[0]){
-         /*<<camlinternalFormat.ml:1217:6>>*/ var
-         fmtty_rest$2 = fmtty[1],
-         sub_fmtty_rest$5 = sub_fmtty[1],
-          /*<<camlinternalFormat.ml:1217:6>>*/ match$2 =
-           type_ignored_format_substituti(sub_fmtty_rest$5, fmt, fmtty_rest$2),
-         fmt$3 = match$2[2],
-         sub_fmtty_rest$6 = match$2[1];
-         /*<<camlinternalFormat.ml:1218:4>>*/ return [0,
-                [3, sub_fmtty_rest$6],
-                fmt$3];
-       }
-       break;
-      case 4:
-       if(typeof fmtty !== "number" && 4 === fmtty[0]){
-         /*<<camlinternalFormat.ml:1221:6>>*/ var
-         fmtty_rest$3 = fmtty[1],
-         sub_fmtty_rest$7 = sub_fmtty[1],
-          /*<<camlinternalFormat.ml:1221:6>>*/ match$3 =
-           type_ignored_format_substituti(sub_fmtty_rest$7, fmt, fmtty_rest$3),
-         fmt$4 = match$3[2],
-         sub_fmtty_rest$8 = match$3[1];
-         /*<<camlinternalFormat.ml:1222:4>>*/ return [0,
-                [4, sub_fmtty_rest$8],
-                fmt$4];
-       }
-       break;
-      case 5:
-       if(typeof fmtty !== "number" && 5 === fmtty[0]){
-         /*<<camlinternalFormat.ml:1225:6>>*/ var
-         fmtty_rest$4 = fmtty[1],
-         sub_fmtty_rest$9 = sub_fmtty[1],
-          /*<<camlinternalFormat.ml:1225:6>>*/ match$4 =
-           type_ignored_format_substituti(sub_fmtty_rest$9, fmt, fmtty_rest$4),
-         fmt$5 = match$4[2],
-         sub_fmtty_rest$10 = match$4[1];
-         /*<<camlinternalFormat.ml:1226:4>>*/ return [0,
-                [5, sub_fmtty_rest$10],
-                fmt$5];
-       }
-       break;
-      case 6:
-       if(typeof fmtty !== "number" && 6 === fmtty[0]){
-         /*<<camlinternalFormat.ml:1229:6>>*/ var
-         fmtty_rest$5 = fmtty[1],
-         sub_fmtty_rest$11 = sub_fmtty[1],
-          /*<<camlinternalFormat.ml:1229:6>>*/ match$5 =
-           type_ignored_format_substituti
-            (sub_fmtty_rest$11, fmt, fmtty_rest$5),
-         fmt$6 = match$5[2],
-         sub_fmtty_rest$12 = match$5[1];
-         /*<<camlinternalFormat.ml:1230:4>>*/ return [0,
-                [6, sub_fmtty_rest$12],
-                fmt$6];
-       }
-       break;
-      case 7:
-       if(typeof fmtty !== "number" && 7 === fmtty[0]){
-         /*<<camlinternalFormat.ml:1233:6>>*/ var
-         fmtty_rest$6 = fmtty[1],
-         sub_fmtty_rest$13 = sub_fmtty[1],
-          /*<<camlinternalFormat.ml:1233:6>>*/ match$6 =
-           type_ignored_format_substituti
-            (sub_fmtty_rest$13, fmt, fmtty_rest$6),
-         fmt$7 = match$6[2],
-         sub_fmtty_rest$14 = match$6[1];
-         /*<<camlinternalFormat.ml:1234:4>>*/ return [0,
-                [7, sub_fmtty_rest$14],
-                fmt$7];
-       }
-       break;
-      case 8:
-       if(typeof fmtty !== "number" && 8 === fmtty[0]){
-        var
-         fmtty_rest$7 = fmtty[2],
-         sub2_fmtty = fmtty[1],
-         sub_fmtty_rest$15 = sub_fmtty[2],
-         sub2_fmtty$0 = sub_fmtty[1];
-         /*<<camlinternalFormat.ml:1254:7>>*/ if
-         ( /*<<camlinternalFormat.ml:1254:7>>*/ caml_notequal
-           ([0, sub2_fmtty$0], [0, sub2_fmtty]))
-          /*<<camlinternalFormat.ml:1254:58>>*/ throw  /*<<camlinternalFormat.ml:1254:58>>*/ caml_maybe_attach_backtrace
-                (Type_mismatch, 1);
-         /*<<camlinternalFormat.ml:1256:6>>*/ var
-          /*<<camlinternalFormat.ml:1256:6>>*/ match$7 =
-           type_ignored_format_substituti
-            (sub_fmtty_rest$15, fmt, fmtty_rest$7),
-         fmt$8 = match$7[2],
-         sub_fmtty_rest$16 = match$7[1];
-         /*<<camlinternalFormat.ml:1257:4>>*/ return [0,
-                [8, sub2_fmtty, sub_fmtty_rest$16],
-                fmt$8];
-       }
-       break;
-      case 9:
-       if(typeof fmtty !== "number" && 9 === fmtty[0]){
-         /*<<camlinternalFormat.ml:1261:43>>*/ var
-         fmtty_rest$8 = fmtty[3],
-         sub2_fmtty$1 = fmtty[2],
-         sub1_fmtty = fmtty[1],
-         sub_fmtty_rest$17 = sub_fmtty[3],
-         sub2_fmtty$2 = sub_fmtty[2],
-         sub1_fmtty$0 = sub_fmtty[1],
-          /*<<camlinternalFormat.ml:1261:43>>*/ _c8_ =
-           [0,
-             /*<<camlinternalFormat.ml:1261:53>>*/ caml_call1
-             (CamlinternalFormatBasics[2], sub1_fmtty)];
-         /*<<camlinternalFormat.ml:1261:7>>*/ if
-         ( /*<<camlinternalFormat.ml:1261:7>>*/ caml_notequal
-           ([0,
-              /*<<camlinternalFormat.ml:1261:17>>*/ caml_call1
-              (CamlinternalFormatBasics[2], sub1_fmtty$0)],
-            _c8_))
-          /*<<camlinternalFormat.ml:1262:9>>*/ throw  /*<<camlinternalFormat.ml:1262:9>>*/ caml_maybe_attach_backtrace
-                (Type_mismatch, 1);
-         /*<<camlinternalFormat.ml:1263:43>>*/  /*<<camlinternalFormat.ml:1263:43>>*/ var
-         _c9_ =
-           [0,
-             /*<<camlinternalFormat.ml:1263:53>>*/ caml_call1
-             (CamlinternalFormatBasics[2], sub2_fmtty$1)];
-         /*<<camlinternalFormat.ml:1263:7>>*/ if
-         ( /*<<camlinternalFormat.ml:1263:7>>*/ caml_notequal
-           ([0,
-              /*<<camlinternalFormat.ml:1263:17>>*/ caml_call1
-              (CamlinternalFormatBasics[2], sub2_fmtty$2)],
-            _c9_))
-          /*<<camlinternalFormat.ml:1264:9>>*/ throw  /*<<camlinternalFormat.ml:1264:9>>*/ caml_maybe_attach_backtrace
-                (Type_mismatch, 1);
-         /*<<camlinternalFormat.ml:1265:21>>*/ var
-          /*<<camlinternalFormat.ml:1265:21>>*/ sub_fmtty$0 =
-           trans(symm(sub1_fmtty), sub2_fmtty$1),
-          /*<<camlinternalFormat.ml:1266:23>>*/ match$8 =
-           fmtty_rel_det(sub_fmtty$0),
-         f4 = match$8[4],
-         f2 = match$8[2];
-         /*<<camlinternalFormat.ml:1267:15>>*/ f2(0);
-         /*<<camlinternalFormat.ml:1268:15>>*/ f4(0);
-         /*<<camlinternalFormat.ml:1270:6>>*/ var
-          /*<<camlinternalFormat.ml:1270:6>>*/ match$9 =
-           type_ignored_format_substituti
-            ( /*<<camlinternalFormat.ml:1270:39>>*/ caml_call1
-              (CamlinternalFormatBasics[2], sub_fmtty_rest$17),
-             fmt,
-             fmtty_rest$8),
-         fmt$9 = match$9[2],
-         sub_fmtty_rest$18 = match$9[1];
-         /*<<camlinternalFormat.ml:1272:4>>*/ return [0,
-                [9, sub1_fmtty, sub2_fmtty$1, symm(sub_fmtty_rest$18)],
-                fmt$9];
-       }
-       break;
-      case 10:
-       if(typeof fmtty !== "number" && 10 === fmtty[0]){
-         /*<<camlinternalFormat.ml:1237:6>>*/ var
-         fmtty_rest$9 = fmtty[1],
-         sub_fmtty_rest$19 = sub_fmtty[1],
-          /*<<camlinternalFormat.ml:1237:6>>*/ match$10 =
-           type_ignored_format_substituti
-            (sub_fmtty_rest$19, fmt, fmtty_rest$9),
-         fmt$10 = match$10[2],
-         sub_fmtty_rest$20 = match$10[1];
-         /*<<camlinternalFormat.ml:1238:4>>*/ return [0,
-                [10, sub_fmtty_rest$20],
-                fmt$10];
-       }
-       break;
-      case 11:
-       if(typeof fmtty !== "number" && 11 === fmtty[0]){
-         /*<<camlinternalFormat.ml:1241:6>>*/ var
-         fmtty_rest$10 = fmtty[1],
-         sub_fmtty_rest$21 = sub_fmtty[1],
-          /*<<camlinternalFormat.ml:1241:6>>*/ match$11 =
-           type_ignored_format_substituti
-            (sub_fmtty_rest$21, fmt, fmtty_rest$10),
-         fmt$11 = match$11[2],
-         sub_fmtty_rest$22 = match$11[1];
-         /*<<camlinternalFormat.ml:1242:4>>*/ return [0,
-                [11, sub_fmtty_rest$22],
-                fmt$11];
-       }
-       break;
-      case 13:
-       if(typeof fmtty !== "number" && 13 === fmtty[0]){
-         /*<<camlinternalFormat.ml:1245:6>>*/ var
-         fmtty_rest$11 = fmtty[1],
-         sub_fmtty_rest$23 = sub_fmtty[1],
-          /*<<camlinternalFormat.ml:1245:6>>*/ match$12 =
-           type_ignored_format_substituti
-            (sub_fmtty_rest$23, fmt, fmtty_rest$11),
-         fmt$12 = match$12[2],
-         sub_fmtty_rest$24 = match$12[1];
-         /*<<camlinternalFormat.ml:1246:4>>*/ return [0,
-                [13, sub_fmtty_rest$24],
-                fmt$12];
-       }
-       break;
-      case 14:
-       if(typeof fmtty !== "number" && 14 === fmtty[0]){
-         /*<<camlinternalFormat.ml:1249:6>>*/ var
-         fmtty_rest$12 = fmtty[1],
-         sub_fmtty_rest$25 = sub_fmtty[1],
-          /*<<camlinternalFormat.ml:1249:6>>*/ match$13 =
-           type_ignored_format_substituti
-            (sub_fmtty_rest$25, fmt, fmtty_rest$12),
-         fmt$13 = match$13[2],
-         sub_fmtty_rest$26 = match$13[1];
-         /*<<camlinternalFormat.ml:1250:4>>*/ return [0,
-                [14, sub_fmtty_rest$26],
-                fmt$13];
-       }
-       break;
-    }
-     /*<<camlinternalFormat.ml:1277:9>>*/ throw  /*<<camlinternalFormat.ml:1277:9>>*/ caml_maybe_attach_backtrace
-           (Type_mismatch, 1);
-    /*<<camlinternalFormat.ml:1277:28>>*/ }
-   function recast(fmt, fmtty){
-     /*<<camlinternalFormat.ml:1312:2>>*/  /*<<camlinternalFormat.ml:1312:29>>*/ var
-     _c7_ = symm(fmtty);
-     /*<<camlinternalFormat.ml:1312:18>>*/ return type_format
-            (fmt,
-              /*<<camlinternalFormat.ml:1312:18>>*/ caml_call1
-              (CamlinternalFormatBasics[2], _c7_));
-    /*<<camlinternalFormat.ml:1312:42>>*/ }
-   function fix_padding(padty, width, str){
-     /*<<camlinternalFormat.ml:1319:2>>*/ var
-     len = caml_ml_string_length(str),
-      /*<<camlinternalFormat.ml:1320:2>>*/ padty$0 = 0 <= width ? padty : 0,
-      /*<<camlinternalFormat.ml:1321:4>>*/ width$0 =
-        /*<<camlinternalFormat.ml:1321:4>>*/ caml_call1(Stdlib[18], width);
-    if(width$0 <= len)  /*<<camlinternalFormat.ml:1332:23>>*/ return str;
-     /*<<camlinternalFormat.ml:1333:14>>*/ var
-     _c6_ = 2 === padty$0 ? 48 : 32,
-      /*<<camlinternalFormat.ml:1333:14>>*/ res =
-        /*<<camlinternalFormat.ml:1333:14>>*/ caml_call2
-        (Stdlib_Bytes[1], width$0, _c6_);
-     /*<<camlinternalFormat.ml:1334:4>>*/ switch(padty$0){
-      case 0:
-        /*<<camlinternalFormat.ml:1335:15>>*/  /*<<camlinternalFormat.ml:1335:15>>*/ caml_call5
-        (Stdlib_String[48], str, 0, res, 0, len);
-       break;
-      case 1:
-        /*<<camlinternalFormat.ml:1336:15>>*/  /*<<camlinternalFormat.ml:1336:15>>*/ caml_call5
-        (Stdlib_String[48], str, 0, res, width$0 - len | 0, len);
-       break;
-      default:
-       a:
-       if(0 < len){
-         /*<<camlinternalFormat.ml:1337:63>>*/ if
-         (43
-          !==  /*<<camlinternalFormat.ml:1337:29>>*/ caml_string_get(str, 0)
-          &&
-           45
-           !==  /*<<camlinternalFormat.ml:1337:46>>*/ caml_string_get(str, 0)
-           &&
-            32
-            !==  /*<<camlinternalFormat.ml:1337:63>>*/ caml_string_get(str, 0))
-         break a;
-         /*<<camlinternalFormat.ml:1338:6>>*/  /*<<camlinternalFormat.ml:1338:6>>*/ caml_bytes_set
-         (res,
-          0,
-           /*<<camlinternalFormat.ml:1338:22>>*/ caml_string_get(str, 0));
-         /*<<camlinternalFormat.ml:1339:6>>*/  /*<<camlinternalFormat.ml:1339:6>>*/ caml_call5
-         (Stdlib_String[48],
-          str,
-          1,
-          res,
-          (width$0 - len | 0) + 1 | 0,
-          len - 1 | 0);
-        break;
-       }
-       a:
-       if
-        (1 < len
-         &&
-          48
-          ===  /*<<camlinternalFormat.ml:1340:28>>*/ caml_string_get(str, 0)){
-         /*<<camlinternalFormat.ml:1340:63>>*/ if
-         (120
-          !==  /*<<camlinternalFormat.ml:1340:46>>*/ caml_string_get(str, 1)
-          &&
-           88
-           !==  /*<<camlinternalFormat.ml:1340:63>>*/ caml_string_get(str, 1))
-         break a;
-         /*<<camlinternalFormat.ml:1341:6>>*/  /*<<camlinternalFormat.ml:1341:6>>*/ caml_bytes_set
-         (res,
-          1,
-           /*<<camlinternalFormat.ml:1341:22>>*/ caml_string_get(str, 1));
-         /*<<camlinternalFormat.ml:1342:6>>*/  /*<<camlinternalFormat.ml:1342:6>>*/ caml_call5
-         (Stdlib_String[48],
-          str,
-          2,
-          res,
-          (width$0 - len | 0) + 2 | 0,
-          len - 2 | 0);
-        break;
-       }
-        /*<<camlinternalFormat.ml:1344:6>>*/  /*<<camlinternalFormat.ml:1344:6>>*/ caml_call5
-        (Stdlib_String[48], str, 0, res, width$0 - len | 0, len);
-    }
-     /*<<camlinternalFormat.ml:1346:4>>*/ return  /*<<camlinternalFormat.ml:1346:4>>*/ caml_call1
-            (Stdlib_Bytes[44], res);
-    /*<<camlinternalFormat.ml:1346:30>>*/ }
-   function fix_int_precision(prec, str){
-     /*<<camlinternalFormat.ml:1350:2>>*/ var
-      /*<<camlinternalFormat.ml:1350:13>>*/ prec$0 =
-        /*<<camlinternalFormat.ml:1350:13>>*/ caml_call1(Stdlib[18], prec),
-      /*<<camlinternalFormat.ml:1351:2>>*/ len =
-        /*<<camlinternalFormat.ml:1351:2>>*/ caml_ml_string_length(str),
-      /*<<camlinternalFormat.ml:1352:8>>*/ c =
-        /*<<camlinternalFormat.ml:1352:8>>*/ caml_string_get(str, 0);
-    a:
-    {
-     b:
-     {
-      if(58 > c){
-       if(32 !== c){
-        if(43 > c) break a;
-        switch(c - 43 | 0){
-          case 5:
-           c:
-           if(len < (prec$0 + 2 | 0) && 1 < len){
-             /*<<camlinternalFormat.ml:1358:60>>*/ if
-             (120
-              !==
-                /*<<camlinternalFormat.ml:1358:43>>*/ caml_string_get(str, 1)
-              &&
-               88
-               !==
-                 /*<<camlinternalFormat.ml:1358:60>>*/ caml_string_get(str, 1))
-             break c;
-             /*<<camlinternalFormat.ml:1359:14>>*/  /*<<camlinternalFormat.ml:1359:14>>*/ var
-             res$1 =
-                /*<<camlinternalFormat.ml:1359:14>>*/ caml_call2
-                (Stdlib_Bytes[1], prec$0 + 2 | 0, 48);
-             /*<<camlinternalFormat.ml:1360:4>>*/  /*<<camlinternalFormat.ml:1360:4>>*/ caml_bytes_set
-             (res$1,
-              1,
-               /*<<camlinternalFormat.ml:1360:20>>*/ caml_string_get(str, 1));
-             /*<<camlinternalFormat.ml:1361:4>>*/  /*<<camlinternalFormat.ml:1361:4>>*/ caml_call5
-             (Stdlib_String[48],
-              str,
-              2,
-              res$1,
-              (prec$0 - len | 0) + 4 | 0,
-              len - 2 | 0);
-             /*<<camlinternalFormat.ml:1361:4>>*/ return  /*<<camlinternalFormat.ml:1361:4>>*/ caml_call1
-                    (Stdlib_Bytes[44], res$1);
-           }
-           break b;
-          case 0:
-          case 2: break;
-          case 1:
-          case 3:
-          case 4:
-           break a;
-          default: break b;
-        }
-       }
-       if(len >= (prec$0 + 1 | 0)) break a;
-        /*<<camlinternalFormat.ml:1354:14>>*/  /*<<camlinternalFormat.ml:1354:14>>*/ var
-        res$0 =
-           /*<<camlinternalFormat.ml:1354:14>>*/ caml_call2
-           (Stdlib_Bytes[1], prec$0 + 1 | 0, 48);
-        /*<<camlinternalFormat.ml:1355:4>>*/  /*<<camlinternalFormat.ml:1355:4>>*/ caml_bytes_set
-        (res$0, 0, c);
-        /*<<camlinternalFormat.ml:1356:4>>*/  /*<<camlinternalFormat.ml:1356:4>>*/ caml_call5
-        (Stdlib_String[48],
-         str,
-         1,
-         res$0,
-         (prec$0 - len | 0) + 2 | 0,
-         len - 1 | 0);
-        /*<<camlinternalFormat.ml:1356:4>>*/ return  /*<<camlinternalFormat.ml:1356:4>>*/ caml_call1
-               (Stdlib_Bytes[44], res$0);
-      }
-      if(71 <= c){if(5 < c - 97 >>> 0) break a;} else if(65 > c) break a;
-     }
-     if(len < prec$0){
-       /*<<camlinternalFormat.ml:1364:14>>*/  /*<<camlinternalFormat.ml:1364:14>>*/ var
-       res =
-          /*<<camlinternalFormat.ml:1364:14>>*/ caml_call2
-          (Stdlib_Bytes[1], prec$0, 48);
-       /*<<camlinternalFormat.ml:1365:4>>*/  /*<<camlinternalFormat.ml:1365:4>>*/ caml_call5
-       (Stdlib_String[48], str, 0, res, prec$0 - len | 0, len);
-       /*<<camlinternalFormat.ml:1365:4>>*/ return  /*<<camlinternalFormat.ml:1365:4>>*/ caml_call1
-              (Stdlib_Bytes[44], res);
-     }
-    }
-     /*<<camlinternalFormat.ml:1368:4>>*/ return str;
-    /*<<camlinternalFormat.ml:1368:7>>*/ }
-   function string_to_caml_string(str){
-     /*<<camlinternalFormat.ml:1372:2>>*/ var
-      /*<<camlinternalFormat.ml:1372:12>>*/ str$0 =
-        /*<<camlinternalFormat.ml:1372:12>>*/ caml_call1
-        (Stdlib_String[24], str),
-      /*<<camlinternalFormat.ml:1373:2>>*/ l =
-        /*<<camlinternalFormat.ml:1373:2>>*/ caml_ml_string_length(str$0),
-      /*<<camlinternalFormat.ml:1374:12>>*/ res =
-        /*<<camlinternalFormat.ml:1374:12>>*/ caml_call2
-        (Stdlib_Bytes[1], l + 2 | 0, 34);
-     /*<<camlinternalFormat.ml:1375:2>>*/  /*<<camlinternalFormat.ml:1375:2>>*/ caml_blit_string
-     (str$0, 0, res, 1, l);
-     /*<<camlinternalFormat.ml:1375:2>>*/ return  /*<<camlinternalFormat.ml:1375:2>>*/ caml_call1
-            (Stdlib_Bytes[44], res);
-    /*<<camlinternalFormat.ml:1376:28>>*/ }
-   function format_of_fconv(fconv, prec){
-     /*<<camlinternalFormat.ml:1414:4>>*/ var
-      /*<<camlinternalFormat.ml:1414:15>>*/ prec$0 =
-        /*<<camlinternalFormat.ml:1414:15>>*/ caml_call1(Stdlib[18], prec),
-      /*<<camlinternalFormat.ml:1415:15>>*/ symb = char_of_fconv(_r_, fconv),
-      /*<<camlinternalFormat.ml:1416:14>>*/ buf = buffer_create(16);
-     /*<<camlinternalFormat.ml:1417:4>>*/ buffer_add_char(buf, 37);
-     /*<<camlinternalFormat.ml:1418:4>>*/ bprint_fconv_flag(buf, fconv);
-     /*<<camlinternalFormat.ml:1419:4>>*/ buffer_add_char(buf, 46);
-     /*<<camlinternalFormat.ml:1420:4>>*/ buffer_add_string
-     (buf,
-       /*<<camlinternalFormat.ml:1420:26>>*/ caml_call1
-       (Stdlib_Int[12], prec$0));
-     /*<<camlinternalFormat.ml:1421:4>>*/ buffer_add_char(buf, symb);
-     /*<<camlinternalFormat.ml:1421:4>>*/ return buffer_contents(buf);
-    /*<<camlinternalFormat.ml:1422:23>>*/ }
-   function transform_int_alt(iconv, s){
-     /*<<camlinternalFormat.ml:1425:2>>*/ if(13 > iconv)
-      /*<<camlinternalFormat.ml:1447:9>>*/ return s;
-     /*<<camlinternalFormat.ml:1428:14>>*/ var
-      /*<<camlinternalFormat.ml:1428:14>>*/ n = [0, 0],
-     _c1_ = caml_ml_string_length(s) - 1 | 0,
-      /*<<camlinternalFormat.ml:1428:14>>*/ _c0_ = 0;
-    if(_c1_ >= 0){
-     var i$0 = _c0_;
-     for(;;){
-      if(9 >= caml_string_unsafe_get(s, i$0) - 48 >>> 0) n[1]++;
-       /*<<camlinternalFormat.ml:1429:6>>*/  /*<<camlinternalFormat.ml:1429:6>>*/ var
-       _c5_ = i$0 + 1 | 0;
-      if(_c1_ === i$0) break;
-      var i$0 = _c5_;
-     }
-    }
-     /*<<camlinternalFormat.ml:1436:14>>*/ var
-     digits = n[1],
-      /*<<camlinternalFormat.ml:1436:14>>*/ buf =
-        /*<<camlinternalFormat.ml:1436:14>>*/ caml_create_bytes
-        (caml_ml_string_length(s) + ((digits - 1 | 0) / 3 | 0) | 0),
-      /*<<camlinternalFormat.ml:1437:14>>*/ pos = [0, 0];
-    function put(c){
-      /*<<camlinternalFormat.ml:1438:16>>*/  /*<<camlinternalFormat.ml:1438:16>>*/ caml_bytes_set
-      (buf, pos[1], c);
-     pos[1]++;
-     return 0;
-     /*<<camlinternalFormat.ml:1438:46>>*/ }
-     /*<<camlinternalFormat.ml:1439:15>>*/ var
-      /*<<camlinternalFormat.ml:1439:15>>*/ left =
-       [0, ((digits - 1 | 0) % 3 | 0) + 1 | 0],
-     _c3_ = caml_ml_string_length(s) - 1 | 0,
-      /*<<camlinternalFormat.ml:1439:15>>*/ _c2_ = 0;
-    if(_c3_ >= 0){
-     var i = _c2_;
-     for(;;){
-      var c = caml_string_unsafe_get(s, i);
-      if(9 < c - 48 >>> 0)
-        /*<<camlinternalFormat.ml:1444:13>>*/ put(c);
-      else{
-       if(0 === left[1]){
-         /*<<camlinternalFormat.ml:1443:29>>*/ put(95);
-        left[1] = 3;
-       }
-       left[1] += -1;
-        /*<<camlinternalFormat.ml:1443:61>>*/ put(c);
-      }
-       /*<<camlinternalFormat.ml:1440:4>>*/  /*<<camlinternalFormat.ml:1440:4>>*/ var
-       _c4_ = i + 1 | 0;
-      if(_c3_ === i) break;
-      var i = _c4_;
-     }
-    }
-     /*<<camlinternalFormat.ml:1446:4>>*/ return  /*<<camlinternalFormat.ml:1446:4>>*/ caml_call1
-            (Stdlib_Bytes[44], buf);
-    /*<<camlinternalFormat.ml:1447:10>>*/ }
-   function convert_int(iconv, n){
-     /*<<camlinternalFormat.ml:1451:2>>*/ switch(iconv){
-      case 1:
-       var _cZ_ = cst_d$0; break;
-      case 2:
-       var _cZ_ = cst_d$1; break;
-      case 4:
-       var _cZ_ = cst_i$1; break;
-      case 5:
-       var _cZ_ = cst_i$2; break;
-      case 6:
-       var _cZ_ = cst_x; break;
-      case 7:
-       var _cZ_ = cst_x$0; break;
-      case 8:
-       var _cZ_ = cst_X; break;
-      case 9:
-       var _cZ_ = cst_X$0; break;
-      case 10:
-       var _cZ_ = cst_o; break;
-      case 11:
-       var _cZ_ = cst_o$0; break;
-      case 0:
-      case 13:
-       var _cZ_ = cst_d; break;
-      case 3:
-      case 14:
-       var _cZ_ = cst_i$0; break;
-      default: var _cZ_ = cst_u;
-    }
-     /*<<camlinternalFormat.ml:1451:26>>*/ return transform_int_alt
-            (iconv,
-              /*<<camlinternalFormat.ml:1451:26>>*/ caml_format_int(_cZ_, n));
-    /*<<camlinternalFormat.ml:1451:64>>*/ }
-   function convert_int32(iconv, n){
-     /*<<camlinternalFormat.ml:1453:2>>*/ switch(iconv){
-      case 1:
-       var _cY_ = cst_ld$0; break;
-      case 2:
-       var _cY_ = cst_ld$1; break;
-      case 4:
-       var _cY_ = cst_li$1; break;
-      case 5:
-       var _cY_ = cst_li$2; break;
-      case 6:
-       var _cY_ = cst_lx; break;
-      case 7:
-       var _cY_ = cst_lx$0; break;
-      case 8:
-       var _cY_ = cst_lX; break;
-      case 9:
-       var _cY_ = cst_lX$0; break;
-      case 10:
-       var _cY_ = cst_lo; break;
-      case 11:
-       var _cY_ = cst_lo$0; break;
-      case 0:
-      case 13:
-       var _cY_ = cst_ld; break;
-      case 3:
-      case 14:
-       var _cY_ = cst_li$0; break;
-      default: var _cY_ = cst_lu;
-    }
-     /*<<camlinternalFormat.ml:1453:26>>*/ return transform_int_alt
-            (iconv,
-              /*<<camlinternalFormat.ml:1453:26>>*/ caml_format_int(_cY_, n));
-    /*<<camlinternalFormat.ml:1453:67>>*/ }
-   function convert_nativeint(iconv, n){
-     /*<<camlinternalFormat.ml:1455:2>>*/ switch(iconv){
-      case 1:
-       var _cX_ = cst_nd$0; break;
-      case 2:
-       var _cX_ = cst_nd$1; break;
-      case 4:
-       var _cX_ = cst_ni$1; break;
-      case 5:
-       var _cX_ = cst_ni$2; break;
-      case 6:
-       var _cX_ = cst_nx; break;
-      case 7:
-       var _cX_ = cst_nx$0; break;
-      case 8:
-       var _cX_ = cst_nX; break;
-      case 9:
-       var _cX_ = cst_nX$0; break;
-      case 10:
-       var _cX_ = cst_no; break;
-      case 11:
-       var _cX_ = cst_no$0; break;
-      case 0:
-      case 13:
-       var _cX_ = cst_nd; break;
-      case 3:
-      case 14:
-       var _cX_ = cst_ni$0; break;
-      default: var _cX_ = cst_nu;
-    }
-     /*<<camlinternalFormat.ml:1455:26>>*/ return transform_int_alt
-            (iconv,
-              /*<<camlinternalFormat.ml:1455:26>>*/ caml_format_int(_cX_, n));
-    /*<<camlinternalFormat.ml:1455:71>>*/ }
-   function convert_int64(iconv, n){
-     /*<<camlinternalFormat.ml:1457:2>>*/ switch(iconv){
-      case 1:
-       var _cW_ = cst_Ld$0; break;
-      case 2:
-       var _cW_ = cst_Ld$1; break;
-      case 4:
-       var _cW_ = cst_Li$1; break;
-      case 5:
-       var _cW_ = cst_Li$2; break;
-      case 6:
-       var _cW_ = cst_Lx; break;
-      case 7:
-       var _cW_ = cst_Lx$0; break;
-      case 8:
-       var _cW_ = cst_LX; break;
-      case 9:
-       var _cW_ = cst_LX$0; break;
-      case 10:
-       var _cW_ = cst_Lo; break;
-      case 11:
-       var _cW_ = cst_Lo$0; break;
-      case 0:
-      case 13:
-       var _cW_ = cst_Ld; break;
-      case 3:
-      case 14:
-       var _cW_ = cst_Li$0; break;
-      default: var _cW_ = cst_Lu;
-    }
-     /*<<camlinternalFormat.ml:1457:26>>*/ return transform_int_alt
-            (iconv,
-              /*<<camlinternalFormat.ml:1457:26>>*/ runtime.caml_int64_format
-              (_cW_, n));
-    /*<<camlinternalFormat.ml:1457:67>>*/ }
-   function convert_float(fconv, prec, x){
-    function hex(param){
-      /*<<camlinternalFormat.ml:1463:4>>*/ switch(fconv[1]){
-       case 0:
-        var sign = 45; break;
-       case 1:
-        var sign = 43; break;
-       default: var sign = 32;
-     }
-      /*<<camlinternalFormat.ml:1468:4>>*/ return  /*<<camlinternalFormat.ml:1468:4>>*/ runtime.caml_hexstring_of_float
-             (x, prec, sign);
-     /*<<camlinternalFormat.ml:1468:34>>*/ }
-     /*<<camlinternalFormat.ml:1477:2>>*/ function caml_special_val(str){
-      /*<<camlinternalFormat.ml:1477:29>>*/  /*<<camlinternalFormat.ml:1477:35>>*/ var
-      match =
-         /*<<camlinternalFormat.ml:1477:35>>*/ runtime.caml_classify_float(x);
-     return 3 === match
-             ? x < 0. ? cst_neg_infinity : cst_infinity
-             : 4 <= match ? cst_nan : str;
-     /*<<camlinternalFormat.ml:1480:21>>*/ }
-    switch(fconv[2]){
-      case 5:
-        /*<<camlinternalFormat.ml:1486:14>>*/ var
-         /*<<camlinternalFormat.ml:1486:14>>*/ str =
-           /*<<camlinternalFormat.ml:1486:14>>*/ caml_format_float
-           (format_of_fconv(fconv, prec), x),
-        len = caml_ml_string_length(str),
-        i = 0;
-        /*<<camlinternalFormat.ml:1472:6>>*/ for(;;){
-        if(i === len)
-         var _cT_ = 0;
-        else{
-          /*<<camlinternalFormat.ml:1473:14>>*/  /*<<camlinternalFormat.ml:1473:14>>*/ var
-          _cS_ =
-             /*<<camlinternalFormat.ml:1473:14>>*/ caml_string_get(str, i)
-            - 46
-            | 0;
-         a:
-         {
-          if(23 < _cS_ >>> 0){
-           if(55 === _cS_) break a;
-          }
-          else if(21 < _cS_ - 1 >>> 0) break a;
-           /*<<camlinternalFormat.ml:1475:15>>*/ var
-            /*<<camlinternalFormat.ml:1475:15>>*/ i$0 = i + 1 | 0,
-           i = i$0;
-          continue;
-         }
-         var _cT_ = 1;
-        }
-         /*<<camlinternalFormat.ml:1476:7>>*/  /*<<camlinternalFormat.ml:1476:7>>*/ var
-         _cU_ =
-           _cT_
-            ? str
-            :  /*<<camlinternalFormat.ml:1476:32>>*/ caml_call2
-              (Stdlib[28], str, cst$17);
-         /*<<camlinternalFormat.ml:1487:21>>*/ return caml_special_val(_cU_);
-       }
-      case 6:
-        /*<<camlinternalFormat.ml:1482:15>>*/ return hex(0);
-      case 7:
-        /*<<camlinternalFormat.ml:1483:38>>*/  /*<<camlinternalFormat.ml:1483:38>>*/ var
-        _cV_ = hex(0);
-        /*<<camlinternalFormat.ml:1483:38>>*/ return  /*<<camlinternalFormat.ml:1483:38>>*/ caml_call1
-               (Stdlib_String[25], _cV_);
-      case 8:
-        /*<<camlinternalFormat.ml:1484:33>>*/ return caml_special_val(hex(0));
-      default:
-        /*<<camlinternalFormat.ml:1489:4>>*/ return  /*<<camlinternalFormat.ml:1489:4>>*/ caml_format_float
-               (format_of_fconv(fconv, prec), x);
-    }
-    /*<<camlinternalFormat.ml:1489:47>>*/ }
-   function string_of_fmtty(fmtty){
-     /*<<camlinternalFormat.ml:1501:2>>*/  /*<<camlinternalFormat.ml:1501:12>>*/ var
-     buf = buffer_create(16);
-     /*<<camlinternalFormat.ml:1502:2>>*/ bprint_fmtty(buf, fmtty);
-     /*<<camlinternalFormat.ml:1502:2>>*/ return buffer_contents(buf);
-    /*<<camlinternalFormat.ml:1503:21>>*/ }
-   function make_int_padding_precision(k, acc, fmt, pad, prec, trans, iconv){
-     /*<<camlinternalFormat.ml:1691:40>>*/ if(typeof pad === "number"){
-     if(typeof prec === "number")
-      return prec
-              ? function
-               (p, x){
-                 /*<<camlinternalFormat.ml:1702:6>>*/  /*<<camlinternalFormat.ml:1702:16>>*/ var
-                 str =
-                   fix_int_precision
-                    (p,
-                      /*<<camlinternalFormat.ml:1702:36>>*/ caml_call2
-                      (trans, iconv, x));
-                 /*<<camlinternalFormat.ml:1703:6>>*/ return make_printf
-                        (k, [4, acc, str], fmt);
-                /*<<camlinternalFormat.ml:1703:52>>*/ }
-              : function
-               (x){
-                 /*<<camlinternalFormat.ml:1694:6>>*/  /*<<camlinternalFormat.ml:1694:16>>*/ var
-                 str =
-                    /*<<camlinternalFormat.ml:1694:16>>*/ caml_call2
-                    (trans, iconv, x);
-                 /*<<camlinternalFormat.ml:1695:6>>*/ return make_printf
-                        (k, [4, acc, str], fmt);
-                /*<<camlinternalFormat.ml:1695:52>>*/ };
-     var p = prec[1];
-      /*<<camlinternalFormat.ml:1697:4>>*/ return function(x){
-       /*<<camlinternalFormat.ml:1698:6>>*/  /*<<camlinternalFormat.ml:1698:16>>*/ var
-       str =
-         fix_int_precision
-          (p,
-            /*<<camlinternalFormat.ml:1698:36>>*/ caml_call2(trans, iconv, x));
-       /*<<camlinternalFormat.ml:1699:6>>*/ return make_printf
-              (k, [4, acc, str], fmt); /*<<camlinternalFormat.ml:1699:52>>*/ };
-    }
-    if(0 === pad[0]){
-     var w = pad[2], padty = pad[1];
-     if(typeof prec === "number")
-      return prec
-              ? function
-               (p, x){
-                 /*<<camlinternalFormat.ml:1714:6>>*/  /*<<camlinternalFormat.ml:1714:16>>*/ var
-                 str =
-                   fix_padding
-                    (padty,
-                     w,
-                     fix_int_precision
-                      (p,
-                        /*<<camlinternalFormat.ml:1714:57>>*/ caml_call2
-                        (trans, iconv, x)));
-                 /*<<camlinternalFormat.ml:1715:6>>*/ return make_printf
-                        (k, [4, acc, str], fmt);
-                /*<<camlinternalFormat.ml:1715:52>>*/ }
-              : function
-               (x){
-                 /*<<camlinternalFormat.ml:1706:6>>*/  /*<<camlinternalFormat.ml:1706:16>>*/ var
-                 str =
-                   fix_padding
-                    (padty,
-                     w,
-                      /*<<camlinternalFormat.ml:1706:36>>*/ caml_call2
-                      (trans, iconv, x));
-                 /*<<camlinternalFormat.ml:1707:6>>*/ return make_printf
-                        (k, [4, acc, str], fmt);
-                /*<<camlinternalFormat.ml:1707:52>>*/ };
-     var p$0 = prec[1];
-      /*<<camlinternalFormat.ml:1709:4>>*/ return function(x){
-       /*<<camlinternalFormat.ml:1710:6>>*/  /*<<camlinternalFormat.ml:1710:16>>*/ var
-       str =
-         fix_padding
-          (padty,
-           w,
-           fix_int_precision
-            (p$0,
-              /*<<camlinternalFormat.ml:1710:57>>*/ caml_call2
-              (trans, iconv, x)));
-       /*<<camlinternalFormat.ml:1711:6>>*/ return make_printf
-              (k, [4, acc, str], fmt); /*<<camlinternalFormat.ml:1711:52>>*/ };
-    }
-    var padty$0 = pad[1];
-    if(typeof prec === "number")
-     return prec
-             ? function
-              (w, p, x){
-                /*<<camlinternalFormat.ml:1726:6>>*/  /*<<camlinternalFormat.ml:1726:16>>*/ var
-                str =
-                  fix_padding
-                   (padty$0,
-                    w,
-                    fix_int_precision
-                     (p,
-                       /*<<camlinternalFormat.ml:1726:57>>*/ caml_call2
-                       (trans, iconv, x)));
-                /*<<camlinternalFormat.ml:1727:6>>*/ return make_printf
-                       (k, [4, acc, str], fmt);
-               /*<<camlinternalFormat.ml:1727:52>>*/ }
-             : function
-              (w, x){
-                /*<<camlinternalFormat.ml:1718:6>>*/  /*<<camlinternalFormat.ml:1718:16>>*/ var
-                str =
-                  fix_padding
-                   (padty$0,
-                    w,
-                     /*<<camlinternalFormat.ml:1718:36>>*/ caml_call2
-                     (trans, iconv, x));
-                /*<<camlinternalFormat.ml:1719:6>>*/ return make_printf
-                       (k, [4, acc, str], fmt);
-               /*<<camlinternalFormat.ml:1719:52>>*/ };
-    var p$1 = prec[1];
-     /*<<camlinternalFormat.ml:1721:4>>*/ return function(w, x){
-      /*<<camlinternalFormat.ml:1722:6>>*/  /*<<camlinternalFormat.ml:1722:16>>*/ var
-      str =
-        fix_padding
-         (padty$0,
-          w,
-          fix_int_precision
-           (p$1,
-             /*<<camlinternalFormat.ml:1722:57>>*/ caml_call2(trans, iconv, x)));
-      /*<<camlinternalFormat.ml:1723:6>>*/ return make_printf
-             (k, [4, acc, str], fmt); /*<<camlinternalFormat.ml:1723:52>>*/ };
-    /*<<camlinternalFormat.ml:1727:52>>*/ }
-   function make_padding(k, acc, fmt, pad, trans){
-     /*<<camlinternalFormat.ml:1670:29>>*/ if(typeof pad === "number")
-      /*<<camlinternalFormat.ml:1672:4>>*/ return function(x){
-       /*<<camlinternalFormat.ml:1673:6>>*/  /*<<camlinternalFormat.ml:1673:20>>*/ var
-       new_acc =
-         [4, acc,  /*<<camlinternalFormat.ml:1673:42>>*/ caml_call1(trans, x)];
-       /*<<camlinternalFormat.ml:1674:6>>*/ return make_printf
-              (k, new_acc, fmt); /*<<camlinternalFormat.ml:1674:31>>*/ };
-    if(0 === pad[0]){
-     var width = pad[2], padty = pad[1];
-      /*<<camlinternalFormat.ml:1676:4>>*/ return function(x){
-       /*<<camlinternalFormat.ml:1677:6>>*/  /*<<camlinternalFormat.ml:1677:20>>*/ var
-       new_acc =
-         [4,
-          acc,
-          fix_padding
-           (padty,
-            width,
-             /*<<camlinternalFormat.ml:1677:66>>*/ caml_call1(trans, x))];
-       /*<<camlinternalFormat.ml:1678:6>>*/ return make_printf
-              (k, new_acc, fmt); /*<<camlinternalFormat.ml:1678:31>>*/ };
-    }
-    var padty$0 = pad[1];
-     /*<<camlinternalFormat.ml:1680:4>>*/ return function(w, x){
-      /*<<camlinternalFormat.ml:1681:6>>*/  /*<<camlinternalFormat.ml:1681:20>>*/ var
-      new_acc =
-        [4,
-         acc,
-         fix_padding
-          (padty$0,
-           w,
-            /*<<camlinternalFormat.ml:1681:62>>*/ caml_call1(trans, x))];
-      /*<<camlinternalFormat.ml:1682:6>>*/ return make_printf(k, new_acc, fmt); /*<<camlinternalFormat.ml:1682:31>>*/ };
-    /*<<camlinternalFormat.ml:1682:31>>*/ }
-   function make_printf$0(counter, k, acc, fmt){
-     /*<<camlinternalFormat.ml:1518:17>>*/ var
-     k$0 = k,
-     acc$0 = acc,
-     fmt$0 = fmt;
-     /*<<camlinternalFormat.ml:1518:17>>*/ for(;;){
-     if(typeof fmt$0 === "number")
-       /*<<camlinternalFormat.ml:1605:4>>*/ return  /*<<camlinternalFormat.ml:1605:4>>*/ caml_call1
-              (k$0, acc$0);
-     switch(fmt$0[0]){
-       case 0:
-        var rest = fmt$0[1];
-         /*<<camlinternalFormat.ml:1520:4>>*/ return function(c){
-          /*<<camlinternalFormat.ml:1521:6>>*/  /*<<camlinternalFormat.ml:1521:20>>*/ var
-          new_acc = [5, acc$0, c];
-          /*<<camlinternalFormat.ml:1522:6>>*/ return make_printf
-                 (k$0, new_acc, rest); /*<<camlinternalFormat.ml:1522:32>>*/ };
-       case 1:
-        var rest$0 = fmt$0[1];
-         /*<<camlinternalFormat.ml:1524:4>>*/ return function(c){
-          /*<<camlinternalFormat.ml:1525:6>>*/ var
-           /*<<camlinternalFormat.ml:1493:12>>*/ str =
-             /*<<camlinternalFormat.ml:1493:12>>*/ caml_call1
-             (Stdlib_Char[2], c),
-           /*<<camlinternalFormat.ml:1494:2>>*/ l =
-             /*<<camlinternalFormat.ml:1494:2>>*/ caml_ml_string_length(str),
-           /*<<camlinternalFormat.ml:1495:12>>*/ res =
-             /*<<camlinternalFormat.ml:1495:12>>*/ caml_call2
-             (Stdlib_Bytes[1], l + 2 | 0, 39);
-          /*<<camlinternalFormat.ml:1496:2>>*/  /*<<camlinternalFormat.ml:1496:2>>*/ caml_blit_string
-          (str, 0, res, 1, l);
-          /*<<camlinternalFormat.ml:1525:20>>*/  /*<<camlinternalFormat.ml:1525:20>>*/ var
-          new_acc =
-            [4,
-             acc$0,
-              /*<<camlinternalFormat.ml:1496:2>>*/ caml_call1
-              (Stdlib_Bytes[44], res)];
-          /*<<camlinternalFormat.ml:1526:6>>*/ return make_printf
-                 (k$0, new_acc, rest$0); /*<<camlinternalFormat.ml:1526:32>>*/ };
-       case 2:
-        var rest$1 = fmt$0[2], pad = fmt$0[1];
-         /*<<camlinternalFormat.ml:1528:32>>*/ return make_padding
-                (k$0,
-                 acc$0,
-                 rest$1,
-                 pad,
-                 function(str){
-                   /*<<camlinternalFormat.ml:1528:44>>*/ return str;
-                  /*<<camlinternalFormat.ml:1528:47>>*/ });
-       case 3:
-        var rest$2 = fmt$0[2], pad$0 = fmt$0[1];
-         /*<<camlinternalFormat.ml:1530:4>>*/ return make_padding
-                (k$0, acc$0, rest$2, pad$0, string_to_caml_string);
-       case 4:
-        var
-         rest$3 = fmt$0[4],
-         prec = fmt$0[3],
-         pad$1 = fmt$0[2],
-         iconv = fmt$0[1];
-         /*<<camlinternalFormat.ml:1532:4>>*/ return make_int_padding_precision
-                (k$0, acc$0, rest$3, pad$1, prec, convert_int, iconv);
-       case 5:
-        var
-         rest$4 = fmt$0[4],
-         prec$0 = fmt$0[3],
-         pad$2 = fmt$0[2],
-         iconv$0 = fmt$0[1];
-         /*<<camlinternalFormat.ml:1534:4>>*/ return make_int_padding_precision
-                (k$0, acc$0, rest$4, pad$2, prec$0, convert_int32, iconv$0);
-       case 6:
-        var
-         rest$5 = fmt$0[4],
-         prec$1 = fmt$0[3],
-         pad$3 = fmt$0[2],
-         iconv$1 = fmt$0[1];
-         /*<<camlinternalFormat.ml:1536:4>>*/ return make_int_padding_precision
-                (k$0,
-                 acc$0,
-                 rest$5,
-                 pad$3,
-                 prec$1,
-                 convert_nativeint,
-                 iconv$1);
-       case 7:
-        var
-         rest$6 = fmt$0[4],
-         prec$2 = fmt$0[3],
-         pad$4 = fmt$0[2],
-         iconv$2 = fmt$0[1];
-         /*<<camlinternalFormat.ml:1538:4>>*/ return make_int_padding_precision
-                (k$0, acc$0, rest$6, pad$4, prec$2, convert_int64, iconv$2);
-       case 8:
-        var
-         rest$7 = fmt$0[4],
-         prec$3 = fmt$0[3],
-         pad$5 = fmt$0[2],
-         fconv = fmt$0[1];
-        if(typeof pad$5 === "number"){
-         if(typeof prec$3 === "number")
-          return prec$3
-                  ? function
-                   (p, x){
-                     /*<<camlinternalFormat.ml:1746:6>>*/  /*<<camlinternalFormat.ml:1746:16>>*/ var
-                     str = convert_float(fconv, p, x);
-                     /*<<camlinternalFormat.ml:1747:6>>*/ return make_printf
-                            (k$0, [4, acc$0, str], rest$7);
-                    /*<<camlinternalFormat.ml:1747:52>>*/ }
-                  : function
-                   (x){
-                     /*<<camlinternalFormat.ml:1738:6>>*/  /*<<camlinternalFormat.ml:1738:16>>*/ var
-                     str =
-                       convert_float(fconv, default_float_precision(fconv), x);
-                     /*<<camlinternalFormat.ml:1739:6>>*/ return make_printf
-                            (k$0, [4, acc$0, str], rest$7);
-                    /*<<camlinternalFormat.ml:1739:52>>*/ };
-         var p = prec$3[1];
-          /*<<camlinternalFormat.ml:1741:4>>*/ return function(x){
-           /*<<camlinternalFormat.ml:1742:6>>*/  /*<<camlinternalFormat.ml:1742:16>>*/ var
-           str = convert_float(fconv, p, x);
-           /*<<camlinternalFormat.ml:1743:6>>*/ return make_printf
-                  (k$0, [4, acc$0, str], rest$7); /*<<camlinternalFormat.ml:1743:52>>*/ };
-        }
-        if(0 === pad$5[0]){
-         var w = pad$5[2], padty = pad$5[1];
-         if(typeof prec$3 === "number")
-          return prec$3
-                  ? function
-                   (p, x){
-                     /*<<camlinternalFormat.ml:1759:6>>*/  /*<<camlinternalFormat.ml:1759:16>>*/ var
-                     str = fix_padding(padty, w, convert_float(fconv, p, x));
-                     /*<<camlinternalFormat.ml:1760:6>>*/ return make_printf
-                            (k$0, [4, acc$0, str], rest$7);
-                    /*<<camlinternalFormat.ml:1760:52>>*/ }
-                  : function
-                   (x){
-                     /*<<camlinternalFormat.ml:1750:6>>*/ var
-                      /*<<camlinternalFormat.ml:1750:16>>*/ str =
-                       convert_float(fconv, default_float_precision(fconv), x),
-                      /*<<camlinternalFormat.ml:1751:17>>*/ str$0 =
-                       fix_padding(padty, w, str);
-                     /*<<camlinternalFormat.ml:1752:6>>*/ return make_printf
-                            (k$0, [4, acc$0, str$0], rest$7);
-                    /*<<camlinternalFormat.ml:1752:53>>*/ };
-         var p$0 = prec$3[1];
-          /*<<camlinternalFormat.ml:1754:4>>*/ return function(x){
-           /*<<camlinternalFormat.ml:1755:6>>*/  /*<<camlinternalFormat.ml:1755:16>>*/ var
-           str = fix_padding(padty, w, convert_float(fconv, p$0, x));
-           /*<<camlinternalFormat.ml:1756:6>>*/ return make_printf
-                  (k$0, [4, acc$0, str], rest$7); /*<<camlinternalFormat.ml:1756:52>>*/ };
-        }
-        var padty$0 = pad$5[1];
-        if(typeof prec$3 === "number")
-         return prec$3
-                 ? function
-                  (w, p, x){
-                    /*<<camlinternalFormat.ml:1772:6>>*/  /*<<camlinternalFormat.ml:1772:16>>*/ var
-                    str = fix_padding(padty$0, w, convert_float(fconv, p, x));
-                    /*<<camlinternalFormat.ml:1773:6>>*/ return make_printf
-                           (k$0, [4, acc$0, str], rest$7);
-                   /*<<camlinternalFormat.ml:1773:52>>*/ }
-                 : function
-                  (w, x){
-                    /*<<camlinternalFormat.ml:1763:6>>*/ var
-                     /*<<camlinternalFormat.ml:1763:16>>*/ str =
-                      convert_float(fconv, default_float_precision(fconv), x),
-                     /*<<camlinternalFormat.ml:1764:17>>*/ str$0 =
-                      fix_padding(padty$0, w, str);
-                    /*<<camlinternalFormat.ml:1765:6>>*/ return make_printf
-                           (k$0, [4, acc$0, str$0], rest$7);
-                   /*<<camlinternalFormat.ml:1765:53>>*/ };
-        var p$1 = prec$3[1];
-         /*<<camlinternalFormat.ml:1767:4>>*/ return function(w, x){
-          /*<<camlinternalFormat.ml:1768:6>>*/  /*<<camlinternalFormat.ml:1768:16>>*/ var
-          str = fix_padding(padty$0, w, convert_float(fconv, p$1, x));
-          /*<<camlinternalFormat.ml:1769:6>>*/ return make_printf
-                 (k$0, [4, acc$0, str], rest$7); /*<<camlinternalFormat.ml:1769:52>>*/ };
-       case 9:
-        var rest$8 = fmt$0[2], pad$6 = fmt$0[1];
-         /*<<camlinternalFormat.ml:1542:4>>*/ return make_padding
-                (k$0, acc$0, rest$8, pad$6, Stdlib[30]);
-       case 10:
-         /*<<camlinternalFormat.ml:1560:18>>*/ var
-         rest$9 = fmt$0[1],
-          /*<<camlinternalFormat.ml:1560:18>>*/ acc$1 = [7, acc$0],
-         acc$0 = acc$1,
-         fmt$0 = rest$9;
-        break;
-       case 11:
-         /*<<camlinternalFormat.ml:1563:18>>*/ var
-         rest$10 = fmt$0[2],
-         str = fmt$0[1],
-          /*<<camlinternalFormat.ml:1563:18>>*/ acc$2 = [2, acc$0, str],
-         acc$0 = acc$2,
-         fmt$0 = rest$10;
-        break;
-       case 12:
-         /*<<camlinternalFormat.ml:1565:18>>*/ var
-         rest$11 = fmt$0[2],
-         chr = fmt$0[1],
-          /*<<camlinternalFormat.ml:1565:18>>*/ acc$3 = [3, acc$0, chr],
-         acc$0 = acc$3,
-         fmt$0 = rest$11;
-        break;
-       case 13:
-         /*<<camlinternalFormat.ml:1568:13>>*/ var
-         rest$12 = fmt$0[3],
-         sub_fmtty = fmt$0[2],
-          /*<<camlinternalFormat.ml:1568:13>>*/ ty =
-           string_of_fmtty(sub_fmtty);
-         /*<<camlinternalFormat.ml:1569:4>>*/ return function(str){
-          /*<<camlinternalFormat.ml:1570:6>>*/ return make_printf
-                 (k$0, [4, acc$0, ty], rest$12); /*<<camlinternalFormat.ml:1571:52>>*/ };
-       case 14:
-        var rest$13 = fmt$0[3], fmtty = fmt$0[2];
-         /*<<camlinternalFormat.ml:1573:4>>*/ return function(param){
-          /*<<camlinternalFormat.ml:1573:4>>*/ var
-          fmt = param[1],
-           /*<<camlinternalFormat.ml:1574:18>>*/ _cR_ = recast(fmt, fmtty);
-          /*<<camlinternalFormat.ml:1574:6>>*/ return make_printf
-                 (k$0,
-                  acc$0,
-                   /*<<camlinternalFormat.ml:1574:6>>*/ caml_call2
-                   (CamlinternalFormatBasics[3], _cR_, rest$13)); /*<<camlinternalFormat.ml:1574:42>>*/ };
-       case 15:
-        var rest$14 = fmt$0[1];
-         /*<<camlinternalFormat.ml:1544:4>>*/ return function(f, x){
-          /*<<camlinternalFormat.ml:1544:15>>*/ return make_printf
-                 (k$0,
-                  [6,
-                   acc$0,
-                   function(o){
-                     /*<<camlinternalFormat.ml:1544:55>>*/ return caml_call2
-                            (f, o, x);
-                    /*<<camlinternalFormat.ml:1544:60>>*/ }],
-                  rest$14); /*<<camlinternalFormat.ml:1544:67>>*/ };
-       case 16:
-        var rest$15 = fmt$0[1];
-         /*<<camlinternalFormat.ml:1546:4>>*/ return function(f){
-          /*<<camlinternalFormat.ml:1546:13>>*/ return make_printf
-                 (k$0, [6, acc$0, f], rest$15); /*<<camlinternalFormat.ml:1546:52>>*/ };
-       case 17:
-         /*<<camlinternalFormat.ml:1594:18>>*/ var
-         rest$16 = fmt$0[2],
-         fmting_lit = fmt$0[1],
-          /*<<camlinternalFormat.ml:1594:18>>*/ acc$4 = [0, acc$0, fmting_lit],
-         acc$0 = acc$4,
-         fmt$0 = rest$16;
-        break;
-       case 18:
-        var _cP_ = fmt$0[1];
-        if(0 === _cP_[0])
-         var
-          rest$17 = fmt$0[2],
-          fmt$1 = _cP_[1][1],
-          k$3 =
-            function(acc, k, rest){
-             function k$0(kacc){
-               /*<<camlinternalFormat.ml:1597:6>>*/ return make_printf
-                      (k, [1, acc, [0, kacc]], rest);
-              /*<<camlinternalFormat.ml:1597:70>>*/ }
-             return k$0;
-            },
-          k$1 = k$3(acc$0, k$0, rest$17),
-          k$0 = k$1,
-          acc$0 = 0,
-          fmt$0 = fmt$1;
-        else
-         var
-          rest$18 = fmt$0[2],
-          fmt$2 = _cP_[1][1],
-          k$4 =
-            function(acc, k, rest){
-             function k$0(kacc){
-               /*<<camlinternalFormat.ml:1601:6>>*/ return make_printf
-                      (k, [1, acc, [1, kacc]], rest);
-              /*<<camlinternalFormat.ml:1601:70>>*/ }
-             return k$0;
-            },
-          k$2 = k$4(acc$0, k$0, rest$18),
-          k$0 = k$2,
-          acc$0 = 0,
-          fmt$0 = fmt$2;
-        break;
-       case 19:
-         /*<<camlinternalFormat.ml:1558:4>>*/ throw  /*<<camlinternalFormat.ml:1558:4>>*/ caml_maybe_attach_backtrace
-               ([0, Assert_failure, _s_], 1);
-       case 20:
-         /*<<camlinternalFormat.ml:1577:18>>*/ var
-         rest$19 = fmt$0[3],
-          /*<<camlinternalFormat.ml:1577:18>>*/ new_acc =
-           [8, acc$0, cst_Printf_bad_conversion];
-         /*<<camlinternalFormat.ml:1578:4>>*/ return function(param){
-          /*<<camlinternalFormat.ml:1578:13>>*/ return make_printf
-                 (k$0, new_acc, rest$19); /*<<camlinternalFormat.ml:1578:39>>*/ };
-       case 21:
-        var rest$20 = fmt$0[2];
-         /*<<camlinternalFormat.ml:1583:4>>*/ return function(n){
-          /*<<camlinternalFormat.ml:1584:6>>*/  /*<<camlinternalFormat.ml:1584:20>>*/ var
-          new_acc =
-            [4,
-             acc$0,
-              /*<<camlinternalFormat.ml:1584:42>>*/ caml_format_int
-              (cst_u$0, n)];
-          /*<<camlinternalFormat.ml:1585:6>>*/ return make_printf
-                 (k$0, new_acc, rest$20); /*<<camlinternalFormat.ml:1585:32>>*/ };
-       case 22:
-        var rest$21 = fmt$0[1];
-         /*<<camlinternalFormat.ml:1587:4>>*/ return function(c){
-          /*<<camlinternalFormat.ml:1588:6>>*/  /*<<camlinternalFormat.ml:1588:20>>*/ var
-          new_acc = [5, acc$0, c];
-          /*<<camlinternalFormat.ml:1589:6>>*/ return make_printf
-                 (k$0, new_acc, rest$21); /*<<camlinternalFormat.ml:1589:32>>*/ };
-       case 23:
-        var rest$22 = fmt$0[2], ign = fmt$0[1];
-         /*<<camlinternalFormat.ml:1591:4>>*/ if(counter >= 50)
-          /*<<camlinternalFormat.ml:1591:4>>*/ return  /*<<camlinternalFormat.ml:1591:4>>*/ caml_trampoline_return
-                 (make_ignored_param$0, [0, k$0, acc$0, ign, rest$22]);
-        var counter$1 = counter + 1 | 0;
-         /*<<camlinternalFormat.ml:1591:4>>*/ return make_ignored_param$0
-                (counter$1, k$0, acc$0, ign, rest$22);
-       default:
-         /*<<camlinternalFormat.ml:1548:33>>*/ var
-         rest$23 = fmt$0[3],
-         f = fmt$0[2],
-         arity = fmt$0[1],
-          /*<<camlinternalFormat.ml:1548:33>>*/ _cQ_ =
-            /*<<camlinternalFormat.ml:1548:33>>*/ caml_call1(f, 0);
-         /*<<camlinternalFormat.ml:1548:33>>*/ if(counter >= 50)
-          /*<<camlinternalFormat.ml:1548:33>>*/ return  /*<<camlinternalFormat.ml:1548:33>>*/ caml_trampoline_return
-                 (make_custom$0, [0, k$0, acc$0, rest$23, arity, _cQ_]);
-        var counter$0 = counter + 1 | 0;
-         /*<<camlinternalFormat.ml:1548:33>>*/ return make_custom$0
-                (counter$0, k$0, acc$0, rest$23, arity, _cQ_);
-     }
-    }
-    /*<<camlinternalFormat.ml:1605:9>>*/ }
-   function make_ignored_param$0(counter, k, acc, ign, fmt){
-     /*<<camlinternalFormat.ml:1613:21>>*/ if(typeof ign === "number")
-     switch(ign){
-       case 0:
-         /*<<camlinternalFormat.ml:1614:39>>*/ if(counter >= 50)
-          /*<<camlinternalFormat.ml:1614:39>>*/ return  /*<<camlinternalFormat.ml:1614:39>>*/ caml_trampoline_return
-                 (make_invalid_arg, [0, k, acc, fmt]);
-        var counter$0 = counter + 1 | 0;
-         /*<<camlinternalFormat.ml:1614:39>>*/ return make_invalid_arg
-                (counter$0, k, acc, fmt);
-       case 1:
-         /*<<camlinternalFormat.ml:1615:39>>*/ if(counter >= 50)
-          /*<<camlinternalFormat.ml:1615:39>>*/ return  /*<<camlinternalFormat.ml:1615:39>>*/ caml_trampoline_return
-                 (make_invalid_arg, [0, k, acc, fmt]);
-        var counter$1 = counter + 1 | 0;
-         /*<<camlinternalFormat.ml:1615:39>>*/ return make_invalid_arg
-                (counter$1, k, acc, fmt);
-       case 2:
-         /*<<camlinternalFormat.ml:1626:39>>*/ throw  /*<<camlinternalFormat.ml:1626:39>>*/ caml_maybe_attach_backtrace
-               ([0, Assert_failure, _t_], 1);
-       default:
-         /*<<camlinternalFormat.ml:1629:39>>*/ if(counter >= 50)
-          /*<<camlinternalFormat.ml:1629:39>>*/ return  /*<<camlinternalFormat.ml:1629:39>>*/ caml_trampoline_return
-                 (make_invalid_arg, [0, k, acc, fmt]);
-        var counter$2 = counter + 1 | 0;
-         /*<<camlinternalFormat.ml:1629:39>>*/ return make_invalid_arg
-                (counter$2, k, acc, fmt);
-     }
-    switch(ign[0]){
-      case 0:
-        /*<<camlinternalFormat.ml:1616:39>>*/ if(counter >= 50)
-         /*<<camlinternalFormat.ml:1616:39>>*/ return  /*<<camlinternalFormat.ml:1616:39>>*/ caml_trampoline_return
-                (make_invalid_arg, [0, k, acc, fmt]);
-       var counter$3 = counter + 1 | 0;
-        /*<<camlinternalFormat.ml:1616:39>>*/ return make_invalid_arg
-               (counter$3, k, acc, fmt);
-      case 1:
-        /*<<camlinternalFormat.ml:1617:39>>*/ if(counter >= 50)
-         /*<<camlinternalFormat.ml:1617:39>>*/ return  /*<<camlinternalFormat.ml:1617:39>>*/ caml_trampoline_return
-                (make_invalid_arg, [0, k, acc, fmt]);
-       var counter$4 = counter + 1 | 0;
-        /*<<camlinternalFormat.ml:1617:39>>*/ return make_invalid_arg
-               (counter$4, k, acc, fmt);
-      case 2:
-        /*<<camlinternalFormat.ml:1618:39>>*/ if(counter >= 50)
-         /*<<camlinternalFormat.ml:1618:39>>*/ return  /*<<camlinternalFormat.ml:1618:39>>*/ caml_trampoline_return
-                (make_invalid_arg, [0, k, acc, fmt]);
-       var counter$5 = counter + 1 | 0;
-        /*<<camlinternalFormat.ml:1618:39>>*/ return make_invalid_arg
-               (counter$5, k, acc, fmt);
-      case 3:
-        /*<<camlinternalFormat.ml:1619:39>>*/ if(counter >= 50)
-         /*<<camlinternalFormat.ml:1619:39>>*/ return  /*<<camlinternalFormat.ml:1619:39>>*/ caml_trampoline_return
-                (make_invalid_arg, [0, k, acc, fmt]);
-       var counter$6 = counter + 1 | 0;
-        /*<<camlinternalFormat.ml:1619:39>>*/ return make_invalid_arg
-               (counter$6, k, acc, fmt);
-      case 4:
-        /*<<camlinternalFormat.ml:1620:39>>*/ if(counter >= 50)
-         /*<<camlinternalFormat.ml:1620:39>>*/ return  /*<<camlinternalFormat.ml:1620:39>>*/ caml_trampoline_return
-                (make_invalid_arg, [0, k, acc, fmt]);
-       var counter$7 = counter + 1 | 0;
-        /*<<camlinternalFormat.ml:1620:39>>*/ return make_invalid_arg
-               (counter$7, k, acc, fmt);
-      case 5:
-        /*<<camlinternalFormat.ml:1621:39>>*/ if(counter >= 50)
-         /*<<camlinternalFormat.ml:1621:39>>*/ return  /*<<camlinternalFormat.ml:1621:39>>*/ caml_trampoline_return
-                (make_invalid_arg, [0, k, acc, fmt]);
-       var counter$8 = counter + 1 | 0;
-        /*<<camlinternalFormat.ml:1621:39>>*/ return make_invalid_arg
-               (counter$8, k, acc, fmt);
-      case 6:
-        /*<<camlinternalFormat.ml:1622:39>>*/ if(counter >= 50)
-         /*<<camlinternalFormat.ml:1622:39>>*/ return  /*<<camlinternalFormat.ml:1622:39>>*/ caml_trampoline_return
-                (make_invalid_arg, [0, k, acc, fmt]);
-       var counter$9 = counter + 1 | 0;
-        /*<<camlinternalFormat.ml:1622:39>>*/ return make_invalid_arg
-               (counter$9, k, acc, fmt);
-      case 7:
-        /*<<camlinternalFormat.ml:1623:39>>*/ if(counter >= 50)
-         /*<<camlinternalFormat.ml:1623:39>>*/ return  /*<<camlinternalFormat.ml:1623:39>>*/ caml_trampoline_return
-                (make_invalid_arg, [0, k, acc, fmt]);
-       var counter$10 = counter + 1 | 0;
-        /*<<camlinternalFormat.ml:1623:39>>*/ return make_invalid_arg
-               (counter$10, k, acc, fmt);
-      case 8:
-        /*<<camlinternalFormat.ml:1624:39>>*/ if(counter >= 50)
-         /*<<camlinternalFormat.ml:1624:39>>*/ return  /*<<camlinternalFormat.ml:1624:39>>*/ caml_trampoline_return
-                (make_invalid_arg, [0, k, acc, fmt]);
-       var counter$11 = counter + 1 | 0;
-        /*<<camlinternalFormat.ml:1624:39>>*/ return make_invalid_arg
-               (counter$11, k, acc, fmt);
-      case 9:
-       var fmtty = ign[2];
-        /*<<camlinternalFormat.ml:1625:39>>*/ if(counter >= 50)
-         /*<<camlinternalFormat.ml:1625:39>>*/ return  /*<<camlinternalFormat.ml:1625:39>>*/ caml_trampoline_return
-                (make_from_fmtty$0, [0, k, acc, fmtty, fmt]);
-       var counter$14 = counter + 1 | 0;
-        /*<<camlinternalFormat.ml:1625:39>>*/ return make_from_fmtty$0
-               (counter$14, k, acc, fmtty, fmt);
-      case 10:
-        /*<<camlinternalFormat.ml:1627:39>>*/ if(counter >= 50)
-         /*<<camlinternalFormat.ml:1627:39>>*/ return  /*<<camlinternalFormat.ml:1627:39>>*/ caml_trampoline_return
-                (make_invalid_arg, [0, k, acc, fmt]);
-       var counter$12 = counter + 1 | 0;
-        /*<<camlinternalFormat.ml:1627:39>>*/ return make_invalid_arg
-               (counter$12, k, acc, fmt);
-      default:
-        /*<<camlinternalFormat.ml:1628:39>>*/ if(counter >= 50)
-         /*<<camlinternalFormat.ml:1628:39>>*/ return  /*<<camlinternalFormat.ml:1628:39>>*/ caml_trampoline_return
-                (make_invalid_arg, [0, k, acc, fmt]);
-       var counter$13 = counter + 1 | 0;
-        /*<<camlinternalFormat.ml:1628:39>>*/ return make_invalid_arg
-               (counter$13, k, acc, fmt);
-    }
-    /*<<camlinternalFormat.ml:1629:65>>*/ }
-   function make_from_fmtty$0(counter, k, acc, fmtty, fmt){
-     /*<<camlinternalFormat.ml:1637:23>>*/ if(typeof fmtty !== "number")
-     switch(fmtty[0]){
-       case 0:
-        var rest = fmtty[1];
-         /*<<camlinternalFormat.ml:1638:31>>*/ return function(param){
-          /*<<camlinternalFormat.ml:1638:40>>*/ return make_from_fmtty
-                 (k, acc, rest, fmt); /*<<camlinternalFormat.ml:1638:70>>*/ };
-       case 1:
-        var rest$0 = fmtty[1];
-         /*<<camlinternalFormat.ml:1639:31>>*/ return function(param){
-          /*<<camlinternalFormat.ml:1639:40>>*/ return make_from_fmtty
-                 (k, acc, rest$0, fmt); /*<<camlinternalFormat.ml:1639:70>>*/ };
-       case 2:
-        var rest$1 = fmtty[1];
-         /*<<camlinternalFormat.ml:1640:31>>*/ return function(param){
-          /*<<camlinternalFormat.ml:1640:40>>*/ return make_from_fmtty
-                 (k, acc, rest$1, fmt); /*<<camlinternalFormat.ml:1640:70>>*/ };
-       case 3:
-        var rest$2 = fmtty[1];
-         /*<<camlinternalFormat.ml:1641:31>>*/ return function(param){
-          /*<<camlinternalFormat.ml:1641:40>>*/ return make_from_fmtty
-                 (k, acc, rest$2, fmt); /*<<camlinternalFormat.ml:1641:70>>*/ };
-       case 4:
-        var rest$3 = fmtty[1];
-         /*<<camlinternalFormat.ml:1642:31>>*/ return function(param){
-          /*<<camlinternalFormat.ml:1642:40>>*/ return make_from_fmtty
-                 (k, acc, rest$3, fmt); /*<<camlinternalFormat.ml:1642:70>>*/ };
-       case 5:
-        var rest$4 = fmtty[1];
-         /*<<camlinternalFormat.ml:1643:31>>*/ return function(param){
-          /*<<camlinternalFormat.ml:1643:40>>*/ return make_from_fmtty
-                 (k, acc, rest$4, fmt); /*<<camlinternalFormat.ml:1643:70>>*/ };
-       case 6:
-        var rest$5 = fmtty[1];
-         /*<<camlinternalFormat.ml:1644:31>>*/ return function(param){
-          /*<<camlinternalFormat.ml:1644:40>>*/ return make_from_fmtty
-                 (k, acc, rest$5, fmt); /*<<camlinternalFormat.ml:1644:70>>*/ };
-       case 7:
-        var rest$6 = fmtty[1];
-         /*<<camlinternalFormat.ml:1645:31>>*/ return function(param){
-          /*<<camlinternalFormat.ml:1645:40>>*/ return make_from_fmtty
-                 (k, acc, rest$6, fmt); /*<<camlinternalFormat.ml:1645:70>>*/ };
-       case 8:
-        var rest$7 = fmtty[2];
-         /*<<camlinternalFormat.ml:1651:31>>*/ return function(param){
-          /*<<camlinternalFormat.ml:1651:40>>*/ return make_from_fmtty
-                 (k, acc, rest$7, fmt); /*<<camlinternalFormat.ml:1651:70>>*/ };
-       case 9:
-         /*<<camlinternalFormat.ml:1654:13>>*/ var
-         rest$8 = fmtty[3],
-         ty2 = fmtty[2],
-         ty1 = fmtty[1],
-          /*<<camlinternalFormat.ml:1654:13>>*/ ty = trans(symm(ty1), ty2);
-         /*<<camlinternalFormat.ml:1655:4>>*/ return function(param){
-          /*<<camlinternalFormat.ml:1655:13>>*/ return make_from_fmtty
-                 (k,
-                  acc,
-                   /*<<camlinternalFormat.ml:1655:35>>*/ caml_call2
-                   (CamlinternalFormatBasics[1], ty, rest$8),
-                  fmt); /*<<camlinternalFormat.ml:1655:61>>*/ };
-       case 10:
-        var rest$9 = fmtty[1];
-         /*<<camlinternalFormat.ml:1646:31>>*/ return function(param, _cO_){
-          /*<<camlinternalFormat.ml:1646:42>>*/ return make_from_fmtty
-                 (k, acc, rest$9, fmt); /*<<camlinternalFormat.ml:1646:72>>*/ };
-       case 11:
-        var rest$10 = fmtty[1];
-         /*<<camlinternalFormat.ml:1647:31>>*/ return function(param){
-          /*<<camlinternalFormat.ml:1647:40>>*/ return make_from_fmtty
-                 (k, acc, rest$10, fmt); /*<<camlinternalFormat.ml:1647:70>>*/ };
-       case 12:
-        var rest$11 = fmtty[1];
-         /*<<camlinternalFormat.ml:1648:31>>*/ return function(param){
-          /*<<camlinternalFormat.ml:1648:40>>*/ return make_from_fmtty
-                 (k, acc, rest$11, fmt); /*<<camlinternalFormat.ml:1648:70>>*/ };
-       case 13:
-         /*<<camlinternalFormat.ml:1649:31>>*/ throw  /*<<camlinternalFormat.ml:1649:31>>*/ caml_maybe_attach_backtrace
-               ([0, Assert_failure, _u_], 1);
-       default:
-         /*<<camlinternalFormat.ml:1650:31>>*/ throw  /*<<camlinternalFormat.ml:1650:31>>*/ caml_maybe_attach_backtrace
-               ([0, Assert_failure, _v_], 1);
-     }
-     /*<<camlinternalFormat.ml:1652:31>>*/ if(counter >= 50)
-      /*<<camlinternalFormat.ml:1652:31>>*/ return  /*<<camlinternalFormat.ml:1652:31>>*/ caml_trampoline_return
-             (make_invalid_arg, [0, k, acc, fmt]);
-    var counter$0 = counter + 1 | 0;
-     /*<<camlinternalFormat.ml:1652:31>>*/ return make_invalid_arg
-            (counter$0, k, acc, fmt);
-    /*<<camlinternalFormat.ml:1655:61>>*/ }
-   function make_invalid_arg(counter, k, acc, fmt){
-     /*<<camlinternalFormat.ml:1663:2>>*/  /*<<camlinternalFormat.ml:1663:16>>*/ var
-     _cN_ = [8, acc, cst_Printf_bad_conversion$0];
-     /*<<camlinternalFormat.ml:1663:2>>*/ if(counter >= 50)
-      /*<<camlinternalFormat.ml:1663:2>>*/ return  /*<<camlinternalFormat.ml:1663:2>>*/ caml_trampoline_return
-             (make_printf$0, [0, k, _cN_, fmt]);
-    var counter$0 = counter + 1 | 0;
-     /*<<camlinternalFormat.ml:1663:2>>*/ return make_printf$0
-            (counter$0, k, _cN_, fmt);
-    /*<<camlinternalFormat.ml:1663:72>>*/ }
-   function make_custom$0(counter, k, acc, rest, arity, f){
-     /*<<camlinternalFormat.ml:1778:28>>*/ if(arity){
-     var arity$0 = arity[1];
-      /*<<camlinternalFormat.ml:1781:4>>*/ return function(x){
-       /*<<camlinternalFormat.ml:1782:6>>*/ return make_custom
-              (k,
-               acc,
-               rest,
-               arity$0,
-                /*<<camlinternalFormat.ml:1782:35>>*/ caml_call1(f, x)); /*<<camlinternalFormat.ml:1782:40>>*/ };
-    }
-     /*<<camlinternalFormat.ml:1779:33>>*/  /*<<camlinternalFormat.ml:1779:33>>*/ var
-     _cM_ = [4, acc, f];
-     /*<<camlinternalFormat.ml:1779:19>>*/ if(counter >= 50)
-      /*<<camlinternalFormat.ml:1779:19>>*/ return  /*<<camlinternalFormat.ml:1779:19>>*/ caml_trampoline_return
-             (make_printf$0, [0, k, _cM_, rest]);
-    var counter$0 = counter + 1 | 0;
-     /*<<camlinternalFormat.ml:1779:19>>*/ return make_printf$0
-            (counter$0, k, _cM_, rest);
-    /*<<camlinternalFormat.ml:1782:40>>*/ }
-   function make_printf(k, acc, fmt){
-     /*<<?>>*/ return caml_trampoline(make_printf$0(0, k, acc, fmt));
-   }
-   function make_ignored_param(k, acc, ign, fmt){
-     /*<<?>>*/ return caml_trampoline
-            (make_ignored_param$0(0, k, acc, ign, fmt));
-   }
-   function make_from_fmtty(k, acc, fmtty, fmt){
-     /*<<?>>*/ return caml_trampoline
-            (make_from_fmtty$0(0, k, acc, fmtty, fmt));
-   }
-   function make_custom(k, acc, rest, arity, f){
-     /*<<?>>*/ return caml_trampoline
-            (make_custom$0(0, k, acc, rest, arity, f));
-   }
-   function fn_of_padding_precision(k, o, fmt, pad, prec){
-     /*<<camlinternalFormat.ml:1863:26>>*/ if(typeof pad === "number"){
-     if(typeof prec !== "number"){
-       /*<<camlinternalFormat.ml:1867:14>>*/  /*<<camlinternalFormat.ml:1867:14>>*/ var
-       _cl_ = make_iprintf(k, o, fmt);
-       /*<<camlinternalFormat.ml:1867:14>>*/ return function(_cL_){
-        /*<<?>>*/ return _cl_;};
-     }
-     if(prec){
-       /*<<camlinternalFormat.ml:1869:21>>*/ var
-        /*<<camlinternalFormat.ml:1869:21>>*/ _ci_ = make_iprintf(k, o, fmt),
-        /*<<camlinternalFormat.ml:1869:14>>*/ _cj_ =
-         function(_cK_){ /*<<?>>*/ return _ci_;};
-       /*<<camlinternalFormat.ml:1869:14>>*/ return function(_cJ_){
-        /*<<?>>*/ return _cj_;};
-     }
-      /*<<camlinternalFormat.ml:1865:14>>*/  /*<<camlinternalFormat.ml:1865:14>>*/ var
-      _ck_ = make_iprintf(k, o, fmt);
-      /*<<camlinternalFormat.ml:1865:14>>*/ return function(_cI_){
-       /*<<?>>*/ return _ck_;};
-    }
-    if(0 === pad[0]){
-     if(typeof prec !== "number"){
-       /*<<camlinternalFormat.ml:1873:14>>*/  /*<<camlinternalFormat.ml:1873:14>>*/ var
-       _cp_ = make_iprintf(k, o, fmt);
-       /*<<camlinternalFormat.ml:1873:14>>*/ return function(_cH_){
-        /*<<?>>*/ return _cp_;};
-     }
-     if(prec){
-       /*<<camlinternalFormat.ml:1875:21>>*/ var
-        /*<<camlinternalFormat.ml:1875:21>>*/ _cm_ = make_iprintf(k, o, fmt),
-        /*<<camlinternalFormat.ml:1875:14>>*/ _cn_ =
-         function(_cG_){ /*<<?>>*/ return _cm_;};
-       /*<<camlinternalFormat.ml:1875:14>>*/ return function(_cF_){
-        /*<<?>>*/ return _cn_;};
-     }
-      /*<<camlinternalFormat.ml:1871:14>>*/  /*<<camlinternalFormat.ml:1871:14>>*/ var
-      _co_ = make_iprintf(k, o, fmt);
-      /*<<camlinternalFormat.ml:1871:14>>*/ return function(_cE_){
-       /*<<?>>*/ return _co_;};
-    }
-    if(typeof prec !== "number"){
-      /*<<camlinternalFormat.ml:1879:21>>*/ var
-       /*<<camlinternalFormat.ml:1879:21>>*/ _cv_ = make_iprintf(k, o, fmt),
-       /*<<camlinternalFormat.ml:1879:14>>*/ _cw_ =
-        function(_cD_){ /*<<?>>*/ return _cv_;};
-      /*<<camlinternalFormat.ml:1879:14>>*/ return function(_cC_){
-       /*<<?>>*/ return _cw_;};
-    }
-    if(prec){
-      /*<<camlinternalFormat.ml:1881:28>>*/ var
-       /*<<camlinternalFormat.ml:1881:28>>*/ _cq_ = make_iprintf(k, o, fmt),
-       /*<<camlinternalFormat.ml:1881:21>>*/ _cr_ =
-        function(_cB_){ /*<<?>>*/ return _cq_;},
-       /*<<camlinternalFormat.ml:1881:14>>*/ _cs_ =
-        function(_cA_){ /*<<?>>*/ return _cr_;};
-      /*<<camlinternalFormat.ml:1881:14>>*/ return function(_cz_){
-       /*<<?>>*/ return _cs_;};
-    }
-     /*<<camlinternalFormat.ml:1877:21>>*/  /*<<camlinternalFormat.ml:1877:21>>*/ var
-     _ct_ = make_iprintf(k, o, fmt);
-     /*<<camlinternalFormat.ml:1877:14>>*/ function _cu_(_cy_){
-      /*<<?>>*/ return _ct_;
-    }
-     /*<<camlinternalFormat.ml:1877:14>>*/ return function(_cx_){
-      /*<<?>>*/ return _cu_;};
-    /*<<camlinternalFormat.ml:1881:52>>*/ }
-   function make_iprintf$0(counter, k, o, fmt){
-     /*<<camlinternalFormat.ml:1788:17>>*/ var k$0 = k, fmt$0 = fmt;
-     /*<<camlinternalFormat.ml:1788:17>>*/ for(;;){
-     if(typeof fmt$0 === "number")
-       /*<<camlinternalFormat.ml:1858:8>>*/ return  /*<<camlinternalFormat.ml:1858:8>>*/ caml_call1
-              (k$0, o);
-     switch(fmt$0[0]){
-       case 0:
-         /*<<camlinternalFormat.ml:1790:14>>*/ var
-         rest = fmt$0[1],
-          /*<<camlinternalFormat.ml:1790:14>>*/ _by_ =
-           make_iprintf(k$0, o, rest);
-         /*<<camlinternalFormat.ml:1790:14>>*/ return function(_ch_){
-          /*<<?>>*/ return _by_;};
-       case 1:
-         /*<<camlinternalFormat.ml:1792:14>>*/ var
-         rest$0 = fmt$0[1],
-          /*<<camlinternalFormat.ml:1792:14>>*/ _bz_ =
-           make_iprintf(k$0, o, rest$0);
-         /*<<camlinternalFormat.ml:1792:14>>*/ return function(_cg_){
-          /*<<?>>*/ return _bz_;};
-       case 2:
-        var _bA_ = fmt$0[1];
-        if(typeof _bA_ === "number"){
-          /*<<camlinternalFormat.ml:1794:14>>*/ var
-          rest$1 = fmt$0[2],
-           /*<<camlinternalFormat.ml:1794:14>>*/ _bB_ =
-            make_iprintf(k$0, o, rest$1);
-          /*<<camlinternalFormat.ml:1794:14>>*/ return function(_cf_){
-           /*<<?>>*/ return _bB_;};
-        }
-        if(0 === _bA_[0]){
-          /*<<camlinternalFormat.ml:1796:14>>*/ var
-          rest$2 = fmt$0[2],
-           /*<<camlinternalFormat.ml:1796:14>>*/ _bC_ =
-            make_iprintf(k$0, o, rest$2);
-          /*<<camlinternalFormat.ml:1796:14>>*/ return function(_ce_){
-           /*<<?>>*/ return _bC_;};
-        }
-         /*<<camlinternalFormat.ml:1798:21>>*/ var
-         rest$3 = fmt$0[2],
-          /*<<camlinternalFormat.ml:1798:21>>*/ _bD_ =
-           make_iprintf(k$0, o, rest$3),
-          /*<<camlinternalFormat.ml:1798:14>>*/ _bE_ =
-           function(_cd_){ /*<<?>>*/ return _bD_;};
-         /*<<camlinternalFormat.ml:1798:14>>*/ return function(_cc_){
-          /*<<?>>*/ return _bE_;};
-       case 3:
-        var _bF_ = fmt$0[1];
-        if(typeof _bF_ === "number"){
-          /*<<camlinternalFormat.ml:1800:14>>*/ var
-          rest$4 = fmt$0[2],
-           /*<<camlinternalFormat.ml:1800:14>>*/ _bG_ =
-            make_iprintf(k$0, o, rest$4);
-          /*<<camlinternalFormat.ml:1800:14>>*/ return function(_cb_){
-           /*<<?>>*/ return _bG_;};
-        }
-        if(0 === _bF_[0]){
-          /*<<camlinternalFormat.ml:1802:14>>*/ var
-          rest$5 = fmt$0[2],
-           /*<<camlinternalFormat.ml:1802:14>>*/ _bH_ =
-            make_iprintf(k$0, o, rest$5);
-          /*<<camlinternalFormat.ml:1802:14>>*/ return function(_ca_){
-           /*<<?>>*/ return _bH_;};
-        }
-         /*<<camlinternalFormat.ml:1804:21>>*/ var
-         rest$6 = fmt$0[2],
-          /*<<camlinternalFormat.ml:1804:21>>*/ _bI_ =
-           make_iprintf(k$0, o, rest$6),
-          /*<<camlinternalFormat.ml:1804:14>>*/ _bJ_ =
-           function(_b$_){ /*<<?>>*/ return _bI_;};
-         /*<<camlinternalFormat.ml:1804:14>>*/ return function(_b__){
-          /*<<?>>*/ return _bJ_;};
-       case 4:
-        var rest$7 = fmt$0[4], prec = fmt$0[3], pad = fmt$0[2];
-         /*<<camlinternalFormat.ml:1806:8>>*/ return fn_of_padding_precision
-                (k$0, o, rest$7, pad, prec);
-       case 5:
-        var rest$8 = fmt$0[4], prec$0 = fmt$0[3], pad$0 = fmt$0[2];
-         /*<<camlinternalFormat.ml:1808:8>>*/ return fn_of_padding_precision
-                (k$0, o, rest$8, pad$0, prec$0);
-       case 6:
-        var rest$9 = fmt$0[4], prec$1 = fmt$0[3], pad$1 = fmt$0[2];
-         /*<<camlinternalFormat.ml:1810:8>>*/ return fn_of_padding_precision
-                (k$0, o, rest$9, pad$1, prec$1);
-       case 7:
-        var rest$10 = fmt$0[4], prec$2 = fmt$0[3], pad$2 = fmt$0[2];
-         /*<<camlinternalFormat.ml:1812:8>>*/ return fn_of_padding_precision
-                (k$0, o, rest$10, pad$2, prec$2);
-       case 8:
-        var rest$11 = fmt$0[4], prec$3 = fmt$0[3], pad$3 = fmt$0[2];
-         /*<<camlinternalFormat.ml:1814:8>>*/ return fn_of_padding_precision
-                (k$0, o, rest$11, pad$3, prec$3);
-       case 9:
-        var _bK_ = fmt$0[1];
-        if(typeof _bK_ === "number"){
-          /*<<camlinternalFormat.ml:1816:14>>*/ var
-          rest$12 = fmt$0[2],
-           /*<<camlinternalFormat.ml:1816:14>>*/ _bL_ =
-            make_iprintf(k$0, o, rest$12);
-          /*<<camlinternalFormat.ml:1816:14>>*/ return function(_b9_){
-           /*<<?>>*/ return _bL_;};
-        }
-        if(0 === _bK_[0]){
-          /*<<camlinternalFormat.ml:1818:14>>*/ var
-          rest$13 = fmt$0[2],
-           /*<<camlinternalFormat.ml:1818:14>>*/ _bM_ =
-            make_iprintf(k$0, o, rest$13);
-          /*<<camlinternalFormat.ml:1818:14>>*/ return function(_b8_){
-           /*<<?>>*/ return _bM_;};
-        }
-         /*<<camlinternalFormat.ml:1820:21>>*/ var
-         rest$14 = fmt$0[2],
-          /*<<camlinternalFormat.ml:1820:21>>*/ _bN_ =
-           make_iprintf(k$0, o, rest$14),
-          /*<<camlinternalFormat.ml:1820:14>>*/ _bO_ =
-           function(_b7_){ /*<<?>>*/ return _bN_;};
-         /*<<camlinternalFormat.ml:1820:14>>*/ return function(_b6_){
-          /*<<?>>*/ return _bO_;};
-       case 10:
-        var rest$15 = fmt$0[1], fmt$0 = rest$15; break;
-       case 11:
-        var rest$16 = fmt$0[2], fmt$0 = rest$16; break;
-       case 12:
-        var rest$17 = fmt$0[2], fmt$0 = rest$17; break;
-       case 13:
-         /*<<camlinternalFormat.ml:1838:14>>*/ var
-         rest$18 = fmt$0[3],
-          /*<<camlinternalFormat.ml:1838:14>>*/ _bP_ =
-           make_iprintf(k$0, o, rest$18);
-         /*<<camlinternalFormat.ml:1838:14>>*/ return function(_b5_){
-          /*<<?>>*/ return _bP_;};
-       case 14:
-        var rest$19 = fmt$0[3], fmtty = fmt$0[2];
-         /*<<camlinternalFormat.ml:1840:8>>*/ return function(param){
-          /*<<camlinternalFormat.ml:1840:8>>*/ var
-          fmt = param[1],
-           /*<<camlinternalFormat.ml:1842:24>>*/ _b4_ = recast(fmt, fmtty);
-          /*<<camlinternalFormat.ml:1842:12>>*/ return make_iprintf
-                 (k$0,
-                  o,
-                   /*<<camlinternalFormat.ml:1842:12>>*/ caml_call2
-                   (CamlinternalFormatBasics[3], _b4_, rest$19)); /*<<camlinternalFormat.ml:1842:48>>*/ };
-       case 15:
-         /*<<camlinternalFormat.ml:1822:21>>*/ var
-         rest$20 = fmt$0[1],
-          /*<<camlinternalFormat.ml:1822:21>>*/ _bQ_ =
-           make_iprintf(k$0, o, rest$20),
-          /*<<camlinternalFormat.ml:1822:14>>*/ _bR_ =
-           function(_b3_){ /*<<?>>*/ return _bQ_;};
-         /*<<camlinternalFormat.ml:1822:14>>*/ return function(_b2_){
-          /*<<?>>*/ return _bR_;};
-       case 16:
-         /*<<camlinternalFormat.ml:1824:14>>*/ var
-         rest$21 = fmt$0[1],
-          /*<<camlinternalFormat.ml:1824:14>>*/ _bS_ =
-           make_iprintf(k$0, o, rest$21);
-         /*<<camlinternalFormat.ml:1824:14>>*/ return function(_b1_){
-          /*<<?>>*/ return _bS_;};
-       case 17:
-        var rest$22 = fmt$0[2], fmt$0 = rest$22; break;
-       case 18:
-        var _bT_ = fmt$0[1];
-        if(0 === _bT_[0])
-         var
-          rest$23 = fmt$0[2],
-          fmt$1 = _bT_[1][1],
-          k$3 =
-            function(k, rest){
-             function k$0(koc){
-               /*<<camlinternalFormat.ml:1854:33>>*/ return make_iprintf
-                      (k, koc, rest);
-              /*<<camlinternalFormat.ml:1854:56>>*/ }
-             return k$0;
-            },
-          k$1 = k$3(k$0, rest$23),
-          k$0 = k$1,
-          fmt$0 = fmt$1;
-        else
-         var
-          rest$24 = fmt$0[2],
-          fmt$2 = _bT_[1][1],
-          k$4 =
-            function(k, rest){
-             function k$0(koc){
-               /*<<camlinternalFormat.ml:1856:33>>*/ return make_iprintf
-                      (k, koc, rest);
-              /*<<camlinternalFormat.ml:1856:56>>*/ }
-             return k$0;
-            },
-          k$2 = k$4(k$0, rest$24),
-          k$0 = k$2,
-          fmt$0 = fmt$2;
-        break;
-       case 19:
-         /*<<camlinternalFormat.ml:1830:8>>*/ throw  /*<<camlinternalFormat.ml:1830:8>>*/ caml_maybe_attach_backtrace
-               ([0, Assert_failure, _w_], 1);
-       case 20:
-         /*<<camlinternalFormat.ml:1844:14>>*/ var
-         rest$25 = fmt$0[3],
-          /*<<camlinternalFormat.ml:1844:14>>*/ _bU_ =
-           make_iprintf(k$0, o, rest$25);
-         /*<<camlinternalFormat.ml:1844:14>>*/ return function(_b0_){
-          /*<<?>>*/ return _bU_;};
-       case 21:
-         /*<<camlinternalFormat.ml:1846:14>>*/ var
-         rest$26 = fmt$0[2],
-          /*<<camlinternalFormat.ml:1846:14>>*/ _bV_ =
-           make_iprintf(k$0, o, rest$26);
-         /*<<camlinternalFormat.ml:1846:14>>*/ return function(_bZ_){
-          /*<<?>>*/ return _bV_;};
-       case 22:
-         /*<<camlinternalFormat.ml:1848:14>>*/ var
-         rest$27 = fmt$0[1],
-          /*<<camlinternalFormat.ml:1848:14>>*/ _bW_ =
-           make_iprintf(k$0, o, rest$27);
-         /*<<camlinternalFormat.ml:1848:14>>*/ return function(_bY_){
-          /*<<?>>*/ return _bW_;};
-       case 23:
-        var rest$28 = fmt$0[2], ign = fmt$0[1], _bX_ = 0;
-         /*<<camlinternalFormat.ml:1850:8>>*/ return make_ignored_param
-                (function(param){
-                   /*<<camlinternalFormat.ml:1850:37>>*/ return caml_call1
-                          (k$0, o);
-                  /*<<camlinternalFormat.ml:1850:40>>*/ },
-                 _bX_,
-                 ign,
-                 rest$28);
-       default:
-        var rest$29 = fmt$0[3], arity = fmt$0[1];
-         /*<<camlinternalFormat.ml:1826:8>>*/ if(counter >= 50)
-          /*<<camlinternalFormat.ml:1826:8>>*/ return  /*<<camlinternalFormat.ml:1826:8>>*/ caml_trampoline_return
-                 (fn_of_custom_arity$0, [0, k$0, o, rest$29, arity]);
-        var counter$0 = counter + 1 | 0;
-         /*<<camlinternalFormat.ml:1826:8>>*/ return fn_of_custom_arity$0
-                (counter$0, k$0, o, rest$29, arity);
-     }
-    }
-    /*<<camlinternalFormat.ml:1858:11>>*/ }
-   function fn_of_custom_arity$0(counter, k, o, fmt, param){
-     /*<<camlinternalFormat.ml:1882:4>>*/ if(param){
-      /*<<camlinternalFormat.ml:1889:14>>*/ var
-      arity = param[1],
-       /*<<camlinternalFormat.ml:1889:14>>*/ _bw_ =
-        fn_of_custom_arity(k, o, fmt, arity);
-      /*<<camlinternalFormat.ml:1889:14>>*/ return function(_bx_){
-       /*<<?>>*/ return _bw_;};
-    }
-     /*<<camlinternalFormat.ml:1887:8>>*/ if(counter >= 50)
-      /*<<camlinternalFormat.ml:1887:8>>*/ return  /*<<camlinternalFormat.ml:1887:8>>*/ caml_trampoline_return
-             (make_iprintf$0, [0, k, o, fmt]);
-    var counter$0 = counter + 1 | 0;
-     /*<<camlinternalFormat.ml:1887:8>>*/ return make_iprintf$0
-            (counter$0, k, o, fmt);
-    /*<<camlinternalFormat.ml:1889:48>>*/ }
-   function make_iprintf(k, o, fmt){
-     /*<<?>>*/ return caml_trampoline(make_iprintf$0(0, k, o, fmt));
-   }
-   function fn_of_custom_arity(k, o, fmt, param){
-     /*<<?>>*/ return caml_trampoline
-            (fn_of_custom_arity$0(0, k, o, fmt, param));
-   }
-   function output_acc(o, acc){
-     /*<<camlinternalFormat.ml:1897:27>>*/ var acc$0 = acc;
-     /*<<camlinternalFormat.ml:1897:27>>*/ for(;;){
-     if(typeof acc$0 === "number")
-       /*<<camlinternalFormat.ml:1912:32>>*/ return 0;
-     switch(acc$0[0]){
-       case 0:
-         /*<<camlinternalFormat.ml:1899:12>>*/ var
-         fmting_lit = acc$0[2],
-         p = acc$0[1],
-          /*<<camlinternalFormat.ml:1899:12>>*/ s =
-           string_of_formatting_lit(fmting_lit);
-         /*<<camlinternalFormat.ml:1900:4>>*/ output_acc(o, p);
-         /*<<camlinternalFormat.ml:1900:4>>*/ return  /*<<camlinternalFormat.ml:1900:4>>*/ caml_call2
-                (Stdlib[66], o, s);
-       case 1:
-        var match = acc$0[2], p$0 = acc$0[1];
-        if(0 === match[0]){
-         var acc$1 = match[1];
-          /*<<camlinternalFormat.ml:1902:4>>*/ output_acc(o, p$0);
-          /*<<camlinternalFormat.ml:1902:20>>*/  /*<<camlinternalFormat.ml:1902:20>>*/ caml_call2
-          (Stdlib[66], o, cst$18);
-         var acc$0 = acc$1;
-        }
-        else{
-         var acc$2 = match[1];
-          /*<<camlinternalFormat.ml:1904:4>>*/ output_acc(o, p$0);
-          /*<<camlinternalFormat.ml:1904:20>>*/  /*<<camlinternalFormat.ml:1904:20>>*/ caml_call2
-          (Stdlib[66], o, cst$19);
-         var acc$0 = acc$2;
-        }
-        break;
-       case 6:
-        var f = acc$0[2], p$3 = acc$0[1];
-         /*<<camlinternalFormat.ml:1909:32>>*/ output_acc(o, p$3);
-         /*<<camlinternalFormat.ml:1909:32>>*/ return  /*<<camlinternalFormat.ml:1909:32>>*/ caml_call1
-                (f, o);
-       case 7:
-        var p$4 = acc$0[1];
-         /*<<camlinternalFormat.ml:1910:32>>*/ output_acc(o, p$4);
-         /*<<camlinternalFormat.ml:1910:32>>*/ return  /*<<camlinternalFormat.ml:1910:32>>*/ caml_call1
-                (Stdlib[63], o);
-       case 8:
-        var msg = acc$0[2], p$5 = acc$0[1];
-         /*<<camlinternalFormat.ml:1911:32>>*/ output_acc(o, p$5);
-         /*<<camlinternalFormat.ml:1911:32>>*/ return  /*<<camlinternalFormat.ml:1911:32>>*/ caml_call1
-                (Stdlib[1], msg);
-       case 2:
-       case 4:
-        var s$0 = acc$0[2], p$1 = acc$0[1];
-         /*<<camlinternalFormat.ml:1906:32>>*/ output_acc(o, p$1);
-         /*<<camlinternalFormat.ml:1906:32>>*/ return  /*<<camlinternalFormat.ml:1906:32>>*/ caml_call2
-                (Stdlib[66], o, s$0);
-       default:
-        var c = acc$0[2], p$2 = acc$0[1];
-         /*<<camlinternalFormat.ml:1908:32>>*/ output_acc(o, p$2);
-         /*<<camlinternalFormat.ml:1908:32>>*/ return  /*<<camlinternalFormat.ml:1908:32>>*/ caml_call2
-                (Stdlib[65], o, c);
-     }
-    }
-    /*<<camlinternalFormat.ml:1912:34>>*/ }
-   function bufput_acc(b, acc){
-     /*<<camlinternalFormat.ml:1917:27>>*/ var acc$0 = acc;
-     /*<<camlinternalFormat.ml:1917:27>>*/ for(;;){
-     if(typeof acc$0 === "number")
-       /*<<camlinternalFormat.ml:1932:32>>*/ return 0;
-     switch(acc$0[0]){
-       case 0:
-         /*<<camlinternalFormat.ml:1919:12>>*/ var
-         fmting_lit = acc$0[2],
-         p = acc$0[1],
-          /*<<camlinternalFormat.ml:1919:12>>*/ s =
-           string_of_formatting_lit(fmting_lit);
-         /*<<camlinternalFormat.ml:1920:4>>*/ bufput_acc(b, p);
-         /*<<camlinternalFormat.ml:1920:4>>*/ return  /*<<camlinternalFormat.ml:1920:4>>*/ caml_call2
-                (Stdlib_Buffer[16], b, s);
-       case 1:
-        var match = acc$0[2], p$0 = acc$0[1];
-        if(0 === match[0]){
-         var acc$1 = match[1];
-          /*<<camlinternalFormat.ml:1922:4>>*/ bufput_acc(b, p$0);
-          /*<<camlinternalFormat.ml:1922:20>>*/  /*<<camlinternalFormat.ml:1922:20>>*/ caml_call2
-          (Stdlib_Buffer[16], b, cst$20);
-         var acc$0 = acc$1;
-        }
-        else{
-         var acc$2 = match[1];
-          /*<<camlinternalFormat.ml:1924:4>>*/ bufput_acc(b, p$0);
-          /*<<camlinternalFormat.ml:1924:20>>*/  /*<<camlinternalFormat.ml:1924:20>>*/ caml_call2
-          (Stdlib_Buffer[16], b, cst$21);
-         var acc$0 = acc$2;
-        }
-        break;
-       case 6:
-        var f = acc$0[2], p$3 = acc$0[1];
-         /*<<camlinternalFormat.ml:1929:32>>*/ bufput_acc(b, p$3);
-         /*<<camlinternalFormat.ml:1929:32>>*/ return  /*<<camlinternalFormat.ml:1929:32>>*/ caml_call1
-                (f, b);
-       case 7:
-        var acc$3 = acc$0[1], acc$0 = acc$3; break;
-       case 8:
-        var msg = acc$0[2], p$4 = acc$0[1];
-         /*<<camlinternalFormat.ml:1931:32>>*/ bufput_acc(b, p$4);
-         /*<<camlinternalFormat.ml:1931:32>>*/ return  /*<<camlinternalFormat.ml:1931:32>>*/ caml_call1
-                (Stdlib[1], msg);
-       case 2:
-       case 4:
-        var s$0 = acc$0[2], p$1 = acc$0[1];
-         /*<<camlinternalFormat.ml:1926:32>>*/ bufput_acc(b, p$1);
-         /*<<camlinternalFormat.ml:1926:32>>*/ return  /*<<camlinternalFormat.ml:1926:32>>*/ caml_call2
-                (Stdlib_Buffer[16], b, s$0);
-       default:
-        var c = acc$0[2], p$2 = acc$0[1];
-         /*<<camlinternalFormat.ml:1928:32>>*/ bufput_acc(b, p$2);
-         /*<<camlinternalFormat.ml:1928:32>>*/ return  /*<<camlinternalFormat.ml:1928:32>>*/ caml_call2
-                (Stdlib_Buffer[12], b, c);
-     }
-    }
-    /*<<camlinternalFormat.ml:1932:34>>*/ }
-   function strput_acc(b, acc){
-     /*<<camlinternalFormat.ml:1938:27>>*/ var acc$0 = acc;
-     /*<<camlinternalFormat.ml:1938:27>>*/ for(;;){
-     if(typeof acc$0 === "number")
-       /*<<camlinternalFormat.ml:1953:32>>*/ return 0;
-     switch(acc$0[0]){
-       case 0:
-         /*<<camlinternalFormat.ml:1940:12>>*/ var
-         fmting_lit = acc$0[2],
-         p = acc$0[1],
-          /*<<camlinternalFormat.ml:1940:12>>*/ s =
-           string_of_formatting_lit(fmting_lit);
-         /*<<camlinternalFormat.ml:1941:4>>*/ strput_acc(b, p);
-         /*<<camlinternalFormat.ml:1941:4>>*/ return  /*<<camlinternalFormat.ml:1941:4>>*/ caml_call2
-                (Stdlib_Buffer[16], b, s);
-       case 1:
-        var match = acc$0[2], p$0 = acc$0[1];
-        if(0 === match[0]){
-         var acc$1 = match[1];
-          /*<<camlinternalFormat.ml:1943:4>>*/ strput_acc(b, p$0);
-          /*<<camlinternalFormat.ml:1943:20>>*/  /*<<camlinternalFormat.ml:1943:20>>*/ caml_call2
-          (Stdlib_Buffer[16], b, cst$22);
-         var acc$0 = acc$1;
-        }
-        else{
-         var acc$2 = match[1];
-          /*<<camlinternalFormat.ml:1945:4>>*/ strput_acc(b, p$0);
-          /*<<camlinternalFormat.ml:1945:20>>*/  /*<<camlinternalFormat.ml:1945:20>>*/ caml_call2
-          (Stdlib_Buffer[16], b, cst$23);
-         var acc$0 = acc$2;
-        }
-        break;
-       case 6:
-        var f = acc$0[2], p$3 = acc$0[1];
-         /*<<camlinternalFormat.ml:1950:32>>*/ strput_acc(b, p$3);
-         /*<<camlinternalFormat.ml:1950:68>>*/  /*<<camlinternalFormat.ml:1950:68>>*/ var
-         _bv_ =  /*<<camlinternalFormat.ml:1950:68>>*/ caml_call1(f, 0);
-         /*<<camlinternalFormat.ml:1950:68>>*/ return  /*<<camlinternalFormat.ml:1950:68>>*/ caml_call2
-                (Stdlib_Buffer[16], b, _bv_);
-       case 7:
-        var acc$3 = acc$0[1], acc$0 = acc$3; break;
-       case 8:
-        var msg = acc$0[2], p$4 = acc$0[1];
-         /*<<camlinternalFormat.ml:1952:32>>*/ strput_acc(b, p$4);
-         /*<<camlinternalFormat.ml:1952:32>>*/ return  /*<<camlinternalFormat.ml:1952:32>>*/ caml_call1
-                (Stdlib[1], msg);
-       case 2:
-       case 4:
-        var s$0 = acc$0[2], p$1 = acc$0[1];
-         /*<<camlinternalFormat.ml:1947:32>>*/ strput_acc(b, p$1);
-         /*<<camlinternalFormat.ml:1947:32>>*/ return  /*<<camlinternalFormat.ml:1947:32>>*/ caml_call2
-                (Stdlib_Buffer[16], b, s$0);
-       default:
-        var c = acc$0[2], p$2 = acc$0[1];
-         /*<<camlinternalFormat.ml:1949:32>>*/ strput_acc(b, p$2);
-         /*<<camlinternalFormat.ml:1949:32>>*/ return  /*<<camlinternalFormat.ml:1949:32>>*/ caml_call2
-                (Stdlib_Buffer[12], b, c);
-     }
-    }
-    /*<<camlinternalFormat.ml:1953:34>>*/ }
-   function failwith_message(param){
-     /*<<camlinternalFormat.ml:1960:12>>*/ var
-     fmt = param[1],
-      /*<<camlinternalFormat.ml:1960:12>>*/ buf =
-        /*<<camlinternalFormat.ml:1960:12>>*/ caml_call1
-        (Stdlib_Buffer[1], 256);
-    function k(acc){
-      /*<<camlinternalFormat.ml:1961:14>>*/ strput_acc(buf, acc);
-      /*<<camlinternalFormat.ml:1961:43>>*/  /*<<camlinternalFormat.ml:1961:43>>*/ var
-      _bu_ =
-         /*<<camlinternalFormat.ml:1961:43>>*/ caml_call1
-         (Stdlib_Buffer[2], buf);
-      /*<<camlinternalFormat.ml:1961:43>>*/ return  /*<<camlinternalFormat.ml:1961:43>>*/ caml_call1
-             (Stdlib[2], _bu_);
-     /*<<camlinternalFormat.ml:1961:64>>*/ }
-     /*<<camlinternalFormat.ml:1962:2>>*/ return make_printf(k, 0, fmt);
-   }
-   function open_box_of_string(str){
-     /*<<camlinternalFormat.ml:1969:2>>*/ if
-     ( /*<<camlinternalFormat.ml:1969:5>>*/ runtime.caml_string_equal
-       (str, cst$43))
-      /*<<camlinternalFormat.ml:1969:19>>*/ return _x_;
-    var len = caml_ml_string_length(str);
-    function invalid_box(param){
-      /*<<camlinternalFormat.ml:1971:25>>*/ return  /*<<camlinternalFormat.ml:1971:4>>*/ caml_call1
-             (failwith_message(_y_), str);
-     /*<<camlinternalFormat.ml:1971:74>>*/ }
-    function parse_spaces(i){
-      /*<<camlinternalFormat.ml:1973:6>>*/ var i$0 = i;
-      /*<<camlinternalFormat.ml:1973:6>>*/ for(;;){
-      if(i$0 === len)  /*<<camlinternalFormat.ml:1973:22>>*/ return i$0;
-       /*<<camlinternalFormat.ml:1974:14>>*/  /*<<camlinternalFormat.ml:1974:14>>*/ var
-       match =
-          /*<<camlinternalFormat.ml:1974:14>>*/ caml_string_get(str, i$0);
-      if(9 !== match && 32 !== match)
-        /*<<camlinternalFormat.ml:1976:15>>*/ return i$0;
-       /*<<camlinternalFormat.ml:1975:24>>*/ var
-        /*<<camlinternalFormat.ml:1975:24>>*/ i$1 = i$0 + 1 | 0,
-       i$0 = i$1;
-     }
-     /*<<camlinternalFormat.ml:1976:16>>*/ }
-     /*<<camlinternalFormat.ml:1987:17>>*/ var
-      /*<<camlinternalFormat.ml:1987:17>>*/ wstart = parse_spaces(0),
-     wend = wstart;
-     /*<<camlinternalFormat.ml:1978:6>>*/ for(;;){
-     if
-      (wend !== len
-       &&
-        25
-        >=
-          /*<<camlinternalFormat.ml:1979:14>>*/ caml_string_get(str, wend)
-         - 97
-         >>> 0){
-       /*<<camlinternalFormat.ml:1980:24>>*/ var
-        /*<<camlinternalFormat.ml:1980:24>>*/ j = wend + 1 | 0,
-       wend = j;
-      continue;
-     }
-      /*<<camlinternalFormat.ml:1989:19>>*/ var
-       /*<<camlinternalFormat.ml:1989:19>>*/ box_name =
-         /*<<camlinternalFormat.ml:1989:19>>*/ caml_call3
-         (Stdlib_String[15], str, wstart, wend - wstart | 0),
-       /*<<camlinternalFormat.ml:1990:17>>*/ nstart = parse_spaces(wend),
-      nend = nstart;
-      /*<<camlinternalFormat.ml:1983:6>>*/ for(;;){
-      a:
-      if(nend !== len){
-        /*<<camlinternalFormat.ml:1984:14>>*/  /*<<camlinternalFormat.ml:1984:14>>*/ var
-        match =
-           /*<<camlinternalFormat.ml:1984:14>>*/ caml_string_get(str, nend);
-       b:
-       {
-        if(48 <= match){
-         if(58 > match) break b;
-        }
-        else if(45 === match) break b;
-        break a;
-       }
-        /*<<camlinternalFormat.ml:1985:30>>*/ var
-         /*<<camlinternalFormat.ml:1985:30>>*/ j$0 = nend + 1 | 0,
-        nend = j$0;
-       continue;
-      }
-      if(nstart === nend)
-       var indent = 0;
-      else
-        /*<<camlinternalFormat.ml:1994:8>>*/ try{
-         /*<<camlinternalFormat.ml:1994:12>>*/ var
-          /*<<camlinternalFormat.ml:1994:12>>*/ _bs_ =
-            /*<<camlinternalFormat.ml:1994:12>>*/ runtime.caml_int_of_string
-            ( /*<<camlinternalFormat.ml:1994:26>>*/ caml_call3
-              (Stdlib_String[15], str, nstart, nend - nstart | 0)),
-         indent = _bs_;
-       }
-       catch(_bt_){
-        var _br_ = caml_wrap_exception(_bt_);
-        if(_br_[1] !== Stdlib[7]) throw caml_maybe_attach_backtrace(_br_, 0);
-        var indent = invalid_box(0);
-       }
-       /*<<camlinternalFormat.ml:1996:18>>*/  /*<<camlinternalFormat.ml:1996:18>>*/ var
-       exp_end = parse_spaces(nend);
-      if(exp_end !== len)
-        /*<<camlinternalFormat.ml:1997:27>>*/ invalid_box(0);
-      a:
-      {
-       if
-        (caml_string_notequal(box_name, cst$43)
-         && caml_string_notequal(box_name, "b")){
-        if(! caml_string_notequal(box_name, "h")){var box_type = 0; break a;}
-        if(! caml_string_notequal(box_name, "hov")){var box_type = 3; break a;}
-        if(! caml_string_notequal(box_name, "hv")){var box_type = 2; break a;}
-        if(caml_string_notequal(box_name, "v")){
-         var box_type = invalid_box(0);
-         break a;
-        }
-        var box_type = 1;
-        break a;
-       }
-       var box_type = 4;
-      }
-       /*<<camlinternalFormat.ml:2005:4>>*/ return [0, indent, box_type];
-     }
-    }
-    /*<<camlinternalFormat.ml:2005:22>>*/ }
-   function make_padding_fmt_ebb(pad, fmt){
-     /*<<camlinternalFormat.ml:2015:15>>*/ if(typeof pad === "number")
-      /*<<camlinternalFormat.ml:2016:26>>*/ return [0, 0, fmt];
-    if(0 === pad[0]){
-     var w = pad[2], s = pad[1];
-      /*<<camlinternalFormat.ml:2017:26>>*/ return [0, [0, s, w], fmt];
-    }
-    var s$0 = pad[1];
-     /*<<camlinternalFormat.ml:2018:26>>*/ return [0, [1, s$0], fmt];
-    /*<<camlinternalFormat.ml:2018:62>>*/ }
-   function make_padprec_fmt_ebb(pad, prec, fmt){
-     /*<<camlinternalFormat.ml:2038:2>>*/ if(typeof prec === "number")
-     var match = prec ? [0, 1, fmt] : [0, 0, fmt];
-    else
-     var p = prec[1], match = [0, [0, p], fmt];
-    var prec$0 = match[1];
-     /*<<camlinternalFormat.ml:2039:2>>*/ if(typeof pad === "number")
-      /*<<camlinternalFormat.ml:2040:26>>*/ return [0, 0, prec$0, fmt];
-     /*<<camlinternalFormat.ml:2039:2>>*/ if(0 === pad[0]){
-     var w = pad[2], s = pad[1];
-      /*<<camlinternalFormat.ml:2041:26>>*/ return [0, [0, s, w], prec$0, fmt];
-    }
-    var s$0 = pad[1];
-     /*<<camlinternalFormat.ml:2042:26>>*/ return [0, [1, s$0], prec$0, fmt];
-    /*<<camlinternalFormat.ml:2042:69>>*/ }
-   function fmt_ebb_of_string(legacy_behavior, str){
-     /*<<?>>*/ if(legacy_behavior)
-     var flag = legacy_behavior[1], legacy_behavior$0 = flag;
-    else
-     var legacy_behavior$0 = 1;
-    function invalid_format_message(str_ind, msg){
-      /*<<camlinternalFormat.ml:2084:4>>*/ return  /*<<camlinternalFormat.ml:2084:4>>*/ caml_call3
-             (failwith_message(_z_), str, str_ind, msg);
-     /*<<camlinternalFormat.ml:2086:21>>*/ }
-     /*<<camlinternalFormat.ml:2091:2>>*/ function unexpected_end_of_format
-    (end_ind){
-      /*<<camlinternalFormat.ml:2092:4>>*/ return invalid_format_message
-             (end_ind, cst_unexpected_end_of_format);
-     /*<<camlinternalFormat.ml:2093:32>>*/ }
-    function invalid_format_without(str_ind, c, s){
-      /*<<camlinternalFormat.ml:2104:4>>*/ return  /*<<camlinternalFormat.ml:2104:4>>*/ caml_call4
-             (failwith_message(_A_), str, str_ind, c, s);
-     /*<<camlinternalFormat.ml:2106:21>>*/ }
-    function expected_character(str_ind, expected, read){
-      /*<<camlinternalFormat.ml:2112:4>>*/ return  /*<<camlinternalFormat.ml:2112:4>>*/ caml_call4
-             (failwith_message(_B_), str, str_ind, expected, read);
-     /*<<camlinternalFormat.ml:2114:31>>*/ }
-    function add_literal(lit_start, str_ind, fmt){
-      /*<<camlinternalFormat.ml:2843:31>>*/ var
-      size = str_ind - lit_start | 0;
-     return 0 === size
-             ? [0, fmt]
-             : 1
-               === size
-               ? [0,
-                 [12,
-                   /*<<camlinternalFormat.ml:2845:37>>*/ caml_string_get
-                   (str, lit_start),
-                  fmt]]
-               : [0,
-                 [11,
-                   /*<<camlinternalFormat.ml:2846:39>>*/ caml_call3
-                   (Stdlib_String[15], str, lit_start, size),
-                  fmt]];
-     /*<<camlinternalFormat.ml:2846:75>>*/ }
-    function parse(lit_start, end_ind){
-      /*<<camlinternalFormat.ml:2119:25>>*/ var str_ind = lit_start;
-      /*<<camlinternalFormat.ml:2124:4>>*/ for(;;){
-      if(str_ind === end_ind)
-        /*<<camlinternalFormat.ml:2124:30>>*/ return add_literal
-               (lit_start, str_ind, 0);
-       /*<<camlinternalFormat.ml:2125:12>>*/  /*<<camlinternalFormat.ml:2125:12>>*/ var
-       match =
-          /*<<camlinternalFormat.ml:2125:12>>*/ caml_string_get(str, str_ind);
-      if(37 === match){
-       var str_ind$2 = str_ind + 1 | 0;
-       if(str_ind$2 === end_ind)
-         /*<<camlinternalFormat.ml:2141:30>>*/ unexpected_end_of_format
-         (end_ind);
-       var
-        match$1 =
-          95
-           ===
-             /*<<camlinternalFormat.ml:2142:10>>*/ caml_string_get
-             (str, str_ind$2)
-           ? parse_flags(str_ind, str_ind$2 + 1 | 0, end_ind, 1)
-           : parse_flags(str_ind, str_ind$2, end_ind, 0),
-        fmt_rest = match$1[1];
-        /*<<camlinternalFormat.ml:2128:8>>*/ return add_literal
-               (lit_start, str_ind, fmt_rest);
-      }
-      if(64 === match){
-       var str_ind$0 = str_ind + 1 | 0;
-       a:
-       if(str_ind$0 === end_ind)
-        var match$0 = _N_;
-       else{
-         /*<<camlinternalFormat.ml:2593:12>>*/  /*<<camlinternalFormat.ml:2593:12>>*/ var
-         c =
-            /*<<camlinternalFormat.ml:2593:12>>*/ caml_string_get
-            (str, str_ind$0);
-        if(65 <= c){
-         if(94 <= c){
-           /*<<camlinternalFormat.ml:2593:12>>*/  /*<<camlinternalFormat.ml:2593:12>>*/ var
-           switcher = c - 123 | 0;
-          if(2 >= switcher >>> 0)
-           switch(switcher){
-             case 0:
-              var match$0 = parse_tag(1, str_ind$0 + 1 | 0, end_ind); break a;
-             case 1: break;
-             default:
-              var
-               fmt_rest$2 = parse(str_ind$0 + 1 | 0, end_ind)[1],
-               match$0 = [0, [17, 1, fmt_rest$2]];
-              break a;
-           }
-         }
-         else if(91 <= c)
-          switch(c - 91 | 0){
-            case 0:
-             var match$0 = parse_tag(0, str_ind$0 + 1 | 0, end_ind); break a;
-            case 1: break;
-            default:
-             var
-              fmt_rest$3 = parse(str_ind$0 + 1 | 0, end_ind)[1],
-              match$0 = [0, [17, 0, fmt_rest$3]];
-             break a;
-          }
-        }
-        else{
-         if(10 === c){
-          var
-           fmt_rest$4 = parse(str_ind$0 + 1 | 0, end_ind)[1],
-           match$0 = [0, [17, 3, fmt_rest$4]];
-          break a;
-         }
-         if(32 <= c)
-          switch(c - 32 | 0){
-            case 0:
-             var
-              fmt_rest$5 = parse(str_ind$0 + 1 | 0, end_ind)[1],
-              match$0 = [0, [17, _O_, fmt_rest$5]];
-             break a;
-            case 5:
-              /*<<camlinternalFormat.ml:2626:42>>*/ if
-              ((str_ind$0 + 1 | 0) < end_ind
-               &&
-                37
-                ===
-                  /*<<camlinternalFormat.ml:2626:42>>*/ caml_string_get
-                  (str, str_ind$0 + 1 | 0)){
-              var
-               fmt_rest$6 = parse(str_ind$0 + 2 | 0, end_ind)[1],
-               match$0 = [0, [17, 6, fmt_rest$6]];
-              break a;
-             }
-             var
-              fmt_rest$7 = parse(str_ind$0, end_ind)[1],
-              match$0 = [0, [12, 64, fmt_rest$7]];
-             break a;
-            case 12:
-             var
-              fmt_rest$8 = parse(str_ind$0 + 1 | 0, end_ind)[1],
-              match$0 = [0, [17, _P_, fmt_rest$8]];
-             break a;
-            case 14:
-             var
-              fmt_rest$9 = parse(str_ind$0 + 1 | 0, end_ind)[1],
-              match$0 = [0, [17, 4, fmt_rest$9]];
-             break a;
-            case 27:
-             var str_ind$3 = str_ind$0 + 1 | 0;
-             b:
-             try{
-              var
-               _bg_ = str_ind$3 === end_ind ? 1 : 0,
-               _bh_ =
-                 _bg_
-                 ||
-                  (60
-                    !==
-                      /*<<camlinternalFormat.ml:2666:32>>*/ caml_string_get
-                      (str, str_ind$3)
-                    ? 1
-                    : 0);
-              if(_bh_)
-                /*<<camlinternalFormat.ml:2666:58>>*/ throw  /*<<camlinternalFormat.ml:2666:58>>*/ caml_maybe_attach_backtrace
-                      (Stdlib[8], 1);
-               /*<<camlinternalFormat.ml:2667:24>>*/ var
-                /*<<camlinternalFormat.ml:2667:24>>*/ str_ind_1 =
-                 parse_spaces(str_ind$3 + 1 | 0, end_ind),
-                /*<<camlinternalFormat.ml:2668:14>>*/ match$2 =
-                  /*<<camlinternalFormat.ml:2668:14>>*/ caml_string_get
-                  (str, str_ind_1);
-              c:
-              {
-               if(48 <= match$2){
-                if(58 > match$2) break c;
-               }
-               else if(45 === match$2) break c;
-                /*<<camlinternalFormat.ml:2684:15>>*/ throw  /*<<camlinternalFormat.ml:2684:15>>*/ caml_maybe_attach_backtrace
-                      (Stdlib[8], 1);
-              }
-               /*<<camlinternalFormat.ml:2670:33>>*/ var
-                /*<<camlinternalFormat.ml:2670:33>>*/ match$3 =
-                 parse_integer(str_ind_1, end_ind),
-               width = match$3[2],
-               str_ind_2 = match$3[1],
-                /*<<camlinternalFormat.ml:2671:28>>*/ str_ind_3 =
-                 parse_spaces(str_ind_2, end_ind),
-                /*<<camlinternalFormat.ml:2672:18>>*/ switcher$0 =
-                  /*<<camlinternalFormat.ml:2672:18>>*/ caml_string_get
-                  (str, str_ind_3)
-                 - 45
-                 | 0;
-              if(12 < switcher$0 >>> 0){
-               if(17 === switcher$0){
-                 /*<<camlinternalFormat.ml:2674:24>>*/ var
-                  /*<<camlinternalFormat.ml:2674:24>>*/ s =
-                    /*<<camlinternalFormat.ml:2674:24>>*/ caml_call3
-                    (Stdlib_String[15],
-                     str,
-                     str_ind$3 - 2 | 0,
-                     (str_ind_3 - str_ind$3 | 0) + 3 | 0),
-                  /*<<camlinternalFormat.ml:2675:31>>*/ _bi_ =
-                   [0, s, width, 0],
-                  /*<<camlinternalFormat.ml:2675:31>>*/ _bj_ =
-                   str_ind_3 + 1 | 0,
-                 formatting_lit$0 = _bi_,
-                 next_ind = _bj_;
-                break b;
-               }
-              }
-              else if(1 < switcher$0 - 1 >>> 0){
-                /*<<camlinternalFormat.ml:2677:40>>*/ var
-                 /*<<camlinternalFormat.ml:2677:40>>*/ match$4 =
-                  parse_integer(str_ind_3, end_ind),
-                offset = match$4[2],
-                str_ind_4 = match$4[1],
-                 /*<<camlinternalFormat.ml:2678:32>>*/ str_ind_5 =
-                  parse_spaces(str_ind_4, end_ind);
-               if
-                (62
-                 !==
-                   /*<<camlinternalFormat.ml:2679:19>>*/ caml_string_get
-                   (str, str_ind_5))
-                 /*<<camlinternalFormat.ml:2679:47>>*/ throw  /*<<camlinternalFormat.ml:2679:47>>*/ caml_maybe_attach_backtrace
-                       (Stdlib[8], 1);
-                /*<<camlinternalFormat.ml:2680:24>>*/ var
-                 /*<<camlinternalFormat.ml:2680:24>>*/ s$0 =
-                   /*<<camlinternalFormat.ml:2680:24>>*/ caml_call3
-                   (Stdlib_String[15],
-                    str,
-                    str_ind$3 - 2 | 0,
-                    (str_ind_5 - str_ind$3 | 0) + 3 | 0),
-                 /*<<camlinternalFormat.ml:2681:31>>*/ _bk_ =
-                  [0, s$0, width, offset],
-                 /*<<camlinternalFormat.ml:2681:31>>*/ _bl_ =
-                  str_ind_5 + 1 | 0,
-                formatting_lit$0 = _bk_,
-                next_ind = _bl_;
-               break b;
-              }
-               /*<<camlinternalFormat.ml:2682:21>>*/ throw  /*<<camlinternalFormat.ml:2682:21>>*/ caml_maybe_attach_backtrace
-                     (Stdlib[8], 1);
-             }
-             catch(_bq_){
-              var _bf_ = caml_wrap_exception(_bq_);
-              if(_bf_ !== Stdlib[8] && _bf_[1] !== Stdlib[7])
-               throw caml_maybe_attach_backtrace(_bf_, 0);
-              var formatting_lit$0 = formatting_lit, next_ind = str_ind$3;
-             }
-             var
-              fmt_rest$12 = parse(next_ind, end_ind)[1],
-              match$0 = [0, [17, formatting_lit$0, fmt_rest$12]];
-             break a;
-            case 28:
-             var str_ind$4 = str_ind$0 + 1 | 0;
-              /*<<camlinternalFormat.ml:2694:4>>*/ try{
-               /*<<camlinternalFormat.ml:2696:24>>*/ var
-                /*<<camlinternalFormat.ml:2696:24>>*/ str_ind_1$0 =
-                 parse_spaces(str_ind$4, end_ind),
-                /*<<camlinternalFormat.ml:2697:14>>*/ match$6 =
-                  /*<<camlinternalFormat.ml:2697:14>>*/ caml_string_get
-                  (str, str_ind_1$0);
-              b:
-              {
-               c:
-               {
-                if(48 <= match$6){
-                 if(58 > match$6) break c;
-                }
-                else if(45 === match$6) break c;
-                var _bo_ = 0;
-                break b;
-               }
-                /*<<camlinternalFormat.ml:2699:32>>*/ var
-                 /*<<camlinternalFormat.ml:2699:32>>*/ match$7 =
-                  parse_integer(str_ind_1$0, end_ind),
-                size = match$7[2],
-                str_ind_2$0 = match$7[1],
-                 /*<<camlinternalFormat.ml:2700:26>>*/ str_ind_3$0 =
-                  parse_spaces(str_ind_2$0, end_ind);
-               if
-                (62
-                 !==
-                   /*<<camlinternalFormat.ml:2701:13>>*/ caml_string_get
-                   (str, str_ind_3$0))
-                 /*<<camlinternalFormat.ml:2701:41>>*/ throw  /*<<camlinternalFormat.ml:2701:41>>*/ caml_maybe_attach_backtrace
-                       (Stdlib[8], 1);
-                /*<<camlinternalFormat.ml:2702:18>>*/ var
-                 /*<<camlinternalFormat.ml:2702:18>>*/ s$1 =
-                   /*<<camlinternalFormat.ml:2702:18>>*/ caml_call3
-                   (Stdlib_String[15],
-                    str,
-                    str_ind$4 - 2 | 0,
-                    (str_ind_3$0 - str_ind$4 | 0) + 3 | 0),
-                _bo_ = [0, [0, str_ind_3$0 + 1 | 0, [1, s$1, size]]];
-              }
-              var _bn_ = _bo_;
-             }
-             catch(_bp_){
-              var _bm_ = caml_wrap_exception(_bp_);
-              if(_bm_ !== Stdlib[8] && _bm_[1] !== Stdlib[7])
-               throw caml_maybe_attach_backtrace(_bm_, 0);
-              var _bn_ = 0;
-             }
-             if(_bn_)
-              var
-               match$5 = _bn_[1],
-               formatting_lit$1 = match$5[2],
-               next_ind$0 = match$5[1],
-               fmt_rest$13 = parse(next_ind$0, end_ind)[1],
-               _be_ = [0, [17, formatting_lit$1, fmt_rest$13]];
-             else
-              var
-               fmt_rest$14 = parse(str_ind$4, end_ind)[1],
-               _be_ = [0, [17, _Q_, fmt_rest$14]];
-             var match$0 = _be_;
-             break a;
-            case 31:
-             var
-              fmt_rest$10 = parse(str_ind$0 + 1 | 0, end_ind)[1],
-              match$0 = [0, [17, 2, fmt_rest$10]];
-             break a;
-            case 32:
-             var
-              fmt_rest$11 = parse(str_ind$0 + 1 | 0, end_ind)[1],
-              match$0 = [0, [17, 5, fmt_rest$11]];
-             break a;
-          }
-        }
-        var
-         fmt_rest$1 = parse(str_ind$0 + 1 | 0, end_ind)[1],
-         match$0 = [0, [17, [2, c], fmt_rest$1]];
-       }
-       var fmt_rest$0 = match$0[1];
-        /*<<camlinternalFormat.ml:2131:8>>*/ return add_literal
-               (lit_start, str_ind, fmt_rest$0);
-      }
-      var str_ind$1 = str_ind + 1 | 0, str_ind = str_ind$1;
-     }
-     /*<<camlinternalFormat.ml:2119:62>>*/ }
-    function parse_conversion
-    (pct_ind,
-     str_ind,
-     end_ind,
-     plus,
-     hash,
-     space,
-     ign,
-     pad,
-     prec,
-     padprec,
-     symb){
-      /*<<camlinternalFormat.ml:2295:21>>*/ var
-       /*<<camlinternalFormat.ml:2295:21>>*/ plus_used = [0, 0],
-       /*<<camlinternalFormat.ml:2295:47>>*/ hash_used = [0, 0],
-       /*<<camlinternalFormat.ml:2296:21>>*/ space_used = [0, 0],
-       /*<<camlinternalFormat.ml:2296:48>>*/ ign_used = [0, 0],
-       /*<<camlinternalFormat.ml:2297:21>>*/ pad_used = [0, 0],
-       /*<<camlinternalFormat.ml:2297:48>>*/ prec_used = [0, 0];
-     function get_plus(param){
-       /*<<camlinternalFormat.ml:2300:25>>*/ plus_used[1] = 1;
-       /*<<camlinternalFormat.ml:2300:4>>*/ return plus;
-      /*<<camlinternalFormat.ml:2300:49>>*/ }
-     function get_hash(param){
-       /*<<camlinternalFormat.ml:2301:24>>*/ hash_used[1] = 1;
-      return hash;
-      /*<<camlinternalFormat.ml:2301:47>>*/ }
-     function get_space(param){
-       /*<<camlinternalFormat.ml:2302:25>>*/ space_used[1] = 1;
-      return space;
-      /*<<camlinternalFormat.ml:2302:50>>*/ }
-     function get_ign(param){
-       /*<<camlinternalFormat.ml:2303:25>>*/ ign_used[1] = 1;
-      return ign;
-      /*<<camlinternalFormat.ml:2303:48>>*/ }
-     function get_pad(param){
-       /*<<camlinternalFormat.ml:2304:25>>*/ pad_used[1] = 1;
-      return pad;
-      /*<<camlinternalFormat.ml:2304:48>>*/ }
-     function get_prec(param){
-       /*<<camlinternalFormat.ml:2305:25>>*/ prec_used[1] = 1;
-      return prec;
-      /*<<camlinternalFormat.ml:2305:49>>*/ }
-     function get_padprec(param){
-       /*<<camlinternalFormat.ml:2306:25>>*/ pad_used[1] = 1;
-      return padprec;
-      /*<<camlinternalFormat.ml:2306:52>>*/ }
-     function get_int_pad(param){
-       /*<<camlinternalFormat.ml:2320:7>>*/ var
-        /*<<camlinternalFormat.ml:2320:13>>*/ pad = get_pad(0),
-        /*<<camlinternalFormat.ml:2320:25>>*/ match = get_prec(0);
-       /*<<camlinternalFormat.ml:2320:25>>*/ if
-       (typeof match === "number" && ! match)
-        /*<<camlinternalFormat.ml:2321:32>>*/ return pad;
-      if(typeof pad === "number")
-        /*<<camlinternalFormat.ml:2322:32>>*/ return 0;
-      if(0 !== pad[0])
-       return 2 <= pad[1]
-               ? legacy_behavior$0
-                 ? _H_
-                 : incompatible_flag(pct_ind, str_ind, 48, cst_precision$1)
-               : pad;
-      if(2 > pad[1])  /*<<camlinternalFormat.ml:2329:38>>*/ return pad;
-      var n = pad[2];
-       /*<<camlinternalFormat.ml:2324:11>>*/ return legacy_behavior$0
-              ? [0, 1, n]
-              : incompatible_flag(pct_ind, str_ind, 48, cst_precision$0);
-      /*<<camlinternalFormat.ml:2330:41>>*/ }
-     function check_no_0(symb, pad){
-       /*<<camlinternalFormat.ml:2334:6>>*/ if(typeof pad === "number")
-        /*<<camlinternalFormat.ml:2335:22>>*/ return pad;
-      if(0 !== pad[0])
-       return 2 <= pad[1]
-               ? legacy_behavior$0
-                 ? _I_
-                 : incompatible_flag(pct_ind, str_ind, symb, cst_0$1)
-               : pad;
-      if(2 > pad[1])  /*<<camlinternalFormat.ml:2336:43>>*/ return pad;
-      var width = pad[2];
-       /*<<camlinternalFormat.ml:2339:8>>*/ return legacy_behavior$0
-              ? [0, 1, width]
-              : incompatible_flag(pct_ind, str_ind, symb, cst_0$0);
-      /*<<camlinternalFormat.ml:2343:55>>*/ }
-     function opt_of_pad(c, pad){
-       /*<<camlinternalFormat.ml:2349:64>>*/ if(typeof pad === "number")
-        /*<<camlinternalFormat.ml:2350:22>>*/ return 0;
-      if(0 === pad[0])
-       switch(pad[1]){
-         case 0:
-          var width = pad[2];
-           /*<<camlinternalFormat.ml:2356:8>>*/ return legacy_behavior$0
-                  ? [0, width]
-                  : incompatible_flag(pct_ind, str_ind, c, cst$24);
-         case 1:
-          var width$0 = pad[2];
-           /*<<camlinternalFormat.ml:2351:38>>*/ return [0, width$0];
-         default:
-          var width$1 = pad[2];
-           /*<<camlinternalFormat.ml:2353:8>>*/ return legacy_behavior$0
-                  ? [0, width$1]
-                  : incompatible_flag(pct_ind, str_ind, c, cst_0$2);
-       }
-       /*<<camlinternalFormat.ml:2358:25>>*/ return incompatible_flag
-              (pct_ind, str_ind, c, cst$25);
-      /*<<camlinternalFormat.ml:2358:66>>*/ }
-     function get_pad_opt(c){
-       /*<<camlinternalFormat.ml:2360:24>>*/ return opt_of_pad(c, get_pad(0));
-      /*<<camlinternalFormat.ml:2360:49>>*/ }
-     function get_padprec_opt(c){
-       /*<<camlinternalFormat.ml:2361:28>>*/ return opt_of_pad
-              (c, get_padprec(0));
-      /*<<camlinternalFormat.ml:2361:57>>*/ }
-     a:
-     {
-       /*<<camlinternalFormat.ml:2372:4>>*/ if(124 > symb)
-       switch(symb){
-         case 33:
-          var
-           fmt_rest$5 = parse(str_ind, end_ind)[1],
-           fmt_result = [0, [10, fmt_rest$5]];
-          break a;
-         case 40:
-           /*<<camlinternalFormat.ml:2531:20>>*/ var
-            /*<<camlinternalFormat.ml:2531:20>>*/ sub_end =
-             search_subformat_end(str_ind, end_ind, 41),
-           fmt_rest$7 = parse(sub_end + 2 | 0, end_ind)[1],
-           sub_fmt = parse(str_ind, sub_end)[1],
-            /*<<camlinternalFormat.ml:2534:22>>*/ sub_fmtty =
-             fmtty_of_fmt(sub_fmt);
-           /*<<camlinternalFormat.ml:2535:9>>*/ if(get_ign(0))
-            /*<<camlinternalFormat.ml:2536:22>>*/ var
-             /*<<camlinternalFormat.ml:2536:22>>*/ ignored$2 =
-              [9, get_pad_opt(95), sub_fmtty],
-            _aN_ = [0, [23, ignored$2, fmt_rest$7]];
-          else
-           var _aN_ = [0, [14, get_pad_opt(40), sub_fmtty, fmt_rest$7]];
-          var fmt_result = _aN_;
-          break a;
-         case 44:
-          var fmt_result = parse(str_ind, end_ind); break a;
-         case 67:
-           /*<<camlinternalFormat.ml:2397:9>>*/ var
-           fmt_rest$10 = parse(str_ind, end_ind)[1],
-            /*<<camlinternalFormat.ml:2397:9>>*/ _aP_ =
-             get_ign(0) ? [0, [23, 1, fmt_rest$10]] : [0, [1, fmt_rest$10]],
-           fmt_result = _aP_;
-          break a;
-         case 78:
-          var fmt_rest$14 = parse(str_ind, end_ind)[1], counter$0 = 2;
-           /*<<camlinternalFormat.ml:2433:9>>*/ if(get_ign(0))
-            /*<<camlinternalFormat.ml:2434:22>>*/ var
-             /*<<camlinternalFormat.ml:2434:22>>*/ ignored$6 = [11, counter$0],
-            _aV_ = [0, [23, ignored$6, fmt_rest$14]];
-          else
-           var _aV_ = [0, [21, counter$0, fmt_rest$14]];
-          var fmt_result = _aV_;
-          break a;
-         case 83:
-           /*<<camlinternalFormat.ml:2410:16>>*/ var
-            /*<<camlinternalFormat.ml:2410:16>>*/ pad$6 =
-             check_no_0(symb, get_padprec(0)),
-           fmt_rest$15 = parse(str_ind, end_ind)[1];
-           /*<<camlinternalFormat.ml:2412:9>>*/ if(get_ign(0))
-            /*<<camlinternalFormat.ml:2413:22>>*/ var
-             /*<<camlinternalFormat.ml:2413:22>>*/ ignored$7 =
-              [1, get_padprec_opt(95)],
-            _aW_ = [0, [23, ignored$7, fmt_rest$15]];
-          else
-            /*<<camlinternalFormat.ml:2417:10>>*/ var
-             /*<<camlinternalFormat.ml:2417:10>>*/ match$5 =
-              make_padding_fmt_ebb(pad$6, fmt_rest$15),
-            fmt_rest$16 = match$5[2],
-            pad$7 = match$5[1],
-            _aW_ = [0, [3, pad$7, fmt_rest$16]];
-          var fmt_result = _aW_;
-          break a;
-         case 91:
-          if(str_ind === end_ind)
-            /*<<camlinternalFormat.ml:2717:30>>*/ unexpected_end_of_format
-            (end_ind);
-           /*<<camlinternalFormat.ml:2719:19>>*/ var
-            /*<<camlinternalFormat.ml:2719:19>>*/ char_set =
-             create_char_set(0),
-           add_char =
-             function(c){
-               /*<<camlinternalFormat.ml:2721:6>>*/ return add_in_char_set
-                      (char_set, c);
-              /*<<camlinternalFormat.ml:2721:32>>*/ },
-           add_range =
-             function(c$0, c){
-               /*<<camlinternalFormat.ml:2724:6>>*/ if(c >= c$0){
-               var i = c$0;
-               for(;;){
-                 /*<<camlinternalFormat.ml:2725:8>>*/ add_in_char_set
-                 (char_set,
-                   /*<<camlinternalFormat.ml:2725:33>>*/ caml_call1
-                   (Stdlib[29], i));
-                 /*<<camlinternalFormat.ml:2725:8>>*/  /*<<camlinternalFormat.ml:2725:8>>*/ var
-                 _bd_ = i + 1 | 0;
-                if(c === i) break;
-                var i = _bd_;
-               }
-              }
-              return 0;
-              /*<<camlinternalFormat.ml:2726:10>>*/ },
-           fail_single_percent =
-             function(str_ind){
-               /*<<camlinternalFormat.ml:2730:6>>*/ return  /*<<camlinternalFormat.ml:2730:6>>*/ caml_call2
-                      (failwith_message(_R_), str, str_ind);
-              /*<<camlinternalFormat.ml:2732:54>>*/ },
-           parse_char_set_content =
-             function(counter, str_ind, end_ind){
-               /*<<camlinternalFormat.ml:2743:6>>*/ var str_ind$0 = str_ind;
-               /*<<camlinternalFormat.ml:2743:6>>*/ for(;;){
-               if(str_ind$0 === end_ind)
-                 /*<<camlinternalFormat.ml:2743:32>>*/ unexpected_end_of_format
-                 (end_ind);
-                /*<<camlinternalFormat.ml:2744:12>>*/  /*<<camlinternalFormat.ml:2744:12>>*/ var
-                c =
-                   /*<<camlinternalFormat.ml:2744:12>>*/ caml_string_get
-                   (str, str_ind$0);
-               if(45 !== c){
-                if(93 === c)
-                  /*<<camlinternalFormat.ml:2746:8>>*/ return str_ind$0 + 1
-                        | 0;
-                var _bc_ = str_ind$0 + 1 | 0;
-                 /*<<camlinternalFormat.ml:2751:8>>*/ if(counter >= 50)
-                  /*<<camlinternalFormat.ml:2751:8>>*/ return  /*<<camlinternalFormat.ml:2751:8>>*/ caml_trampoline_return
-                         (parse_char_set_after_char$0, [0, _bc_, end_ind, c]);
-                var counter$0 = counter + 1 | 0;
-                 /*<<camlinternalFormat.ml:2751:8>>*/ return parse_char_set_after_char$0
-                        (counter$0, _bc_, end_ind, c);
-               }
-                /*<<camlinternalFormat.ml:2748:8>>*/ add_char(45);
-               var str_ind$1 = str_ind$0 + 1 | 0, str_ind$0 = str_ind$1;
-              }
-              /*<<camlinternalFormat.ml:2751:57>>*/ },
-           parse_char_set_after_char$0 =
-             function(counter, str_ind, end_ind, c){
-               /*<<camlinternalFormat.ml:2755:6>>*/ var
-               str_ind$0 = str_ind,
-               c$0 = c;
-               /*<<camlinternalFormat.ml:2755:6>>*/ for(;;){
-               if(str_ind$0 === end_ind)
-                 /*<<camlinternalFormat.ml:2755:32>>*/ unexpected_end_of_format
-                 (end_ind);
-                /*<<camlinternalFormat.ml:2756:12>>*/  /*<<camlinternalFormat.ml:2756:12>>*/ var
-                c$1 =
-                   /*<<camlinternalFormat.ml:2756:12>>*/ caml_string_get
-                   (str, str_ind$0);
-               a:
-               {
-                if(46 <= c$1){
-                 if(64 !== c$1){
-                  if(93 !== c$1) break a;
-                   /*<<camlinternalFormat.ml:2758:8>>*/ add_char(c$0);
-                   /*<<camlinternalFormat.ml:2758:8>>*/ return str_ind$0 + 1
-                         | 0;
-                 }
-                }
-                else if(37 !== c$1){
-                 if(45 > c$1) break a;
-                 var str_ind$2 = str_ind$0 + 1 | 0;
-                 if(str_ind$2 === end_ind)
-                   /*<<camlinternalFormat.ml:2775:32>>*/ unexpected_end_of_format
-                   (end_ind);
-                  /*<<camlinternalFormat.ml:2776:12>>*/  /*<<camlinternalFormat.ml:2776:12>>*/ var
-                  c$2 =
-                     /*<<camlinternalFormat.ml:2776:12>>*/ caml_string_get
-                     (str, str_ind$2);
-                 if(37 === c$2){
-                  if((str_ind$2 + 1 | 0) === end_ind)
-                    /*<<camlinternalFormat.ml:2782:38>>*/ unexpected_end_of_format
-                    (end_ind);
-                   /*<<camlinternalFormat.ml:2783:20>>*/  /*<<camlinternalFormat.ml:2783:20>>*/ var
-                   c$3 =
-                      /*<<camlinternalFormat.ml:2783:20>>*/ caml_string_get
-                      (str, str_ind$2 + 1 | 0);
-                  if(37 !== c$3 && 64 !== c$3)
-                    /*<<camlinternalFormat.ml:2787:17>>*/ return fail_single_percent
-                           (str_ind$2);
-                   /*<<camlinternalFormat.ml:2785:12>>*/ add_range(c$0, c$3);
-                  var _ba_ = str_ind$2 + 2 | 0;
-                   /*<<camlinternalFormat.ml:2785:12>>*/ if(counter >= 50)
-                    /*<<camlinternalFormat.ml:2785:12>>*/ return  /*<<camlinternalFormat.ml:2785:12>>*/ caml_trampoline_return
-                           (parse_char_set_content, [0, _ba_, end_ind]);
-                  var counter$2 = counter + 1 | 0;
-                   /*<<camlinternalFormat.ml:2785:12>>*/ return parse_char_set_content
-                          (counter$2, _ba_, end_ind);
-                 }
-                 if(93 === c$2){
-                   /*<<camlinternalFormat.ml:2778:8>>*/ add_char(c$0);
-                   /*<<camlinternalFormat.ml:2779:8>>*/ add_char(45);
-                   /*<<camlinternalFormat.ml:2779:8>>*/ return str_ind$2 + 1
-                         | 0;
-                 }
-                  /*<<camlinternalFormat.ml:2790:8>>*/ add_range(c$0, c$2);
-                 var _bb_ = str_ind$2 + 1 | 0;
-                  /*<<camlinternalFormat.ml:2790:8>>*/ if(counter >= 50)
-                   /*<<camlinternalFormat.ml:2790:8>>*/ return  /*<<camlinternalFormat.ml:2790:8>>*/ caml_trampoline_return
-                          (parse_char_set_content, [0, _bb_, end_ind]);
-                 var counter$1 = counter + 1 | 0;
-                  /*<<camlinternalFormat.ml:2790:8>>*/ return parse_char_set_content
-                         (counter$1, _bb_, end_ind);
-                }
-                if(37 === c$0){
-                  /*<<camlinternalFormat.ml:2763:8>>*/ add_char(c$1);
-                 var _a$_ = str_ind$0 + 1 | 0;
-                  /*<<camlinternalFormat.ml:2763:8>>*/ if(counter >= 50)
-                   /*<<camlinternalFormat.ml:2763:8>>*/ return  /*<<camlinternalFormat.ml:2763:8>>*/ caml_trampoline_return
-                          (parse_char_set_content, [0, _a$_, end_ind]);
-                 var counter$0 = counter + 1 | 0;
-                  /*<<camlinternalFormat.ml:2763:8>>*/ return parse_char_set_content
-                         (counter$0, _a$_, end_ind);
-                }
-               }
-               if(37 === c$0)
-                 /*<<camlinternalFormat.ml:2766:24>>*/ fail_single_percent
-                 (str_ind$0);
-                /*<<camlinternalFormat.ml:2770:8>>*/ add_char(c$0);
-               var
-                str_ind$1 = str_ind$0 + 1 | 0,
-                str_ind$0 = str_ind$1,
-                c$0 = c$1;
-              }
-              /*<<camlinternalFormat.ml:2771:58>>*/ },
-           parse_char_set_after_char =
-             function(str_ind, end_ind, c){
-               /*<<?>>*/ return caml_trampoline
-                      (parse_char_set_after_char$0(0, str_ind, end_ind, c));
-             };
-          if(str_ind === end_ind)
-            /*<<camlinternalFormat.ml:2794:32>>*/ unexpected_end_of_format
-            (end_ind);
-          if
-           (94
-            ===
-              /*<<camlinternalFormat.ml:2795:12>>*/ caml_string_get
-              (str, str_ind))
-           var
-            str_ind$0 = str_ind + 1 | 0,
-            reverse = 1,
-            str_ind$1 = str_ind$0;
-          else
-           var reverse = 0, str_ind$1 = str_ind;
-          if(str_ind$1 === end_ind)
-            /*<<camlinternalFormat.ml:2737:32>>*/ unexpected_end_of_format
-            (end_ind);
-           /*<<camlinternalFormat.ml:2738:14>>*/ var
-            /*<<camlinternalFormat.ml:2738:14>>*/ c =
-              /*<<camlinternalFormat.ml:2738:14>>*/ caml_string_get
-              (str, str_ind$1),
-            /*<<camlinternalFormat.ml:2739:6>>*/ next_ind =
-             parse_char_set_after_char(str_ind$1 + 1 | 0, end_ind, c),
-            /*<<camlinternalFormat.ml:2799:19>>*/ char_set$0 =
-             freeze_char_set(char_set),
-            /*<<camlinternalFormat.ml:2800:4>>*/ char_set$1 =
-             reverse ? rev_char_set(char_set$0) : char_set$0,
-           fmt_rest$19 = parse(next_ind, end_ind)[1];
-           /*<<camlinternalFormat.ml:2543:9>>*/ if(get_ign(0))
-            /*<<camlinternalFormat.ml:2544:22>>*/ var
-             /*<<camlinternalFormat.ml:2544:22>>*/ ignored$9 =
-              [10, get_pad_opt(95), char_set$1],
-            _a1_ = [0, [23, ignored$9, fmt_rest$19]];
-          else
-           var _a1_ = [0, [20, get_pad_opt(91), char_set$1, fmt_rest$19]];
-          var fmt_result = _a1_;
-          break a;
-         case 97:
-          var
-           fmt_rest$20 = parse(str_ind, end_ind)[1],
-           fmt_result = [0, [15, fmt_rest$20]];
-          break a;
-         case 99:
-           /*<<camlinternalFormat.ml:2387:18>>*/ var
-           char_format =
-             function(fmt_rest){
-               /*<<camlinternalFormat.ml:2377:8>>*/ return get_ign(0)
-                      ? [0, [23, 0, fmt_rest]]
-                      : [0, [0, fmt_rest]];
-              /*<<camlinternalFormat.ml:2379:36>>*/ },
-           fmt_rest$21 = parse(str_ind, end_ind)[1],
-            /*<<camlinternalFormat.ml:2387:18>>*/ match$7 = get_pad_opt(99);
-          if(match$7){
-           if(0 === match$7[1])
-             /*<<camlinternalFormat.ml:2382:11>>*/ var
-              /*<<camlinternalFormat.ml:2382:11>>*/ _a2_ =
-               get_ign(0) ? [0, [23, 3, fmt_rest$21]] : [0, [22, fmt_rest$21]],
-             _a3_ = _a2_;
-           else
-            var
-             _a3_ =
-               legacy_behavior$0
-                ? char_format(fmt_rest$21)
-                : invalid_format_message
-                  (str_ind, cst_non_zero_widths_are_unsupp);
-           var _a4_ = _a3_;
-          }
-          else
-           var _a4_ = char_format(fmt_rest$21);
-          var fmt_result = _a4_;
-          break a;
-         case 114:
-           /*<<camlinternalFormat.ml:2512:9>>*/ var
-           fmt_rest$22 = parse(str_ind, end_ind)[1],
-            /*<<camlinternalFormat.ml:2512:9>>*/ _a5_ =
-             get_ign(0) ? [0, [23, 2, fmt_rest$22]] : [0, [19, fmt_rest$22]],
-           fmt_result = _a5_;
-          break a;
-         case 115:
-           /*<<camlinternalFormat.ml:2400:16>>*/ var
-            /*<<camlinternalFormat.ml:2400:16>>*/ pad$9 =
-             check_no_0(symb, get_padprec(0)),
-           fmt_rest$23 = parse(str_ind, end_ind)[1];
-           /*<<camlinternalFormat.ml:2402:9>>*/ if(get_ign(0))
-            /*<<camlinternalFormat.ml:2403:22>>*/ var
-             /*<<camlinternalFormat.ml:2403:22>>*/ ignored$10 =
-              [0, get_padprec_opt(95)],
-            _a6_ = [0, [23, ignored$10, fmt_rest$23]];
-          else
-            /*<<camlinternalFormat.ml:2407:10>>*/ var
-             /*<<camlinternalFormat.ml:2407:10>>*/ match$8 =
-              make_padding_fmt_ebb(pad$9, fmt_rest$23),
-            fmt_rest$24 = match$8[2],
-            pad$10 = match$8[1],
-            _a6_ = [0, [2, pad$10, fmt_rest$24]];
-          var fmt_result = _a6_;
-          break a;
-         case 116:
-          var
-           fmt_rest$25 = parse(str_ind, end_ind)[1],
-           fmt_result = [0, [16, fmt_rest$25]];
-          break a;
-         case 123:
-           /*<<camlinternalFormat.ml:2521:20>>*/ var
-            /*<<camlinternalFormat.ml:2521:20>>*/ sub_end$0 =
-             search_subformat_end(str_ind, end_ind, 125),
-           sub_fmt$0 = parse(str_ind, sub_end$0)[1],
-           fmt_rest$26 = parse(sub_end$0 + 2 | 0, end_ind)[1],
-            /*<<camlinternalFormat.ml:2524:22>>*/ sub_fmtty$0 =
-             fmtty_of_fmt(sub_fmt$0);
-           /*<<camlinternalFormat.ml:2525:9>>*/ if(get_ign(0))
-            /*<<camlinternalFormat.ml:2526:22>>*/ var
-             /*<<camlinternalFormat.ml:2526:22>>*/ ignored$11 =
-              [8, get_pad_opt(95), sub_fmtty$0],
-            _a7_ = [0, [23, ignored$11, fmt_rest$26]];
-          else
-           var _a7_ = [0, [13, get_pad_opt(123), sub_fmtty$0, fmt_rest$26]];
-          var fmt_result = _a7_;
-          break a;
-         case 66:
-         case 98:
-           /*<<camlinternalFormat.ml:2495:16>>*/ var
-            /*<<camlinternalFormat.ml:2495:16>>*/ pad$3 =
-             check_no_0(symb, get_padprec(0)),
-           fmt_rest$8 = parse(str_ind, end_ind)[1];
-           /*<<camlinternalFormat.ml:2497:9>>*/ if(get_ign(0))
-            /*<<camlinternalFormat.ml:2498:22>>*/ var
-             /*<<camlinternalFormat.ml:2498:22>>*/ ignored$3 =
-              [7, get_padprec_opt(95)],
-            _aO_ = [0, [23, ignored$3, fmt_rest$8]];
-          else
-            /*<<camlinternalFormat.ml:2502:10>>*/ var
-             /*<<camlinternalFormat.ml:2502:10>>*/ match$3 =
-              make_padding_fmt_ebb(pad$3, fmt_rest$8),
-            fmt_rest$9 = match$3[2],
-            pad$4 = match$3[1],
-            _aO_ = [0, [9, pad$4, fmt_rest$9]];
-          var fmt_result = _aO_;
-          break a;
-         case 37:
-         case 64:
-          var
-           fmt_rest$6 = parse(str_ind, end_ind)[1],
-           fmt_result = [0, [12, symb, fmt_rest$6]];
-          break a;
-         case 76:
-         case 108:
-         case 110:
-          if(str_ind !== end_ind){
-            /*<<camlinternalFormat.ml:2438:63>>*/ var
-             /*<<camlinternalFormat.ml:2438:63>>*/ symb$0 =
-               /*<<camlinternalFormat.ml:2438:63>>*/ caml_string_get
-               (str, str_ind),
-             /*<<camlinternalFormat.ml:2892:25>>*/ _a8_ = symb$0 - 88 | 0;
-           b:
-           {
-            if(32 >= _a8_ >>> 0)
-             switch(_a8_){
-               case 0:
-               case 12:
-               case 17:
-               case 23:
-               case 29:
-               case 32:
-                var _aU_ = 1; break b;
-             }
-            var _aU_ = 0;
-           }
-            /*<<camlinternalFormat.ml:2438:50>>*/ if(_aU_) break;
-          }
-          var fmt_rest$13 = parse(str_ind, end_ind)[1];
-          b:
-          {
-           if(108 <= symb){
-            if(111 > symb)
-             switch(symb - 108 | 0){
-               case 0:
-                var counter = 0; break b;
-               case 1: break;
-               default: var counter = 1; break b;
-             }
-           }
-           else if(76 === symb){var counter = 2; break b;}
-            /*<<camlinternalFormat.ml:2899:34>>*/ throw  /*<<camlinternalFormat.ml:2899:34>>*/ caml_maybe_attach_backtrace
-                  ([0, Assert_failure, _V_], 1);
-          }
-           /*<<camlinternalFormat.ml:2441:9>>*/ if(get_ign(0))
-            /*<<camlinternalFormat.ml:2442:22>>*/ var
-             /*<<camlinternalFormat.ml:2442:22>>*/ ignored$5 = [11, counter],
-            _aT_ = [0, [23, ignored$5, fmt_rest$13]];
-          else
-           var _aT_ = [0, [21, counter, fmt_rest$13]];
-          var fmt_result = _aT_;
-          break a;
-         case 32:
-         case 35:
-         case 43:
-         case 45:
-         case 95:
-          var
-           fmt_result =
-              /*<<camlinternalFormat.ml:2549:6>>*/ caml_call3
-              (failwith_message(_M_), str, pct_ind, symb);
-          break a;
-         case 88:
-         case 100:
-         case 105:
-         case 111:
-         case 117:
-         case 120:
-           /*<<camlinternalFormat.ml:2421:8>>*/ var
-            /*<<camlinternalFormat.ml:2421:8>>*/ _aX_ = get_space(0),
-            /*<<camlinternalFormat.ml:2420:65>>*/ _aY_ = get_hash(0),
-            /*<<camlinternalFormat.ml:2420:18>>*/ iconv$2 =
-             compute_int_conv(pct_ind, str_ind, get_plus(0), _aY_, _aX_, symb),
-           fmt_rest$17 = parse(str_ind, end_ind)[1];
-           /*<<camlinternalFormat.ml:2423:9>>*/ if(get_ign(0))
-            /*<<camlinternalFormat.ml:2424:22>>*/ var
-             /*<<camlinternalFormat.ml:2424:22>>*/ ignored$8 =
-              [2, iconv$2, get_pad_opt(95)],
-            _aZ_ = [0, [23, ignored$8, fmt_rest$17]];
-          else
-            /*<<camlinternalFormat.ml:2428:48>>*/ var
-             /*<<camlinternalFormat.ml:2428:48>>*/ _a0_ = get_prec(0),
-             /*<<camlinternalFormat.ml:2428:10>>*/ match$6 =
-              make_padprec_fmt_ebb(get_int_pad(0), _a0_, fmt_rest$17),
-            fmt_rest$18 = match$6[3],
-            prec$4 = match$6[2],
-            pad$8 = match$6[1],
-            _aZ_ = [0, [4, iconv$2, pad$8, prec$4, fmt_rest$18]];
-          var fmt_result = _aZ_;
-          break a;
-         case 69:
-         case 70:
-         case 71:
-         case 72:
-         case 101:
-         case 102:
-         case 103:
-         case 104:
-           /*<<camlinternalFormat.ml:2485:38>>*/ var
-            /*<<camlinternalFormat.ml:2485:38>>*/ space$1 = get_space(0),
-            /*<<camlinternalFormat.ml:2485:24>>*/ hash$1 = get_hash(0),
-            /*<<camlinternalFormat.ml:2485:10>>*/ plus$2 = get_plus(0),
-           flag =
-             plus$2
-              ? space$1
-                ? legacy_behavior$0
-                  ? 1
-                  : incompatible_flag(pct_ind, str_ind, 32, cst$36)
-                : 1
-              : space$1 ? 2 : 0;
-          b:
-          {
-           c:
-           if(73 <= symb){
-            var switcher = symb - 101 | 0;
-            if(3 >= switcher >>> 0){
-             switch(switcher){
-               case 0:
-                var _a9_ = 1; break;
-               case 1:
-                var _a9_ = 0; break;
-               case 2:
-                var _a9_ = 3; break;
-               default: var _a9_ = 6;
-             }
-             var kind = _a9_;
-             break b;
-            }
-           }
-           else if(69 <= symb){
-            switch(symb - 69 | 0){
-              case 0:
-               var _a__ = 2; break;
-              case 1:
-               break c;
-              case 2:
-               var _a__ = 4; break;
-              default: var _a__ = 7;
-            }
-            var kind = _a__;
-            break b;
-           }
-           if(hash$1){
-            if(70 === symb){var kind = 8; break b;}
-           }
-           else if(70 === symb){var kind = 5; break b;}
-            /*<<camlinternalFormat.ml:2957:11>>*/ throw  /*<<camlinternalFormat.ml:2957:11>>*/ caml_maybe_attach_backtrace
-                  ([0, Assert_failure, _X_], 1);
-          }
-           /*<<camlinternalFormat.ml:2958:4>>*/ var
-            /*<<camlinternalFormat.ml:2958:4>>*/ fconv = [0, flag, kind],
-           fmt_rest$11 = parse(str_ind, end_ind)[1];
-           /*<<camlinternalFormat.ml:2487:9>>*/ if(get_ign(0)){
-            /*<<camlinternalFormat.ml:2366:32>>*/  /*<<camlinternalFormat.ml:2366:32>>*/ var
-            match = get_prec(0);
-           if(typeof match === "number")
-            var
-             _aQ_ =
-               match ? incompatible_flag(pct_ind, str_ind, 95, cst$26) : 0;
-           else
-            var ndec = match[1], _aQ_ = [0, ndec];
-            /*<<camlinternalFormat.ml:2488:22>>*/ var
-             /*<<camlinternalFormat.ml:2488:22>>*/ ignored$4 =
-              [6, get_pad_opt(95), _aQ_],
-            _aR_ = [0, [23, ignored$4, fmt_rest$11]];
-          }
-          else
-            /*<<camlinternalFormat.ml:2492:44>>*/ var
-             /*<<camlinternalFormat.ml:2492:44>>*/ _aS_ = get_prec(0),
-             /*<<camlinternalFormat.ml:2492:10>>*/ match$4 =
-              make_padprec_fmt_ebb(get_pad(0), _aS_, fmt_rest$11),
-            fmt_rest$12 = match$4[3],
-            prec$3 = match$4[2],
-            pad$5 = match$4[1],
-            _aR_ = [0, [8, fconv, pad$5, prec$3, fmt_rest$12]];
-          var fmt_result = _aR_;
-          break a;
-       }
-      b:
-      if(108 <= symb){
-       if(111 > symb){
-        switch(symb - 108 | 0){
-          case 0:
-            /*<<camlinternalFormat.ml:2449:25>>*/ var
-             /*<<camlinternalFormat.ml:2449:25>>*/ _ax_ =
-               /*<<camlinternalFormat.ml:2449:25>>*/ caml_string_get
-               (str, str_ind),
-             /*<<camlinternalFormat.ml:2449:10>>*/ _ay_ = get_space(0),
-             /*<<camlinternalFormat.ml:2448:61>>*/ _az_ = get_hash(0),
-             /*<<camlinternalFormat.ml:2448:8>>*/ iconv =
-              compute_int_conv
-               (pct_ind, str_ind + 1 | 0, get_plus(0), _az_, _ay_, _ax_),
-            fmt_rest = parse(str_ind + 1 | 0, end_ind)[1];
-            /*<<camlinternalFormat.ml:2451:9>>*/ if(get_ign(0))
-             /*<<camlinternalFormat.ml:2452:22>>*/ var
-              /*<<camlinternalFormat.ml:2452:22>>*/ ignored =
-               [3, iconv, get_pad_opt(95)],
-             _aA_ = [0, [23, ignored, fmt_rest]];
-           else
-             /*<<camlinternalFormat.ml:2456:48>>*/ var
-              /*<<camlinternalFormat.ml:2456:48>>*/ _aC_ = get_prec(0),
-              /*<<camlinternalFormat.ml:2456:10>>*/ match$0 =
-               make_padprec_fmt_ebb(get_int_pad(0), _aC_, fmt_rest),
-             fmt_rest$0 = match$0[3],
-             prec$0 = match$0[2],
-             pad$0 = match$0[1],
-             _aA_ = [0, [5, iconv, pad$0, prec$0, fmt_rest$0]];
-           var _aB_ = _aA_;
-           break;
-          case 1:
-           break b;
-          default:
-            /*<<camlinternalFormat.ml:2461:39>>*/ var
-             /*<<camlinternalFormat.ml:2461:39>>*/ _aD_ =
-               /*<<camlinternalFormat.ml:2461:39>>*/ caml_string_get
-               (str, str_ind),
-             /*<<camlinternalFormat.ml:2461:24>>*/ _aE_ = get_space(0),
-             /*<<camlinternalFormat.ml:2461:10>>*/ _aF_ = get_hash(0),
-             /*<<camlinternalFormat.ml:2460:8>>*/ iconv$0 =
-              compute_int_conv
-               (pct_ind, str_ind + 1 | 0, get_plus(0), _aF_, _aE_, _aD_),
-            fmt_rest$1 = parse(str_ind + 1 | 0, end_ind)[1];
-            /*<<camlinternalFormat.ml:2463:9>>*/ if(get_ign(0))
-             /*<<camlinternalFormat.ml:2464:22>>*/ var
-              /*<<camlinternalFormat.ml:2464:22>>*/ ignored$0 =
-               [4, iconv$0, get_pad_opt(95)],
-             _aG_ = [0, [23, ignored$0, fmt_rest$1]];
-           else
-             /*<<camlinternalFormat.ml:2468:48>>*/ var
-              /*<<camlinternalFormat.ml:2468:48>>*/ _aH_ = get_prec(0),
-              /*<<camlinternalFormat.ml:2468:10>>*/ match$1 =
-               make_padprec_fmt_ebb(get_int_pad(0), _aH_, fmt_rest$1),
-             fmt_rest$2 = match$1[3],
-             prec$1 = match$1[2],
-             pad$1 = match$1[1],
-             _aG_ = [0, [6, iconv$0, pad$1, prec$1, fmt_rest$2]];
-           var _aB_ = _aG_;
-        }
-        var fmt_result = _aB_;
-        break a;
-       }
-      }
-      else if(76 === symb){
-        /*<<camlinternalFormat.ml:2473:25>>*/ var
-         /*<<camlinternalFormat.ml:2473:25>>*/ _aI_ =
-           /*<<camlinternalFormat.ml:2473:25>>*/ caml_string_get(str, str_ind),
-         /*<<camlinternalFormat.ml:2473:10>>*/ _aJ_ = get_space(0),
-         /*<<camlinternalFormat.ml:2472:61>>*/ _aK_ = get_hash(0),
-         /*<<camlinternalFormat.ml:2472:8>>*/ iconv$1 =
-          compute_int_conv
-           (pct_ind, str_ind + 1 | 0, get_plus(0), _aK_, _aJ_, _aI_),
-        fmt_rest$3 = parse(str_ind + 1 | 0, end_ind)[1];
-        /*<<camlinternalFormat.ml:2475:9>>*/ if(get_ign(0))
-         /*<<camlinternalFormat.ml:2476:22>>*/ var
-          /*<<camlinternalFormat.ml:2476:22>>*/ ignored$1 =
-           [5, iconv$1, get_pad_opt(95)],
-         _aL_ = [0, [23, ignored$1, fmt_rest$3]];
-       else
-         /*<<camlinternalFormat.ml:2480:48>>*/ var
-          /*<<camlinternalFormat.ml:2480:48>>*/ _aM_ = get_prec(0),
-          /*<<camlinternalFormat.ml:2480:10>>*/ match$2 =
-           make_padprec_fmt_ebb(get_int_pad(0), _aM_, fmt_rest$3),
-         fmt_rest$4 = match$2[3],
-         prec$2 = match$2[2],
-         pad$2 = match$2[1],
-         _aL_ = [0, [7, iconv$1, pad$2, prec$2, fmt_rest$4]];
-       var fmt_result = _aL_;
-       break a;
-      }
-      var
-       fmt_result =
-          /*<<camlinternalFormat.ml:2554:6>>*/ caml_call3
-          (failwith_message(_J_), str, str_ind - 1 | 0, symb);
-     }
-     if(1 - legacy_behavior$0){
-      var _ao_ = 1 - plus_used[1], plus$0 = _ao_ ? plus : _ao_;
-      if(plus$0)
-        /*<<camlinternalFormat.ml:2564:6>>*/ incompatible_flag
-        (pct_ind, str_ind, symb, cst$27);
-      var _ap_ = 1 - hash_used[1], hash$0 = _ap_ ? hash : _ap_;
-      if(hash$0)
-        /*<<camlinternalFormat.ml:2566:6>>*/ incompatible_flag
-        (pct_ind, str_ind, symb, cst$28);
-      var _aq_ = 1 - space_used[1], space$0 = _aq_ ? space : _aq_;
-      if(space$0)
-        /*<<camlinternalFormat.ml:2568:6>>*/ incompatible_flag
-        (pct_ind, str_ind, symb, cst$29);
-      var
-       _ar_ = 1 - pad_used[1],
-       _as_ =
-         _ar_
-          ?  /*<<camlinternalFormat.ml:2569:25>>*/ caml_notequal
-            ([0, pad], _K_)
-          : _ar_;
-       /*<<camlinternalFormat.ml:2569:25>>*/ if(_as_)
-        /*<<camlinternalFormat.ml:2570:6>>*/ incompatible_flag
-        (pct_ind, str_ind, symb, cst_padding$0);
-      var
-       _at_ = 1 - prec_used[1],
-       _au_ =
-         _at_
-          ?  /*<<camlinternalFormat.ml:2571:25>>*/ caml_notequal
-            ([0, prec], _L_)
-          : _at_;
-       /*<<camlinternalFormat.ml:2571:25>>*/ if(_au_){
-       var _av_ = ign ? 95 : symb;
-        /*<<camlinternalFormat.ml:2572:6>>*/ incompatible_flag
-        (pct_ind, str_ind, _av_, cst_precision$2);
-      }
-      var plus$1 = ign ? plus : ign;
-      if(plus$1)
-        /*<<camlinternalFormat.ml:2574:24>>*/ incompatible_flag
-        (pct_ind, str_ind, 95, cst$30);
-     }
-     var _aw_ = 1 - ign_used[1], ign$0 = _aw_ ? ign : _aw_;
-     a:
-     if(ign$0){
-      b:
-      {
-       if(38 <= symb){
-        if(44 !== symb && 64 !== symb) break b;
-       }
-       else if(33 !== symb && 37 > symb) break b;
-       if(legacy_behavior$0) break a;
-      }
-       /*<<camlinternalFormat.ml:2584:10>>*/ incompatible_flag
-       (pct_ind, str_ind, symb, cst$31);
-     }
-      /*<<camlinternalFormat.ml:2584:10>>*/ return fmt_result;
-    }
-    function parse_after_precision
-    (pct_ind, str_ind, end_ind, minus, plus, hash, space, ign, pad, prec){
-      /*<<camlinternalFormat.ml:2268:4>>*/ if(str_ind === end_ind)
-       /*<<camlinternalFormat.ml:2268:30>>*/ unexpected_end_of_format(end_ind);
-     function parse_conv(padprec){
-       /*<<camlinternalFormat.ml:2270:6>>*/ return parse_conversion
-              (pct_ind,
-               str_ind + 1 | 0,
-               end_ind,
-               plus,
-               hash,
-               space,
-               ign,
-               pad,
-               prec,
-               padprec,
-                /*<<camlinternalFormat.ml:2271:21>>*/ caml_string_get
-                (str, str_ind));
-      /*<<camlinternalFormat.ml:2271:34>>*/ }
-     if(typeof pad !== "number")
-       /*<<camlinternalFormat.ml:2287:13>>*/ return parse_conv(pad);
-     if(typeof prec === "number" && ! prec)
-       /*<<camlinternalFormat.ml:2281:29>>*/ return parse_conv(0);
-     if(minus){
-      if(typeof prec === "number")
-        /*<<camlinternalFormat.ml:2285:33>>*/ return parse_conv(_F_);
-      var n = prec[1];
-       /*<<camlinternalFormat.ml:2283:46>>*/ return parse_conv([0, 0, n]);
-     }
-     if(typeof prec === "number")
-       /*<<camlinternalFormat.ml:2284:34>>*/ return parse_conv(_G_);
-     var n$0 = prec[1];
-      /*<<camlinternalFormat.ml:2282:47>>*/ return parse_conv([0, 1, n$0]);
-     /*<<camlinternalFormat.ml:2287:27>>*/ }
-    function parse_after_padding
-    (pct_ind, str_ind, end_ind, minus, plus, hash, space, ign, pad){
-      /*<<camlinternalFormat.ml:2219:4>>*/ if(str_ind === end_ind)
-       /*<<camlinternalFormat.ml:2219:30>>*/ unexpected_end_of_format(end_ind);
-      /*<<camlinternalFormat.ml:2220:10>>*/  /*<<camlinternalFormat.ml:2220:10>>*/ var
-      symb =
-         /*<<camlinternalFormat.ml:2220:10>>*/ caml_string_get(str, str_ind);
-     if(46 !== symb)
-       /*<<camlinternalFormat.ml:2225:6>>*/ return parse_conversion
-              (pct_ind,
-               str_ind + 1 | 0,
-               end_ind,
-               plus,
-               hash,
-               space,
-               ign,
-               pad,
-               0,
-               pad,
-               symb);
-     var str_ind$0 = str_ind + 1 | 0;
-     if(str_ind$0 === end_ind)
-       /*<<camlinternalFormat.ml:2233:30>>*/ unexpected_end_of_format(end_ind);
-     function parse_literal(minus, str_ind){
-       /*<<camlinternalFormat.ml:2235:6>>*/ var
-        /*<<camlinternalFormat.ml:2235:26>>*/ match =
-         parse_positive(str_ind, end_ind, 0),
-       prec = match[2],
-       new_ind = match[1];
-       /*<<camlinternalFormat.ml:2237:12>>*/ return parse_after_precision
-              (pct_ind,
-               new_ind,
-               end_ind,
-               minus,
-               plus,
-               hash,
-               space,
-               ign,
-               pad,
-               [0, prec]);
-      /*<<camlinternalFormat.ml:2237:32>>*/ }
-      /*<<camlinternalFormat.ml:2238:10>>*/  /*<<camlinternalFormat.ml:2238:10>>*/ var
-      symb$0 =
-         /*<<camlinternalFormat.ml:2238:10>>*/ caml_string_get(str, str_ind$0);
-     if(48 <= symb$0){
-      if(58 > symb$0)
-        /*<<camlinternalFormat.ml:2239:20>>*/ return parse_literal
-               (minus, str_ind$0);
-     }
-     else if(42 <= symb$0)
-      switch(symb$0 - 42 | 0){
-        case 0:
-          /*<<camlinternalFormat.ml:2251:6>>*/ return parse_after_precision
-                 (pct_ind,
-                  str_ind$0 + 1 | 0,
-                  end_ind,
-                  minus,
-                  plus,
-                  hash,
-                  space,
-                  ign,
-                  pad,
-                  1);
-        case 1:
-        case 3:
-         if(legacy_behavior$0){
-           /*<<camlinternalFormat.ml:2249:6>>*/ var
-            /*<<camlinternalFormat.ml:2249:6>>*/ _an_ = str_ind$0 + 1 | 0,
-           minus$0 = minus || (45 === symb$0 ? 1 : 0);
-           /*<<camlinternalFormat.ml:2249:6>>*/ return parse_literal
-                  (minus$0, _an_);
-         }
-         break;
-      }
-     return legacy_behavior$0
-             ? parse_after_precision
-               (pct_ind,
-                str_ind$0,
-                end_ind,
-                minus,
-                plus,
-                hash,
-                space,
-                ign,
-                pad,
-                _E_)
-             : invalid_format_without(str_ind$0 - 1 | 0, 46, cst_precision);
-     /*<<camlinternalFormat.ml:2226:29>>*/ }
-    function parse_flags(pct_ind, str_ind, end_ind, ign){
-      /*<<camlinternalFormat.ml:2149:4>>*/ var
-       /*<<camlinternalFormat.ml:2149:15>>*/ zero = [0, 0],
-       /*<<camlinternalFormat.ml:2149:37>>*/ minus = [0, 0],
-       /*<<camlinternalFormat.ml:2150:15>>*/ plus = [0, 0],
-       /*<<camlinternalFormat.ml:2150:37>>*/ space = [0, 0],
-       /*<<camlinternalFormat.ml:2151:15>>*/ hash = [0, 0];
-     function set_flag(str_ind, flag){
-       /*<<camlinternalFormat.ml:2154:6>>*/ var
-       _ak_ = flag[1],
-       _al_ = _ak_ ? 1 - legacy_behavior$0 : _ak_;
-      if(_al_){
-        /*<<camlinternalFormat.ml:2157:22>>*/  /*<<camlinternalFormat.ml:2157:22>>*/ var
-        _am_ =
-           /*<<camlinternalFormat.ml:2157:22>>*/ caml_string_get(str, str_ind);
-        /*<<camlinternalFormat.ml:2155:8>>*/  /*<<camlinternalFormat.ml:2155:8>>*/ caml_call3
-        (failwith_message(_C_), str, str_ind, _am_);
-      }
-      flag[1] = 1;
-      return 0;
-      /*<<camlinternalFormat.ml:2158:19>>*/ }
-     var str_ind$0 = str_ind;
-      /*<<camlinternalFormat.ml:2161:6>>*/ for(;;){
-      if(str_ind$0 === end_ind)
-        /*<<camlinternalFormat.ml:2161:32>>*/ unexpected_end_of_format
-        (end_ind);
-       /*<<camlinternalFormat.ml:2162:18>>*/  /*<<camlinternalFormat.ml:2162:18>>*/ var
-       switcher =
-          /*<<camlinternalFormat.ml:2162:18>>*/ caml_string_get
-          (str, str_ind$0)
-         - 32
-         | 0;
-      if(16 >= switcher >>> 0)
-       switch(switcher){
-         case 0:
-           /*<<camlinternalFormat.ml:2167:15>>*/ set_flag(str_ind$0, space);
-           /*<<camlinternalFormat.ml:2167:15>>*/ var
-            /*<<camlinternalFormat.ml:2167:15>>*/ str_ind$1 =
-             str_ind$0 + 1 | 0,
-           str_ind$0 = str_ind$1;
-          continue;
-         case 3:
-           /*<<camlinternalFormat.ml:2166:15>>*/ set_flag(str_ind$0, hash);
-           /*<<camlinternalFormat.ml:2166:15>>*/ var
-            /*<<camlinternalFormat.ml:2166:15>>*/ str_ind$2 =
-             str_ind$0 + 1 | 0,
-           str_ind$0 = str_ind$2;
-          continue;
-         case 11:
-           /*<<camlinternalFormat.ml:2165:15>>*/ set_flag(str_ind$0, plus);
-           /*<<camlinternalFormat.ml:2165:15>>*/ var
-            /*<<camlinternalFormat.ml:2165:15>>*/ str_ind$3 =
-             str_ind$0 + 1 | 0,
-           str_ind$0 = str_ind$3;
-          continue;
-         case 13:
-           /*<<camlinternalFormat.ml:2164:15>>*/ set_flag(str_ind$0, minus);
-           /*<<camlinternalFormat.ml:2164:15>>*/ var
-            /*<<camlinternalFormat.ml:2164:15>>*/ str_ind$4 =
-             str_ind$0 + 1 | 0,
-           str_ind$0 = str_ind$4;
-          continue;
-         case 16:
-           /*<<camlinternalFormat.ml:2163:15>>*/ set_flag(str_ind$0, zero);
-           /*<<camlinternalFormat.ml:2163:15>>*/ var
-            /*<<camlinternalFormat.ml:2163:15>>*/ str_ind$5 =
-             str_ind$0 + 1 | 0,
-           str_ind$0 = str_ind$5;
-          continue;
-       }
-      var
-       space$0 = space[1],
-       hash$0 = hash[1],
-       plus$0 = plus[1],
-       minus$0 = minus[1],
-       zero$0 = zero[1];
-      if(str_ind$0 === end_ind)
-        /*<<camlinternalFormat.ml:2180:30>>*/ unexpected_end_of_format
-        (end_ind);
-       /*<<camlinternalFormat.ml:2188:10>>*/ var
-       padty =
-         zero$0
-          ? minus$0
-            ? legacy_behavior$0
-              ? 0
-              : incompatible_flag(pct_ind, str_ind$0, 45, cst_0)
-            : 2
-          : minus$0 ? 0 : 1,
-        /*<<camlinternalFormat.ml:2188:10>>*/ match =
-          /*<<camlinternalFormat.ml:2188:10>>*/ caml_string_get
-          (str, str_ind$0);
-      if(48 <= match){
-       if(58 > match){
-         /*<<camlinternalFormat.ml:2190:27>>*/ var
-          /*<<camlinternalFormat.ml:2190:27>>*/ match$0 =
-           parse_positive(str_ind$0, end_ind, 0),
-         width = match$0[2],
-         new_ind = match$0[1];
-         /*<<camlinternalFormat.ml:2192:8>>*/ return parse_after_padding
-                (pct_ind,
-                 new_ind,
-                 end_ind,
-                 minus$0,
-                 plus$0,
-                 hash$0,
-                 space$0,
-                 ign,
-                 [0, padty, width]);
-       }
-      }
-      else if(42 === match)
-        /*<<camlinternalFormat.ml:2195:12>>*/ return parse_after_padding
-               (pct_ind,
-                str_ind$0 + 1 | 0,
-                end_ind,
-                minus$0,
-                plus$0,
-                hash$0,
-                space$0,
-                ign,
-                [1, padty]);
-      switch(padty){
-        case 0:
-         if(1 - legacy_behavior$0)
-           /*<<camlinternalFormat.ml:2200:10>>*/ invalid_format_without
-           (str_ind$0 - 1 | 0, 45, cst_padding);
-          /*<<camlinternalFormat.ml:2200:10>>*/ return parse_after_padding
-                 (pct_ind,
-                  str_ind$0,
-                  end_ind,
-                  minus$0,
-                  plus$0,
-                  hash$0,
-                  space$0,
-                  ign,
-                  0);
-        case 1:
-          /*<<camlinternalFormat.ml:2210:8>>*/ return parse_after_padding
-                 (pct_ind,
-                  str_ind$0,
-                  end_ind,
-                  minus$0,
-                  plus$0,
-                  hash$0,
-                  space$0,
-                  ign,
-                  0);
-        default:
-          /*<<camlinternalFormat.ml:2207:8>>*/ return parse_after_padding
-                 (pct_ind,
-                  str_ind$0,
-                  end_ind,
-                  minus$0,
-                  plus$0,
-                  hash$0,
-                  space$0,
-                  ign,
-                  _D_);
-      }
-     }
-     /*<<camlinternalFormat.ml:2173:22>>*/ }
-    function parse_tag(is_open_tag, str_ind, end_ind){
-      /*<<camlinternalFormat.ml:2639:4>>*/ try{
-      if(str_ind === end_ind)
-        /*<<camlinternalFormat.ml:2640:32>>*/ throw  /*<<camlinternalFormat.ml:2640:32>>*/ caml_maybe_attach_backtrace
-              (Stdlib[8], 1);
-      if
-       (60
-        !==
-          /*<<camlinternalFormat.ml:2641:12>>*/ caml_string_get(str, str_ind))
-        /*<<camlinternalFormat.ml:2653:8>>*/ throw  /*<<camlinternalFormat.ml:2653:8>>*/ caml_maybe_attach_backtrace
-              (Stdlib[8], 1);
-       /*<<camlinternalFormat.ml:2643:18>>*/  /*<<camlinternalFormat.ml:2643:18>>*/ var
-       ind =
-          /*<<camlinternalFormat.ml:2643:18>>*/ caml_call3
-          (Stdlib_String[31], str, str_ind + 1 | 0, 62);
-      if(end_ind <= ind)
-        /*<<camlinternalFormat.ml:2644:31>>*/ throw  /*<<camlinternalFormat.ml:2644:31>>*/ caml_maybe_attach_backtrace
-              (Stdlib[8], 1);
-       /*<<camlinternalFormat.ml:2645:22>>*/ var
-        /*<<camlinternalFormat.ml:2645:22>>*/ sub_str =
-          /*<<camlinternalFormat.ml:2645:22>>*/ caml_call3
-          (Stdlib_String[15], str, str_ind, (ind - str_ind | 0) + 1 | 0),
-       fmt_rest$0 = parse(ind + 1 | 0, end_ind)[1],
-       sub_fmt = parse(str_ind, ind + 1 | 0)[1],
-        /*<<camlinternalFormat.ml:2648:25>>*/ sub_format$0 =
-         [0, sub_fmt, sub_str],
-        /*<<camlinternalFormat.ml:2649:8>>*/ formatting$0 =
-         is_open_tag ? [0, sub_format$0] : [1, sub_format$0],
-        /*<<camlinternalFormat.ml:2651:8>>*/ _ai_ =
-         [0, [18, formatting$0, fmt_rest$0]];
-       /*<<camlinternalFormat.ml:2651:8>>*/ return _ai_;
-     }
-     catch(_aj_){
-      var _ah_ = caml_wrap_exception(_aj_);
-      if(_ah_ !== Stdlib[8]) throw caml_maybe_attach_backtrace(_ah_, 0);
-       /*<<camlinternalFormat.ml:2657:6>>*/ var
-       fmt_rest = parse(str_ind, end_ind)[1],
-        /*<<camlinternalFormat.ml:2657:6>>*/ formatting =
-         is_open_tag ? [0, sub_format] : [1, sub_format];
-       /*<<camlinternalFormat.ml:2659:6>>*/ return [0,
-              [18, formatting, fmt_rest]];
-     }
-     /*<<camlinternalFormat.ml:2659:53>>*/ }
-    function parse_spaces(str_ind, end_ind){
-      /*<<camlinternalFormat.ml:2804:4>>*/ var str_ind$0 = str_ind;
-      /*<<camlinternalFormat.ml:2804:4>>*/ for(;;){
-      if(str_ind$0 === end_ind)
-        /*<<camlinternalFormat.ml:2804:30>>*/ unexpected_end_of_format
-        (end_ind);
-       /*<<camlinternalFormat.ml:2805:7>>*/ if
-       (32
-        !==
-          /*<<camlinternalFormat.ml:2805:7>>*/ caml_string_get(str, str_ind$0))
-        /*<<camlinternalFormat.ml:2805:72>>*/ return str_ind$0;
-      var str_ind$1 = str_ind$0 + 1 | 0, str_ind$0 = str_ind$1;
-     }
-     /*<<camlinternalFormat.ml:2805:79>>*/ }
-    function parse_positive(str_ind, end_ind, acc){
-      /*<<camlinternalFormat.ml:2810:4>>*/ var
-      str_ind$0 = str_ind,
-      acc$0 = acc;
-      /*<<camlinternalFormat.ml:2810:4>>*/ for(;;){
-      if(str_ind$0 === end_ind)
-        /*<<camlinternalFormat.ml:2810:30>>*/ unexpected_end_of_format
-        (end_ind);
-       /*<<camlinternalFormat.ml:2811:10>>*/  /*<<camlinternalFormat.ml:2811:10>>*/ var
-       c =
-          /*<<camlinternalFormat.ml:2811:10>>*/ caml_string_get
-          (str, str_ind$0);
-      if(9 < c - 48 >>> 0)
-        /*<<camlinternalFormat.ml:2820:11>>*/ return [0, str_ind$0, acc$0];
-      var new_acc = (acc$0 * 10 | 0) + (c - 48 | 0) | 0;
-      if(Stdlib_Sys[12] < new_acc){
-        /*<<camlinternalFormat.ml:2815:8>>*/  /*<<camlinternalFormat.ml:2815:8>>*/ var
-        _ag_ = Stdlib_Sys[12];
-        /*<<camlinternalFormat.ml:2815:8>>*/ return  /*<<camlinternalFormat.ml:2815:8>>*/ caml_call3
-               (failwith_message(_S_), str, new_acc, _ag_);
-      }
-      var
-       str_ind$1 = str_ind$0 + 1 | 0,
-       str_ind$0 = str_ind$1,
-       acc$0 = new_acc;
-     }
-     /*<<camlinternalFormat.ml:2820:23>>*/ }
-    function parse_integer(str_ind, end_ind){
-      /*<<camlinternalFormat.ml:2825:4>>*/ if(str_ind === end_ind)
-       /*<<camlinternalFormat.ml:2825:30>>*/ unexpected_end_of_format(end_ind);
-      /*<<camlinternalFormat.ml:2826:10>>*/  /*<<camlinternalFormat.ml:2826:10>>*/ var
-      match =
-         /*<<camlinternalFormat.ml:2826:10>>*/ caml_string_get(str, str_ind);
-     if(48 <= match){
-      if(58 > match)
-        /*<<camlinternalFormat.ml:2827:20>>*/ return parse_positive
-               (str_ind, end_ind, 0);
-     }
-     else if(45 === match){
-      if((str_ind + 1 | 0) === end_ind)
-        /*<<camlinternalFormat.ml:2829:36>>*/ unexpected_end_of_format
-        (end_ind);
-       /*<<camlinternalFormat.ml:2830:12>>*/  /*<<camlinternalFormat.ml:2830:12>>*/ var
-       c =
-          /*<<camlinternalFormat.ml:2830:12>>*/ caml_string_get
-          (str, str_ind + 1 | 0);
-      if(9 < c - 48 >>> 0)
-        /*<<camlinternalFormat.ml:2835:8>>*/ return expected_character
-               (str_ind + 1 | 0, cst_digit, c);
-       /*<<camlinternalFormat.ml:2832:26>>*/ var
-        /*<<camlinternalFormat.ml:2832:26>>*/ match$0 =
-         parse_positive(str_ind + 1 | 0, end_ind, 0),
-       n = match$0[2],
-       next_ind = match$0[1];
-       /*<<camlinternalFormat.ml:2833:8>>*/ return [0, next_ind, - n | 0];
-     }
-      /*<<camlinternalFormat.ml:2837:11>>*/ throw  /*<<camlinternalFormat.ml:2837:11>>*/ caml_maybe_attach_backtrace
-            ([0, Assert_failure, _T_], 1);
-     /*<<camlinternalFormat.ml:2837:23>>*/ }
-    function search_subformat_end(str_ind, end_ind, c){
-      /*<<camlinternalFormat.ml:2851:4>>*/ var str_ind$0 = str_ind;
-      /*<<camlinternalFormat.ml:2851:4>>*/ for(;;){
-      if(str_ind$0 === end_ind)
-        /*<<camlinternalFormat.ml:2852:6>>*/  /*<<camlinternalFormat.ml:2852:6>>*/ caml_call3
-        (failwith_message(_U_), str, c, end_ind);
-      if
-       (37
-        ===
-          /*<<camlinternalFormat.ml:2855:10>>*/ caml_string_get
-          (str, str_ind$0)){
-       if((str_ind$0 + 1 | 0) === end_ind)
-         /*<<camlinternalFormat.ml:2857:36>>*/ unexpected_end_of_format
-         (end_ind);
-       if
-        ( /*<<camlinternalFormat.ml:2858:9>>*/ caml_string_get
-          (str, str_ind$0 + 1 | 0)
-         === c)
-         /*<<camlinternalFormat.ml:2858:62>>*/ return str_ind$0;
-        /*<<camlinternalFormat.ml:2859:20>>*/  /*<<camlinternalFormat.ml:2859:20>>*/ var
-        match =
-           /*<<camlinternalFormat.ml:2859:20>>*/ caml_string_get
-           (str, str_ind$0 + 1 | 0);
-       if(95 <= match){
-        if(123 <= match){
-         if(126 > match)
-          switch(match - 123 | 0){
-            case 0:
-              /*<<camlinternalFormat.ml:2874:24>>*/ var
-               /*<<camlinternalFormat.ml:2874:24>>*/ sub_end =
-                search_subformat_end(str_ind$0 + 2 | 0, end_ind, 125),
-               /*<<camlinternalFormat.ml:2874:24>>*/ str_ind$2 =
-                sub_end + 2 | 0,
-              str_ind$0 = str_ind$2;
-             continue;
-            case 1: break;
-            default:
-              /*<<camlinternalFormat.ml:2882:10>>*/ return expected_character
-                     (str_ind$0 + 1 | 0, cst_character, 125);
-          }
-        }
-        else if(96 > match){
-         if((str_ind$0 + 2 | 0) === end_ind)
-           /*<<camlinternalFormat.ml:2862:40>>*/ unexpected_end_of_format
-           (end_ind);
-          /*<<camlinternalFormat.ml:2863:22>>*/  /*<<camlinternalFormat.ml:2863:22>>*/ var
-          match$0 =
-             /*<<camlinternalFormat.ml:2863:22>>*/ caml_string_get
-             (str, str_ind$0 + 2 | 0);
-         if(40 === match$0){
-           /*<<camlinternalFormat.ml:2868:26>>*/ var
-            /*<<camlinternalFormat.ml:2868:26>>*/ sub_end$0 =
-             search_subformat_end(str_ind$0 + 3 | 0, end_ind, 41),
-            /*<<camlinternalFormat.ml:2868:26>>*/ str_ind$3 =
-             sub_end$0 + 2 | 0,
-           str_ind$0 = str_ind$3;
-          continue;
-         }
-         if(123 === match$0){
-           /*<<camlinternalFormat.ml:2865:26>>*/ var
-            /*<<camlinternalFormat.ml:2865:26>>*/ sub_end$1 =
-             search_subformat_end(str_ind$0 + 3 | 0, end_ind, 125),
-            /*<<camlinternalFormat.ml:2865:26>>*/ str_ind$4 =
-             sub_end$1 + 2 | 0,
-           str_ind$0 = str_ind$4;
-          continue;
-         }
-         var str_ind$5 = str_ind$0 + 3 | 0, str_ind$0 = str_ind$5;
-         continue;
-        }
-       }
-       else{
-        if(40 === match){
-          /*<<camlinternalFormat.ml:2878:24>>*/ var
-           /*<<camlinternalFormat.ml:2878:24>>*/ sub_end$2 =
-            search_subformat_end(str_ind$0 + 2 | 0, end_ind, 41),
-           /*<<camlinternalFormat.ml:2878:24>>*/ str_ind$6 = sub_end$2 + 2 | 0,
-          str_ind$0 = str_ind$6;
-         continue;
-        }
-        if(41 === match)
-          /*<<camlinternalFormat.ml:2885:10>>*/ return expected_character
-                 (str_ind$0 + 1 | 0, cst_character$0, 41);
-       }
-       var str_ind$1 = str_ind$0 + 2 | 0, str_ind$0 = str_ind$1;
-      }
-      else
-       var str_ind$7 = str_ind$0 + 1 | 0, str_ind$0 = str_ind$7;
-     }
-     /*<<camlinternalFormat.ml:2889:55>>*/ }
-    function incompatible_flag(pct_ind, str_ind, symb, option){
-      /*<<camlinternalFormat.ml:2963:6>>*/  /*<<camlinternalFormat.ml:2963:19>>*/ var
-      subfmt =
-         /*<<camlinternalFormat.ml:2963:19>>*/ caml_call3
-         (Stdlib_String[15], str, pct_ind, str_ind - pct_ind | 0);
-      /*<<camlinternalFormat.ml:2964:6>>*/ return  /*<<camlinternalFormat.ml:2964:6>>*/ caml_call5
-             (failwith_message(_Y_), str, pct_ind, option, symb, subfmt);
-     /*<<camlinternalFormat.ml:2967:38>>*/ }
-    function compute_int_conv(pct_ind, str_ind, plus, hash, space, symb){
-      /*<<camlinternalFormat.ml:2903:4>>*/ var
-      plus$0 = plus,
-      hash$0 = hash,
-      space$0 = space;
-      /*<<camlinternalFormat.ml:2903:4>>*/ for(;;){
-      a:
-      {
-       if(plus$0){
-        if(! hash$0){
-         if(space$0) break a;
-         if(100 === symb)  /*<<camlinternalFormat.ml:2906:34>>*/ return 1;
-         if(105 === symb)  /*<<camlinternalFormat.ml:2906:71>>*/ return 4;
-         break a;
-        }
-       }
-       else{
-        if(! hash$0){
-         if(space$0){
-          if(100 === symb)  /*<<camlinternalFormat.ml:2905:34>>*/ return 2;
-          if(105 === symb)  /*<<camlinternalFormat.ml:2905:71>>*/ return 5;
-          break a;
-         }
-         var switcher$1 = symb - 88 | 0;
-         if(32 < switcher$1 >>> 0) break a;
-         switch(switcher$1){
-           case 0:
-             /*<<camlinternalFormat.ml:2907:71>>*/ return 8;
-           case 12:
-             /*<<camlinternalFormat.ml:2904:34>>*/ return 0;
-           case 17:
-             /*<<camlinternalFormat.ml:2904:71>>*/ return 3;
-           case 23:
-             /*<<camlinternalFormat.ml:2909:34>>*/ return 10;
-           case 29:
-             /*<<camlinternalFormat.ml:2911:34>>*/ return 12;
-           case 32:
-             /*<<camlinternalFormat.ml:2907:34>>*/ return 6;
-           default: break a;
-         }
-        }
-        if(! space$0){
-         var switcher$0 = symb - 88 | 0;
-         if(32 >= switcher$0 >>> 0)
-          switch(switcher$0){
-            case 0:
-              /*<<camlinternalFormat.ml:2908:71>>*/ return 9;
-            case 12:
-              /*<<camlinternalFormat.ml:2912:34>>*/ return 13;
-            case 17:
-              /*<<camlinternalFormat.ml:2913:34>>*/ return 14;
-            case 23:
-              /*<<camlinternalFormat.ml:2910:34>>*/ return 11;
-            case 29:
-              /*<<camlinternalFormat.ml:2914:34>>*/ return 15;
-            case 32:
-              /*<<camlinternalFormat.ml:2908:34>>*/ return 7;
-          }
-        }
-       }
-       var switcher = symb - 88 | 0;
-       if(32 >= switcher >>> 0)
-        switch(switcher){
-          case 0:
-           if(legacy_behavior$0)
-             /*<<camlinternalFormat.ml:2916:46>>*/ return 9;
-           break;
-          case 23:
-           if(legacy_behavior$0)
-             /*<<camlinternalFormat.ml:2917:46>>*/ return 11;
-           break;
-          case 32:
-           if(legacy_behavior$0)
-             /*<<camlinternalFormat.ml:2915:46>>*/ return 7;
-           break;
-          case 12:
-          case 17:
-          case 29:
-           if(! legacy_behavior$0)
-             /*<<camlinternalFormat.ml:2921:11>>*/ return incompatible_flag
-                    (pct_ind, str_ind, symb, cst$35);
-           var hash$0 = 0;
-           continue;
-        }
-      }
-      if(plus$0)
-       if(space$0){
-        if(! legacy_behavior$0)
-          /*<<camlinternalFormat.ml:2926:11>>*/ return incompatible_flag
-                 (pct_ind, str_ind, 32, cst$32);
-        var space$0 = 0;
-       }
-       else{
-        if(! legacy_behavior$0)
-          /*<<camlinternalFormat.ml:2934:11>>*/ return incompatible_flag
-                 (pct_ind, str_ind, symb, cst$33);
-        var plus$0 = 0;
-       }
-      else{
-       if(! space$0)
-         /*<<camlinternalFormat.ml:2935:28>>*/ throw  /*<<camlinternalFormat.ml:2935:28>>*/ caml_maybe_attach_backtrace
-               ([0, Assert_failure, _W_], 1);
-       if(! legacy_behavior$0)
-         /*<<camlinternalFormat.ml:2930:11>>*/ return incompatible_flag
-                (pct_ind, str_ind, symb, cst$34);
-       var space$0 = 0;
-      }
-     }
-     /*<<camlinternalFormat.ml:2935:40>>*/ }
-    return parse(0, caml_ml_string_length(str));
-   }
-   function format_of_string_fmtty(str, fmtty){
-     /*<<camlinternalFormat.ml:2977:2>>*/ var
-     fmt = fmt_ebb_of_string(0, str)[1];
-     /*<<camlinternalFormat.ml:2978:2>>*/ try{
-      /*<<camlinternalFormat.ml:2978:6>>*/  /*<<camlinternalFormat.ml:2978:6>>*/ var
-      _ae_ = [0, type_format(fmt, fmtty), str];
-      /*<<camlinternalFormat.ml:2978:6>>*/ return _ae_;
-    }
-    catch(_af_){
-     var _ac_ = caml_wrap_exception(_af_);
-     if(_ac_ !== Type_mismatch) throw caml_maybe_attach_backtrace(_ac_, 0);
-      /*<<camlinternalFormat.ml:2982:10>>*/  /*<<camlinternalFormat.ml:2982:10>>*/ var
-      _ad_ = string_of_fmtty(fmtty);
-      /*<<camlinternalFormat.ml:2982:10>>*/ return  /*<<camlinternalFormat.ml:2982:10>>*/ caml_call2
-             (failwith_message(_Z_), str, _ad_);
-    }
-    /*<<camlinternalFormat.ml:2982:33>>*/ }
-   function format_of_string_format(str, param){
-    var
-     str$0 = param[2],
-     fmt = param[1],
-     fmt$0 = fmt_ebb_of_string(0, str)[1];
-     /*<<camlinternalFormat.ml:2988:2>>*/ try{
-      /*<<camlinternalFormat.ml:2988:6>>*/  /*<<camlinternalFormat.ml:2988:6>>*/ var
-      _aa_ = [0, type_format(fmt$0, fmtty_of_fmt(fmt)), str];
-      /*<<camlinternalFormat.ml:2988:6>>*/ return _aa_;
-    }
-    catch(_ab_){
-     var _$_ = caml_wrap_exception(_ab_);
-     if(_$_ === Type_mismatch)
-       /*<<camlinternalFormat.ml:2990:4>>*/ return  /*<<camlinternalFormat.ml:2990:4>>*/ caml_call2
-              (failwith_message(___), str, str$0);
-     throw caml_maybe_attach_backtrace(_$_, 0);
-    }
-   }
-   var
-    CamlinternalFormat =
-      [0,
-       is_in_char_set,
-       rev_char_set,
-       create_char_set,
-       add_in_char_set,
-       freeze_char_set,
-       param_format_of_ignored_format,
-       make_printf,
-       make_iprintf,
-       output_acc,
-       bufput_acc,
-       strput_acc,
-       type_format,
-       fmt_ebb_of_string,
-       format_of_string_fmtty,
-       format_of_string_format,
-       char_of_iconv,
-       string_of_formatting_lit,
-       string_of_fmtty,
-       string_of_fmt,
-       open_box_of_string,
-       symm,
-       trans,
-       recast];
-   runtime.caml_register_global(197, CamlinternalFormat, "CamlinternalFormat");
-   return;
-   /*<<?>>*/ }
-  (globalThis));
-
-//# unitInfo: Provides: Stdlib__Printf
-//# unitInfo: Requires: CamlinternalFormat, Stdlib, Stdlib__Buffer
-(function
-  (globalThis){
-   "use strict";
-   var runtime = globalThis.jsoo_runtime;
-    /*<<?>>*/ function caml_call1(f, a0){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 1
-            ? f(a0)
-            : runtime.caml_call_gen(f, [a0]);
-   }
-    /*<<?>>*/ function caml_call2(f, a0, a1){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 2
-            ? f(a0, a1)
-            : runtime.caml_call_gen(f, [a0, a1]);
-   }
-    /*<<?>>*/ function caml_call3(f, a0, a1, a2){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 3
-            ? f(a0, a1, a2)
-            : runtime.caml_call_gen(f, [a0, a1, a2]);
-   }
-   var
-    global_data = runtime.caml_get_global_data(),
-    Stdlib_Buffer = global_data.Stdlib__Buffer,
-    CamlinternalFormat = global_data.CamlinternalFormat,
-    Stdlib = global_data.Stdlib;
-   function kfprintf(k, o, param){
-     /*<<printf.ml:20:2>>*/ var
-     fmt = param[1],
-      /*<<printf.ml:20:2>>*/ _g_ = 0;
-    function _h_(acc){
-      /*<<printf.ml:20:26>>*/  /*<<printf.ml:20:26>>*/ caml_call2
-      (CamlinternalFormat[9], o, acc);
-     return caml_call1(k, o);
-     /*<<printf.ml:20:47>>*/ }
-     /*<<printf.ml:20:2>>*/ return  /*<<printf.ml:20:2>>*/ caml_call3
-            (CamlinternalFormat[7], _h_, _g_, fmt);
-   }
-   function kbprintf(k, b, param){
-     /*<<printf.ml:22:2>>*/ var
-     fmt = param[1],
-      /*<<printf.ml:22:2>>*/ _e_ = 0;
-    function _f_(acc){
-      /*<<printf.ml:22:26>>*/  /*<<printf.ml:22:26>>*/ caml_call2
-      (CamlinternalFormat[10], b, acc);
-     return caml_call1(k, b);
-     /*<<printf.ml:22:47>>*/ }
-     /*<<printf.ml:22:2>>*/ return  /*<<printf.ml:22:2>>*/ caml_call3
-            (CamlinternalFormat[7], _f_, _e_, fmt);
-   }
-   function ikfprintf(k, oc, param){
-    var fmt = param[1];
-     /*<<printf.ml:24:2>>*/ return  /*<<printf.ml:24:2>>*/ caml_call3
-            (CamlinternalFormat[8], k, oc, fmt);
-   }
-   function fprintf(oc, fmt){
-     /*<<printf.ml:27:21>>*/ return kfprintf
-            (function(_d_){ /*<<?>>*/ return 0;}, oc, fmt);
-    /*<<printf.ml:27:43>>*/ }
-   function bprintf(b, fmt){
-     /*<<printf.ml:28:20>>*/ return kbprintf
-            (function(_c_){ /*<<?>>*/ return 0;}, b, fmt);
-    /*<<printf.ml:28:41>>*/ }
-   function ifprintf(oc, fmt){
-     /*<<printf.ml:29:22>>*/ return ikfprintf
-            (function(_b_){ /*<<?>>*/ return 0;}, oc, fmt);
-    /*<<printf.ml:29:45>>*/ }
-   function ibprintf(b, fmt){
-     /*<<printf.ml:30:21>>*/ return ikfprintf
-            (function(_a_){ /*<<?>>*/ return 0;}, b, fmt);
-    /*<<printf.ml:30:43>>*/ }
-   function printf(fmt){
-     /*<<printf.ml:31:17>>*/ return fprintf(Stdlib[39], fmt);
-    /*<<printf.ml:31:35>>*/ }
-   function eprintf(fmt){
-     /*<<printf.ml:32:18>>*/ return fprintf(Stdlib[40], fmt);
-    /*<<printf.ml:32:36>>*/ }
-   function ksprintf(k, param){
-    var fmt = param[1];
-     /*<<printf.ml:35:2>>*/ function k$0(acc){
-      /*<<printf.ml:36:4>>*/  /*<<printf.ml:36:14>>*/ var
-      buf =  /*<<printf.ml:36:14>>*/ caml_call1(Stdlib_Buffer[1], 64);
-      /*<<printf.ml:37:4>>*/  /*<<printf.ml:37:4>>*/ caml_call2
-      (CamlinternalFormat[11], buf, acc);
-      /*<<printf.ml:38:6>>*/ return  /*<<printf.ml:38:6>>*/ caml_call1
-             (k,  /*<<printf.ml:38:6>>*/ caml_call1(Stdlib_Buffer[2], buf));
-     /*<<printf.ml:38:27>>*/ }
-     /*<<printf.ml:39:2>>*/ return  /*<<printf.ml:39:2>>*/ caml_call3
-            (CamlinternalFormat[7], k$0, 0, fmt);
-   }
-   function sprintf(fmt){
-     /*<<printf.ml:41:18>>*/ return ksprintf
-            (function(s){
-               /*<<printf.ml:41:37>>*/ return s;
-              /*<<printf.ml:41:38>>*/ },
-             fmt);
-    /*<<printf.ml:41:43>>*/ }
-   var
-    Stdlib_Printf =
-      [0,
-       fprintf,
-       printf,
-       eprintf,
-       sprintf,
-       bprintf,
-       ifprintf,
-       ibprintf,
-       kfprintf,
-       ikfprintf,
-       ksprintf,
-       kbprintf,
-       ikfprintf,
-       ksprintf];
-   runtime.caml_register_global(3, Stdlib_Printf, "Stdlib__Printf");
-   return;
-   /*<<?>>*/ }
-  (globalThis));
-
-//# unitInfo: Provides: Stdlib__Arg
-//# unitInfo: Requires: Stdlib, Stdlib__Array, Stdlib__Buffer, Stdlib__Int, Stdlib__List, Stdlib__Printf, Stdlib__String, Stdlib__Sys
-(function
-  (globalThis){
-   "use strict";
-   var
-    runtime = globalThis.jsoo_runtime,
-    cst$7 = "",
-    cst$9 = "  ",
-    cst_Display_this_list_of_optio$1 = " Display this list of options",
-    cst_s = "%s",
-    cst_help$4 = "--help",
-    cst_help$3 = "-help",
-    cst$8 = ".\n",
-    cst_a_float$1 = "a float",
-    cst_an_integer$1 = "an integer",
-    caml_check_bound = runtime.caml_check_bound,
-    caml_equal = runtime.caml_equal,
-    caml_fresh_oo_id = runtime.caml_fresh_oo_id,
-    caml_maybe_attach_backtrace = runtime.caml_maybe_attach_backtrace,
-    caml_ml_string_length = runtime.caml_ml_string_length,
-    caml_string_get = runtime.caml_string_get,
-    caml_string_notequal = runtime.caml_string_notequal,
-    caml_sys_argv = runtime.caml_sys_argv,
-    caml_wrap_exception = runtime.caml_wrap_exception;
-    /*<<?>>*/ function caml_call1(f, a0){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 1
-            ? f(a0)
-            : runtime.caml_call_gen(f, [a0]);
-   }
-    /*<<?>>*/ function caml_call2(f, a0, a1){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 2
-            ? f(a0, a1)
-            : runtime.caml_call_gen(f, [a0, a1]);
-   }
-    /*<<?>>*/ function caml_call3(f, a0, a1, a2){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 3
-            ? f(a0, a1, a2)
-            : runtime.caml_call_gen(f, [a0, a1, a2]);
-   }
-    /*<<?>>*/ function caml_call4(f, a0, a1, a2, a3){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 4
-            ? f(a0, a1, a2, a3)
-            : runtime.caml_call_gen(f, [a0, a1, a2, a3]);
-   }
-    /*<<?>>*/ function caml_call5(f, a0, a1, a2, a3, a4){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 5
-            ? f(a0, a1, a2, a3, a4)
-            : runtime.caml_call_gen(f, [a0, a1, a2, a3, a4]);
-   }
-    /*<<?>>*/ function caml_call6(f, a0, a1, a2, a3, a4, a5){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 6
-            ? f(a0, a1, a2, a3, a4, a5)
-            : runtime.caml_call_gen(f, [a0, a1, a2, a3, a4, a5]);
-   }
-    /*<<arg.ml:50:0>>*/ var
-    global_data = runtime.caml_get_global_data(),
-    cst$6 = "\n",
-    cst$3 = cst$7,
-    cst$4 = " ",
-    cst$5 = cst$7,
-    cst$2 = "(?)",
-    cst = "}",
-    cst$0 = "|",
-    cst$1 = "{",
-    Stdlib = global_data.Stdlib,
-    Stdlib_Printf = global_data.Stdlib__Printf,
-    Stdlib_Array = global_data.Stdlib__Array,
-    Stdlib_Buffer = global_data.Stdlib__Buffer,
-    Stdlib_List = global_data.Stdlib__List,
-    Stdlib_String = global_data.Stdlib__String,
-    Stdlib_Int = global_data.Stdlib__Int,
-     /*<<arg.ml:50:0>>*/ Bad = [248, "Stdlib.Arg.Bad", caml_fresh_oo_id(0)],
-     /*<<arg.ml:51:0>>*/ Help = [248, "Stdlib.Arg.Help", caml_fresh_oo_id(0)],
-     /*<<arg.ml:59:0>>*/ Stop = [248, "Stdlib.Arg.Stop", caml_fresh_oo_id(0)],
-    _v_ = [0, [2, 0, [0, 0]], "%s%c"],
-    _p_ = [0, [2, 0, 0], cst_s],
-    _q_ = [0, [2, 0, 0], cst_s],
-    _n_ = [0, [2, 0, 0], cst_s],
-    _o_ = [0, [2, 0, 0], cst_s],
-    _l_ = [0, [2, 0, 0], cst_s],
-    _m_ = [0, [2, 0, 0], cst_s],
-    cst_a_boolean = "a boolean",
-    cst_an_integer = cst_an_integer$1,
-    cst_an_integer$0 = cst_an_integer$1,
-    cst_a_float = cst_a_float$1,
-    cst_a_float$0 = cst_a_float$1,
-    cst_one_of = "one of: ",
-    cst_Arg_Expand_is_is_only_allo =
-      "Arg.Expand is is only allowed with Arg.parse_and_expand_argv_dynamic",
-    cst_no_argument = "no argument",
-    _f_ =
-      [0,
-       [2, 0, [11, ": unknown option '", [2, 0, [11, "'.\n", 0]]]],
-       "%s: unknown option '%s'.\n"],
-    _i_ =
-      [0,
-       [2,
-        0,
-        [11,
-         ": wrong argument '",
-         [2,
-          0,
-          [11,
-           "'; option '",
-           [2, 0, [11, "' expects ", [2, 0, [11, cst$8, 0]]]]]]]],
-       "%s: wrong argument '%s'; option '%s' expects %s.\n"],
-    _j_ =
-      [0,
-       [2, 0, [11, ": option '", [2, 0, [11, "' needs an argument.\n", 0]]]],
-       "%s: option '%s' needs an argument.\n"],
-    _k_ = [0, [2, 0, [11, ": ", [2, 0, [11, cst$8, 0]]]], "%s: %s.\n"],
-    _g_ = [0, cst_help$3],
-    _h_ = [0, cst_help$4],
-    _e_ = [0, [2, 0, 0], cst_s],
-    _d_ = [0, [2, 0, [12, 10, 0]], "%s\n"],
-    cst_help$2 = cst_help$3,
-    cst_Display_this_list_of_optio = cst_Display_this_list_of_optio$1,
-    cst_help = cst_help$3,
-    cst_help$1 = cst_help$4,
-    cst_Display_this_list_of_optio$0 = cst_Display_this_list_of_optio$1,
-    cst_help$0 = cst_help$4,
-    _c_ = [0, cst_help$3],
-    _a_ = [0, [11, cst$9, [2, 0, [12, 32, [2, 0, [12, 10, 0]]]]], "  %s %s\n"],
-    _b_ =
-      [0,
-       [11, cst$9, [2, 0, [12, 32, [2, 0, [2, 0, [12, 10, 0]]]]]],
-       "  %s %s%s\n"],
-    cst_none = "<none>";
-   function assoc3(x, l){
-     /*<<arg.ml:64:2>>*/ var l$0 = l;
-     /*<<arg.ml:64:2>>*/ for(;;){
-     if(! l$0)
-       /*<<arg.ml:65:10>>*/ throw  /*<<arg.ml:65:10>>*/ caml_maybe_attach_backtrace
-             (Stdlib[8], 1);
-     var match = l$0[1], y2 = match[2], y1 = match[1];
-      /*<<arg.ml:66:26>>*/ if( /*<<arg.ml:66:26>>*/ caml_equal(y1, x))
-       /*<<arg.ml:66:36>>*/ return y2;
-     var t = l$0[2], l$0 = t;
-    }
-    /*<<arg.ml:67:24>>*/ }
-   function make_symlist(prefix, sep, suffix, l){
-     /*<<arg.ml:77:2>>*/ if(! l)  /*<<arg.ml:78:10>>*/ return cst_none;
-     /*<<arg.ml:79:53>>*/ var
-     t = l[2],
-     h = l[1],
-      /*<<arg.ml:79:53>>*/ _aD_ =
-        /*<<arg.ml:79:53>>*/ caml_call2(Stdlib[28], prefix, h);
-    function _aE_(x, y){
-      /*<<arg.ml:79:40>>*/  /*<<arg.ml:79:44>>*/ var
-      _aG_ =  /*<<arg.ml:79:44>>*/ caml_call2(Stdlib[28], sep, y);
-      /*<<arg.ml:79:44>>*/ return  /*<<arg.ml:79:44>>*/ caml_call2
-             (Stdlib[28], x, _aG_);
-     /*<<arg.ml:79:51>>*/ }
-     /*<<arg.ml:79:12>>*/  /*<<arg.ml:79:12>>*/ var
-     _aF_ =  /*<<arg.ml:79:12>>*/ caml_call3(Stdlib_List[25], _aE_, _aD_, t);
-     /*<<arg.ml:79:12>>*/ return  /*<<arg.ml:79:12>>*/ caml_call2
-            (Stdlib[28], _aF_, suffix);
-    /*<<arg.ml:79:77>>*/ }
-   function help_action(param){
-     /*<<arg.ml:91:21>>*/ throw  /*<<arg.ml:91:21>>*/ caml_maybe_attach_backtrace
-           ([0, Stop, _c_], 1);
-    /*<<arg.ml:91:51>>*/ }
-   function add_help(speclist){
-     /*<<arg.ml:94:2>>*/ try{
-      /*<<arg.ml:95:15>>*/ assoc3(cst_help$2, speclist);
-      /*<<arg.ml:95:42>>*/ var  /*<<arg.ml:95:42>>*/ _aA_ = 0, add1 = _aA_;
-    }
-    catch(_aC_){
-     var _aw_ = caml_wrap_exception(_aC_);
-     if(_aw_ !== Stdlib[8]) throw caml_maybe_attach_backtrace(_aw_, 0);
-     var
-      add1 =
-        [0,
-         [0, cst_help, [0, help_action], cst_Display_this_list_of_optio],
-         0];
-    }
-    try{
-      /*<<arg.ml:99:15>>*/ assoc3(cst_help$1, speclist);
-      /*<<arg.ml:99:43>>*/ var  /*<<arg.ml:99:43>>*/ _az_ = 0, add2 = _az_;
-    }
-    catch(_aB_){
-     var _ax_ = caml_wrap_exception(_aB_);
-     if(_ax_ !== Stdlib[8]) throw caml_maybe_attach_backtrace(_ax_, 0);
-     var
-      add2 =
-        [0,
-         [0, cst_help$0, [0, help_action], cst_Display_this_list_of_optio$0],
-         0];
-    }
-     /*<<arg.ml:103:13>>*/  /*<<arg.ml:103:13>>*/ var
-     _ay_ =  /*<<arg.ml:103:13>>*/ caml_call2(Stdlib[37], add1, add2);
-     /*<<arg.ml:103:13>>*/ return  /*<<arg.ml:103:13>>*/ caml_call2
-            (Stdlib[37], speclist, _ay_);
-    /*<<arg.ml:103:26>>*/ }
-   function usage_b(buf, speclist, errmsg){
-     /*<<arg.ml:107:2>>*/  /*<<arg.ml:107:2>>*/ caml_call3
-     (Stdlib_Printf[5], buf, _d_, errmsg);
-     /*<<arg.ml:108:29>>*/  /*<<arg.ml:108:29>>*/ var
-     _as_ = add_help(speclist);
-     /*<<arg.ml:108:12>>*/ function _at_(param){
-     var
-      doc = param[3],
-      spec = param[2],
-      key = param[1],
-      _au_ = 0 <  /*<<arg.ml:83:2>>*/ caml_ml_string_length(doc) ? 1 : 0;
-     if(! _au_) return _au_;
-     if(11 !== spec[0])
-       /*<<arg.ml:88:8>>*/ return  /*<<arg.ml:88:8>>*/ caml_call4
-              (Stdlib_Printf[5], buf, _a_, key, doc);
-      /*<<arg.ml:86:38>>*/ var
-      l = spec[1],
-       /*<<arg.ml:86:38>>*/ _av_ = make_symlist(cst$1, cst$0, cst, l);
-      /*<<arg.ml:86:8>>*/ return  /*<<arg.ml:86:8>>*/ caml_call5
-             (Stdlib_Printf[5], buf, _b_, key, _av_, doc);
-    }
-     /*<<arg.ml:108:29>>*/ return  /*<<arg.ml:108:29>>*/ caml_call2
-            (Stdlib_List[17], _at_, _as_);
-    /*<<arg.ml:108:48>>*/ }
-   function usage_string(speclist, errmsg){
-     /*<<arg.ml:112:2>>*/  /*<<arg.ml:112:10>>*/ var
-     b =  /*<<arg.ml:112:10>>*/ caml_call1(Stdlib_Buffer[1], 200);
-     /*<<arg.ml:113:2>>*/ usage_b(b, speclist, errmsg);
-     /*<<arg.ml:113:2>>*/ return  /*<<arg.ml:113:2>>*/ caml_call1
-            (Stdlib_Buffer[2], b);
-    /*<<arg.ml:114:19>>*/ }
-   function usage(speclist, errmsg){
-     /*<<arg.ml:118:2>>*/  /*<<arg.ml:118:15>>*/ var
-     _ar_ = usage_string(speclist, errmsg);
-     /*<<arg.ml:118:15>>*/ return  /*<<arg.ml:118:15>>*/ caml_call2
-            (Stdlib_Printf[3], _e_, _ar_);
-    /*<<arg.ml:118:45>>*/ }
-    /*<<arg.ml:121:14>>*/  /*<<arg.ml:121:14>>*/ var current = [0, 0];
-   function int_of_string_opt(x){
-     /*<<arg.ml:128:2>>*/ try{
-      /*<<arg.ml:128:6>>*/  /*<<arg.ml:128:6>>*/ var
-      _ap_ = [0,  /*<<arg.ml:128:11>>*/ runtime.caml_int_of_string(x)];
-      /*<<arg.ml:128:6>>*/ return _ap_;
-    }
-    catch(_aq_){
-     var _ao_ = caml_wrap_exception(_aq_);
-     if(_ao_[1] === Stdlib[7])  /*<<arg.ml:129:20>>*/ return 0;
-     throw caml_maybe_attach_backtrace(_ao_, 0);
-    }
-    /*<<arg.ml:129:24>>*/ }
-   function float_of_string_opt(x){
-     /*<<arg.ml:132:2>>*/ try{
-      /*<<arg.ml:132:6>>*/  /*<<arg.ml:132:6>>*/ var
-      _am_ = [0,  /*<<arg.ml:132:11>>*/ runtime.caml_float_of_string(x)];
-      /*<<arg.ml:132:6>>*/ return _am_;
-    }
-    catch(_an_){
-     var _al_ = caml_wrap_exception(_an_);
-     if(_al_[1] === Stdlib[7])  /*<<arg.ml:133:20>>*/ return 0;
-     throw caml_maybe_attach_backtrace(_al_, 0);
-    }
-    /*<<arg.ml:133:24>>*/ }
-   function parse_and_expand_argv_dynamic_
-   (allow_expand, current, argv, speclist, anonfun, errmsg){
-    var initpos = current[1];
-    function convert_error(error){
-      /*<<arg.ml:143:4>>*/ var
-       /*<<arg.ml:143:12>>*/ b =
-         /*<<arg.ml:143:12>>*/ caml_call1(Stdlib_Buffer[1], 200),
-      progname =
-        initpos < argv[1].length - 1
-         ? caml_check_bound(argv[1], initpos)[1 + initpos]
-         : cst$2;
-      /*<<arg.ml:146:4>>*/ switch(error[0]){
-       case 0:
-        var s = error[1];
-        if
-         (caml_string_notequal(s, cst_help$4)
-          && caml_string_notequal(s, cst_help$3))
-          /*<<arg.ml:150:10>>*/  /*<<arg.ml:150:10>>*/ caml_call4
-          (Stdlib_Printf[5], b, _f_, progname, s);
-        break;
-       case 1:
-        var expected = error[3], arg = error[2], opt = error[1];
-         /*<<arg.ml:154:10>>*/  /*<<arg.ml:154:10>>*/ caml_call6
-         (Stdlib_Printf[5], b, _i_, progname, arg, opt, expected);
-        break;
-       case 2:
-        var s$0 = error[1];
-         /*<<arg.ml:152:10>>*/  /*<<arg.ml:152:10>>*/ caml_call4
-         (Stdlib_Printf[5], b, _j_, progname, s$0);
-        break;
-       default:
-        var s$1 = error[1];
-         /*<<arg.ml:157:10>>*/  /*<<arg.ml:157:10>>*/ caml_call4
-         (Stdlib_Printf[5], b, _k_, progname, s$1);
-     }
-      /*<<arg.ml:159:4>>*/ usage_b(b, speclist[1], errmsg);
-      /*<<arg.ml:160:34>>*/ if
-      (!
-        /*<<arg.ml:160:7>>*/ caml_equal(error, _g_)
-       && !  /*<<arg.ml:160:34>>*/ caml_equal(error, _h_))
-       /*<<arg.ml:162:9>>*/ return [0,
-              Bad,
-               /*<<arg.ml:162:13>>*/ caml_call1(Stdlib_Buffer[2], b)];
-      /*<<arg.ml:161:9>>*/ return [0,
-             Help,
-              /*<<arg.ml:161:14>>*/ caml_call1(Stdlib_Buffer[2], b)];
-     /*<<arg.ml:162:32>>*/ }
-     /*<<arg.ml:164:2>>*/ current[1]++;
-    for(;;){
-     if(current[1] >= argv[1].length - 1) return 0;
-      /*<<arg.ml:166:4>>*/ try{
-       /*<<arg.ml:167:14>>*/ var
-       _Y_ = current[1],
-        /*<<arg.ml:167:14>>*/ s = caml_check_bound(argv[1], _Y_)[1 + _Y_];
-      a:
-      {
-        /*<<arg.ml:168:33>>*/ if
-        (1 <=  /*<<arg.ml:168:6>>*/ caml_ml_string_length(s)
-         && 45 ===  /*<<arg.ml:168:33>>*/ caml_string_get(s, 0)){
-        try{
-          /*<<arg.ml:170:14>>*/ var
-          follow$1 = 0,
-           /*<<arg.ml:170:14>>*/ _aa_ = assoc3(s, speclist[1]),
-          follow$0 = follow$1,
-          action = _aa_;
-        }
-        catch(_aj_){
-         var _Z_ = caml_wrap_exception(_aj_);
-         if(_Z_ !== Stdlib[8]) throw caml_maybe_attach_backtrace(_Z_, 0);
-          /*<<arg.ml:172:10>>*/ try{
-           /*<<arg.ml:71:10>>*/ var
-            /*<<arg.ml:71:10>>*/ i =
-              /*<<arg.ml:71:10>>*/ caml_call2(Stdlib_String[35], s, 61),
-            /*<<arg.ml:72:2>>*/ len =
-              /*<<arg.ml:72:2>>*/ caml_ml_string_length(s),
-            /*<<arg.ml:73:20>>*/ arg =
-              /*<<arg.ml:73:20>>*/ caml_call3
-              (Stdlib_String[15], s, i + 1 | 0, len - (i + 1 | 0) | 0),
-            /*<<arg.ml:73:2>>*/ keyword =
-              /*<<arg.ml:73:2>>*/ caml_call3(Stdlib_String[15], s, 0, i),
-            /*<<arg.ml:174:38>>*/ follow = [0, arg],
-            /*<<arg.ml:174:12>>*/ _$_ = assoc3(keyword, speclist[1]),
-           follow$0 = follow,
-           action = _$_;
-         }
-         catch(_ak_){
-          var ___ = caml_wrap_exception(_ak_);
-          if(___ === Stdlib[8])
-            /*<<arg.ml:175:28>>*/ throw  /*<<arg.ml:175:28>>*/ caml_maybe_attach_backtrace
-                  ([0, Stop, [0, s]], 1);
-          throw caml_maybe_attach_backtrace(___, 0);
-         }
-        }
-        var
-         no_arg$0 =
-           function(s, follow){
-            function no_arg(param){
-              /*<<arg.ml:178:10>>*/ if(! follow)
-               /*<<arg.ml:179:20>>*/ return 0;
-             var arg = follow[1];
-              /*<<arg.ml:180:24>>*/ throw  /*<<arg.ml:180:24>>*/ caml_maybe_attach_backtrace
-                    ([0, Stop, [1, s, arg, cst_no_argument]], 1);
-             /*<<arg.ml:180:68>>*/ }
-            return no_arg;
-           },
-         no_arg = no_arg$0(s, follow$0),
-         get_arg$0 =
-           function(s, follow){
-            function get_arg(param){
-              /*<<arg.ml:182:10>>*/ if(follow){
-              var arg = follow[1];
-               /*<<arg.ml:186:24>>*/ return arg;
-             }
-             if((current[1] + 1 | 0) >= argv[1].length - 1)
-               /*<<arg.ml:185:19>>*/ throw  /*<<arg.ml:185:19>>*/ caml_maybe_attach_backtrace
-                     ([0, Stop, [2, s]], 1);
-             var _ai_ = current[1] + 1 | 0;
-              /*<<arg.ml:184:58>>*/ return caml_check_bound(argv[1], _ai_)
-                     [1 + _ai_];
-             /*<<arg.ml:186:27>>*/ }
-            return get_arg;
-           },
-         get_arg = get_arg$0(s, follow$0),
-         consume_arg$0 =
-           function(follow){
-            function consume_arg(param){
-              /*<<arg.ml:189:10>>*/ return follow ? 0 : (current[1]++, 0);
-             /*<<arg.ml:191:24>>*/ }
-            return consume_arg;
-           },
-         consume_arg = consume_arg$0(follow$0),
-         treat_action$0 =
-           function(s, no_arg, get_arg, consume_arg){
-            function treat_action(param){
-              /*<<arg.ml:193:31>>*/ switch(param[0]){
-               case 0:
-                var f = param[1];
-                 /*<<arg.ml:194:20>>*/ no_arg(0);
-                 /*<<arg.ml:194:20>>*/ return  /*<<arg.ml:194:20>>*/ caml_call1
-                        (f, 0);
-               case 1:
-                 /*<<arg.ml:196:22>>*/ var
-                 f$0 = param[1],
-                  /*<<arg.ml:196:22>>*/ arg = get_arg(0);
-                 /*<<arg.ml:124:2>>*/ try{
-                  /*<<arg.ml:124:6>>*/ var
-                   /*<<arg.ml:124:6>>*/ _ac_ =
-                    [0,  /*<<arg.ml:124:11>>*/ caml_call1(Stdlib[32], arg)],
-                  match = _ac_;
-                }
-                catch(_ah_){
-                 var _ab_ = caml_wrap_exception(_ah_);
-                 if(_ab_[1] !== Stdlib[6])
-                  throw caml_maybe_attach_backtrace(_ab_, 0);
-                 var match = 0;
-                }
-                if(! match)
-                  /*<<arg.ml:198:22>>*/ throw  /*<<arg.ml:198:22>>*/ caml_maybe_attach_backtrace
-                        ([0, Stop, [1, s, arg, cst_a_boolean]], 1);
-                var s$0 = match[1];
-                 /*<<arg.ml:199:24>>*/  /*<<arg.ml:199:24>>*/ caml_call1
-                 (f$0, s$0);
-                 /*<<arg.ml:201:12>>*/ return consume_arg(0);
-               case 2:
-                var r = param[1];
-                 /*<<arg.ml:202:19>>*/ no_arg(0);
-                r[1] = 1;
-                return 0;
-               case 3:
-                var r$0 = param[1];
-                 /*<<arg.ml:203:21>>*/ no_arg(0);
-                r$0[1] = 0;
-                return 0;
-               case 4:
-                 /*<<arg.ml:205:22>>*/ var
-                 f$1 = param[1],
-                  /*<<arg.ml:205:22>>*/ arg$0 = get_arg(0);
-                 /*<<arg.ml:206:12>>*/  /*<<arg.ml:206:12>>*/ caml_call1
-                 (f$1, arg$0);
-                 /*<<arg.ml:206:12>>*/ return consume_arg(0);
-               case 5:
-                var r$1 = param[1];
-                r$1[1] = get_arg(0);
-                 /*<<arg.ml:219:12>>*/ return consume_arg(0);
-               case 6:
-                 /*<<arg.ml:221:22>>*/ var
-                 f$2 = param[1],
-                  /*<<arg.ml:221:22>>*/ arg$1 = get_arg(0),
-                  /*<<arg.ml:222:24>>*/ match$0 = int_of_string_opt(arg$1);
-                if(! match$0)
-                  /*<<arg.ml:223:22>>*/ throw  /*<<arg.ml:223:22>>*/ caml_maybe_attach_backtrace
-                        ([0, Stop, [1, s, arg$1, cst_an_integer]], 1);
-                var x = match$0[1];
-                 /*<<arg.ml:224:24>>*/  /*<<arg.ml:224:24>>*/ caml_call1
-                 (f$2, x);
-                 /*<<arg.ml:226:12>>*/ return consume_arg(0);
-               case 7:
-                 /*<<arg.ml:228:22>>*/ var
-                 r$2 = param[1],
-                  /*<<arg.ml:228:22>>*/ arg$2 = get_arg(0),
-                  /*<<arg.ml:229:24>>*/ match$1 = int_of_string_opt(arg$2);
-                if(! match$1)
-                  /*<<arg.ml:230:22>>*/ throw  /*<<arg.ml:230:22>>*/ caml_maybe_attach_backtrace
-                        ([0, Stop, [1, s, arg$2, cst_an_integer$0]], 1);
-                var x$0 = match$1[1];
-                r$2[1] = x$0;
-                 /*<<arg.ml:233:12>>*/ return consume_arg(0);
-               case 8:
-                 /*<<arg.ml:235:22>>*/ var
-                 f$3 = param[1],
-                  /*<<arg.ml:235:22>>*/ arg$3 = get_arg(0),
-                  /*<<arg.ml:236:24>>*/ match$2 = float_of_string_opt(arg$3);
-                if(! match$2)
-                  /*<<arg.ml:237:22>>*/ throw  /*<<arg.ml:237:22>>*/ caml_maybe_attach_backtrace
-                        ([0, Stop, [1, s, arg$3, cst_a_float]], 1);
-                var x$1 = match$2[1];
-                 /*<<arg.ml:238:24>>*/  /*<<arg.ml:238:24>>*/ caml_call1
-                 (f$3, x$1);
-                 /*<<arg.ml:240:12>>*/ return consume_arg(0);
-               case 9:
-                 /*<<arg.ml:242:22>>*/ var
-                 r$3 = param[1],
-                  /*<<arg.ml:242:22>>*/ arg$4 = get_arg(0),
-                  /*<<arg.ml:243:24>>*/ match$3 = float_of_string_opt(arg$4);
-                if(! match$3)
-                  /*<<arg.ml:244:22>>*/ throw  /*<<arg.ml:244:22>>*/ caml_maybe_attach_backtrace
-                        ([0, Stop, [1, s, arg$4, cst_a_float$0]], 1);
-                var x$2 = match$3[1];
-                r$3[1] = x$2;
-                 /*<<arg.ml:247:12>>*/ return consume_arg(0);
-               case 10:
-                var specs = param[1];
-                 /*<<arg.ml:249:12>>*/ no_arg(0);
-                 /*<<arg.ml:249:12>>*/ return  /*<<arg.ml:249:12>>*/ caml_call2
-                        (Stdlib_List[17], treat_action, specs);
-               case 11:
-                 /*<<arg.ml:209:22>>*/ var
-                 f$4 = param[2],
-                 symb = param[1],
-                  /*<<arg.ml:209:22>>*/ arg$5 = get_arg(0);
-                 /*<<arg.ml:210:15>>*/ if
-                 ( /*<<arg.ml:210:15>>*/ caml_call2
-                   (Stdlib_List[36], arg$5, symb)){
-                  /*<<arg.ml:211:14>>*/  /*<<arg.ml:211:14>>*/ caml_call1
-                  (f$4, arg$5);
-                  /*<<arg.ml:211:14>>*/ return consume_arg(0);
-                }
-                 /*<<arg.ml:215:44>>*/  /*<<arg.ml:215:44>>*/ var
-                 _ad_ = make_symlist(cst$5, cst$4, cst$3, symb);
-                 /*<<arg.ml:213:21>>*/ throw  /*<<arg.ml:213:21>>*/ caml_maybe_attach_backtrace
-                       ([0,
-                         Stop,
-                         [1,
-                          s,
-                          arg$5,
-                           /*<<arg.ml:214:42>>*/ caml_call2
-                           (Stdlib[28], cst_one_of, _ad_)]],
-                        1);
-               case 12:
-                var f$5 = param[1];
-                 /*<<arg.ml:252:12>>*/ no_arg(0);
-                 /*<<arg.ml:255:14>>*/ for(;;){
-                 if(current[1] >= (argv[1].length - 1 - 1 | 0)) return 0;
-                 var _ae_ = current[1] + 1 | 0;
-                  /*<<arg.ml:254:14>>*/  /*<<arg.ml:254:14>>*/ caml_call1
-                  (f$5, caml_check_bound(argv[1], _ae_)[1 + _ae_]);
-                  /*<<arg.ml:255:14>>*/ consume_arg(0);
-                }
-                break;
-               case 13:
-                var f$6 = param[1];
-                 /*<<arg.ml:258:12>>*/ no_arg(0);
-                 /*<<arg.ml:259:22>>*/  /*<<arg.ml:259:22>>*/ var
-                 acc = [0, 0];
-                 /*<<arg.ml:262:14>>*/ for(;;){
-                 if(current[1] >= (argv[1].length - 1 - 1 | 0))
-                   /*<<arg.ml:264:14>>*/ return  /*<<arg.ml:264:14>>*/ caml_call1
-                          (f$6,
-                            /*<<arg.ml:264:14>>*/ caml_call1(Stdlib_List[9], acc[1]));
-                 var _ag_ = current[1] + 1 | 0, _af_ = acc[1];
-                 acc[1] = [0, caml_check_bound(argv[1], _ag_)[1 + _ag_], _af_];
-                  /*<<arg.ml:262:14>>*/ consume_arg(0);
-                }
-                break;
-               default:
-                var f$7 = param[1];
-                if(1 - allow_expand)
-                  /*<<arg.ml:267:14>>*/ throw  /*<<arg.ml:267:14>>*/ caml_maybe_attach_backtrace
-                        ([0, Stdlib[6], cst_Arg_Expand_is_is_only_allo], 1);
-                 /*<<arg.ml:269:22>>*/ var
-                  /*<<arg.ml:269:22>>*/ arg$6 = get_arg(0),
-                  /*<<arg.ml:270:25>>*/ newarg =
-                    /*<<arg.ml:270:25>>*/ caml_call1(f$7, arg$6);
-                 /*<<arg.ml:271:12>>*/ consume_arg(0);
-                 /*<<arg.ml:272:25>>*/ var
-                  /*<<arg.ml:272:25>>*/ before =
-                    /*<<arg.ml:272:25>>*/ caml_call3
-                    (Stdlib_Array[5], argv[1], 0, current[1] + 1 | 0),
-                  /*<<arg.ml:274:14>>*/ after =
-                    /*<<arg.ml:274:14>>*/ caml_call3
-                    (Stdlib_Array[5],
-                     argv[1],
-                     current[1] + 1 | 0,
-                     (argv[1].length - 1 - current[1] | 0) - 1 | 0);
-                argv[1] =
-                  /*<<arg.ml:276:19>>*/ caml_call1
-                  (Stdlib_Array[4], [0, before, [0, newarg, [0, after, 0]]]);
-                return 0;
-             }
-             /*<<arg.ml:276:54>>*/ }
-            return treat_action;
-           },
-         treat_action = treat_action$0(s, no_arg, get_arg, consume_arg);
-         /*<<arg.ml:278:8>>*/ treat_action(action);
-        break a;
-       }
-        /*<<arg.ml:279:11>>*/  /*<<arg.ml:279:11>>*/ caml_call1(anonfun, s);
-      }
-     }
-     catch(exn$0){
-      var exn = caml_wrap_exception(exn$0);
-      if(exn[1] === Bad){
-       var m = exn[2];
-        /*<<arg.ml:280:26>>*/ throw  /*<<arg.ml:280:26>>*/ caml_maybe_attach_backtrace
-              (convert_error([3, m]), 1);
-      }
-      if(exn[1] !== Stop) throw caml_maybe_attach_backtrace(exn, 0);
-      var e = exn[2];
-       /*<<arg.ml:281:27>>*/ throw  /*<<arg.ml:281:27>>*/ caml_maybe_attach_backtrace
-             (convert_error(e), 1);
-     }
-     current[1]++;
-    }
-   }
-   function parse_and_expand_argv_dynamic
-   (current, argv, speclist, anonfun, errmsg){
-     /*<<arg.ml:287:2>>*/ return parse_and_expand_argv_dynamic_
-            (1, current, argv, speclist, anonfun, errmsg);
-    /*<<arg.ml:287:77>>*/ }
-   function parse_argv_dynamic(opt, argv, speclist, anonfun, errmsg){
-     /*<<arg.ml:290:2>>*/ if(opt)
-     var sth = opt[1], current$0 = sth;
-    else
-     var current$0 = current;
-     /*<<arg.ml:290:2>>*/ return parse_and_expand_argv_dynamic_
-            (0, current$0, [0, argv], speclist, anonfun, errmsg);
-    /*<<arg.ml:291:10>>*/ }
-   function parse_argv(opt, argv, speclist, anonfun, errmsg){
-     /*<<arg.ml:295:2>>*/ if(opt)
-     var sth = opt[1], current$0 = sth;
-    else
-     var current$0 = current;
-     /*<<arg.ml:295:2>>*/ return parse_argv_dynamic
-            ([0, current$0], argv, [0, speclist], anonfun, errmsg);
-    /*<<arg.ml:295:72>>*/ }
-   function parse(l, f, msg){
-     /*<<arg.ml:299:2>>*/ try{
-      /*<<arg.ml:300:4>>*/  /*<<arg.ml:300:4>>*/ var
-      _X_ = parse_argv(0, caml_sys_argv(0), l, f, msg);
-      /*<<arg.ml:300:4>>*/ return _X_;
-    }
-    catch(exn$0){
-     var exn = caml_wrap_exception(exn$0);
-     if(exn[1] === Bad){
-      var msg$0 = exn[2];
-       /*<<arg.ml:302:15>>*/  /*<<arg.ml:302:15>>*/ caml_call2
-       (Stdlib_Printf[3], _l_, msg$0);
-       /*<<arg.ml:302:15>>*/ return  /*<<arg.ml:302:15>>*/ caml_call1
-              (Stdlib[99], 2);
-     }
-     if(exn[1] !== Help) throw caml_maybe_attach_backtrace(exn, 0);
-     var msg$1 = exn[2];
-      /*<<arg.ml:303:16>>*/  /*<<arg.ml:303:16>>*/ caml_call2
-      (Stdlib_Printf[2], _m_, msg$1);
-      /*<<arg.ml:303:16>>*/ return  /*<<arg.ml:303:16>>*/ caml_call1
-             (Stdlib[99], 0);
-    }
-    /*<<arg.ml:303:39>>*/ }
-   function parse_dynamic(l, f, msg){
-     /*<<arg.ml:307:2>>*/ try{
-      /*<<arg.ml:308:4>>*/  /*<<arg.ml:308:4>>*/ var
-      _W_ = parse_argv_dynamic(0, caml_sys_argv(0), l, f, msg);
-      /*<<arg.ml:308:4>>*/ return _W_;
-    }
-    catch(exn$0){
-     var exn = caml_wrap_exception(exn$0);
-     if(exn[1] === Bad){
-      var msg$0 = exn[2];
-       /*<<arg.ml:310:15>>*/  /*<<arg.ml:310:15>>*/ caml_call2
-       (Stdlib_Printf[3], _n_, msg$0);
-       /*<<arg.ml:310:15>>*/ return  /*<<arg.ml:310:15>>*/ caml_call1
-              (Stdlib[99], 2);
-     }
-     if(exn[1] !== Help) throw caml_maybe_attach_backtrace(exn, 0);
-     var msg$1 = exn[2];
-      /*<<arg.ml:311:16>>*/  /*<<arg.ml:311:16>>*/ caml_call2
-      (Stdlib_Printf[2], _o_, msg$1);
-      /*<<arg.ml:311:16>>*/ return  /*<<arg.ml:311:16>>*/ caml_call1
-             (Stdlib[99], 0);
-    }
-    /*<<arg.ml:311:39>>*/ }
-   function parse_expand(l, f, msg){
-     /*<<arg.ml:314:2>>*/ try{
-      /*<<arg.ml:315:15>>*/ var
-       /*<<arg.ml:315:15>>*/ argv = [0, caml_sys_argv(0)],
-       /*<<arg.ml:316:15>>*/ spec = [0, l],
-       /*<<arg.ml:317:18>>*/ current$0 = [0, current[1]],
-       /*<<arg.ml:318:4>>*/ _V_ =
-        parse_and_expand_argv_dynamic(current$0, argv, spec, f, msg);
-      /*<<arg.ml:318:4>>*/ return _V_;
-    }
-    catch(exn$0){
-     var exn = caml_wrap_exception(exn$0);
-     if(exn[1] === Bad){
-      var msg$0 = exn[2];
-       /*<<arg.ml:320:15>>*/  /*<<arg.ml:320:15>>*/ caml_call2
-       (Stdlib_Printf[3], _p_, msg$0);
-       /*<<arg.ml:320:15>>*/ return  /*<<arg.ml:320:15>>*/ caml_call1
-              (Stdlib[99], 2);
-     }
-     if(exn[1] !== Help) throw caml_maybe_attach_backtrace(exn, 0);
-     var msg$1 = exn[2];
-      /*<<arg.ml:321:16>>*/  /*<<arg.ml:321:16>>*/ caml_call2
-      (Stdlib_Printf[2], _q_, msg$1);
-      /*<<arg.ml:321:16>>*/ return  /*<<arg.ml:321:16>>*/ caml_call1
-             (Stdlib[99], 0);
-    }
-    /*<<arg.ml:321:39>>*/ }
-   function second_word(s){
-     /*<<arg.ml:325:2>>*/ var len = caml_ml_string_length(s);
-    function loop(n){
-      /*<<arg.ml:327:4>>*/ var n$0 = n;
-      /*<<arg.ml:327:4>>*/ for(;;){
-      if(len <= n$0)  /*<<arg.ml:326:2>>*/ return len;
-       /*<<arg.ml:328:12>>*/ if
-       (32 !==  /*<<arg.ml:328:12>>*/ caml_string_get(s, n$0))
-        /*<<arg.ml:329:9>>*/ return n$0;
-       /*<<arg.ml:328:29>>*/ var
-        /*<<arg.ml:328:29>>*/ n$1 = n$0 + 1 | 0,
-       n$0 = n$1;
-     }
-     /*<<arg.ml:329:10>>*/ }
-     /*<<arg.ml:331:2>>*/ try{
-      /*<<arg.ml:331:8>>*/  /*<<arg.ml:331:8>>*/ var
-      n$0 =  /*<<arg.ml:331:8>>*/ caml_call2(Stdlib_String[35], s, 9);
-    }
-    catch(_T_){
-     var _R_ = caml_wrap_exception(_T_);
-     if(_R_ !== Stdlib[8]) throw caml_maybe_attach_backtrace(_R_, 0);
-      /*<<arg.ml:334:6>>*/ try{
-       /*<<arg.ml:334:18>>*/  /*<<arg.ml:334:18>>*/ var
-       n =  /*<<arg.ml:334:18>>*/ caml_call2(Stdlib_String[35], s, 32);
-     }
-     catch(_U_){
-      var _S_ = caml_wrap_exception(_U_);
-      if(_S_ === Stdlib[8])  /*<<arg.ml:336:31>>*/ return len;
-      throw caml_maybe_attach_backtrace(_S_, 0);
-     }
-      /*<<arg.ml:334:18>>*/ return loop(n + 1 | 0);
-    }
-     /*<<arg.ml:331:8>>*/ return loop(n$0 + 1 | 0);
-    /*<<arg.ml:337:9>>*/ }
-   function max_arg_len(cur, param){
-    var doc = param[3], spec = param[2], kwd = param[1];
-     /*<<arg.ml:341:2>>*/ if(11 === spec[0])
-     return caml_call2(Stdlib_Int[11], cur, caml_ml_string_length(kwd));
-    var _Q_ = caml_ml_string_length(kwd) + second_word(doc) | 0;
-    return caml_call2(Stdlib_Int[11], cur, _Q_);
-   }
-   function replace_leading_tab(s){
-     /*<<arg.ml:347:2>>*/  /*<<arg.ml:347:13>>*/ var seen = [0, 0];
-    function _P_(c){
-      /*<<arg.ml:348:13>>*/ if(9 === c && ! seen[1]){
-      seen[1] = 1;
-       /*<<arg.ml:348:60>>*/ return 32;
-     }
-      /*<<arg.ml:348:71>>*/ return c;
-     /*<<arg.ml:348:73>>*/ }
-     /*<<arg.ml:348:2>>*/ return  /*<<arg.ml:348:2>>*/ caml_call2
-            (Stdlib_String[17], _P_, s);
-    /*<<arg.ml:348:75>>*/ }
-   function align(opt, speclist){
-     /*<<arg.ml:374:2>>*/ if(opt)
-     var sth = opt[1], limit = sth;
-    else
-     var limit = Stdlib[19];
-     /*<<arg.ml:374:18>>*/ var
-      /*<<arg.ml:374:18>>*/ completed = add_help(speclist),
-      /*<<arg.ml:375:12>>*/ len =
-        /*<<arg.ml:375:12>>*/ caml_call3
-        (Stdlib_List[25], max_arg_len, 0, completed),
-      /*<<arg.ml:376:12>>*/ len$0 =
-        /*<<arg.ml:376:12>>*/ caml_call2(Stdlib_Int[10], len, limit);
-     /*<<arg.ml:377:11>>*/ function _J_(ksd){
-     var kwd = ksd[1], spec = ksd[2];
-     if(! caml_string_notequal(ksd[3], cst$7))
-       /*<<arg.ml:355:6>>*/ return ksd;
-     if(11 === spec[0]){
-       /*<<arg.ml:357:19>>*/ var
-       msg$0 = ksd[3],
-        /*<<arg.ml:357:19>>*/ cutcol$0 = second_word(msg$0),
-        /*<<arg.ml:358:32>>*/ _M_ =
-          /*<<arg.ml:358:32>>*/ caml_call2
-          (Stdlib_Int[11], 0, len$0 - cutcol$0 | 0)
-         + 3
-         | 0,
-        /*<<arg.ml:358:19>>*/ spaces$0 =
-          /*<<arg.ml:358:19>>*/ caml_call2(Stdlib_String[1], _M_, 32),
-        /*<<arg.ml:359:34>>*/ _N_ = replace_leading_tab(msg$0),
-        /*<<arg.ml:359:25>>*/ _O_ =
-          /*<<arg.ml:359:25>>*/ caml_call2(Stdlib[28], spaces$0, _N_);
-       /*<<arg.ml:359:6>>*/ return [0,
-              kwd,
-              spec,
-               /*<<arg.ml:359:18>>*/ caml_call2(Stdlib[28], cst$6, _O_)];
-     }
-      /*<<arg.ml:361:19>>*/ var
-      msg = ksd[3],
-      spec$0 = ksd[2],
-       /*<<arg.ml:361:19>>*/ cutcol = second_word(msg),
-       /*<<arg.ml:362:6>>*/ kwd_len =
-         /*<<arg.ml:362:6>>*/ caml_ml_string_length(kwd),
-      diff = (len$0 - kwd_len | 0) - cutcol | 0;
-      /*<<arg.ml:364:6>>*/ if(0 >= diff)
-       /*<<arg.ml:365:8>>*/ return [0, kwd, spec$0, replace_leading_tab(msg)];
-      /*<<arg.ml:367:21>>*/ var
-       /*<<arg.ml:367:21>>*/ spaces =
-         /*<<arg.ml:367:21>>*/ caml_call2(Stdlib_String[1], diff, 32),
-       /*<<arg.ml:368:32>>*/ _K_ = replace_leading_tab(msg),
-       /*<<arg.ml:368:21>>*/ prefix =
-         /*<<arg.ml:368:21>>*/ caml_call3(Stdlib_String[15], _K_, 0, cutcol),
-       /*<<arg.ml:369:21>>*/ suffix =
-         /*<<arg.ml:369:21>>*/ caml_call3
-         (Stdlib_String[15],
-          msg,
-          cutcol,
-          caml_ml_string_length(msg) - cutcol | 0),
-       /*<<arg.ml:370:29>>*/ _L_ =
-         /*<<arg.ml:370:29>>*/ caml_call2(Stdlib[28], spaces, suffix);
-      /*<<arg.ml:370:8>>*/ return [0,
-             kwd,
-             spec$0,
-              /*<<arg.ml:370:20>>*/ caml_call2(Stdlib[28], prefix, _L_)];
-    }
-     /*<<arg.ml:377:2>>*/ return  /*<<arg.ml:377:2>>*/ caml_call2
-            (Stdlib_List[19], _J_, completed);
-    /*<<arg.ml:377:38>>*/ }
-   function read_aux(trim, sep, file){
-     /*<<arg.ml:387:2>>*/ var
-      /*<<arg.ml:387:11>>*/ ic =
-        /*<<arg.ml:387:11>>*/ caml_call1(Stdlib[80], file),
-      /*<<arg.ml:388:12>>*/ buf =
-        /*<<arg.ml:388:12>>*/ caml_call1(Stdlib_Buffer[1], 200),
-      /*<<arg.ml:389:14>>*/ words = [0, 0];
-    function stash(param){
-      /*<<arg.ml:391:4>>*/  /*<<arg.ml:391:15>>*/ var
-      word =  /*<<arg.ml:391:15>>*/ caml_call1(Stdlib_Buffer[2], buf);
-      /*<<arg.ml:392:4>>*/ if(trim){
-      var len = caml_ml_string_length(word);
-      a:
-      {
-        /*<<arg.ml:381:16>>*/ if
-        (0 < len
-         && 13 ===  /*<<arg.ml:381:16>>*/ caml_string_get(word, len - 1 | 0)){
-        var
-         _I_ =
-            /*<<arg.ml:382:4>>*/ caml_call3
-            (Stdlib_String[15], word, 0, len - 1 | 0);
-        break a;
-       }
-       var _I_ = word;
-      }
-      var word$0 = _I_;
-     }
-     else
-      var word$0 = word;
-     words[1] = [0, word$0, words[1]];
-      /*<<arg.ml:390:2>>*/ return  /*<<arg.ml:390:2>>*/ caml_call1
-             (Stdlib_Buffer[8], buf);
-     /*<<arg.ml:394:20>>*/ }
-     /*<<arg.ml:396:2>>*/ try{
-     for(;;){
-       /*<<arg.ml:398:16>>*/  /*<<arg.ml:398:16>>*/ var
-       c =  /*<<arg.ml:398:16>>*/ caml_call1(Stdlib[82], ic);
-      if(c === sep)
-        /*<<arg.ml:399:24>>*/ stash(0);
-      else
-        /*<<arg.ml:399:38>>*/  /*<<arg.ml:399:38>>*/ caml_call2
-        (Stdlib_Buffer[12], buf, c);
-     }
-    }
-    catch(_H_){
-     var _F_ = caml_wrap_exception(_H_);
-     if(_F_ !== Stdlib[12]) throw caml_maybe_attach_backtrace(_F_, 0);
-     if(0 <  /*<<arg.ml:403:5>>*/ caml_call1(Stdlib_Buffer[7], buf))
-       /*<<arg.ml:403:32>>*/ stash(0);
-      /*<<arg.ml:404:2>>*/  /*<<arg.ml:404:2>>*/ caml_call1(Stdlib[93], ic);
-      /*<<arg.ml:405:16>>*/  /*<<arg.ml:405:16>>*/ var
-      _G_ =  /*<<arg.ml:405:16>>*/ caml_call1(Stdlib_List[9], words[1]);
-      /*<<arg.ml:405:16>>*/ return  /*<<arg.ml:405:16>>*/ caml_call1
-             (Stdlib_Array[10], _G_);
-    }
-    /*<<arg.ml:405:33>>*/ }
-   var _r_ = 10, _s_ = 1;
-    /*<<arg.ml:407:15>>*/ function read_arg(_E_){
-     /*<<?>>*/ return read_aux(_s_, _r_, _E_);
-   }
-    /*<<arg.ml:407:15>>*/ var  /*<<arg.ml:407:15>>*/ _t_ = 0, _u_ = 0;
-    /*<<arg.ml:409:16>>*/ function read_arg0(_D_){
-     /*<<?>>*/ return read_aux(_u_, _t_, _D_);
-   }
-   function write_aux(sep, file, args){
-     /*<<arg.ml:412:2>>*/  /*<<arg.ml:412:11>>*/ var
-     oc =  /*<<arg.ml:412:11>>*/ caml_call1(Stdlib[61], file);
-    function _C_(s){
-      /*<<arg.ml:413:23>>*/ return caml_call4
-             (Stdlib_Printf[1], oc, _v_, s, sep);
-     /*<<arg.ml:413:46>>*/ }
-     /*<<arg.ml:413:2>>*/  /*<<arg.ml:413:2>>*/ caml_call2
-     (Stdlib_Array[11], _C_, args);
-     /*<<arg.ml:413:2>>*/ return  /*<<arg.ml:413:2>>*/ caml_call1
-            (Stdlib[76], oc);
-    /*<<arg.ml:414:14>>*/ }
-   var _w_ = 10;
-    /*<<arg.ml:416:16>>*/ function write_arg(_A_, _B_){
-     /*<<?>>*/ return write_aux(_w_, _A_, _B_);
-   }
-    /*<<arg.ml:416:16>>*/  /*<<arg.ml:416:16>>*/ var _x_ = 0;
-    /*<<arg.ml:418:17>>*/ function write_arg0(_y_, _z_){
-     /*<<?>>*/ return write_aux(_x_, _y_, _z_);
-   }
-   var
-    Stdlib_Arg =
-      [0,
-       parse,
-       parse_dynamic,
-       parse_argv,
-       parse_argv_dynamic,
-       parse_and_expand_argv_dynamic,
-       parse_expand,
-       Help,
-       Bad,
-       usage,
-       usage_string,
-       align,
-       current,
-       read_arg,
-       read_arg0,
-       write_arg,
-       write_arg0];
-   runtime.caml_register_global(54, Stdlib_Arg, "Stdlib__Arg");
-   return;
-   /*<<?>>*/ }
-  (globalThis));
-
-//# unitInfo: Provides: Stdlib__Printexc
-//# unitInfo: Requires: Stdlib, Stdlib__Atomic, Stdlib__Buffer, Stdlib__Obj, Stdlib__Printf
-(function
-  (globalThis){
-   "use strict";
-   var
-    runtime = globalThis.jsoo_runtime,
-    cst$4 = "",
-    cst_s = "%s\n",
-    cst_Program_not_linked_with_g_$0 =
-      "(Program not linked with -g, cannot print stack backtrace)\n",
-    cst_characters = ", characters ",
-    cst_Fatal_error_exception = "Fatal error: exception ",
-    cst_Fatal_error_exception_s = "Fatal error: exception %s\n",
-    cst_Uncaught_exception = "Uncaught exception: ",
-    cst_Uncaught_exception_s = "Uncaught exception: %s\n",
-    caml_check_bound = runtime.caml_check_bound,
-    caml_get_exception_raw_backtra = runtime.caml_get_exception_raw_backtrace,
-    caml_maybe_attach_backtrace = runtime.caml_maybe_attach_backtrace,
-    caml_obj_tag = runtime.caml_obj_tag,
-    caml_wrap_exception = runtime.caml_wrap_exception;
-    /*<<?>>*/ function caml_call1(f, a0){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 1
-            ? f(a0)
-            : runtime.caml_call_gen(f, [a0]);
-   }
-    /*<<?>>*/ function caml_call2(f, a0, a1){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 2
-            ? f(a0, a1)
-            : runtime.caml_call_gen(f, [a0, a1]);
-   }
-    /*<<?>>*/ function caml_call3(f, a0, a1, a2){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 3
-            ? f(a0, a1, a2)
-            : runtime.caml_call_gen(f, [a0, a1, a2]);
-   }
-    /*<<?>>*/ function caml_call6(f, a0, a1, a2, a3, a4, a5){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 6
-            ? f(a0, a1, a2, a3, a4, a5)
-            : runtime.caml_call_gen(f, [a0, a1, a2, a3, a4, a5]);
-   }
-    /*<<?>>*/ function caml_call8(f, a0, a1, a2, a3, a4, a5, a6, a7){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 8
-            ? f(a0, a1, a2, a3, a4, a5, a6, a7)
-            : runtime.caml_call_gen(f, [a0, a1, a2, a3, a4, a5, a6, a7]);
-   }
-    /*<<printexc.ml:20:15>>*/ var
-    global_data = runtime.caml_get_global_data(),
-    cst$0 = cst$4,
-    cst$3 = cst$4,
-    partial = [4, 0, 0, 0, [12, 45, [4, 0, 0, 0, 0]]],
-    cst$1 = cst$4,
-    cst$2 = cst$4,
-    cst = "_",
-    locfmt =
-      [0,
-       [11,
-        'File "',
-        [2,
-         0,
-         [11,
-          '", line ',
-          [4,
-           0,
-           0,
-           0,
-           [11,
-            cst_characters,
-            [4, 0, 0, 0, [12, 45, [4, 0, 0, 0, [11, ": ", [2, 0, 0]]]]]]]]]],
-       'File "%s", line %d, characters %d-%d: %s'],
-    Stdlib_Printf = global_data.Stdlib__Printf,
-    Stdlib_Atomic = global_data.Stdlib__Atomic,
-    Stdlib = global_data.Stdlib,
-    Stdlib_Buffer = global_data.Stdlib__Buffer,
-    Stdlib_Obj = global_data.Stdlib__Obj,
-     /*<<printexc.ml:20:15>>*/ printers =
-       /*<<printexc.ml:20:15>>*/ caml_call1(Stdlib_Atomic[1], 0),
-    _c_ = [0, [11, ", ", [2, 0, [2, 0, 0]]], ", %s%s"],
-    _o_ =
-      [0,
-       [11, cst_Fatal_error_exception, [2, 0, [12, 10, 0]]],
-       cst_Fatal_error_exception_s],
-    _p_ =
-      [0,
-       [11,
-        "Fatal error in uncaught exception handler: exception ",
-        [2, 0, [12, 10, 0]]],
-       "Fatal error in uncaught exception handler: exception %s\n"],
-    cst_Fatal_error_out_of_memory_ =
-      "Fatal error: out of memory in uncaught exception handler",
-    _n_ =
-      [0,
-       [11, cst_Fatal_error_exception, [2, 0, [12, 10, 0]]],
-       cst_Fatal_error_exception_s],
-    _l_ = [0, [2, 0, [12, 10, 0]], cst_s],
-    cst_Program_not_linked_with_g_ = cst_Program_not_linked_with_g_$0,
-    _j_ = [0, [2, 0, [12, 10, 0]], cst_s],
-    _k_ =
-      [0,
-       [11, cst_Program_not_linked_with_g_$0, 0],
-       cst_Program_not_linked_with_g_$0],
-    cst_Raised_at = "Raised at",
-    cst_Re_raised_at = "Re-raised at",
-    cst_Raised_by_primitive_operat = "Raised by primitive operation at",
-    cst_Called_from = "Called from",
-    cst_inlined = " (inlined)",
-    _h_ =
-      [0,
-       [2,
-        0,
-        [12,
-         32,
-         [2,
-          0,
-          [11,
-           ' in file "',
-           [2,
-            0,
-            [12,
-             34,
-             [2,
-              0,
-              [11, ", line ", [4, 0, 0, 0, [11, cst_characters, partial]]]]]]]]]],
-       '%s %s in file "%s"%s, line %d, characters %d-%d'],
-    _i_ = [0, [2, 0, [11, " unknown location", 0]], "%s unknown location"],
-    _g_ =
-      [0,
-       [11, cst_Uncaught_exception, [2, 0, [12, 10, 0]]],
-       cst_Uncaught_exception_s],
-    _f_ =
-      [0,
-       [11, cst_Uncaught_exception, [2, 0, [12, 10, 0]]],
-       cst_Uncaught_exception_s],
-    cst_Out_of_memory = "Out of memory",
-    cst_Stack_overflow = "Stack overflow",
-    cst_Pattern_matching_failed = "Pattern matching failed",
-    cst_Assertion_failed = "Assertion failed",
-    cst_Undefined_recursive_module = "Undefined recursive module",
-    _d_ = [0, [12, 40, [2, 0, [2, 0, [12, 41, 0]]]], "(%s%s)"],
-    _e_ = [0, [12, 40, [2, 0, [12, 41, 0]]], "(%s)"],
-    _b_ = [0, [4, 0, 0, 0, 0], "%d"],
-    _a_ = [0, [3, 0, 0], "%S"],
-    _m_ =
-      [0,
-       cst$4,
-       "(Cannot print locations:\n bytecode executable program file not found)",
-       "(Cannot print locations:\n bytecode executable program file appears to be corrupt)",
-       "(Cannot print locations:\n bytecode executable program file has wrong magic number)",
-       "(Cannot print locations:\n bytecode executable program file cannot be opened;\n -- too many open files. Try running with OCAMLRUNPARAM=b=2)"];
-   function field(x, i){
-     /*<<printexc.ml:25:2>>*/  /*<<printexc.ml:25:10>>*/ var f = x[1 + i];
-     /*<<printexc.ml:26:9>>*/ if
-     (!  /*<<printexc.ml:26:9>>*/ caml_call1(Stdlib_Obj[1], f))
-      /*<<printexc.ml:27:4>>*/ return  /*<<printexc.ml:27:4>>*/ caml_call2
-             (Stdlib_Printf[4], _b_, f);
-     /*<<printexc.ml:28:7>>*/  /*<<printexc.ml:28:7>>*/ var
-     _al_ = Stdlib_Obj[15];
-    if( /*<<printexc.ml:28:10>>*/ caml_obj_tag(f) === _al_)
-      /*<<printexc.ml:29:4>>*/ return  /*<<printexc.ml:29:4>>*/ caml_call2
-             (Stdlib_Printf[4], _a_, f);
-     /*<<printexc.ml:30:7>>*/  /*<<printexc.ml:30:7>>*/ var
-     _am_ = Stdlib_Obj[16];
-    return  /*<<printexc.ml:30:10>>*/ caml_obj_tag(f) === _am_
-            ?  /*<<printexc.ml:31:4>>*/ caml_call1(Stdlib[35], f)
-            : cst;
-    /*<<printexc.ml:33:7>>*/ }
-   function other_fields(x, i){
-     /*<<printexc.ml:36:2>>*/ if(x.length - 1 <= i)
-      /*<<printexc.ml:36:26>>*/ return cst$0;
-     /*<<printexc.ml:37:36>>*/ var
-      /*<<printexc.ml:37:36>>*/ _aj_ = other_fields(x, i + 1 | 0),
-      /*<<printexc.ml:37:24>>*/ _ak_ = field(x, i);
-     /*<<printexc.ml:37:36>>*/ return  /*<<printexc.ml:37:36>>*/ caml_call3
-            (Stdlib_Printf[4], _c_, _ak_, _aj_);
-    /*<<printexc.ml:37:58>>*/ }
-   function use_printers(x){
-     /*<<printexc.ml:47:2>>*/ var
-     param =  /*<<printexc.ml:53:7>>*/ caml_call1(Stdlib_Atomic[2], printers);
-     /*<<printexc.ml:47:17>>*/ for(;;){
-     if(! param)  /*<<printexc.ml:52:12>>*/ return 0;
-     var tl = param[2], hd = param[1];
-     a:
-     {
-       /*<<printexc.ml:49:8>>*/ try{
-        /*<<printexc.ml:49:15>>*/  /*<<printexc.ml:49:15>>*/ var
-        val =  /*<<printexc.ml:49:15>>*/ caml_call1(hd, x);
-      }
-      catch(_ai_){break a;}
-      if(val){var s = val[1];  /*<<printexc.ml:51:21>>*/ return [0, s];}
-     }
-     var param = tl;
-    }
-    /*<<printexc.ml:53:28>>*/ }
-   function string_of_extension_constructo(t){
-     /*<<printexc.ml:64:2>>*/ if
-     (0 ===  /*<<printexc.ml:56:5>>*/ caml_obj_tag(t)){
-      /*<<printexc.ml:60:17>>*/ var
-       /*<<printexc.ml:60:17>>*/ constructor = t[1][1],
-      match = t.length - 1;
-     if(2 < match >>> 0)
-       /*<<printexc.ml:44:38>>*/ var
-        /*<<printexc.ml:44:38>>*/ _ae_ = other_fields(t, 2),
-        /*<<printexc.ml:44:26>>*/ _af_ = field(t, 1),
-       _ah_ =
-          /*<<printexc.ml:44:38>>*/ caml_call3
-          (Stdlib_Printf[4], _d_, _af_, _ae_);
-     else
-      switch(match){
-        case 0:
-         var _ah_ = cst$1; break;
-        case 1:
-         var _ah_ = cst$2; break;
-        default:
-          /*<<printexc.ml:43:24>>*/ var
-           /*<<printexc.ml:43:24>>*/ _ag_ = field(t, 1),
-          _ah_ =
-             /*<<printexc.ml:43:24>>*/ caml_call2(Stdlib_Printf[4], _e_, _ag_);
-      }
-     var match$0 = [0, constructor, [0, _ah_]];
-    }
-    else
-     var match$0 = [0, t[1], 0];
-    var fields_opt = match$0[2], constructor$0 = match$0[1];
-     /*<<printexc.ml:65:2>>*/ if(! fields_opt)
-      /*<<printexc.ml:66:12>>*/ return constructor$0;
-    var f = fields_opt[1];
-     /*<<printexc.ml:67:14>>*/ return  /*<<printexc.ml:67:14>>*/ caml_call2
-            (Stdlib[28], constructor$0, f);
-    /*<<printexc.ml:67:29>>*/ }
-   function to_string_default(x){
-     /*<<printexc.ml:69:24>>*/ if(x === Stdlib[9])
-      /*<<printexc.ml:70:21>>*/ return cst_Out_of_memory;
-    if(x === Stdlib[10])  /*<<printexc.ml:71:22>>*/ return cst_Stack_overflow;
-    if(x[1] === Stdlib[4]){
-     var match = x[2], char$0 = match[3], line = match[2], file = match[1];
-      /*<<printexc.ml:73:6>>*/ return  /*<<printexc.ml:73:6>>*/ caml_call6
-             (Stdlib_Printf[4],
-              locfmt,
-              file,
-              line,
-              char$0,
-              char$0 + 5 | 0,
-              cst_Pattern_matching_failed);
-    }
-    if(x[1] === Stdlib[5]){
-     var
-      match$0 = x[2],
-      char$1 = match$0[3],
-      line$0 = match$0[2],
-      file$0 = match$0[1];
-      /*<<printexc.ml:75:6>>*/ return  /*<<printexc.ml:75:6>>*/ caml_call6
-             (Stdlib_Printf[4],
-              locfmt,
-              file$0,
-              line$0,
-              char$1,
-              char$1 + 6 | 0,
-              cst_Assertion_failed);
-    }
-    if(x[1] !== Stdlib[15])
-      /*<<printexc.ml:79:6>>*/ return string_of_extension_constructo(x);
-    var
-     match$1 = x[2],
-     char$2 = match$1[3],
-     line$1 = match$1[2],
-     file$1 = match$1[1];
-     /*<<printexc.ml:77:6>>*/ return  /*<<printexc.ml:77:6>>*/ caml_call6
-            (Stdlib_Printf[4],
-             locfmt,
-             file$1,
-             line$1,
-             char$2,
-             char$2 + 6 | 0,
-             cst_Undefined_recursive_module);
-    /*<<printexc.ml:79:50>>*/ }
-   function to_string(e){
-     /*<<printexc.ml:82:2>>*/  /*<<printexc.ml:82:8>>*/ var
-     match = use_printers(e);
-    if(! match)  /*<<printexc.ml:84:12>>*/ return to_string_default(e);
-    var s = match[1];
-     /*<<printexc.ml:83:14>>*/ return s;
-    /*<<printexc.ml:84:31>>*/ }
-   function print(fct, arg){
-     /*<<printexc.ml:87:2>>*/ try{
-      /*<<printexc.ml:88:4>>*/  /*<<printexc.ml:88:4>>*/ var
-      _ad_ =  /*<<printexc.ml:88:4>>*/ caml_call1(fct, arg);
-      /*<<printexc.ml:88:4>>*/ return _ad_;
-    }
-    catch(x$0){
-      /*<<printexc.ml:90:39>>*/ var
-      x = caml_wrap_exception(x$0),
-       /*<<printexc.ml:90:39>>*/ _ac_ = to_string(x);
-      /*<<printexc.ml:90:4>>*/  /*<<printexc.ml:90:4>>*/ caml_call2
-      (Stdlib_Printf[3], _f_, _ac_);
-      /*<<printexc.ml:91:4>>*/  /*<<printexc.ml:91:4>>*/ caml_call1
-      (Stdlib[63], Stdlib[40]);
-      /*<<printexc.ml:92:4>>*/ throw  /*<<printexc.ml:92:4>>*/ caml_maybe_attach_backtrace
-            (x, 0);
-    }
-    /*<<printexc.ml:92:11>>*/ }
-   function catch$0(fct, arg){
-     /*<<printexc.ml:95:2>>*/ try{
-      /*<<printexc.ml:96:4>>*/  /*<<printexc.ml:96:4>>*/ var
-      _ab_ =  /*<<printexc.ml:96:4>>*/ caml_call1(fct, arg);
-      /*<<printexc.ml:96:4>>*/ return _ab_;
-    }
-    catch(x$0){
-     var x = caml_wrap_exception(x$0);
-      /*<<printexc.ml:98:4>>*/  /*<<printexc.ml:98:4>>*/ caml_call1
-      (Stdlib[63], Stdlib[39]);
-      /*<<printexc.ml:99:39>>*/  /*<<printexc.ml:99:39>>*/ var
-      _aa_ = to_string(x);
-      /*<<printexc.ml:99:4>>*/  /*<<printexc.ml:99:4>>*/ caml_call2
-      (Stdlib_Printf[3], _g_, _aa_);
-      /*<<printexc.ml:99:4>>*/ return  /*<<printexc.ml:99:4>>*/ caml_call1
-             (Stdlib[99], 2);
-    }
-    /*<<printexc.ml:100:10>>*/ }
-   function raw_backtrace_entries(bt){
-     /*<<printexc.ml:106:31>>*/ return bt;
-    /*<<printexc.ml:106:33>>*/ }
-   function convert_raw_backtrace(bt){
-     /*<<printexc.ml:141:2>>*/ return [0,
-             /*<<printexc.ml:141:11>>*/ runtime.caml_convert_raw_backtrace(bt)];
-    /*<<printexc.ml:142:24>>*/ }
-   function format_backtrace_slot(pos, slot){
-    function info(is_raise){
-      /*<<printexc.ml:146:4>>*/ return is_raise
-             ? 0 === pos ? cst_Raised_at : cst_Re_raised_at
-             : 0 === pos ? cst_Raised_by_primitive_operat : cst_Called_from;
-     /*<<printexc.ml:149:75>>*/ }
-     /*<<printexc.ml:151:2>>*/ if(0 === slot[0]){
-      /*<<printexc.ml:159:14>>*/ var
-      _U_ = slot[5],
-      _V_ = slot[4],
-      _W_ = slot[3],
-      _X_ = slot[6] ? cst_inlined : cst$3,
-      _Y_ = slot[2],
-      _Z_ = slot[7],
-       /*<<printexc.ml:159:14>>*/ ___ = info(slot[1]);
-      /*<<printexc.ml:158:6>>*/ return [0,
-              /*<<printexc.ml:158:11>>*/ caml_call8
-              (Stdlib_Printf[4], _h_, ___, _Z_, _Y_, _X_, _W_, _V_, _U_)];
-    }
-    if(slot[1])  /*<<printexc.ml:154:50>>*/ return 0;
-     /*<<printexc.ml:156:44>>*/  /*<<printexc.ml:156:44>>*/ var _$_ = info(0);
-     /*<<printexc.ml:156:8>>*/ return [0,
-             /*<<printexc.ml:156:13>>*/ caml_call2(Stdlib_Printf[4], _i_, _$_)];
-    /*<<printexc.ml:161:52>>*/ }
-   function print_raw_backtrace(outchan, raw_backtrace){
-     /*<<printexc.ml:176:2>>*/  /*<<printexc.ml:176:36>>*/ var
-     backtrace = convert_raw_backtrace(raw_backtrace);
-    if(! backtrace)
-      /*<<printexc.ml:166:6>>*/ return  /*<<printexc.ml:166:6>>*/ caml_call2
-             (Stdlib_Printf[1], outchan, _k_);
-    var a = backtrace[1], _S_ = a.length - 1 - 1 | 0, _R_ = 0;
-    if(_S_ >= 0){
-     var i = _R_;
-     for(;;){
-       /*<<printexc.ml:170:14>>*/  /*<<printexc.ml:170:14>>*/ var
-       match = format_backtrace_slot(i, caml_check_bound(a, i)[1 + i]);
-      if(match){
-       var str = match[1];
-        /*<<printexc.ml:172:24>>*/  /*<<printexc.ml:172:24>>*/ caml_call3
-        (Stdlib_Printf[1], outchan, _j_, str);
-      }
-       /*<<printexc.ml:169:6>>*/  /*<<printexc.ml:169:6>>*/ var
-       _T_ = i + 1 | 0;
-      if(_S_ === i) break;
-      var i = _T_;
-     }
-    }
-    return 0;
-    /*<<printexc.ml:176:73>>*/ }
-   function print_backtrace(outchan){
-     /*<<printexc.ml:180:2>>*/ return print_raw_backtrace
-            (outchan,
-              /*<<printexc.ml:180:30>>*/ caml_get_exception_raw_backtra(0));
-    /*<<printexc.ml:180:52>>*/ }
-   function raw_backtrace_to_string(raw_backtrace){
-     /*<<printexc.ml:196:2>>*/  /*<<printexc.ml:196:22>>*/ var
-     backtrace = convert_raw_backtrace(raw_backtrace);
-    if(! backtrace)
-      /*<<printexc.ml:185:5>>*/ return cst_Program_not_linked_with_g_;
-     /*<<printexc.ml:187:14>>*/ var
-     a = backtrace[1],
-      /*<<printexc.ml:187:14>>*/ b =
-        /*<<printexc.ml:187:14>>*/ caml_call1(Stdlib_Buffer[1], 1024),
-     _P_ = a.length - 1 - 1 | 0,
-      /*<<printexc.ml:187:14>>*/ _O_ = 0;
-    if(_P_ >= 0){
-     var i = _O_;
-     for(;;){
-       /*<<printexc.ml:189:14>>*/  /*<<printexc.ml:189:14>>*/ var
-       match = format_backtrace_slot(i, caml_check_bound(a, i)[1 + i]);
-      if(match){
-       var str = match[1];
-        /*<<printexc.ml:191:24>>*/  /*<<printexc.ml:191:24>>*/ caml_call3
-        (Stdlib_Printf[5], b, _l_, str);
-      }
-       /*<<printexc.ml:188:6>>*/  /*<<printexc.ml:188:6>>*/ var
-       _Q_ = i + 1 | 0;
-      if(_P_ === i) break;
-      var i = _Q_;
-     }
-    }
-     /*<<printexc.ml:193:6>>*/ return  /*<<printexc.ml:193:6>>*/ caml_call1
-            (Stdlib_Buffer[2], b);
-    /*<<printexc.ml:196:59>>*/ }
-   function backtrace_slot_is_raise(param){
-     /*<<printexc.ml:198:30>>*/ return 0 === param[0] ? param[1] : param[1];
-    /*<<printexc.ml:200:36>>*/ }
-   function backtrace_slot_is_inline(param){
-     /*<<printexc.ml:202:31>>*/ return 0 === param[0] ? param[6] : 0;
-    /*<<printexc.ml:204:31>>*/ }
-   function backtrace_slot_location(param){
-     /*<<printexc.ml:213:30>>*/ return 0 === param[0]
-            ? [0, [0, param[2], param[3], param[4], param[5]]]
-            : 0;
-    /*<<printexc.ml:221:5>>*/ }
-   function backtrace_slot_defname(param){
-     /*<<printexc.ml:223:29>>*/ if
-     (0 === param[0] && runtime.caml_string_notequal(param[7], cst$4))
-      /*<<printexc.ml:226:24>>*/ return [0, param[7]];
-     /*<<printexc.ml:225:39>>*/ return 0;
-    /*<<printexc.ml:226:38>>*/ }
-   function backtrace_slots(raw_backtrace){
-     /*<<printexc.ml:235:2>>*/  /*<<printexc.ml:235:8>>*/ var
-     match = convert_raw_backtrace(raw_backtrace);
-    if(! match)  /*<<printexc.ml:236:14>>*/ return 0;
-    var backtrace = match[1], i$1 = backtrace.length - 1 - 1 | 0, i = i$1;
-     /*<<printexc.ml:241:30>>*/ for(;;){
-     if(-1 === i)
-      var _N_ = 0;
-     else{
-      var _M_ = 0 === caml_check_bound(backtrace, i)[1 + i][0] ? 1 : 0;
-       /*<<printexc.ml:243:15>>*/ if(! _M_){
-       var i$0 = i - 1 | 0, i = i$0;
-       continue;
-      }
-      var _N_ = _M_;
-     }
-      /*<<printexc.ml:244:9>>*/ return _N_ ? [0, backtrace] : 0;
-    }
-    /*<<printexc.ml:246:15>>*/ }
-   function backtrace_slots_of_raw_entry(entry){
-     /*<<printexc.ml:249:2>>*/ return backtrace_slots([0, entry]);
-    /*<<printexc.ml:249:29>>*/ }
-   function raw_backtrace_length(bt){
-     /*<<printexc.ml:260:30>>*/ return bt.length - 1;
-    /*<<printexc.ml:260:45>>*/ }
-   function get_backtrace(param){
-     /*<<printexc.ml:271:23>>*/ return raw_backtrace_to_string
-            ( /*<<printexc.ml:271:47>>*/ caml_get_exception_raw_backtra(0));
-    /*<<printexc.ml:271:69>>*/ }
-   function register_printer(fn){
-     /*<<printexc.ml:277:2>>*/ for(;;){
-      /*<<printexc.ml:277:21>>*/ var
-       /*<<printexc.ml:277:21>>*/ old_printers =
-         /*<<printexc.ml:277:21>>*/ caml_call1(Stdlib_Atomic[2], printers),
-       /*<<printexc.ml:278:21>>*/ new_printers = [0, fn, old_printers],
-       /*<<printexc.ml:279:16>>*/ success =
-         /*<<printexc.ml:279:16>>*/ caml_call3
-         (Stdlib_Atomic[5], printers, old_printers, new_printers),
-       /*<<printexc.ml:280:2>>*/ _L_ = 1 - success;
-     if(! _L_)  /*<<printexc.ml:280:2>>*/ return _L_;
-    }
-    /*<<printexc.ml:280:41>>*/ }
-   function exn_slot(x){
-     /*<<printexc.ml:285:2>>*/ return 0
-            ===  /*<<printexc.ml:286:5>>*/ caml_obj_tag(x)
-            ? x[1]
-            : x;
-    /*<<printexc.ml:286:44>>*/ }
-   function exn_slot_id(x){
-     /*<<printexc.ml:289:2>>*/  /*<<printexc.ml:289:13>>*/ var
-     slot = exn_slot(x);
-     /*<<printexc.ml:290:11>>*/ return slot[2];
-    /*<<printexc.ml:290:36>>*/ }
-   function exn_slot_name(x){
-     /*<<printexc.ml:293:2>>*/  /*<<printexc.ml:293:13>>*/ var
-     slot = exn_slot(x);
-     /*<<printexc.ml:294:11>>*/ return slot[1];
-    /*<<printexc.ml:294:39>>*/ }
-   var errors = _m_.slice();
-   function default_uncaught_exception_han(exn, raw_backtrace){
-     /*<<printexc.ml:316:2>>*/  /*<<printexc.ml:316:40>>*/ var
-     _I_ = to_string(exn);
-     /*<<printexc.ml:316:2>>*/  /*<<printexc.ml:316:2>>*/ caml_call2
-     (Stdlib_Printf[3], _n_, _I_);
-     /*<<printexc.ml:317:2>>*/ print_raw_backtrace(Stdlib[40], raw_backtrace);
-     /*<<printexc.ml:318:15>>*/  /*<<printexc.ml:318:15>>*/ var
-     status =  /*<<printexc.ml:318:15>>*/ runtime.caml_ml_debug_info_status(0);
-    if(status < 0){
-      /*<<printexc.ml:320:26>>*/ var
-       /*<<printexc.ml:320:26>>*/ _J_ =
-         /*<<printexc.ml:320:26>>*/ caml_call1(Stdlib[18], status),
-       /*<<printexc.ml:320:18>>*/ _K_ = caml_check_bound(errors, _J_)[1 + _J_];
-      /*<<printexc.ml:320:4>>*/  /*<<printexc.ml:320:4>>*/ caml_call1
-      (Stdlib[53], _K_);
-    }
-     /*<<printexc.ml:320:4>>*/ return  /*<<printexc.ml:320:4>>*/ caml_call1
-            (Stdlib[63], Stdlib[40]);
-    /*<<printexc.ml:321:14>>*/ }
-    /*<<printexc.ml:323:33>>*/  /*<<printexc.ml:323:33>>*/ var
-    uncaught_exception_handler = [0, default_uncaught_exception_han];
-   function set_uncaught_exception_handler(fn){
-     /*<<printexc.ml:325:40>>*/ uncaught_exception_handler[1] = fn;
-    return 0;
-    /*<<printexc.ml:325:72>>*/ }
-   var empty_backtrace = [0];
-   function handle_uncaught_exception(exn$0, debugger_in_use){
-     /*<<printexc.ml:364:2>>*/ try{
-      /*<<printexc.ml:336:2>>*/ try{
-      var
-       raw_backtrace =
-         debugger_in_use
-          ? empty_backtrace
-          :  /*<<printexc.ml:343:8>>*/ caml_get_exception_raw_backtra(0);
-       /*<<printexc.ml:345:4>>*/ try{
-        /*<<printexc.ml:345:9>>*/  /*<<printexc.ml:345:9>>*/ caml_call1
-        (Stdlib[103], 0);
-      }
-      catch(_H_){}
-       /*<<printexc.ml:346:4>>*/ try{
-        /*<<printexc.ml:347:6>>*/ var
-         /*<<printexc.ml:347:6>>*/ _D_ =
-           /*<<printexc.ml:347:6>>*/ caml_call2
-           (uncaught_exception_handler[1], exn$0, raw_backtrace),
-        _C_ = _D_;
-      }
-      catch(exn$1){
-        /*<<printexc.ml:349:27>>*/ var
-        exn = caml_wrap_exception(exn$1),
-         /*<<printexc.ml:349:27>>*/ raw_backtrace$0 =
-           /*<<printexc.ml:349:27>>*/ caml_get_exception_raw_backtra(0),
-         /*<<printexc.ml:350:44>>*/ _A_ = to_string(exn$0);
-        /*<<printexc.ml:350:6>>*/  /*<<printexc.ml:350:6>>*/ caml_call2
-        (Stdlib_Printf[3], _o_, _A_);
-        /*<<printexc.ml:351:6>>*/ print_raw_backtrace
-        (Stdlib[40], raw_backtrace);
-        /*<<printexc.ml:353:8>>*/  /*<<printexc.ml:353:8>>*/ var
-        _B_ = to_string(exn);
-        /*<<printexc.ml:352:6>>*/  /*<<printexc.ml:352:6>>*/ caml_call2
-        (Stdlib_Printf[3], _p_, _B_);
-        /*<<printexc.ml:354:6>>*/ print_raw_backtrace
-        (Stdlib[40], raw_backtrace$0);
-       var
-        _C_ =  /*<<printexc.ml:355:6>>*/ caml_call1(Stdlib[63], Stdlib[40]);
-      }
-      var _E_ = _C_;
-     }
-     catch(_G_){
-      var _z_ = caml_wrap_exception(_G_);
-      if(_z_ !== Stdlib[9]) throw caml_maybe_attach_backtrace(_z_, 0);
-      var
-       _E_ =
-          /*<<printexc.ml:358:8>>*/ caml_call1
-          (Stdlib[53], cst_Fatal_error_out_of_memory_);
-     }
-      /*<<printexc.ml:365:4>>*/ return _E_;
-    }
-    catch(_F_){ /*<<printexc.ml:368:4>>*/ return 0;}
-    /*<<printexc.ml:368:6>>*/ }
-    /*<<printexc.ml:374:2>>*/  /*<<printexc.ml:374:2>>*/ runtime.caml_register_named_value
-    ("Printexc.handle_uncaught_exception", handle_uncaught_exception);
-   function _q_(_y_){
-     /*<<?>>*/ return runtime.caml_raw_backtrace_next_slot(_y_);
-   }
-   function _r_(_x_){
-     /*<<?>>*/ return runtime.caml_convert_raw_backtrace_slot(_x_);
-   }
-   function _s_(_w_, _v_){
-     /*<<?>>*/ return runtime.caml_raw_backtrace_slot(_w_, _v_);
-   }
-   var
-    _t_ =
-      [0,
-       backtrace_slot_is_raise,
-       backtrace_slot_is_inline,
-       backtrace_slot_location,
-       backtrace_slot_defname,
-       format_backtrace_slot],
-    Stdlib_Printexc =
-      [0,
-       to_string,
-       to_string_default,
-       print,
-       catch$0,
-       print_backtrace,
-       get_backtrace,
-       runtime.caml_record_backtrace,
-       runtime.caml_backtrace_status,
-       register_printer,
-       use_printers,
-       raw_backtrace_entries,
-       function(_u_){ /*<<?>>*/ return caml_get_exception_raw_backtra(_u_);},
-       print_raw_backtrace,
-       raw_backtrace_to_string,
-       default_uncaught_exception_han,
-       set_uncaught_exception_handler,
-       backtrace_slots,
-       backtrace_slots_of_raw_entry,
-       _t_,
-       raw_backtrace_length,
-       _s_,
-       _r_,
-       _q_,
-       exn_slot_id,
-       exn_slot_name,
-       string_of_extension_constructo];
-   runtime.caml_register_global(42, Stdlib_Printexc, "Stdlib__Printexc");
-   return;
-   /*<<?>>*/ }
-  (globalThis));
-
-//# unitInfo: Provides: Stdlib__Fun
-//# unitInfo: Requires: Stdlib, Stdlib__Printexc
-(function
-  (globalThis){
-   "use strict";
-   var
-    runtime = globalThis.jsoo_runtime,
-    caml_maybe_attach_backtrace = runtime.caml_maybe_attach_backtrace,
-    caml_restore_raw_backtrace = runtime.caml_restore_raw_backtrace,
-    caml_wrap_exception = runtime.caml_wrap_exception;
-    /*<<?>>*/ function caml_call1(f, a0){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 1
-            ? f(a0)
-            : runtime.caml_call_gen(f, [a0]);
-   }
-    /*<<?>>*/ function caml_call2(f, a0, a1){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 2
-            ? f(a0, a1)
-            : runtime.caml_call_gen(f, [a0, a1]);
-   }
-   var
-    global_data = runtime.caml_get_global_data(),
-    Stdlib_Printexc = global_data.Stdlib__Printexc,
-    Stdlib = global_data.Stdlib,
-    cst_Fun_Finally_raised = "Fun.Finally_raised: ",
-    cst_Stdlib_Fun_Finally_raised = "Stdlib.Fun.Finally_raised";
-   function const$0(c, param){
-     /*<<fun.ml:17:16>>*/ return c;
-    /*<<fun.ml:17:17>>*/ }
-   function flip(f, x, y){
-     /*<<fun.ml:18:17>>*/ return  /*<<fun.ml:18:17>>*/ caml_call2(f, y, x);
-    /*<<fun.ml:18:22>>*/ }
-   function negate(p, v){
-     /*<<fun.ml:19:17>>*/ return 1 -  /*<<fun.ml:19:21>>*/ caml_call1(p, v);
-    /*<<fun.ml:19:26>>*/ }
-    /*<<fun.ml:21:0>>*/  /*<<fun.ml:21:0>>*/ var
-    Finally_raised =
-      [248, cst_Stdlib_Fun_Finally_raised, runtime.caml_fresh_oo_id(0)];
-   function _a_(param){
-     /*<<fun.ml:23:38>>*/ if(param[1] !== Finally_raised)
-      /*<<fun.ml:25:7>>*/ return 0;
-     /*<<fun.ml:24:55>>*/ var
-     exn = param[2],
-      /*<<fun.ml:24:55>>*/ _c_ =
-        /*<<fun.ml:24:55>>*/ caml_call1(Stdlib_Printexc[1], exn);
-     /*<<fun.ml:24:24>>*/ return [0,
-             /*<<fun.ml:24:29>>*/ caml_call2
-             (Stdlib[28], cst_Fun_Finally_raised, _c_)];
-    /*<<fun.ml:25:11>>*/ }
-    /*<<fun.ml:23:9>>*/  /*<<fun.ml:23:9>>*/ caml_call1
-    (Stdlib_Printexc[9], _a_);
-   function protect(finally$0, work){
-    function finally_no_exn(param){
-      /*<<fun.ml:29:4>>*/ try{
-       /*<<fun.ml:29:8>>*/  /*<<fun.ml:29:8>>*/ var
-       _b_ =  /*<<fun.ml:29:8>>*/ caml_call1(finally$0, 0);
-       /*<<fun.ml:29:8>>*/ return _b_;
-     }
-     catch(e$0){
-       /*<<fun.ml:30:15>>*/ var
-       e = caml_wrap_exception(e$0),
-        /*<<fun.ml:30:15>>*/ bt =
-          /*<<fun.ml:30:15>>*/ caml_call1(Stdlib_Printexc[12], 0),
-        /*<<fun.ml:31:36>>*/ exn = [0, Finally_raised, e];
-      caml_restore_raw_backtrace(exn, bt);
-       /*<<fun.ml:31:6>>*/ throw  /*<<fun.ml:31:6>>*/ caml_maybe_attach_backtrace
-             (exn, 0);
-     }
-     /*<<fun.ml:31:57>>*/ }
-     /*<<fun.ml:33:2>>*/ try{
-      /*<<fun.ml:33:8>>*/  /*<<fun.ml:33:8>>*/ var
-      result =  /*<<fun.ml:33:8>>*/ caml_call1(work, 0);
-    }
-    catch(work_exn$0){
-      /*<<fun.ml:36:20>>*/ var
-      work_exn = caml_wrap_exception(work_exn$0),
-       /*<<fun.ml:36:20>>*/ work_bt =
-         /*<<fun.ml:36:20>>*/ caml_call1(Stdlib_Printexc[12], 0);
-      /*<<fun.ml:37:6>>*/ finally_no_exn(0);
-     caml_restore_raw_backtrace(work_exn, work_bt);
-      /*<<fun.ml:38:6>>*/ throw  /*<<fun.ml:38:6>>*/ caml_maybe_attach_backtrace
-            (work_exn, 0);
-    }
-     /*<<fun.ml:34:14>>*/ finally_no_exn(0);
-     /*<<fun.ml:34:14>>*/ return result;
-    /*<<fun.ml:38:52>>*/ }
-   var Stdlib_Fun = [0, const$0, flip, negate, protect, Finally_raised];
-   runtime.caml_register_global(4, Stdlib_Fun, "Stdlib__Fun");
-   return;
-   /*<<?>>*/ }
-  (globalThis));
-
-//# unitInfo: Provides: Stdlib__Gc
-//# unitInfo: Requires: Stdlib, Stdlib__Atomic, Stdlib__Printf, Stdlib__Sys
-(function
-  (globalThis){
-   "use strict";
-   var
-    runtime = globalThis.jsoo_runtime,
-    cst = "\n",
-    caml_ml_string_length = runtime.caml_ml_string_length;
-    /*<<?>>*/ function caml_call1(f, a0){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 1
-            ? f(a0)
-            : runtime.caml_call_gen(f, [a0]);
-   }
-    /*<<?>>*/ function caml_call2(f, a0, a1){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 2
-            ? f(a0, a1)
-            : runtime.caml_call_gen(f, [a0, a1]);
-   }
-    /*<<?>>*/ function caml_call3(f, a0, a1, a2){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 3
-            ? f(a0, a1, a2)
-            : runtime.caml_call_gen(f, [a0, a1, a2]);
-   }
-    /*<<?>>*/ function caml_call4(f, a0, a1, a2, a3){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 4
-            ? f(a0, a1, a2, a3)
-            : runtime.caml_call_gen(f, [a0, a1, a2, a3]);
-   }
-   var
-    global_data = runtime.caml_get_global_data(),
-    Stdlib_Atomic = global_data.Stdlib__Atomic,
-    Stdlib = global_data.Stdlib,
-    Stdlib_Sys = global_data.Stdlib__Sys,
-    Stdlib_Printf = global_data.Stdlib__Printf,
-    _a_ =
-      [0,
-       [11, "minor_collections:      ", [4, 0, 0, 0, [12, 10, 0]]],
-       "minor_collections:      %d\n"],
-    _b_ =
-      [0,
-       [11, "major_collections:      ", [4, 0, 0, 0, [12, 10, 0]]],
-       "major_collections:      %d\n"],
-    _c_ =
-      [0,
-       [11, "compactions:            ", [4, 0, 0, 0, [12, 10, 0]]],
-       "compactions:            %d\n"],
-    _d_ =
-      [0,
-       [11, "forced_major_collections: ", [4, 0, 0, 0, [12, 10, 0]]],
-       "forced_major_collections: %d\n"],
-    _e_ = [0, [12, 10, 0], cst],
-    _f_ = [0, [8, [0, 0, 0], 0, [0, 0], 0], "%.0f"],
-    _g_ =
-      [0,
-       [11, "minor_words:    ", [8, [0, 0, 0], [1, 1], [0, 0], [12, 10, 0]]],
-       "minor_words:    %*.0f\n"],
-    _h_ =
-      [0,
-       [11, "promoted_words: ", [8, [0, 0, 0], [1, 1], [0, 0], [12, 10, 0]]],
-       "promoted_words: %*.0f\n"],
-    _i_ =
-      [0,
-       [11, "major_words:    ", [8, [0, 0, 0], [1, 1], [0, 0], [12, 10, 0]]],
-       "major_words:    %*.0f\n"],
-    _j_ = [0, [12, 10, 0], cst],
-    _k_ = [0, [4, 0, 0, 0, 0], "%d"],
-    _l_ =
-      [0,
-       [11, "top_heap_words: ", [4, 0, [1, 1], 0, [12, 10, 0]]],
-       "top_heap_words: %*d\n"],
-    _m_ =
-      [0,
-       [11, "heap_words:     ", [4, 0, [1, 1], 0, [12, 10, 0]]],
-       "heap_words:     %*d\n"],
-    _n_ =
-      [0,
-       [11, "live_words:     ", [4, 0, [1, 1], 0, [12, 10, 0]]],
-       "live_words:     %*d\n"],
-    _o_ =
-      [0,
-       [11, "free_words:     ", [4, 0, [1, 1], 0, [12, 10, 0]]],
-       "free_words:     %*d\n"],
-    _p_ =
-      [0,
-       [11, "largest_free:   ", [4, 0, [1, 1], 0, [12, 10, 0]]],
-       "largest_free:   %*d\n"],
-    _q_ =
-      [0,
-       [11, "fragments:      ", [4, 0, [1, 1], 0, [12, 10, 0]]],
-       "fragments:      %*d\n"],
-    _r_ = [0, [12, 10, 0], cst],
-    _s_ =
-      [0,
-       [11, "live_blocks: ", [4, 0, 0, 0, [12, 10, 0]]],
-       "live_blocks: %d\n"],
-    _t_ =
-      [0,
-       [11, "free_blocks: ", [4, 0, 0, 0, [12, 10, 0]]],
-       "free_blocks: %d\n"],
-    _u_ =
-      [0,
-       [11, "heap_chunks: ", [4, 0, 0, 0, [12, 10, 0]]],
-       "heap_chunks: %d\n"];
-   function eventlog_pause(param){
-     /*<<gc.ml:65:24>>*/ return 0;
-    /*<<gc.ml:65:26>>*/ }
-   function eventlog_resume(param){ /*<<gc.ml:66:25>>*/ return 0;
-    /*<<gc.ml:66:27>>*/ }
-   function print_stat(c){
-     /*<<gc.ml:71:2>>*/  /*<<gc.ml:71:11>>*/ var
-     st =  /*<<gc.ml:71:11>>*/ runtime.caml_gc_stat(0);
-     /*<<gc.ml:72:2>>*/  /*<<gc.ml:72:2>>*/ caml_call3
-     (Stdlib_Printf[1], c, _a_, st[4]);
-     /*<<gc.ml:73:2>>*/  /*<<gc.ml:73:2>>*/ caml_call3
-     (Stdlib_Printf[1], c, _b_, st[5]);
-     /*<<gc.ml:74:2>>*/  /*<<gc.ml:74:2>>*/ caml_call3
-     (Stdlib_Printf[1], c, _c_, st[14]);
-     /*<<gc.ml:75:2>>*/  /*<<gc.ml:75:2>>*/ caml_call3
-     (Stdlib_Printf[1], c, _d_, st[17]);
-     /*<<gc.ml:76:2>>*/  /*<<gc.ml:76:2>>*/ caml_call2
-     (Stdlib_Printf[1], c, _e_);
-     /*<<gc.ml:77:25>>*/  /*<<gc.ml:77:25>>*/ var
-     l1 =
-        /*<<gc.ml:77:25>>*/ caml_ml_string_length
-        ( /*<<gc.ml:77:25>>*/ caml_call2(Stdlib_Printf[4], _f_, st[1]));
-     /*<<gc.ml:78:2>>*/  /*<<gc.ml:78:2>>*/ caml_call4
-     (Stdlib_Printf[1], c, _g_, l1, st[1]);
-     /*<<gc.ml:79:2>>*/  /*<<gc.ml:79:2>>*/ caml_call4
-     (Stdlib_Printf[1], c, _h_, l1, st[2]);
-     /*<<gc.ml:80:2>>*/  /*<<gc.ml:80:2>>*/ caml_call4
-     (Stdlib_Printf[1], c, _i_, l1, st[3]);
-     /*<<gc.ml:81:2>>*/  /*<<gc.ml:81:2>>*/ caml_call2
-     (Stdlib_Printf[1], c, _j_);
-     /*<<gc.ml:82:25>>*/  /*<<gc.ml:82:25>>*/ var
-     l2 =
-        /*<<gc.ml:82:25>>*/ caml_ml_string_length
-        ( /*<<gc.ml:82:25>>*/ caml_call2(Stdlib_Printf[4], _k_, st[15]));
-     /*<<gc.ml:83:2>>*/  /*<<gc.ml:83:2>>*/ caml_call4
-     (Stdlib_Printf[1], c, _l_, l2, st[15]);
-     /*<<gc.ml:84:2>>*/  /*<<gc.ml:84:2>>*/ caml_call4
-     (Stdlib_Printf[1], c, _m_, l2, st[6]);
-     /*<<gc.ml:85:2>>*/  /*<<gc.ml:85:2>>*/ caml_call4
-     (Stdlib_Printf[1], c, _n_, l2, st[8]);
-     /*<<gc.ml:86:2>>*/  /*<<gc.ml:86:2>>*/ caml_call4
-     (Stdlib_Printf[1], c, _o_, l2, st[10]);
-     /*<<gc.ml:87:2>>*/  /*<<gc.ml:87:2>>*/ caml_call4
-     (Stdlib_Printf[1], c, _p_, l2, st[12]);
-     /*<<gc.ml:88:2>>*/  /*<<gc.ml:88:2>>*/ caml_call4
-     (Stdlib_Printf[1], c, _q_, l2, st[13]);
-     /*<<gc.ml:89:2>>*/  /*<<gc.ml:89:2>>*/ caml_call2
-     (Stdlib_Printf[1], c, _r_);
-     /*<<gc.ml:90:2>>*/  /*<<gc.ml:90:2>>*/ caml_call3
-     (Stdlib_Printf[1], c, _s_, st[9]);
-     /*<<gc.ml:91:2>>*/  /*<<gc.ml:91:2>>*/ caml_call3
-     (Stdlib_Printf[1], c, _t_, st[11]);
-    return caml_call3(Stdlib_Printf[1], c, _u_, st[7]);
-    /*<<gc.ml:92:46>>*/ }
-   function allocated_bytes(param){
-     /*<<gc.ml:96:2>>*/ var
-      /*<<gc.ml:96:22>>*/ match =
-        /*<<gc.ml:96:22>>*/ runtime.caml_gc_counters(0),
-     ma = match[3],
-     pro = match[2],
-     mi = match[1];
-     /*<<gc.ml:97:2>>*/ return (mi + ma - pro) * (Stdlib_Sys[9] / 8 | 0);
-    /*<<gc.ml:97:55>>*/ }
-   function create_alarm(f){
-     /*<<gc.ml:117:2>>*/ return  /*<<gc.ml:117:24>>*/ caml_call1
-            (Stdlib_Atomic[1], 1);
-    /*<<gc.ml:119:13>>*/ }
-   function delete_alarm(a){
-     /*<<gc.ml:122:21>>*/ return  /*<<gc.ml:122:21>>*/ caml_call2
-            (Stdlib_Atomic[3], a, 0);
-    /*<<gc.ml:122:39>>*/ }
-   function _v_(param){ /*<<gc.ml:146:32>>*/ return 0; /*<<gc.ml:146:34>>*/ }
-   function _w_(param){ /*<<gc.ml:145:32>>*/ return 0; /*<<gc.ml:145:34>>*/ }
-   function _x_(param){ /*<<gc.ml:144:26>>*/ return 0; /*<<gc.ml:144:30>>*/ }
-   function _y_(param){ /*<<gc.ml:143:30>>*/ return 0; /*<<gc.ml:143:34>>*/ }
-    /*<<gc.ml:141:23>>*/  /*<<gc.ml:141:23>>*/ var
-    null_tracker =
-      [0,
-       function(param){ /*<<gc.ml:142:30>>*/ return 0; /*<<gc.ml:142:34>>*/ },
-       _y_,
-       _x_,
-       _w_,
-       _v_];
-   function start(sampling_rate, opt, tracker){
-     /*<<gc.ml:157:6>>*/ if(opt)
-     var sth = opt[1], callstack_size = sth;
-    else
-     var callstack_size = Stdlib[19];
-     /*<<gc.ml:157:6>>*/ return  /*<<gc.ml:157:6>>*/ runtime.caml_memprof_start
-            (sampling_rate, callstack_size, tracker);
-    /*<<gc.ml:157:50>>*/ }
-   var _z_ = [0, null_tracker, start, runtime.caml_memprof_stop];
-   function _A_(_E_){ /*<<?>>*/ return runtime.caml_final_release(_E_);}
-   var
-    _B_ = runtime.caml_final_register_called_without_value,
-    Stdlib_Gc =
-      [0,
-       print_stat,
-       allocated_bytes,
-       function(_D_, _C_){
-         /*<<?>>*/ return runtime.caml_final_register(_D_, _C_);
-       },
-       _B_,
-       _A_,
-       create_alarm,
-       delete_alarm,
-       eventlog_pause,
-       eventlog_resume,
-       _z_];
-   runtime.caml_register_global(25, Stdlib_Gc, "Stdlib__Gc");
-   return;
-   /*<<?>>*/ }
-  (globalThis));
-
-//# unitInfo: Provides: Stdlib__Digest
-//# unitInfo: Requires: Stdlib, Stdlib__Bytes, Stdlib__Char, Stdlib__String
-(function
-  (globalThis){
-   "use strict";
-   var
-    runtime = globalThis.jsoo_runtime,
-    cst_Digest_from_hex$1 = "Digest.from_hex",
-    caml_bytes_unsafe_set = runtime.caml_bytes_unsafe_set,
-    caml_create_bytes = runtime.caml_create_bytes,
-    caml_maybe_attach_backtrace = runtime.caml_maybe_attach_backtrace,
-    caml_md5_string = runtime.caml_md5_string,
-    caml_ml_string_length = runtime.caml_ml_string_length,
-    caml_string_get = runtime.caml_string_get,
-    caml_wrap_exception = runtime.caml_wrap_exception;
-    /*<<?>>*/ function caml_call1(f, a0){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 1
-            ? f(a0)
-            : runtime.caml_call_gen(f, [a0]);
-   }
-    /*<<?>>*/ function caml_call2(f, a0, a1){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 2
-            ? f(a0, a1)
-            : runtime.caml_call_gen(f, [a0, a1]);
-   }
-   var
-    global_data = runtime.caml_get_global_data(),
-    Stdlib = global_data.Stdlib,
-    Stdlib_Char = global_data.Stdlib__Char,
-    Stdlib_Bytes = global_data.Stdlib__Bytes,
-    Stdlib_String = global_data.Stdlib__String,
-    compare = Stdlib_String[9],
-    equal = Stdlib_String[8],
-    cst_Digest_from_hex$0 = cst_Digest_from_hex$1,
-    cst_Digest_from_hex = cst_Digest_from_hex$1,
-    cst_Digest_to_hex = "Digest.to_hex",
-    cst_Digest_substring = "Digest.substring";
-   function string(str){
-     /*<<digest.ml:27:2>>*/ return  /*<<digest.ml:27:2>>*/ caml_md5_string
-            (str, 0, caml_ml_string_length(str));
-    /*<<digest.ml:27:41>>*/ }
-   function bytes(b){
-     /*<<digest.ml:29:14>>*/ return string
-            ( /*<<digest.ml:29:21>>*/ caml_call1(Stdlib_Bytes[44], b));
-    /*<<digest.ml:29:47>>*/ }
-   function substring(str, ofs, len){
-     /*<<digest.ml:32:2>>*/ if
-     (0 <= ofs && 0 <= len && (caml_ml_string_length(str) - len | 0) >= ofs)
-      /*<<digest.ml:34:7>>*/ return  /*<<digest.ml:34:7>>*/ caml_md5_string
-             (str, ofs, len);
-     /*<<digest.ml:33:7>>*/ return  /*<<digest.ml:33:7>>*/ caml_call1
-            (Stdlib[1], cst_Digest_substring);
-    /*<<digest.ml:34:32>>*/ }
-   function subbytes(b, ofs, len){
-     /*<<digest.ml:36:25>>*/ return substring
-            ( /*<<digest.ml:36:35>>*/ caml_call1(Stdlib_Bytes[44], b),
-             ofs,
-             len);
-    /*<<digest.ml:36:69>>*/ }
-   function file(filename){
-     /*<<digest.ml:39:2>>*/  /*<<digest.ml:39:11>>*/ var
-     ic =  /*<<digest.ml:39:11>>*/ caml_call1(Stdlib[80], filename);
-     /*<<digest.ml:40:2>>*/ try{
-      /*<<digest.ml:40:8>>*/  /*<<digest.ml:40:8>>*/ var
-      d =  /*<<digest.ml:40:8>>*/ runtime.caml_md5_chan(ic, -1);
-    }
-    catch(e$0){
-     var e = caml_wrap_exception(e$0);
-      /*<<digest.ml:42:21>>*/  /*<<digest.ml:42:21>>*/ caml_call1
-      (Stdlib[93], ic);
-      /*<<digest.ml:42:34>>*/ throw  /*<<digest.ml:42:34>>*/ caml_maybe_attach_backtrace
-            (e, 0);
-    }
-     /*<<digest.ml:41:11>>*/  /*<<digest.ml:41:11>>*/ caml_call1
-     (Stdlib[93], ic);
-     /*<<digest.ml:41:11>>*/ return d;
-    /*<<digest.ml:42:41>>*/ }
-   function output(chan, digest){
-     /*<<digest.ml:45:2>>*/ return  /*<<digest.ml:45:2>>*/ caml_call2
-            (Stdlib[66], chan, digest);
-    /*<<digest.ml:45:27>>*/ }
-   function input(chan){
-     /*<<digest.ml:47:17>>*/ return  /*<<digest.ml:47:17>>*/ caml_call2
-            (Stdlib[86], chan, 16);
-    /*<<digest.ml:47:44>>*/ }
-   function char_hex(n){
-     /*<<digest.ml:50:2>>*/ var _e_ = 10 <= n ? 87 : 48;
-    return n + _e_ | 0;
-    /*<<digest.ml:50:78>>*/ }
-   function to_hex(d){
-     /*<<digest.ml:53:2>>*/ if(16 !== caml_ml_string_length(d))
-      /*<<digest.ml:53:32>>*/  /*<<digest.ml:53:32>>*/ caml_call1
-      (Stdlib[1], cst_Digest_to_hex);
-     /*<<digest.ml:54:15>>*/ var
-      /*<<digest.ml:54:15>>*/ result =
-        /*<<digest.ml:54:15>>*/ caml_create_bytes(32),
-     i = 0;
-    for(;;){
-      /*<<digest.ml:56:22>>*/  /*<<digest.ml:56:22>>*/ var
-      x =  /*<<digest.ml:56:22>>*/ caml_string_get(d, i);
-     caml_bytes_unsafe_set(result, i * 2 | 0, char_hex(x >>> 4 | 0));
-     caml_bytes_unsafe_set(result, (i * 2 | 0) + 1 | 0, char_hex(x & 15));
-      /*<<digest.ml:55:2>>*/  /*<<digest.ml:55:2>>*/ var _d_ = i + 1 | 0;
-     if(15 === i)
-       /*<<digest.ml:60:2>>*/ return  /*<<digest.ml:60:2>>*/ caml_call1
-              (Stdlib_Bytes[44], result);
-     var i = _d_;
-    }
-    /*<<digest.ml:60:31>>*/ }
-   function from_hex(s){
-     /*<<digest.ml:63:2>>*/ if(32 !== caml_ml_string_length(s))
-      /*<<digest.ml:63:32>>*/  /*<<digest.ml:63:32>>*/ caml_call1
-      (Stdlib[1], cst_Digest_from_hex);
-     /*<<digest.ml:63:32>>*/ function digit(c){
-      /*<<digest.ml:65:4>>*/ if(65 <= c){
-      if(97 <= c){
-       if(103 > c) return (c - 97 | 0) + 10 | 0;
-      }
-      else if(71 > c) return (c - 65 | 0) + 10 | 0;
-     }
-     else if(9 >= c - 48 >>> 0) return c - 48 | 0;
-      /*<<digest.ml:69:11>>*/ throw  /*<<digest.ml:69:11>>*/ caml_maybe_attach_backtrace
-            ([0, Stdlib[6], cst_Digest_from_hex$0], 1);
-     /*<<digest.ml:69:53>>*/ }
-     /*<<digest.ml:72:15>>*/ var
-      /*<<digest.ml:72:15>>*/ result =
-        /*<<digest.ml:72:15>>*/ caml_create_bytes(16),
-     i = 0;
-    for(;;){
-      /*<<digest.ml:71:35>>*/ var
-      i$0 = 2 * i | 0,
-       /*<<digest.ml:71:35>>*/ _a_ =
-        digit( /*<<digest.ml:71:41>>*/ caml_string_get(s, i$0 + 1 | 0)),
-      _b_ =
-        (digit( /*<<digest.ml:71:21>>*/ caml_string_get(s, i$0)) << 4) + _a_
-        | 0;
-      /*<<digest.ml:74:4>>*/  /*<<digest.ml:74:4>>*/ runtime.caml_bytes_set
-      (result, i,  /*<<digest.ml:74:23>>*/ caml_call1(Stdlib_Char[1], _b_));
-      /*<<digest.ml:74:4>>*/  /*<<digest.ml:74:4>>*/ var _c_ = i + 1 | 0;
-     if(15 === i)
-       /*<<digest.ml:76:2>>*/ return  /*<<digest.ml:76:2>>*/ caml_call1
-              (Stdlib_Bytes[44], result);
-     var i = _c_;
-    }
-    /*<<digest.ml:76:31>>*/ }
-   var
-    Stdlib_Digest =
-      [0,
-       compare,
-       equal,
-       string,
-       bytes,
-       substring,
-       subbytes,
-       file,
-       output,
-       input,
-       to_hex,
-       from_hex];
-   runtime.caml_register_global(8, Stdlib_Digest, "Stdlib__Digest");
-   return;
-   /*<<?>>*/ }
-  (globalThis));
-
-//# unitInfo: Provides: Stdlib__Bigarray
-//# unitInfo: Requires: Stdlib, Stdlib__Array, Stdlib__Sys
-(function
-  (globalThis){
-   "use strict";
-   var
-    runtime = globalThis.jsoo_runtime,
-    cst_Bigarray_Array3_of_array_n$1 =
-      "Bigarray.Array3.of_array: non-cubic data",
-    caml_ba_change_layout = runtime.caml_ba_change_layout,
-    caml_ba_create = runtime.caml_ba_create,
-    caml_ba_dim_1 = runtime.caml_ba_dim_1,
-    caml_ba_dim_2 = runtime.caml_ba_dim_2,
-    caml_ba_kind = runtime.caml_ba_kind,
-    caml_ba_num_dims = runtime.caml_ba_num_dims,
-    caml_ba_reshape = runtime.caml_ba_reshape,
-    caml_ba_set_1 = runtime.caml_ba_set_1,
-    caml_ba_set_2 = runtime.caml_ba_set_2,
-    caml_ba_set_3 = runtime.caml_ba_set_3,
-    caml_ba_set_generic = runtime.caml_ba_set_generic,
-    caml_ba_slice = runtime.caml_ba_slice,
-    caml_check_bound = runtime.caml_check_bound,
-    caml_make_vect = runtime.caml_make_vect,
-    caml_mul = runtime.caml_mul;
-    /*<<?>>*/ function caml_call1(f, a0){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 1
-            ? f(a0)
-            : runtime.caml_call_gen(f, [a0]);
-   }
-    /*<<?>>*/ function caml_call2(f, a0, a1){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 2
-            ? f(a0, a1)
-            : runtime.caml_call_gen(f, [a0, a1]);
-   }
-    /*<<?>>*/ function caml_call3(f, a0, a1, a2){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 3
-            ? f(a0, a1, a2)
-            : runtime.caml_call_gen(f, [a0, a1, a2]);
-   }
-   var
-    global_data = runtime.caml_get_global_data(),
-    Stdlib = global_data.Stdlib,
-    Stdlib_Array = global_data.Stdlib__Array,
-    Stdlib_Sys = global_data.Stdlib__Sys,
-    cst_Bigarray_array3_of_genarra = "Bigarray.array3_of_genarray",
-    cst_Bigarray_array2_of_genarra = "Bigarray.array2_of_genarray",
-    cst_Bigarray_array1_of_genarra = "Bigarray.array1_of_genarray",
-    cst_Bigarray_array0_of_genarra = "Bigarray.array0_of_genarray",
-    cst_Bigarray_Array3_of_array_n = cst_Bigarray_Array3_of_array_n$1,
-    cst_Bigarray_Array3_of_array_n$0 = cst_Bigarray_Array3_of_array_n$1,
-    cst_Bigarray_Array2_of_array_n =
-      "Bigarray.Array2.of_array: non-rectangular data",
-    float32 = 0,
-    float64 = 1,
-    int8_signed = 2,
-    int8_unsigned = 3,
-    int16_signed = 4,
-    int16_unsigned = 5,
-    int32 = 6,
-    int64 = 7,
-    int$0 = 8,
-    nativeint = 9,
-    complex32 = 10,
-    complex64 = 11,
-    char$0 = 12;
-   function kind_size_in_bytes(param){
-     /*<<bigarray.ml:73:4>>*/ switch(param){
-      case 0:
-        /*<<bigarray.ml:74:15>>*/ return 4;
-      case 1:
-        /*<<bigarray.ml:75:15>>*/ return 8;
-      case 2:
-        /*<<bigarray.ml:76:19>>*/ return 1;
-      case 3:
-        /*<<bigarray.ml:77:21>>*/ return 1;
-      case 4:
-        /*<<bigarray.ml:78:20>>*/ return 2;
-      case 5:
-        /*<<bigarray.ml:79:22>>*/ return 2;
-      case 6:
-        /*<<bigarray.ml:80:13>>*/ return 4;
-      case 7:
-        /*<<bigarray.ml:81:13>>*/ return 8;
-      case 8:
-       return Stdlib_Sys[9] / 8 | 0;
-      case 9:
-       return Stdlib_Sys[9] / 8 | 0;
-      case 10:
-        /*<<bigarray.ml:84:17>>*/ return 8;
-      case 11:
-        /*<<bigarray.ml:85:17>>*/ return 16;
-      default:  /*<<bigarray.ml:86:12>>*/ return 1;
-    }
-    /*<<bigarray.ml:86:13>>*/ }
-    /*<<bigarray.ml:73:4>>*/ var
-     /*<<bigarray.ml:73:4>>*/ c_layout = 0,
-    fortran_layout = 1;
-   function cloop(arr, idx, f, col, max){
-     /*<<bigarray.ml:104:4>>*/ if(col === idx.length - 1)
-      /*<<bigarray.ml:104:35>>*/ return  /*<<bigarray.ml:104:35>>*/ caml_ba_set_generic
-             (arr, idx,  /*<<bigarray.ml:104:47>>*/ caml_call1(f, idx));
-     /*<<bigarray.ml:105:27>>*/ var
-      /*<<bigarray.ml:105:27>>*/ _am_ =
-       caml_check_bound(max, col)[1 + col] - 1 | 0,
-      /*<<bigarray.ml:105:9>>*/ _al_ = 0;
-    if(_am_ >= 0){
-     var j = _al_;
-     for(;;){
-       /*<<bigarray.ml:106:11>>*/ caml_check_bound(idx, col)[1 + col] = j;
-       /*<<bigarray.ml:107:11>>*/ cloop(arr, idx, f, col + 1 | 0, max);
-       /*<<bigarray.ml:107:11>>*/  /*<<bigarray.ml:107:11>>*/ var
-       _an_ = j + 1 | 0;
-      if(_am_ === j) break;
-      var j = _an_;
-     }
-    }
-    return 0;
-    /*<<bigarray.ml:108:13>>*/ }
-   function floop(arr, idx, f, col, max){
-     /*<<bigarray.ml:110:4>>*/ if(0 > col)
-      /*<<bigarray.ml:110:20>>*/ return  /*<<bigarray.ml:110:20>>*/ caml_ba_set_generic
-             (arr, idx,  /*<<bigarray.ml:110:32>>*/ caml_call1(f, idx));
-     /*<<bigarray.ml:111:22>>*/ var
-      /*<<bigarray.ml:111:22>>*/ _aj_ = caml_check_bound(max, col)[1 + col],
-      /*<<bigarray.ml:111:9>>*/ _ai_ = 1;
-    if(_aj_ >= 1){
-     var j = _ai_;
-     for(;;){
-       /*<<bigarray.ml:112:11>>*/ caml_check_bound(idx, col)[1 + col] = j;
-       /*<<bigarray.ml:113:11>>*/ floop(arr, idx, f, col - 1 | 0, max);
-       /*<<bigarray.ml:113:11>>*/  /*<<bigarray.ml:113:11>>*/ var
-       _ak_ = j + 1 | 0;
-      if(_aj_ === j) break;
-      var j = _ak_;
-     }
-    }
-    return 0;
-    /*<<bigarray.ml:114:13>>*/ }
-   function init(kind, layout, dims, f){
-     /*<<bigarray.ml:116:4>>*/ var
-      /*<<bigarray.ml:116:14>>*/ arr =
-        /*<<bigarray.ml:116:14>>*/ caml_ba_create(kind, layout, dims),
-      /*<<bigarray.ml:117:4>>*/ dlen = dims.length - 1;
-     /*<<bigarray.ml:118:4>>*/ return layout
-            ? (floop
-               (arr,
-                 /*<<bigarray.ml:120:34>>*/ caml_make_vect(dlen, 1),
-                f,
-                dlen - 1 | 0,
-                dims),
-              arr)
-            : (cloop
-               (arr,
-                 /*<<bigarray.ml:119:28>>*/ caml_make_vect(dlen, 0),
-                f,
-                0,
-                dims),
-              arr);
-    /*<<bigarray.ml:120:77>>*/ }
-   function dims(a){
-     /*<<bigarray.ml:125:4>>*/ var
-      /*<<bigarray.ml:125:12>>*/ n =
-        /*<<bigarray.ml:125:12>>*/ caml_ba_num_dims(a),
-      /*<<bigarray.ml:126:12>>*/ d =
-        /*<<bigarray.ml:126:12>>*/ caml_make_vect(n, 0),
-      /*<<bigarray.ml:127:4>>*/ _af_ = n - 1 | 0,
-      /*<<bigarray.ml:126:12>>*/ _ae_ = 0;
-    if(_af_ >= 0){
-     var i = _ae_;
-     for(;;){
-       /*<<bigarray.ml:127:33>>*/  /*<<bigarray.ml:127:33>>*/ var
-       _ag_ =  /*<<bigarray.ml:127:33>>*/ runtime.caml_ba_dim(a, i);
-       /*<<bigarray.ml:127:24>>*/ caml_check_bound(d, i)[1 + i] = _ag_;
-       /*<<bigarray.ml:127:24>>*/  /*<<bigarray.ml:127:24>>*/ var
-       _ah_ = i + 1 | 0;
-      if(_af_ === i) break;
-      var i = _ah_;
-     }
-    }
-     /*<<bigarray.ml:128:4>>*/ return d;
-    /*<<bigarray.ml:128:5>>*/ }
-   function size_in_bytes(arr){
-     /*<<bigarray.ml:136:4>>*/ var
-      /*<<bigarray.ml:136:63>>*/ _ac_ = dims(arr),
-      /*<<bigarray.ml:136:38>>*/ _ad_ =
-        /*<<bigarray.ml:136:38>>*/ caml_call3
-        (Stdlib_Array[15], caml_mul, 1, _ac_);
-     /*<<bigarray.ml:136:4>>*/ return  /*<<bigarray.ml:136:4>>*/ caml_mul
-            (kind_size_in_bytes( /*<<bigarray.ml:136:24>>*/ caml_ba_kind(arr)),
-             _ad_);
-    /*<<bigarray.ml:136:74>>*/ }
-   function create(kind, layout){
-     /*<<bigarray.ml:157:4>>*/ return  /*<<bigarray.ml:157:4>>*/ caml_ba_create
-            (kind, layout, [0]);
-    /*<<bigarray.ml:157:36>>*/ }
-   function get(arr){
-     /*<<bigarray.ml:158:16>>*/ return  /*<<bigarray.ml:158:16>>*/ runtime.caml_ba_get_generic
-            (arr, [0]);
-    /*<<bigarray.ml:158:37>>*/ }
-   function set(arr){
-     /*<<bigarray.ml:159:16>>*/  /*<<bigarray.ml:159:16>>*/ var _aa_ = [0];
-     /*<<bigarray.ml:159:33>>*/ return function(_ab_){
-      /*<<?>>*/ return caml_ba_set_generic(arr, _aa_, _ab_);};
-    /*<<bigarray.ml:159:37>>*/ }
-   function size_in_bytes$0(arr){
-     /*<<bigarray.ml:166:26>>*/ return kind_size_in_bytes
-            ( /*<<bigarray.ml:166:45>>*/ caml_ba_kind(arr));
-    /*<<bigarray.ml:166:55>>*/ }
-   function of_value(kind, layout, v){
-     /*<<bigarray.ml:172:4>>*/  /*<<bigarray.ml:172:12>>*/ var
-     a = create(kind, layout);
-     /*<<bigarray.ml:173:4>>*/ set(a)(v);
-     /*<<bigarray.ml:173:4>>*/ return a;
-    /*<<bigarray.ml:174:5>>*/ }
-   function create$0(kind, layout, dim){
-     /*<<bigarray.ml:181:4>>*/ return  /*<<bigarray.ml:181:4>>*/ caml_ba_create
-            (kind, layout, [0, dim]);
-    /*<<bigarray.ml:181:39>>*/ }
-   function size_in_bytes$1(arr){
-     /*<<bigarray.ml:195:4>>*/  /*<<bigarray.ml:195:38>>*/ var
-     _$_ =  /*<<bigarray.ml:195:38>>*/ caml_ba_dim_1(arr);
-     /*<<bigarray.ml:195:4>>*/ return  /*<<bigarray.ml:195:4>>*/ caml_mul
-            (kind_size_in_bytes( /*<<bigarray.ml:195:24>>*/ caml_ba_kind(arr)),
-             _$_);
-    /*<<bigarray.ml:195:47>>*/ }
-   function slice(a, n){
-     /*<<bigarray.ml:199:4>>*/ return  /*<<bigarray.ml:199:10>>*/ runtime.caml_ba_layout
-             (a)
-            ?  /*<<bigarray.ml:201:25>>*/ caml_ba_slice(a, [0, n])
-            :  /*<<bigarray.ml:200:19>>*/ caml_ba_slice(a, [0, n]);
-    /*<<bigarray.ml:201:76>>*/ }
-   function init$0(kind, layout, dim, f){
-     /*<<bigarray.ml:209:4>>*/  /*<<bigarray.ml:209:14>>*/ var
-     arr = create$0(kind, layout, dim);
-     /*<<bigarray.ml:210:4>>*/ if(layout){
-      /*<<bigarray.ml:207:4>>*/  /*<<bigarray.ml:207:4>>*/ var _Z_ = 1;
-     if(dim >= 1){
-      var i$0 = _Z_;
-      for(;;){
-        /*<<bigarray.ml:207:24>>*/  /*<<bigarray.ml:207:24>>*/ caml_ba_set_1
-        (arr, i$0,  /*<<bigarray.ml:207:41>>*/ caml_call1(f, i$0));
-        /*<<bigarray.ml:207:24>>*/  /*<<bigarray.ml:207:24>>*/ var
-        ___ = i$0 + 1 | 0;
-       if(dim === i$0) break;
-       var i$0 = ___;
-      }
-     }
-      /*<<bigarray.ml:212:24>>*/ return arr;
-    }
-     /*<<bigarray.ml:205:4>>*/ var
-     _X_ = dim - 1 | 0,
-      /*<<bigarray.ml:205:4>>*/ _W_ = 0;
-    if(_X_ >= 0){
-     var i = _W_;
-     for(;;){
-       /*<<bigarray.ml:205:29>>*/  /*<<bigarray.ml:205:29>>*/ caml_ba_set_1
-       (arr, i,  /*<<bigarray.ml:205:46>>*/ caml_call1(f, i));
-       /*<<bigarray.ml:205:29>>*/  /*<<bigarray.ml:205:29>>*/ var
-       _Y_ = i + 1 | 0;
-      if(_X_ === i) break;
-      var i = _Y_;
-     }
-    }
-     /*<<bigarray.ml:211:18>>*/ return arr;
-    /*<<bigarray.ml:212:51>>*/ }
-   function of_array(kind, layout, data){
-     /*<<bigarray.ml:214:4>>*/ var
-      /*<<bigarray.ml:214:13>>*/ ba = create$0(kind, layout, data.length - 1),
-      /*<<bigarray.ml:215:4>>*/ ofs = layout ? 1 : 0,
-     _U_ = data.length - 1 - 1 | 0,
-     _T_ = 0;
-    if(_U_ >= 0){
-     var i = _T_;
-     for(;;){
-       /*<<bigarray.ml:220:42>>*/  /*<<bigarray.ml:220:42>>*/ caml_ba_set_1
-       (ba, i + ofs | 0, caml_check_bound(data, i)[1 + i]);
-       /*<<bigarray.ml:220:42>>*/  /*<<bigarray.ml:220:42>>*/ var
-       _V_ = i + 1 | 0;
-      if(_U_ === i) break;
-      var i = _V_;
-     }
-    }
-     /*<<bigarray.ml:221:4>>*/ return ba;
-    /*<<bigarray.ml:221:6>>*/ }
-   function create$1(kind, layout, dim1, dim2){
-     /*<<bigarray.ml:227:4>>*/ return  /*<<bigarray.ml:227:4>>*/ caml_ba_create
-            (kind, layout, [0, dim1, dim2]);
-    /*<<bigarray.ml:227:46>>*/ }
-   function size_in_bytes$2(arr){
-     /*<<bigarray.ml:243:4>>*/ var
-      /*<<bigarray.ml:243:51>>*/ _R_ =
-        /*<<bigarray.ml:243:51>>*/ caml_ba_dim_2(arr),
-      /*<<bigarray.ml:243:38>>*/ _S_ =
-        /*<<bigarray.ml:243:38>>*/ caml_ba_dim_1(arr);
-    return caml_mul
-            ( /*<<bigarray.ml:243:4>>*/ caml_mul
-              (kind_size_in_bytes
-                ( /*<<bigarray.ml:243:24>>*/ caml_ba_kind(arr)),
-               _S_),
-             _R_);
-    /*<<bigarray.ml:243:61>>*/ }
-   function slice_left(a, n){
-     /*<<bigarray.ml:250:23>>*/ return  /*<<bigarray.ml:250:23>>*/ caml_ba_slice
-            (a, [0, n]);
-    /*<<bigarray.ml:250:50>>*/ }
-   function slice_right(a, n){
-     /*<<bigarray.ml:251:24>>*/ return  /*<<bigarray.ml:251:24>>*/ caml_ba_slice
-            (a, [0, n]);
-    /*<<bigarray.ml:251:52>>*/ }
-   function init$1(kind, layout, dim1, dim2, f){
-     /*<<bigarray.ml:267:4>>*/  /*<<bigarray.ml:267:14>>*/ var
-     arr = create$1(kind, layout, dim1, dim2);
-     /*<<bigarray.ml:268:4>>*/ if(layout){
-      /*<<bigarray.ml:261:4>>*/  /*<<bigarray.ml:261:4>>*/ var _N_ = 1;
-     if(dim2 >= 1){
-      var j$0 = _N_;
-      for(;;){
-        /*<<bigarray.ml:262:6>>*/  /*<<bigarray.ml:262:6>>*/ var _O_ = 1;
-       if(dim1 >= 1){
-        var i$0 = _O_;
-        for(;;){
-          /*<<bigarray.ml:263:8>>*/  /*<<bigarray.ml:263:8>>*/ caml_ba_set_2
-          (arr, i$0, j$0,  /*<<bigarray.ml:263:27>>*/ caml_call2(f, i$0, j$0));
-          /*<<bigarray.ml:263:8>>*/  /*<<bigarray.ml:263:8>>*/ var
-          _Q_ = i$0 + 1 | 0;
-         if(dim1 === i$0) break;
-         var i$0 = _Q_;
-        }
-       }
-        /*<<bigarray.ml:261:4>>*/  /*<<bigarray.ml:261:4>>*/ var
-        _P_ = j$0 + 1 | 0;
-       if(dim2 === j$0) break;
-       var j$0 = _P_;
-      }
-     }
-      /*<<bigarray.ml:270:24>>*/ return arr;
-    }
-     /*<<bigarray.ml:255:4>>*/ var
-     _I_ = dim1 - 1 | 0,
-      /*<<bigarray.ml:255:4>>*/ _H_ = 0;
-    if(_I_ >= 0){
-     var i = _H_;
-     for(;;){
-       /*<<bigarray.ml:256:6>>*/ var
-       _K_ = dim2 - 1 | 0,
-        /*<<bigarray.ml:256:6>>*/ _J_ = 0;
-      if(_K_ >= 0){
-       var j = _J_;
-       for(;;){
-         /*<<bigarray.ml:257:8>>*/  /*<<bigarray.ml:257:8>>*/ caml_ba_set_2
-         (arr, i, j,  /*<<bigarray.ml:257:27>>*/ caml_call2(f, i, j));
-         /*<<bigarray.ml:257:8>>*/  /*<<bigarray.ml:257:8>>*/ var
-         _M_ = j + 1 | 0;
-        if(_K_ === j) break;
-        var j = _M_;
-       }
-      }
-       /*<<bigarray.ml:255:4>>*/  /*<<bigarray.ml:255:4>>*/ var
-       _L_ = i + 1 | 0;
-      if(_I_ === i) break;
-      var i = _L_;
-     }
-    }
-     /*<<bigarray.ml:269:18>>*/ return arr;
-    /*<<bigarray.ml:270:57>>*/ }
-   function of_array$0(kind, layout, data){
-     /*<<bigarray.ml:272:4>>*/ var
-     dim1 = data.length - 1,
-      /*<<bigarray.ml:273:4>>*/ dim2 =
-       0 === dim1 ? 0 : caml_check_bound(data, 0)[1].length - 1,
-      /*<<bigarray.ml:274:13>>*/ ba = create$1(kind, layout, dim1, dim2),
-      /*<<bigarray.ml:275:4>>*/ ofs = layout ? 1 : 0,
-      /*<<bigarray.ml:280:4>>*/ _C_ = dim1 - 1 | 0,
-     _B_ = 0;
-    if(_C_ >= 0){
-     var i = _B_;
-     for(;;){
-       /*<<bigarray.ml:281:16>>*/  /*<<bigarray.ml:281:16>>*/ var
-       row = caml_check_bound(data, i)[1 + i];
-      if(row.length - 1 !== dim2)
-        /*<<bigarray.ml:283:8>>*/  /*<<bigarray.ml:283:8>>*/ caml_call1
-        (Stdlib[1], cst_Bigarray_Array2_of_array_n);
-       /*<<bigarray.ml:273:32>>*/ var
-        /*<<bigarray.ml:273:32>>*/ _E_ = dim2 - 1 | 0,
-        /*<<bigarray.ml:283:8>>*/ _D_ = 0;
-      if(_E_ >= 0){
-       var j = _D_;
-       for(;;){
-         /*<<bigarray.ml:285:8>>*/  /*<<bigarray.ml:285:8>>*/ caml_ba_set_2
-         (ba, i + ofs | 0, j + ofs | 0, caml_check_bound(row, j)[1 + j]);
-         /*<<bigarray.ml:285:8>>*/  /*<<bigarray.ml:285:8>>*/ var
-         _G_ = j + 1 | 0;
-        if(_E_ === j) break;
-        var j = _G_;
-       }
-      }
-       /*<<bigarray.ml:280:4>>*/  /*<<bigarray.ml:280:4>>*/ var
-       _F_ = i + 1 | 0;
-      if(_C_ === i) break;
-      var i = _F_;
-     }
-    }
-     /*<<bigarray.ml:288:4>>*/ return ba;
-    /*<<bigarray.ml:288:6>>*/ }
-   function create$2(kind, layout, dim1, dim2, dim3){
-     /*<<bigarray.ml:294:4>>*/ return  /*<<bigarray.ml:294:4>>*/ caml_ba_create
-            (kind, layout, [0, dim1, dim2, dim3]);
-    /*<<bigarray.ml:294:52>>*/ }
-   function size_in_bytes$3(arr){
-     /*<<bigarray.ml:312:4>>*/ var
-      /*<<bigarray.ml:312:64>>*/ _y_ =
-        /*<<bigarray.ml:312:64>>*/ runtime.caml_ba_dim_3(arr),
-      /*<<bigarray.ml:312:51>>*/ _z_ =
-        /*<<bigarray.ml:312:51>>*/ caml_ba_dim_2(arr),
-      /*<<bigarray.ml:312:38>>*/ _A_ =
-        /*<<bigarray.ml:312:38>>*/ caml_ba_dim_1(arr);
-    return caml_mul
-            (caml_mul
-              ( /*<<bigarray.ml:312:4>>*/ caml_mul
-                (kind_size_in_bytes
-                  ( /*<<bigarray.ml:312:24>>*/ caml_ba_kind(arr)),
-                 _A_),
-               _z_),
-             _y_);
-    /*<<bigarray.ml:312:74>>*/ }
-   function slice_left_1(a, n, m){
-     /*<<bigarray.ml:319:27>>*/ return  /*<<bigarray.ml:319:27>>*/ caml_ba_slice
-            (a, [0, n, m]);
-    /*<<bigarray.ml:319:57>>*/ }
-   function slice_right_1(a, n, m){
-     /*<<bigarray.ml:320:28>>*/ return  /*<<bigarray.ml:320:28>>*/ caml_ba_slice
-            (a, [0, n, m]);
-    /*<<bigarray.ml:320:59>>*/ }
-   function slice_left_2(a, n){
-     /*<<bigarray.ml:321:25>>*/ return  /*<<bigarray.ml:321:25>>*/ caml_ba_slice
-            (a, [0, n]);
-    /*<<bigarray.ml:321:52>>*/ }
-   function slice_right_2(a, n){
-     /*<<bigarray.ml:322:26>>*/ return  /*<<bigarray.ml:322:26>>*/ caml_ba_slice
-            (a, [0, n]);
-    /*<<bigarray.ml:322:54>>*/ }
-   function init$2(kind, layout, dim1, dim2, dim3, f){
-     /*<<bigarray.ml:342:4>>*/  /*<<bigarray.ml:342:14>>*/ var
-     arr = create$2(kind, layout, dim1, dim2, dim3);
-     /*<<bigarray.ml:343:4>>*/ if(layout){
-      /*<<bigarray.ml:334:4>>*/  /*<<bigarray.ml:334:4>>*/ var _s_ = 1;
-     if(dim3 >= 1){
-      var k$0 = _s_;
-      for(;;){
-        /*<<bigarray.ml:335:6>>*/  /*<<bigarray.ml:335:6>>*/ var _t_ = 1;
-       if(dim2 >= 1){
-        var j$0 = _t_;
-        for(;;){
-          /*<<bigarray.ml:336:8>>*/  /*<<bigarray.ml:336:8>>*/ var _v_ = 1;
-         if(dim1 >= 1){
-          var i$0 = _v_;
-          for(;;){
-            /*<<bigarray.ml:337:10>>*/  /*<<bigarray.ml:337:10>>*/ caml_ba_set_3
-            (arr,
-             i$0,
-             j$0,
-             k$0,
-              /*<<bigarray.ml:337:31>>*/ caml_call3(f, i$0, j$0, k$0));
-            /*<<bigarray.ml:337:10>>*/  /*<<bigarray.ml:337:10>>*/ var
-            _x_ = i$0 + 1 | 0;
-           if(dim1 === i$0) break;
-           var i$0 = _x_;
-          }
-         }
-          /*<<bigarray.ml:335:6>>*/  /*<<bigarray.ml:335:6>>*/ var
-          _w_ = j$0 + 1 | 0;
-         if(dim2 === j$0) break;
-         var j$0 = _w_;
-        }
-       }
-        /*<<bigarray.ml:334:4>>*/  /*<<bigarray.ml:334:4>>*/ var
-        _u_ = k$0 + 1 | 0;
-       if(dim3 === k$0) break;
-       var k$0 = _u_;
-      }
-     }
-      /*<<bigarray.ml:345:24>>*/ return arr;
-    }
-     /*<<bigarray.ml:326:4>>*/ var
-     _k_ = dim1 - 1 | 0,
-      /*<<bigarray.ml:326:4>>*/ _j_ = 0;
-    if(_k_ >= 0){
-     var i = _j_;
-     for(;;){
-       /*<<bigarray.ml:327:6>>*/ var
-       _m_ = dim2 - 1 | 0,
-        /*<<bigarray.ml:327:6>>*/ _l_ = 0;
-      if(_m_ >= 0){
-       var j = _l_;
-       for(;;){
-         /*<<bigarray.ml:328:8>>*/ var
-         _p_ = dim3 - 1 | 0,
-          /*<<bigarray.ml:328:8>>*/ _o_ = 0;
-        if(_p_ >= 0){
-         var k = _o_;
-         for(;;){
-           /*<<bigarray.ml:329:10>>*/  /*<<bigarray.ml:329:10>>*/ caml_ba_set_3
-           (arr, i, j, k,  /*<<bigarray.ml:329:31>>*/ caml_call3(f, i, j, k));
-           /*<<bigarray.ml:329:10>>*/  /*<<bigarray.ml:329:10>>*/ var
-           _r_ = k + 1 | 0;
-          if(_p_ === k) break;
-          var k = _r_;
-         }
-        }
-         /*<<bigarray.ml:327:6>>*/  /*<<bigarray.ml:327:6>>*/ var
-         _q_ = j + 1 | 0;
-        if(_m_ === j) break;
-        var j = _q_;
-       }
-      }
-       /*<<bigarray.ml:326:4>>*/  /*<<bigarray.ml:326:4>>*/ var
-       _n_ = i + 1 | 0;
-      if(_k_ === i) break;
-      var i = _n_;
-     }
-    }
-     /*<<bigarray.ml:344:18>>*/ return arr;
-    /*<<bigarray.ml:345:62>>*/ }
-   function of_array$1(kind, layout, data){
-     /*<<bigarray.ml:347:4>>*/ var
-     dim1 = data.length - 1,
-      /*<<bigarray.ml:348:4>>*/ dim2 =
-       0 === dim1 ? 0 : caml_check_bound(data, 0)[1].length - 1,
-      /*<<bigarray.ml:349:4>>*/ dim3 =
-       0 === dim2
-        ? 0
-        : caml_check_bound(caml_check_bound(data, 0)[1], 0)[1].length - 1,
-      /*<<bigarray.ml:350:13>>*/ ba = create$2(kind, layout, dim1, dim2, dim3),
-      /*<<bigarray.ml:351:4>>*/ ofs = layout ? 1 : 0,
-      /*<<bigarray.ml:356:4>>*/ _b_ = dim1 - 1 | 0,
-     _a_ = 0;
-    if(_b_ >= 0){
-     var i = _a_;
-     for(;;){
-       /*<<bigarray.ml:357:16>>*/  /*<<bigarray.ml:357:16>>*/ var
-       row = caml_check_bound(data, i)[1 + i];
-      if(row.length - 1 !== dim2)
-        /*<<bigarray.ml:359:8>>*/  /*<<bigarray.ml:359:8>>*/ caml_call1
-        (Stdlib[1], cst_Bigarray_Array3_of_array_n);
-       /*<<bigarray.ml:348:32>>*/ var
-        /*<<bigarray.ml:348:32>>*/ _d_ = dim2 - 1 | 0,
-        /*<<bigarray.ml:359:8>>*/ _c_ = 0;
-      if(_d_ >= 0){
-       var j = _c_;
-       for(;;){
-         /*<<bigarray.ml:361:18>>*/  /*<<bigarray.ml:361:18>>*/ var
-         col = caml_check_bound(row, j)[1 + j];
-        if(col.length - 1 !== dim3)
-          /*<<bigarray.ml:363:10>>*/  /*<<bigarray.ml:363:10>>*/ caml_call1
-          (Stdlib[1], cst_Bigarray_Array3_of_array_n$0);
-         /*<<bigarray.ml:349:32>>*/ var
-          /*<<bigarray.ml:349:32>>*/ _g_ = dim3 - 1 | 0,
-          /*<<bigarray.ml:363:10>>*/ _f_ = 0;
-        if(_g_ >= 0){
-         var k = _f_;
-         for(;;){
-           /*<<bigarray.ml:365:10>>*/  /*<<bigarray.ml:365:10>>*/ caml_ba_set_3
-           (ba,
-            i + ofs | 0,
-            j + ofs | 0,
-            k + ofs | 0,
-            caml_check_bound(col, k)[1 + k]);
-           /*<<bigarray.ml:365:10>>*/  /*<<bigarray.ml:365:10>>*/ var
-           _i_ = k + 1 | 0;
-          if(_g_ === k) break;
-          var k = _i_;
-         }
-        }
-         /*<<bigarray.ml:359:8>>*/  /*<<bigarray.ml:359:8>>*/ var
-         _h_ = j + 1 | 0;
-        if(_d_ === j) break;
-        var j = _h_;
-       }
-      }
-       /*<<bigarray.ml:356:4>>*/  /*<<bigarray.ml:356:4>>*/ var
-       _e_ = i + 1 | 0;
-      if(_b_ === i) break;
-      var i = _e_;
-     }
-    }
-     /*<<bigarray.ml:369:4>>*/ return ba;
-    /*<<bigarray.ml:369:6>>*/ }
-   function array0_of_genarray(a){
-     /*<<bigarray.ml:381:2>>*/ return 0
-            ===  /*<<bigarray.ml:381:5>>*/ caml_ba_num_dims(a)
-            ? a
-            :  /*<<bigarray.ml:382:7>>*/ caml_call1
-              (Stdlib[1], cst_Bigarray_array0_of_genarra);
-    /*<<bigarray.ml:382:48>>*/ }
-   function array1_of_genarray(a){
-     /*<<bigarray.ml:384:2>>*/ return 1
-            ===  /*<<bigarray.ml:384:5>>*/ caml_ba_num_dims(a)
-            ? a
-            :  /*<<bigarray.ml:385:7>>*/ caml_call1
-              (Stdlib[1], cst_Bigarray_array1_of_genarra);
-    /*<<bigarray.ml:385:48>>*/ }
-   function array2_of_genarray(a){
-     /*<<bigarray.ml:387:2>>*/ return 2
-            ===  /*<<bigarray.ml:387:5>>*/ caml_ba_num_dims(a)
-            ? a
-            :  /*<<bigarray.ml:388:7>>*/ caml_call1
-              (Stdlib[1], cst_Bigarray_array2_of_genarra);
-    /*<<bigarray.ml:388:48>>*/ }
-   function array3_of_genarray(a){
-     /*<<bigarray.ml:390:2>>*/ return 3
-            ===  /*<<bigarray.ml:390:5>>*/ caml_ba_num_dims(a)
-            ? a
-            :  /*<<bigarray.ml:391:7>>*/ caml_call1
-              (Stdlib[1], cst_Bigarray_array3_of_genarra);
-    /*<<bigarray.ml:391:48>>*/ }
-   function reshape_0(a){
-     /*<<bigarray.ml:396:18>>*/ return  /*<<bigarray.ml:396:18>>*/ caml_ba_reshape
-            (a, [0]);
-    /*<<bigarray.ml:396:32>>*/ }
-   function reshape_1(a, dim1){
-     /*<<bigarray.ml:397:23>>*/ return  /*<<bigarray.ml:397:23>>*/ caml_ba_reshape
-            (a, [0, dim1]);
-    /*<<bigarray.ml:397:41>>*/ }
-   function reshape_2(a, dim1, dim2){
-     /*<<bigarray.ml:398:28>>*/ return  /*<<bigarray.ml:398:28>>*/ caml_ba_reshape
-            (a, [0, dim1, dim2]);
-    /*<<bigarray.ml:398:51>>*/ }
-   function reshape_3(a, dim1, dim2, dim3){
-     /*<<bigarray.ml:399:33>>*/ return  /*<<bigarray.ml:399:33>>*/ caml_ba_reshape
-            (a, [0, dim1, dim2, dim3]);
-    /*<<bigarray.ml:399:61>>*/ }
-   var
-    Stdlib_Bigarray =
-      [0,
-       float32,
-       float64,
-       complex32,
-       complex64,
-       int8_signed,
-       int8_unsigned,
-       int16_signed,
-       int16_unsigned,
-       int$0,
-       int32,
-       int64,
-       nativeint,
-       char$0,
-       kind_size_in_bytes,
-       c_layout,
-       fortran_layout,
-       [0, init, dims, size_in_bytes],
-       [0,
-        create,
-        of_value,
-        caml_ba_change_layout,
-        size_in_bytes$0,
-        get,
-        set,
-        of_value],
-       [0,
-        create$0,
-        init$0,
-        caml_ba_change_layout,
-        size_in_bytes$1,
-        slice,
-        of_array],
-       [0,
-        create$1,
-        init$1,
-        caml_ba_change_layout,
-        size_in_bytes$2,
-        slice_left,
-        slice_right,
-        of_array$0],
-       [0,
-        create$2,
-        init$2,
-        caml_ba_change_layout,
-        size_in_bytes$3,
-        slice_left_1,
-        slice_right_1,
-        slice_left_2,
-        slice_right_2,
-        of_array$1],
-       array0_of_genarray,
-       array1_of_genarray,
-       array2_of_genarray,
-       array3_of_genarray,
-       caml_ba_reshape,
-       reshape_0,
-       reshape_1,
-       reshape_2,
-       reshape_3];
-   runtime.caml_register_global(10, Stdlib_Bigarray, "Stdlib__Bigarray");
-   return;
-   /*<<?>>*/ }
-  (globalThis));
-
-//# unitInfo: Provides: Stdlib__Random
-//# unitInfo: Requires: Stdlib, Stdlib__Bigarray, Stdlib__Bytes, Stdlib__Digest, Stdlib__Domain, Stdlib__Int32, Stdlib__Int64, Stdlib__Nativeint, Stdlib__String
-(function
-  (globalThis){
-   "use strict";
-   var
-    runtime = globalThis.jsoo_runtime,
-    caml_ba_blit = runtime.caml_ba_blit,
-    caml_ba_set_1 = runtime.caml_ba_set_1,
-    caml_bytes_set = runtime.caml_bytes_set,
-    caml_greaterthan = runtime.caml_greaterthan,
-    caml_int64_of_int32 = runtime.caml_int64_of_int32,
-    caml_int64_shift_right_unsigne = runtime.caml_int64_shift_right_unsigned,
-    caml_int64_sub = runtime.caml_int64_sub,
-    caml_int64_to_int32 = runtime.caml_int64_to_int32,
-    caml_lessequal = runtime.caml_lessequal,
-    caml_lxm_next = runtime.caml_lxm_next,
-    caml_mod = runtime.caml_mod,
-    caml_notequal = runtime.caml_notequal,
-    caml_sys_random_seed = runtime.caml_sys_random_seed;
-    /*<<?>>*/ function caml_call1(f, a0){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 1
-            ? f(a0)
-            : runtime.caml_call_gen(f, [a0]);
-   }
-    /*<<?>>*/ function caml_call2(f, a0, a1){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 2
-            ? f(a0, a1)
-            : runtime.caml_call_gen(f, [a0, a1]);
-   }
-    /*<<?>>*/ function caml_call3(f, a0, a1, a2){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 3
-            ? f(a0, a1, a2)
-            : runtime.caml_call_gen(f, [a0, a1, a2]);
-   }
-   var
-    global_data = runtime.caml_get_global_data(),
-    Stdlib_Domain = global_data.Stdlib__Domain,
-    Stdlib = global_data.Stdlib,
-    Stdlib_Int32 = global_data.Stdlib__Int32,
-    Stdlib_Int64 = global_data.Stdlib__Int64,
-    Stdlib_Bytes = global_data.Stdlib__Bytes,
-    Stdlib_Digest = global_data.Stdlib__Digest,
-    Stdlib_String = global_data.Stdlib__String,
-    Stdlib_Bigarray = global_data.Stdlib__Bigarray,
-    Stdlib_Nativeint = global_data.Stdlib__Nativeint,
-    _j_ = runtime.caml_int64_create_lo_mi_hi(14371852, 15349651, 22696),
-    _k_ = runtime.caml_int64_create_lo_mi_hi(12230193, 11438743, 35013),
-    _l_ = runtime.caml_int64_create_lo_mi_hi(1424933, 15549263, 2083),
-    _m_ = runtime.caml_int64_create_lo_mi_hi(9492471, 4696708, 43520),
-    _f_ = runtime.caml_int64_create_lo_mi_hi(1, 0, 0),
-    _h_ = runtime.caml_int64_create_lo_mi_hi(0, 0, 0),
-    _i_ = runtime.caml_int64_create_lo_mi_hi(0, 0, 0),
-    _g_ = runtime.caml_int64_create_lo_mi_hi(0, 0, 0),
-    cst_Random_int64 = "Random.int64",
-    cst_Random_int32 = "Random.int32",
-    cst_Random_full_int = "Random.full_int",
-    cst_Random_int = "Random.int",
-    _a_ = runtime.caml_int64_create_lo_mi_hi(1, 0, 0),
-    _b_ = runtime.caml_int64_create_lo_mi_hi(0, 0, 0),
-    _e_ = runtime.caml_int64_create_lo_mi_hi(1, 0, 0),
-    _c_ = runtime.caml_int64_create_lo_mi_hi(0, 0, 0),
-    _d_ = runtime.caml_int64_create_lo_mi_hi(2, 0, 0);
-   function create(param){
-     /*<<random.ml:31:4>>*/ return  /*<<random.ml:31:4>>*/ caml_call3
-            (Stdlib_Bigarray[19][1], 7, 0, 4);
-    /*<<random.ml:31:34>>*/ }
-   function set(s, i1, i2, i3, i4){
-     /*<<random.ml:34:4>>*/  /*<<random.ml:34:4>>*/ caml_ba_set_1
-     (s, 0,  /*<<random.ml:34:26>>*/ runtime.caml_int64_or(i1, _a_));
-     /*<<random.ml:35:4>>*/  /*<<random.ml:35:4>>*/ caml_ba_set_1(s, 1, i2);
-     /*<<random.ml:36:30>>*/  /*<<random.ml:36:30>>*/ var
-     i3$0 =  /*<<random.ml:36:30>>*/ caml_notequal(i3, _b_) ? i3 : _e_;
-     /*<<random.ml:36:4>>*/  /*<<random.ml:36:4>>*/ caml_ba_set_1(s, 2, i3$0);
-     /*<<random.ml:37:30>>*/  /*<<random.ml:37:30>>*/ var
-     i4$0 =  /*<<random.ml:37:30>>*/ caml_notequal(i4, _c_) ? i4 : _d_;
-     /*<<random.ml:37:4>>*/ return  /*<<random.ml:37:4>>*/ caml_ba_set_1
-            (s, 3, i4$0);
-    /*<<random.ml:37:55>>*/ }
-   function mk(i1, i2, i3, i4){
-     /*<<random.ml:40:4>>*/  /*<<random.ml:40:12>>*/ var s = create(0);
-     /*<<random.ml:41:4>>*/ set(s, i1, i2, i3, i4);
-     /*<<random.ml:41:4>>*/ return s;
-    /*<<random.ml:41:24>>*/ }
-   function copy(s){
-     /*<<random.ml:47:4>>*/  /*<<random.ml:47:13>>*/ var s$0 = create(0);
-     /*<<random.ml:47:25>>*/  /*<<random.ml:47:25>>*/ caml_ba_blit(s, s$0);
-     /*<<random.ml:47:25>>*/ return s$0;
-    /*<<random.ml:47:40>>*/ }
-   function reinit(s, seed){
-     /*<<random.ml:55:4>>*/ var
-     n = seed.length - 1,
-      /*<<random.ml:56:12>>*/ b =
-        /*<<random.ml:56:12>>*/ runtime.caml_create_bytes((n * 8 | 0) + 1 | 0),
-      /*<<random.ml:57:4>>*/ _p_ = n - 1 | 0,
-      /*<<random.ml:56:12>>*/ _o_ = 0;
-    if(_p_ >= 0){
-     var i = _o_;
-     for(;;){
-       /*<<random.ml:58:35>>*/  /*<<random.ml:58:35>>*/ var
-       _t_ =
-          /*<<random.ml:58:35>>*/ caml_int64_of_int32
-          (runtime.caml_check_bound(seed, i)[1 + i]);
-       /*<<random.ml:58:6>>*/  /*<<random.ml:58:6>>*/ caml_call3
-       (Stdlib_Bytes[86], b, i * 8 | 0, _t_);
-       /*<<random.ml:58:6>>*/  /*<<random.ml:58:6>>*/ var _u_ = i + 1 | 0;
-      if(_p_ === i) break;
-      var i = _u_;
-     }
-    }
-     /*<<random.ml:60:4>>*/  /*<<random.ml:60:4>>*/ caml_bytes_set
-     (b, n * 8 | 0, 1);
-     /*<<random.ml:61:13>>*/  /*<<random.ml:61:13>>*/ var
-     d1 =  /*<<random.ml:61:13>>*/ caml_call1(Stdlib_Digest[4], b);
-     /*<<random.ml:62:4>>*/  /*<<random.ml:62:4>>*/ caml_bytes_set
-     (b, n * 8 | 0, 2);
-     /*<<random.ml:63:13>>*/ var
-      /*<<random.ml:63:13>>*/ d2 =
-        /*<<random.ml:63:13>>*/ caml_call1(Stdlib_Digest[4], b),
-      /*<<random.ml:67:10>>*/ _q_ =
-        /*<<random.ml:67:10>>*/ caml_call2(Stdlib_String[64], d2, 8),
-      /*<<random.ml:66:10>>*/ _r_ =
-        /*<<random.ml:66:10>>*/ caml_call2(Stdlib_String[64], d2, 0),
-      /*<<random.ml:65:10>>*/ _s_ =
-        /*<<random.ml:65:10>>*/ caml_call2(Stdlib_String[64], d1, 8);
-     /*<<random.ml:67:10>>*/ return set
-            (s,
-              /*<<random.ml:64:10>>*/ caml_call2(Stdlib_String[64], d1, 0),
-             _s_,
-             _r_,
-             _q_);
-    /*<<random.ml:67:36>>*/ }
-   function make(seed){
-     /*<<random.ml:70:4>>*/  /*<<random.ml:70:12>>*/ var s = create(0);
-     /*<<random.ml:70:24>>*/ reinit(s, seed);
-     /*<<random.ml:70:24>>*/ return s;
-    /*<<random.ml:70:40>>*/ }
-   function make_self_init(param){
-     /*<<random.ml:73:4>>*/ return make
-            ( /*<<random.ml:73:9>>*/ caml_sys_random_seed(0));
-    /*<<random.ml:73:25>>*/ }
-   function bits(s){
-     /*<<random.ml:77:4>>*/ return  /*<<random.ml:77:17>>*/ caml_int64_to_int32
-            ( /*<<random.ml:77:17>>*/ caml_lxm_next(s))
-           & 1073741823;
-    /*<<random.ml:77:42>>*/ }
-   function intaux(s, n){
-     /*<<random.ml:81:4>>*/ for(;;){
-      /*<<random.ml:81:12>>*/ var
-       /*<<random.ml:81:12>>*/ r = bits(s),
-      v = caml_mod(r, n);
-     if(((1073741823 - n | 0) + 1 | 0) >= (r - v | 0))
-       /*<<random.ml:83:55>>*/ return v;
-    }
-    /*<<random.ml:83:56>>*/ }
-   function int$0(s, bound){
-     /*<<random.ml:86:4>>*/ if(1073741823 >= bound && 0 < bound)
-      /*<<random.ml:88:9>>*/ return intaux(s, bound);
-     /*<<random.ml:87:9>>*/ return  /*<<random.ml:87:9>>*/ caml_call1
-            (Stdlib[1], cst_Random_int);
-    /*<<random.ml:88:23>>*/ }
-   function full_int(s, bound){
-     /*<<random.ml:98:4>>*/ if(0 >= bound)
-      /*<<random.ml:99:6>>*/ return  /*<<random.ml:99:6>>*/ caml_call1
-             (Stdlib[1], cst_Random_full_int);
-    if(1073741823 >= bound)  /*<<random.ml:103:6>>*/ return intaux(s, bound);
-     /*<<random.ml:93:4>>*/ for(;;){
-      /*<<random.ml:93:4>>*/ var
-       /*<<random.ml:93:4>>*/ _n_ = Stdlib[19],
-      r =
-         /*<<random.ml:93:25>>*/ caml_int64_to_int32
-         ( /*<<random.ml:93:25>>*/ caml_lxm_next(s))
-        & _n_,
-      v = caml_mod(r, bound);
-     if(((Stdlib[19] - bound | 0) + 1 | 0) >= (r - v | 0))
-       /*<<random.ml:95:54>>*/ return v;
-    }
-    /*<<random.ml:103:20>>*/ }
-   function bits32(s){
-     /*<<random.ml:107:4>>*/ return  /*<<random.ml:107:4>>*/ caml_int64_to_int32
-            ( /*<<random.ml:107:19>>*/ caml_lxm_next(s));
-    /*<<random.ml:107:27>>*/ }
-   function int32(s, bound){
-     /*<<random.ml:118:4>>*/ if
-     ( /*<<random.ml:118:7>>*/ caml_lessequal(bound, 0))
-      /*<<random.ml:119:9>>*/ return  /*<<random.ml:119:9>>*/ caml_call1
-             (Stdlib[1], cst_Random_int32);
-     /*<<random.ml:111:4>>*/ for(;;){
-      /*<<random.ml:111:12>>*/ var
-       /*<<random.ml:111:12>>*/ r = bits32(s) >>> 1 | 0,
-       /*<<random.ml:112:12>>*/ v =
-         /*<<random.ml:112:12>>*/ caml_mod(r, bound);
-      /*<<random.ml:113:14>>*/ if
-      (!
-        /*<<random.ml:113:14>>*/ caml_greaterthan
-        (r - v | 0, (Stdlib_Int32[9] - bound | 0) + 1 | 0))
-       /*<<random.ml:115:9>>*/ return v;
-    }
-    /*<<random.ml:120:25>>*/ }
-   var bits64 = caml_lxm_next;
-   function int64(s, bound){
-     /*<<random.ml:135:4>>*/ if
-     ( /*<<random.ml:135:7>>*/ caml_lessequal(bound, _g_))
-      /*<<random.ml:136:9>>*/ return  /*<<random.ml:136:9>>*/ caml_call1
-             (Stdlib[1], cst_Random_int64);
-     /*<<random.ml:128:4>>*/ for(;;){
-      /*<<random.ml:128:12>>*/ var
-       /*<<random.ml:128:12>>*/ r =
-         /*<<random.ml:128:12>>*/ caml_int64_shift_right_unsigne
-         ( /*<<random.ml:128:38>>*/ caml_lxm_next(s), 1),
-       /*<<random.ml:129:12>>*/ v =
-         /*<<random.ml:129:12>>*/ runtime.caml_int64_mod(r, bound);
-      /*<<random.ml:130:14>>*/ if
-      (!
-        /*<<random.ml:130:14>>*/ caml_greaterthan
-        ( /*<<random.ml:130:14>>*/ caml_int64_sub(r, v),
-          /*<<random.ml:130:24>>*/ runtime.caml_int64_add
-          ( /*<<random.ml:130:28>>*/ caml_int64_sub(Stdlib_Int64[9], bound),
-           _f_)))
-       /*<<random.ml:132:9>>*/ return v;
-    }
-    /*<<random.ml:137:25>>*/ }
-   var
-    nativebits =
-      32 === Stdlib_Nativeint[9]
-       ? function
-        (s){
-          /*<<random.ml:142:18>>*/ return bits32(s);
-         /*<<random.ml:142:47>>*/ }
-       : function
-        (s){
-          /*<<random.ml:143:18>>*/ return  /*<<random.ml:143:18>>*/ caml_int64_to_int32
-                 ( /*<<random.ml:143:37>>*/ caml_lxm_next(s));
-         /*<<random.ml:143:47>>*/ },
-    nativeint =
-      32 === Stdlib_Nativeint[9]
-       ? function
-        (s, bound){
-          /*<<random.ml:148:24>>*/ return int32(s, bound);
-         /*<<random.ml:148:79>>*/ }
-       : function
-        (s, bound){
-          /*<<random.ml:149:24>>*/ return  /*<<random.ml:149:24>>*/ caml_int64_to_int32
-                 (int64
-                   (s,  /*<<random.ml:149:52>>*/ caml_int64_of_int32(bound)));
-         /*<<random.ml:149:79>>*/ };
-   function float$0(s, bound){
-     /*<<random.ml:159:22>>*/ for(;;){
-      /*<<random.ml:154:12>>*/ var
-       /*<<random.ml:154:12>>*/ b =  /*<<random.ml:154:12>>*/ caml_lxm_next(s),
-       /*<<random.ml:155:12>>*/ n =
-         /*<<random.ml:155:12>>*/ caml_int64_shift_right_unsigne(b, 11);
-      /*<<random.ml:156:7>>*/ if
-      ( /*<<random.ml:156:7>>*/ caml_notequal(n, _h_))
-       /*<<random.ml:159:22>>*/ return  /*<<random.ml:156:20>>*/ runtime.caml_int64_to_float
-              (n)
-             * 1.1102230246251565e-16
-             * bound;
-    }
-    /*<<random.ml:159:41>>*/ }
-   function bool(s){
-     /*<<random.ml:162:15>>*/ return  /*<<random.ml:162:15>>*/ runtime.caml_lessthan
-            ( /*<<random.ml:162:15>>*/ caml_lxm_next(s), _i_);
-    /*<<random.ml:162:26>>*/ }
-   function split(s){
-     /*<<random.ml:166:4>>*/ var
-      /*<<random.ml:166:13>>*/ i1 =  /*<<random.ml:166:13>>*/ caml_lxm_next(s),
-      /*<<random.ml:166:34>>*/ i2 =  /*<<random.ml:166:34>>*/ caml_lxm_next(s),
-      /*<<random.ml:167:13>>*/ i3 =  /*<<random.ml:167:13>>*/ caml_lxm_next(s),
-      /*<<random.ml:167:34>>*/ i4 =  /*<<random.ml:167:34>>*/ caml_lxm_next(s);
-     /*<<random.ml:168:4>>*/ return mk(i1, i2, i3, i4);
-    /*<<random.ml:168:18>>*/ }
-   function mk_default(param){
-     /*<<random.ml:173:2>>*/ return mk(_m_, _l_, _k_, _j_);
-    /*<<random.ml:176:31>>*/ }
-    /*<<random.ml:179:2>>*/  /*<<random.ml:179:2>>*/ var
-    random_key =
-       /*<<random.ml:179:2>>*/ caml_call2
-       (Stdlib_Domain[10][1], [0, split], mk_default);
-   function bits$0(param){
-     /*<<random.ml:181:14>>*/ return bits
-            ( /*<<random.ml:181:25>>*/ caml_call1
-              (Stdlib_Domain[10][2], random_key));
-    /*<<random.ml:181:52>>*/ }
-   function int$1(bound){
-     /*<<random.ml:182:16>>*/ return int$0
-            ( /*<<random.ml:182:26>>*/ caml_call1
-              (Stdlib_Domain[10][2], random_key),
-             bound);
-    /*<<random.ml:182:59>>*/ }
-   function full_int$0(bound){
-     /*<<random.ml:183:21>>*/ return full_int
-            ( /*<<random.ml:183:36>>*/ caml_call1
-              (Stdlib_Domain[10][2], random_key),
-             bound);
-    /*<<random.ml:183:69>>*/ }
-   function int32$0(bound){
-     /*<<random.ml:184:18>>*/ return int32
-            ( /*<<random.ml:184:30>>*/ caml_call1
-              (Stdlib_Domain[10][2], random_key),
-             bound);
-    /*<<random.ml:184:63>>*/ }
-   function nativeint$0(bound){
-     /*<<random.ml:185:22>>*/ return nativeint
-            ( /*<<random.ml:185:38>>*/ caml_call1
-              (Stdlib_Domain[10][2], random_key),
-             bound);
-    /*<<random.ml:185:71>>*/ }
-   function int64$0(bound){
-     /*<<random.ml:186:18>>*/ return int64
-            ( /*<<random.ml:186:30>>*/ caml_call1
-              (Stdlib_Domain[10][2], random_key),
-             bound);
-    /*<<random.ml:186:63>>*/ }
-   function float$1(scale){
-     /*<<random.ml:187:18>>*/ return float$0
-            ( /*<<random.ml:187:30>>*/ caml_call1
-              (Stdlib_Domain[10][2], random_key),
-             scale);
-    /*<<random.ml:187:63>>*/ }
-   function bool$0(param){
-     /*<<random.ml:188:14>>*/ return bool
-            ( /*<<random.ml:188:25>>*/ caml_call1
-              (Stdlib_Domain[10][2], random_key));
-    /*<<random.ml:188:52>>*/ }
-   function bits32$0(param){
-     /*<<random.ml:189:16>>*/ return bits32
-            ( /*<<random.ml:189:29>>*/ caml_call1
-              (Stdlib_Domain[10][2], random_key));
-    /*<<random.ml:189:56>>*/ }
-   function bits64$0(param){
-     /*<<random.ml:190:16>>*/ return  /*<<random.ml:190:29>>*/ caml_lxm_next
-            ( /*<<random.ml:190:29>>*/ caml_call1
-              (Stdlib_Domain[10][2], random_key));
-    /*<<random.ml:190:56>>*/ }
-   function nativebits$0(param){
-     /*<<random.ml:191:20>>*/ return nativebits
-            ( /*<<random.ml:191:37>>*/ caml_call1
-              (Stdlib_Domain[10][2], random_key));
-    /*<<random.ml:191:64>>*/ }
-   function full_init(seed){
-     /*<<random.ml:193:21>>*/ return reinit
-            ( /*<<random.ml:193:34>>*/ caml_call1
-              (Stdlib_Domain[10][2], random_key),
-             seed);
-    /*<<random.ml:193:66>>*/ }
-   function init(seed){
-     /*<<random.ml:194:16>>*/ return full_init([0, seed]);
-    /*<<random.ml:194:36>>*/ }
-   function self_init(param){
-     /*<<random.ml:195:19>>*/ return full_init
-            ( /*<<random.ml:195:29>>*/ caml_sys_random_seed(0));
-    /*<<random.ml:195:44>>*/ }
-   function split$0(param){
-     /*<<random.ml:199:15>>*/ return split
-            ( /*<<random.ml:199:27>>*/ caml_call1
-              (Stdlib_Domain[10][2], random_key));
-    /*<<random.ml:199:54>>*/ }
-   function get_state(param){
-     /*<<random.ml:203:19>>*/ return copy
-            ( /*<<random.ml:203:30>>*/ caml_call1
-              (Stdlib_Domain[10][2], random_key));
-    /*<<random.ml:203:57>>*/ }
-   function set_state(s){
-     /*<<random.ml:204:18>>*/ return  /*<<random.ml:204:18>>*/ caml_ba_blit
-            (s,
-              /*<<random.ml:204:31>>*/ caml_call1
-              (Stdlib_Domain[10][2], random_key));
-    /*<<random.ml:204:60>>*/ }
-   var
-    Stdlib_Random =
-      [0,
-       init,
-       full_init,
-       self_init,
-       bits$0,
-       int$1,
-       full_int$0,
-       int32$0,
-       nativeint$0,
-       int64$0,
-       float$1,
-       bool$0,
-       bits32$0,
-       bits64$0,
-       nativebits$0,
-       [0,
-        make,
-        make_self_init,
-        copy,
-        bits,
-        int$0,
-        full_int,
-        int32,
-        nativeint,
-        int64,
-        float$0,
-        bool,
-        bits32,
-        bits64,
-        nativebits,
-        split],
-       get_state,
-       set_state,
-       split$0];
-   runtime.caml_register_global(29, Stdlib_Random, "Stdlib__Random");
-   return;
-   /*<<?>>*/ }
-  (globalThis));
-
-//# unitInfo: Provides: Stdlib__Hashtbl
-//# unitInfo: Requires: Assert_failure, Stdlib, Stdlib__Array, Stdlib__Atomic, Stdlib__Domain, Stdlib__Int, Stdlib__Random, Stdlib__Seq, Stdlib__String, Stdlib__Sys
-(function
-  (globalThis){
-   "use strict";
-   var
-    runtime = globalThis.jsoo_runtime,
-    caml_check_bound = runtime.caml_check_bound,
-    caml_compare = runtime.caml_compare,
-    caml_hash = runtime.caml_hash,
-    caml_make_vect = runtime.caml_make_vect,
-    caml_maybe_attach_backtrace = runtime.caml_maybe_attach_backtrace,
-    caml_sys_getenv = runtime.caml_sys_getenv,
-    caml_wrap_exception = runtime.caml_wrap_exception;
-    /*<<?>>*/ function caml_call1(f, a0){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 1
-            ? f(a0)
-            : runtime.caml_call_gen(f, [a0]);
-   }
-    /*<<?>>*/ function caml_call2(f, a0, a1){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 2
-            ? f(a0, a1)
-            : runtime.caml_call_gen(f, [a0, a1]);
-   }
-    /*<<?>>*/ function caml_call3(f, a0, a1, a2){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 3
-            ? f(a0, a1, a2)
-            : runtime.caml_call_gen(f, [a0, a1, a2]);
-   }
-    /*<<?>>*/ function caml_call4(f, a0, a1, a2, a3){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 4
-            ? f(a0, a1, a2, a3)
-            : runtime.caml_call_gen(f, [a0, a1, a2, a3]);
-   }
-   var
-    global_data = runtime.caml_get_global_data(),
-    cst = "",
-    Stdlib_Sys = global_data.Stdlib__Sys,
-    Stdlib = global_data.Stdlib,
-    Stdlib_Atomic = global_data.Stdlib__Atomic,
-    Stdlib_Domain = global_data.Stdlib__Domain,
-    Stdlib_Random = global_data.Stdlib__Random,
-    Stdlib_Seq = global_data.Stdlib__Seq,
-    Stdlib_Int = global_data.Stdlib__Int,
-    Stdlib_Array = global_data.Stdlib__Array;
-   global_data.Assert_failure;
-   var
-    Stdlib_String = global_data.Stdlib__String,
-    cst_Hashtbl_unsupported_hash_t = "Hashtbl: unsupported hash table format",
-    _d_ = [0, 0];
-   function ongoing_traversal(h){
-     /*<<hashtbl.ml:41:2>>*/ var
-     _aB_ = h.length - 1 < 4 ? 1 : 0,
-     _aC_ = _aB_ || (h[4] < 0 ? 1 : 0);
-    return _aC_;
-    /*<<hashtbl.ml:42:23>>*/ }
-   function flip_ongoing_traversal(h){
-     /*<<hashtbl.ml:45:2>>*/ h[4] = - h[4] | 0;
-    return 0;
-    /*<<hashtbl.ml:45:36>>*/ }
-   try{
-     /*<<hashtbl.ml:51:8>>*/ var
-      /*<<hashtbl.ml:51:8>>*/ _f_ =
-        /*<<hashtbl.ml:51:8>>*/ caml_sys_getenv("OCAMLRUNPARAM"),
-     params = _f_;
-   }
-   catch(_az_){
-    var _a_ = caml_wrap_exception(_az_);
-    if(_a_ !== Stdlib[8]) throw caml_maybe_attach_backtrace(_a_, 0);
-     /*<<hashtbl.ml:52:4>>*/ try{
-      /*<<hashtbl.ml:52:8>>*/ var
-       /*<<hashtbl.ml:52:8>>*/ _e_ =
-         /*<<hashtbl.ml:52:8>>*/ caml_sys_getenv("CAMLRUNPARAM"),
-      _c_ = _e_;
-    }
-    catch(_aA_){
-     var _b_ = caml_wrap_exception(_aA_);
-     if(_b_ !== Stdlib[8]) throw caml_maybe_attach_backtrace(_b_, 0);
-     var _c_ = cst;
-    }
-    var params = _c_;
-   }
-    /*<<hashtbl.ml:53:2>>*/ var
-     /*<<hashtbl.ml:53:2>>*/ randomized_default =
-       /*<<hashtbl.ml:53:2>>*/ caml_call2(Stdlib_String[14], params, 82),
-     /*<<hashtbl.ml:55:17>>*/ randomized =
-       /*<<hashtbl.ml:55:17>>*/ caml_call1
-       (Stdlib_Atomic[1], randomized_default);
-   function randomize(param){
-     /*<<hashtbl.ml:57:19>>*/ return  /*<<hashtbl.ml:57:19>>*/ caml_call2
-            (Stdlib_Atomic[3], randomized, 1);
-    /*<<hashtbl.ml:57:45>>*/ }
-   function is_randomized(param){
-     /*<<hashtbl.ml:58:23>>*/ return caml_call1(Stdlib_Atomic[2], randomized);
-    /*<<hashtbl.ml:58:44>>*/ }
-    /*<<hashtbl.ml:60:15>>*/  /*<<hashtbl.ml:60:15>>*/ var
-    prng_key =
-       /*<<hashtbl.ml:60:15>>*/ caml_call2
-       (Stdlib_Domain[10][1], 0, Stdlib_Random[15][2]);
-   function power_2_above(x, n){
-     /*<<hashtbl.ml:69:2>>*/ var x$0 = x;
-     /*<<hashtbl.ml:69:2>>*/ for(;;){
-     if(n <= x$0)  /*<<hashtbl.ml:69:17>>*/ return x$0;
-     if(Stdlib_Sys[13] < (x$0 * 2 | 0))  /*<<hashtbl.ml:70:44>>*/ return x$0;
-     var x$1 = x$0 * 2 | 0, x$0 = x$1;
-    }
-    /*<<hashtbl.ml:71:30>>*/ }
-   function create(opt, initial_size){
-     /*<<hashtbl.ml:74:2>>*/ if(opt)
-     var sth = opt[1], random = sth;
-    else
-     var
-      random =
-         /*<<hashtbl.ml:73:22>>*/ caml_call1(Stdlib_Atomic[2], randomized);
-     /*<<hashtbl.ml:74:10>>*/  /*<<hashtbl.ml:74:10>>*/ var
-     s = power_2_above(16, initial_size);
-     /*<<hashtbl.ml:75:2>>*/ if(random)
-      /*<<hashtbl.ml:76:37>>*/ var
-       /*<<hashtbl.ml:76:37>>*/ _ay_ =
-         /*<<hashtbl.ml:76:37>>*/ caml_call1(Stdlib_Domain[10][2], prng_key),
-      seed =  /*<<hashtbl.ml:76:19>>*/ caml_call1(Stdlib_Random[15][4], _ay_);
-    else
-     var seed = 0;
-     /*<<hashtbl.ml:78:2>>*/ return [0,
-            0,
-             /*<<hashtbl.ml:78:52>>*/ caml_make_vect(s, 0),
-            seed,
-            s];
-    /*<<hashtbl.ml:78:72>>*/ }
-   function clear(h){
-     /*<<hashtbl.ml:81:2>>*/ var _ax_ = 0 < h[1] ? 1 : 0;
-    return _ax_
-            ? (h
-               [1]
-              = 0,
-               /*<<hashtbl.ml:83:4>>*/ caml_call4
-               (Stdlib_Array[7], h[2], 0, h[2].length - 1, 0))
-            : _ax_;
-    /*<<hashtbl.ml:84:5>>*/ }
-   function reset(h){
-     /*<<hashtbl.ml:87:2>>*/ var len = h[2].length - 1;
-    if
-     (4 <= h.length - 1
-      && len !==  /*<<hashtbl.ml:89:13>>*/ caml_call1(Stdlib[18], h[4])){
-     h[1] = 0;
-     h[2] =
-       /*<<hashtbl.ml:93:14>>*/ caml_make_vect
-       ( /*<<hashtbl.ml:93:25>>*/ caml_call1(Stdlib[18], h[4]), 0);
-     return 0;
-    }
-     /*<<hashtbl.ml:90:4>>*/ return clear(h);
-    /*<<hashtbl.ml:94:5>>*/ }
-   function copy_bucketlist(param){
-     /*<<hashtbl.ml:96:22>>*/ if(! param)  /*<<hashtbl.ml:97:13>>*/ return 0;
-     /*<<hashtbl.ml:109:19>>*/ var
-     key = param[1],
-     data = param[2],
-     next = param[3],
-      /*<<hashtbl.ml:109:19>>*/ prec$1 = [0, key, data, next],
-     prec = prec$1,
-     param$0 = next;
-    for(;;){
-     if(! param$0)  /*<<hashtbl.ml:110:6>>*/ return prec$1;
-      /*<<hashtbl.ml:102:25>>*/ var
-      key$0 = param$0[1],
-      data$0 = param$0[2],
-      next$0 = param$0[3],
-       /*<<hashtbl.ml:102:25>>*/ prec$0 = [0, key$0, data$0, next$0];
-     prec[3] = prec$0;
-     var prec = prec$0, param$0 = next$0;
-    }
-    /*<<hashtbl.ml:111:7>>*/ }
-   function copy(h){
-     /*<<hashtbl.ml:113:13>>*/ var
-     _au_ = h[4],
-     _av_ = h[3],
-      /*<<hashtbl.ml:113:29>>*/ _aw_ =
-        /*<<hashtbl.ml:113:29>>*/ caml_call2
-        (Stdlib_Array[13], copy_bucketlist, h[2]);
-     /*<<hashtbl.ml:113:13>>*/ return [0, h[1], _aw_, _av_, _au_];
-    /*<<hashtbl.ml:113:63>>*/ }
-   function length(h){
-     /*<<hashtbl.ml:115:15>>*/ return h[1];
-    /*<<hashtbl.ml:115:21>>*/ }
-   function insert_all_buckets(indexfun, inplace, odata, ndata){
-     /*<<hashtbl.ml:118:2>>*/ var
-     nsize = ndata.length - 1,
-      /*<<hashtbl.ml:119:19>>*/ ndata_tail =
-        /*<<hashtbl.ml:119:19>>*/ caml_make_vect(nsize, 0),
-     _ao_ = odata.length - 1 - 1 | 0,
-      /*<<hashtbl.ml:135:2>>*/ _an_ = 0;
-    if(_ao_ >= 0){
-     var i$0 = _an_;
-     a:
-     for(;;){
-       /*<<hashtbl.ml:136:18>>*/ var
-        /*<<hashtbl.ml:136:18>>*/ cell$1 =
-         caml_check_bound(odata, i$0)[1 + i$0],
-       cell = cell$1;
-       /*<<hashtbl.ml:120:26>>*/ for(;;){
-       if(! cell){
-         /*<<hashtbl.ml:136:4>>*/  /*<<hashtbl.ml:136:4>>*/ var
-         _at_ = i$0 + 1 | 0;
-        if(_ao_ === i$0) break a;
-        var i$0 = _at_;
-        break;
-       }
-        /*<<hashtbl.ml:123:8>>*/ var
-        key = cell[1],
-        data = cell[2],
-        next = cell[3],
-         /*<<hashtbl.ml:123:8>>*/ cell$0 = inplace ? cell : [0, key, data, 0],
-         /*<<hashtbl.ml:127:19>>*/ nidx =
-           /*<<hashtbl.ml:127:19>>*/ caml_call1(indexfun, key),
-         /*<<hashtbl.ml:128:20>>*/ match =
-          caml_check_bound(ndata_tail, nidx)[1 + nidx];
-       if(match)
-        match[3] = cell$0;
-       else
-         /*<<hashtbl.ml:129:19>>*/ caml_check_bound(ndata, nidx)[1 + nidx] = cell$0;
-        /*<<hashtbl.ml:132:8>>*/ caml_check_bound(ndata_tail, nidx)[1 + nidx]
-       = cell$0;
-       var cell = next;
-      }
-     }
-    }
-    if(inplace){
-      /*<<hashtbl.ml:139:4>>*/ var
-      _aq_ = nsize - 1 | 0,
-       /*<<hashtbl.ml:139:4>>*/ _ap_ = 0;
-     if(_aq_ >= 0){
-      var i = _ap_;
-      for(;;){
-        /*<<hashtbl.ml:140:12>>*/  /*<<hashtbl.ml:140:12>>*/ var
-        match$0 = caml_check_bound(ndata_tail, i)[1 + i];
-       if(match$0) match$0[3] = 0;
-        /*<<hashtbl.ml:139:4>>*/  /*<<hashtbl.ml:139:4>>*/ var
-        _as_ = i + 1 | 0;
-       if(_aq_ === i) break;
-       var i = _as_;
-      }
-     }
-     var _ar_ = 0;
-    }
-    else
-     var _ar_ = inplace;
-    return _ar_;
-    /*<<hashtbl.ml:143:8>>*/ }
-   function resize(indexfun, h){
-     /*<<hashtbl.ml:146:2>>*/ var
-     odata = h[2],
-      /*<<hashtbl.ml:147:2>>*/ osize = odata.length - 1,
-     nsize = osize * 2 | 0,
-     _am_ = nsize < Stdlib_Sys[13] ? 1 : 0;
-    if(! _am_) return _am_;
-     /*<<hashtbl.ml:150:16>>*/ var
-      /*<<hashtbl.ml:150:16>>*/ ndata =
-        /*<<hashtbl.ml:150:16>>*/ caml_make_vect(nsize, 0),
-      /*<<hashtbl.ml:151:22>>*/ inplace = 1 - ongoing_traversal(h);
-    h[2] = ndata;
-     /*<<hashtbl.ml:153:4>>*/ return insert_all_buckets
-            ( /*<<hashtbl.ml:153:23>>*/ caml_call1(indexfun, h),
-             inplace,
-             odata,
-             ndata);
-    /*<<hashtbl.ml:154:5>>*/ }
-   function iter(f, h){
-     /*<<hashtbl.ml:157:2>>*/  /*<<hashtbl.ml:162:17>>*/ var
-     old_trav = ongoing_traversal(h);
-    if(1 - old_trav)  /*<<hashtbl.ml:163:23>>*/ flip_ongoing_traversal(h);
-     /*<<hashtbl.ml:163:23>>*/ try{
-     var d = h[2], _ai_ = d.length - 1 - 1 | 0, _ah_ = 0;
-     if(_ai_ >= 0){
-      var i = _ah_;
-      a:
-      for(;;){
-       var param = caml_check_bound(d, i)[1 + i];
-        /*<<hashtbl.ml:157:22>>*/ for(;;){
-        if(! param){
-          /*<<hashtbl.ml:167:6>>*/  /*<<hashtbl.ml:167:6>>*/ var
-          _al_ = i + 1 | 0;
-         if(_ai_ === i) break a;
-         var i = _al_;
-         break;
-        }
-        var key = param[1], data = param[2], next = param[3];
-         /*<<hashtbl.ml:161:8>>*/  /*<<hashtbl.ml:161:8>>*/ caml_call2
-         (f, key, data);
-        var param = next;
-       }
-      }
-     }
-     var _aj_ = 1 - old_trav, _ak_ = _aj_ ? flip_ongoing_traversal(h) : _aj_;
-      /*<<hashtbl.ml:169:25>>*/ return _ak_;
-    }
-    catch(exn$0){
-     var exn = caml_wrap_exception(exn$0);
-      /*<<hashtbl.ml:170:16>>*/ if(old_trav)
-      throw caml_maybe_attach_backtrace(exn, 0);
-      /*<<hashtbl.ml:171:4>>*/ flip_ongoing_traversal(h);
-      /*<<hashtbl.ml:172:4>>*/ throw  /*<<hashtbl.ml:172:4>>*/ caml_maybe_attach_backtrace
-            (exn, 0);
-    }
-    /*<<hashtbl.ml:172:13>>*/ }
-   function filter_map_inplace(f, h){
-     /*<<hashtbl.ml:195:2>>*/ var
-     d = h[2],
-      /*<<hashtbl.ml:196:17>>*/ old_trav = ongoing_traversal(h);
-    if(1 - old_trav)  /*<<hashtbl.ml:197:23>>*/ flip_ongoing_traversal(h);
-     /*<<hashtbl.ml:197:23>>*/ try{
-     var _ad_ = d.length - 1 - 1 | 0, _ac_ = 0;
-     if(_ad_ >= 0){
-      var i = _ac_;
-      a:
-      for(;;){
-        /*<<hashtbl.ml:200:44>>*/ var
-         /*<<hashtbl.ml:200:44>>*/ slot$0 = caml_check_bound(h[2], i)[1 + i],
-        prec = 0,
-        slot = slot$0;
-       for(;;){
-        if(! slot){
-         if(prec)
-          prec[3] = 0;
-         else
-           /*<<hashtbl.ml:177:17>>*/ caml_check_bound(h[2], i)[1 + i] = 0;
-          /*<<hashtbl.ml:200:6>>*/  /*<<hashtbl.ml:200:6>>*/ var
-          _ag_ = i + 1 | 0;
-         if(_ad_ === i) break a;
-         var i = _ag_;
-         break;
-        }
-         /*<<hashtbl.ml:181:18>>*/ var
-         key = slot[1],
-         data = slot[2],
-         next = slot[3],
-          /*<<hashtbl.ml:181:18>>*/ match =
-            /*<<hashtbl.ml:181:18>>*/ caml_call2(f, key, data);
-        if(match){
-         var data$0 = match[1];
-          /*<<hashtbl.ml:186:10>>*/ if(prec)
-          prec[3] = slot;
-         else
-           /*<<hashtbl.ml:187:21>>*/ caml_check_bound(h[2], i)[1 + i] = slot;
-         slot[2] = data$0;
-         var prec = slot, slot = next;
-        }
-        else{h[1] = h[1] - 1 | 0; var slot = next;}
-       }
-      }
-     }
-     var _ae_ = 1 - old_trav, _af_ = _ae_ ? flip_ongoing_traversal(h) : _ae_;
-      /*<<hashtbl.ml:202:25>>*/ return _af_;
-    }
-    catch(exn$0){
-     var exn = caml_wrap_exception(exn$0);
-      /*<<hashtbl.ml:203:16>>*/ if(old_trav)
-      throw caml_maybe_attach_backtrace(exn, 0);
-      /*<<hashtbl.ml:204:4>>*/ flip_ongoing_traversal(h);
-      /*<<hashtbl.ml:205:4>>*/ throw  /*<<hashtbl.ml:205:4>>*/ caml_maybe_attach_backtrace
-            (exn, 0);
-    }
-    /*<<hashtbl.ml:205:13>>*/ }
-   function fold(f, h, init){
-     /*<<hashtbl.ml:208:2>>*/  /*<<hashtbl.ml:214:17>>*/ var
-     old_trav = ongoing_traversal(h);
-    if(1 - old_trav)  /*<<hashtbl.ml:215:23>>*/ flip_ongoing_traversal(h);
-     /*<<hashtbl.ml:215:23>>*/ try{
-      /*<<hashtbl.ml:218:15>>*/ var
-      d = h[2],
-       /*<<hashtbl.ml:218:15>>*/ accu$1 = [0, init],
-      _$_ = d.length - 1 - 1 | 0,
-       /*<<hashtbl.ml:218:15>>*/ ___ = 0;
-     if(_$_ >= 0){
-      var i = ___;
-      a:
-      for(;;){
-        /*<<hashtbl.ml:220:24>>*/ var
-        accu$2 = accu$1[1],
-         /*<<hashtbl.ml:220:24>>*/ b$0 = caml_check_bound(d, i)[1 + i],
-        b = b$0,
-        accu = accu$2;
-        /*<<hashtbl.ml:209:4>>*/ for(;;){
-        if(! b){
-         accu$1[1] = accu;
-          /*<<hashtbl.ml:219:4>>*/  /*<<hashtbl.ml:219:4>>*/ var
-          _ab_ = i + 1 | 0;
-         if(_$_ === i) break a;
-         var i = _ab_;
-         break;
-        }
-         /*<<hashtbl.ml:213:23>>*/ var
-         key = b[1],
-         data = b[2],
-         next = b[3],
-          /*<<hashtbl.ml:213:23>>*/ accu$0 =
-            /*<<hashtbl.ml:213:23>>*/ caml_call3(f, key, data, accu),
-         b = next,
-         accu = accu$0;
-       }
-      }
-     }
-     if(1 - old_trav)  /*<<hashtbl.ml:222:25>>*/ flip_ongoing_traversal(h);
-     var _aa_ = accu$1[1];
-     return _aa_;
-    }
-    catch(exn$0){
-     var exn = caml_wrap_exception(exn$0);
-      /*<<hashtbl.ml:224:16>>*/ if(old_trav)
-      throw caml_maybe_attach_backtrace(exn, 0);
-      /*<<hashtbl.ml:225:4>>*/ flip_ongoing_traversal(h);
-      /*<<hashtbl.ml:226:4>>*/ throw  /*<<hashtbl.ml:226:4>>*/ caml_maybe_attach_backtrace
-            (exn, 0);
-    }
-    /*<<hashtbl.ml:226:13>>*/ }
-   function bucket_length(accu, param){
-    var accu$0 = accu, param$0 = param;
-    for(;;){
-     if(! param$0)  /*<<hashtbl.ml:236:13>>*/ return accu$0;
-      /*<<hashtbl.ml:237:18>>*/ var
-      next = param$0[3],
-       /*<<hashtbl.ml:237:18>>*/ accu$1 = accu$0 + 1 | 0,
-      accu$0 = accu$1,
-      param$0 = next;
-    }
-   }
-   function stats(h){
-     /*<<hashtbl.ml:240:2>>*/ var _U_ = h[2], _V_ = 0;
-    function _W_(m, b){
-      /*<<hashtbl.ml:241:32>>*/  /*<<hashtbl.ml:241:42>>*/ var
-      _Z_ = bucket_length(0, b);
-      /*<<hashtbl.ml:241:42>>*/ return  /*<<hashtbl.ml:241:42>>*/ caml_call2
-             (Stdlib_Int[11], m, _Z_);
-     /*<<hashtbl.ml:241:61>>*/ }
-     /*<<hashtbl.ml:241:4>>*/ var
-      /*<<hashtbl.ml:241:4>>*/ mbl =
-        /*<<hashtbl.ml:241:4>>*/ caml_call3(Stdlib_Array[15], _W_, _V_, _U_),
-      /*<<hashtbl.ml:242:14>>*/ histo =
-        /*<<hashtbl.ml:242:14>>*/ caml_make_vect(mbl + 1 | 0, 0),
-      /*<<hashtbl.ml:243:2>>*/ _X_ = h[2];
-    function _Y_(b){
-      /*<<hashtbl.ml:245:6>>*/  /*<<hashtbl.ml:245:14>>*/ var
-      l = bucket_length(0, b);
-      /*<<hashtbl.ml:246:6>>*/ histo[1 + l] =
-      caml_check_bound(histo, l)[1 + l] + 1 | 0;
-      /*<<hashtbl.ml:246:6>>*/ return 0;
-     /*<<hashtbl.ml:246:32>>*/ }
-     /*<<hashtbl.ml:243:2>>*/  /*<<hashtbl.ml:243:2>>*/ caml_call2
-     (Stdlib_Array[11], _Y_, _X_);
-     /*<<hashtbl.ml:248:2>>*/ return [0, h[1], h[2].length - 1, mbl, histo];
-    /*<<hashtbl.ml:251:30>>*/ }
-   function to_seq(tbl){
-     /*<<hashtbl.ml:258:2>>*/ var tbl_data = tbl[2];
-     /*<<hashtbl.ml:260:2>>*/ function aux(i, buck, param){
-      /*<<hashtbl.ml:260:26>>*/ var i$0 = i, buck$0 = buck;
-      /*<<hashtbl.ml:260:26>>*/ for(;;){
-      if(buck$0){
-       var key = buck$0[1], data = buck$0[2], next = buck$0[3];
-        /*<<hashtbl.ml:266:8>>*/ return [0,
-               [0, key, data],
-               function(_T_){ /*<<?>>*/ return aux(i$0, next, _T_);}];
-      }
-      if(i$0 === tbl_data.length - 1)  /*<<hashtbl.ml:263:13>>*/ return 0;
-       /*<<hashtbl.ml:264:22>>*/ var
-        /*<<hashtbl.ml:264:22>>*/ buck$1 =
-         caml_check_bound(tbl_data, i$0)[1 + i$0],
-        /*<<hashtbl.ml:264:22>>*/ i$1 = i$0 + 1 | 0,
-       i$0 = i$1,
-       buck$0 = buck$1;
-     }
-     /*<<hashtbl.ml:266:42>>*/ }
-     /*<<hashtbl.ml:268:2>>*/ var  /*<<hashtbl.ml:268:2>>*/ _Q_ = 0, _R_ = 0;
-     /*<<hashtbl.ml:268:2>>*/ return function(_S_){
-      /*<<?>>*/ return aux(_R_, _Q_, _S_);};
-    /*<<hashtbl.ml:268:13>>*/ }
-   function to_seq_keys(m){
-     /*<<hashtbl.ml:270:20>>*/  /*<<hashtbl.ml:270:32>>*/ var _N_ = to_seq(m);
-    function _O_(_P_){ /*<<?>>*/ return _P_[1];}
-     /*<<hashtbl.ml:270:32>>*/ return  /*<<hashtbl.ml:270:32>>*/ caml_call2
-            (Stdlib_Seq[27], _O_, _N_);
-    /*<<hashtbl.ml:270:42>>*/ }
-   function to_seq_values(m){
-     /*<<hashtbl.ml:272:22>>*/  /*<<hashtbl.ml:272:34>>*/ var _K_ = to_seq(m);
-    function _L_(_M_){ /*<<?>>*/ return _M_[2];}
-     /*<<hashtbl.ml:272:34>>*/ return  /*<<hashtbl.ml:272:34>>*/ caml_call2
-            (Stdlib_Seq[27], _L_, _K_);
-    /*<<hashtbl.ml:272:44>>*/ }
-   function MakeSeeded(H){
-    function key_index(h, key){
-      /*<<hashtbl.ml:357:6>>*/ var _J_ = h[2].length - 1 - 1 | 0;
-      /*<<hashtbl.ml:357:6>>*/ return  /*<<hashtbl.ml:357:6>>*/ caml_call2
-             (H[2], h[3], key)
-            & _J_;
-     /*<<hashtbl.ml:357:63>>*/ }
-    function add(h, key, data){
-      /*<<hashtbl.ml:360:6>>*/ var
-       /*<<hashtbl.ml:360:14>>*/ i = key_index(h, key),
-       /*<<hashtbl.ml:361:23>>*/ bucket =
-        [0, key, data, caml_check_bound(h[2], i)[1 + i]];
-      /*<<hashtbl.ml:362:6>>*/ caml_check_bound(h[2], i)[1 + i] = bucket;
-     h[1] = h[1] + 1 | 0;
-     var _I_ = h[2].length - 1 << 1 < h[1] ? 1 : 0;
-     return _I_ ? resize(key_index, h) : _I_;
-     /*<<hashtbl.ml:364:67>>*/ }
-    function remove(h, key){
-      /*<<hashtbl.ml:380:6>>*/ var
-       /*<<hashtbl.ml:380:14>>*/ i = key_index(h, key),
-       /*<<hashtbl.ml:381:34>>*/ c = caml_check_bound(h[2], i)[1 + i],
-      prec$0 = 0,
-      prec = c;
-     for(;;){
-      if(! prec)  /*<<hashtbl.ml:368:10>>*/ return 0;
-      var k = prec[1], next = prec[3];
-       /*<<hashtbl.ml:370:13>>*/ if
-       ( /*<<hashtbl.ml:370:13>>*/ caml_call2(H[1], k, key)){
-       h[1] = h[1] - 1 | 0;
-       return prec$0
-               ? (prec$0[3] = next, 0)
-               : (caml_check_bound(h[2], i)[1 + i] = next, 0);
-      }
-      var prec$0 = prec, prec = next;
-     }
-     /*<<hashtbl.ml:381:44>>*/ }
-    function find(h, key){
-      /*<<hashtbl.ml:390:6>>*/ var
-       /*<<hashtbl.ml:390:20>>*/ _H_ = key_index(h, key),
-       /*<<hashtbl.ml:390:12>>*/ match = caml_check_bound(h[2], _H_)[1 + _H_];
-     if(! match)
-       /*<<hashtbl.ml:391:17>>*/ throw  /*<<hashtbl.ml:391:17>>*/ caml_maybe_attach_backtrace
-             (Stdlib[8], 1);
-     var k1 = match[1], d1 = match[2], next1 = match[3];
-      /*<<hashtbl.ml:393:13>>*/ if
-      ( /*<<hashtbl.ml:393:13>>*/ caml_call2(H[1], key, k1))
-       /*<<hashtbl.ml:393:33>>*/ return d1;
-     if(! next1)
-       /*<<hashtbl.ml:395:21>>*/ throw  /*<<hashtbl.ml:395:21>>*/ caml_maybe_attach_backtrace
-             (Stdlib[8], 1);
-     var k2 = next1[1], d2 = next1[2], next2 = next1[3];
-      /*<<hashtbl.ml:397:17>>*/ if
-      ( /*<<hashtbl.ml:397:17>>*/ caml_call2(H[1], key, k2))
-       /*<<hashtbl.ml:397:37>>*/ return d2;
-     if(! next2)
-       /*<<hashtbl.ml:399:25>>*/ throw  /*<<hashtbl.ml:399:25>>*/ caml_maybe_attach_backtrace
-             (Stdlib[8], 1);
-     var k3 = next2[1], d3 = next2[2], next3 = next2[3];
-      /*<<hashtbl.ml:401:21>>*/ if
-      ( /*<<hashtbl.ml:401:21>>*/ caml_call2(H[1], key, k3))
-       /*<<hashtbl.ml:401:41>>*/ return d3;
-     var param = next3;
-     for(;;){
-      if(! param)
-        /*<<hashtbl.ml:385:10>>*/ throw  /*<<hashtbl.ml:385:10>>*/ caml_maybe_attach_backtrace
-              (Stdlib[8], 1);
-      var k = param[1], data = param[2], next = param[3];
-       /*<<hashtbl.ml:387:13>>*/ if
-       ( /*<<hashtbl.ml:387:13>>*/ caml_call2(H[1], key, k))
-        /*<<hashtbl.ml:387:32>>*/ return data;
-      var param = next;
-     }
-     /*<<hashtbl.ml:401:67>>*/ }
-    function find_opt(h, key){
-      /*<<hashtbl.ml:410:6>>*/ var
-       /*<<hashtbl.ml:410:20>>*/ _G_ = key_index(h, key),
-       /*<<hashtbl.ml:410:12>>*/ match = caml_check_bound(h[2], _G_)[1 + _G_];
-     if(! match)  /*<<hashtbl.ml:411:17>>*/ return 0;
-     var k1 = match[1], d1 = match[2], next1 = match[3];
-      /*<<hashtbl.ml:413:13>>*/ if
-      ( /*<<hashtbl.ml:413:13>>*/ caml_call2(H[1], key, k1))
-       /*<<hashtbl.ml:413:33>>*/ return [0, d1];
-     if(! next1)  /*<<hashtbl.ml:415:21>>*/ return 0;
-     var k2 = next1[1], d2 = next1[2], next2 = next1[3];
-      /*<<hashtbl.ml:417:17>>*/ if
-      ( /*<<hashtbl.ml:417:17>>*/ caml_call2(H[1], key, k2))
-       /*<<hashtbl.ml:417:37>>*/ return [0, d2];
-     if(! next2)  /*<<hashtbl.ml:419:25>>*/ return 0;
-     var k3 = next2[1], d3 = next2[2], next3 = next2[3];
-      /*<<hashtbl.ml:421:21>>*/ if
-      ( /*<<hashtbl.ml:421:21>>*/ caml_call2(H[1], key, k3))
-       /*<<hashtbl.ml:421:41>>*/ return [0, d3];
-     var param = next3;
-     for(;;){
-      if(! param)  /*<<hashtbl.ml:405:10>>*/ return 0;
-      var k = param[1], data = param[2], next = param[3];
-       /*<<hashtbl.ml:407:13>>*/ if
-       ( /*<<hashtbl.ml:407:13>>*/ caml_call2(H[1], key, k))
-        /*<<hashtbl.ml:407:32>>*/ return [0, data];
-      var param = next;
-     }
-     /*<<hashtbl.ml:421:76>>*/ }
-    function find_all(h, key){
-     function find_in_bucket(param){
-       /*<<hashtbl.ml:424:31>>*/ var param$0 = param;
-       /*<<hashtbl.ml:424:31>>*/ for(;;){
-       if(! param$0)  /*<<hashtbl.ml:426:10>>*/ return 0;
-       var k = param$0[1], d = param$0[2], next = param$0[3];
-        /*<<hashtbl.ml:428:13>>*/ if
-        ( /*<<hashtbl.ml:428:13>>*/ caml_call2(H[1], k, key))
-         /*<<hashtbl.ml:429:15>>*/ return [0, d, find_in_bucket(next)];
-       var param$0 = next;
-      }
-      /*<<hashtbl.ml:430:34>>*/ }
-      /*<<hashtbl.ml:431:29>>*/  /*<<hashtbl.ml:431:29>>*/ var
-      _F_ = key_index(h, key);
-      /*<<hashtbl.ml:431:21>>*/ return find_in_bucket
-             (caml_check_bound(h[2], _F_)[1 + _F_]);
-     /*<<hashtbl.ml:431:45>>*/ }
-    function replace(h, key, data){
-      /*<<hashtbl.ml:442:6>>*/ var
-       /*<<hashtbl.ml:442:14>>*/ i = key_index(h, key),
-       /*<<hashtbl.ml:443:14>>*/ l = caml_check_bound(h[2], i)[1 + i],
-      slot = l;
-     for(;;){
-      if(slot){
-       var k = slot[1], next = slot[3];
-        /*<<hashtbl.ml:437:13>>*/ if
-        (!  /*<<hashtbl.ml:437:13>>*/ caml_call2(H[1], k, key)){var slot = next; continue;}
-       slot[1] = key;
-       slot[2] = data;
-       var _C_ = 0;
-      }
-      else
-       var _C_ = 1;
-       /*<<hashtbl.ml:444:9>>*/ if(_C_){
-        /*<<hashtbl.ml:445:8>>*/ caml_check_bound(h[2], i)[1 + i] = [0, key, data, l];
-       h[1] = h[1] + 1 | 0;
-       var _D_ = h[2].length - 1 << 1 < h[1] ? 1 : 0;
-       if(_D_)  /*<<hashtbl.ml:447:51>>*/ return resize(key_index, h);
-       var _E_ = _D_;
-      }
-      else
-       var _E_ = _C_;
-      return _E_;
-     }
-     /*<<hashtbl.ml:448:9>>*/ }
-    function mem(h, key){
-      /*<<hashtbl.ml:451:6>>*/ var
-       /*<<hashtbl.ml:456:28>>*/ _B_ = key_index(h, key),
-      param = caml_check_bound(h[2], _B_)[1 + _B_];
-      /*<<hashtbl.ml:451:30>>*/ for(;;){
-      if(! param)  /*<<hashtbl.ml:453:10>>*/ return 0;
-       /*<<hashtbl.ml:455:10>>*/ var
-       k = param[1],
-       next = param[3],
-        /*<<hashtbl.ml:455:10>>*/ _A_ =
-          /*<<hashtbl.ml:455:10>>*/ caml_call2(H[1], k, key);
-       /*<<hashtbl.ml:455:10>>*/ if(_A_)
-        /*<<hashtbl.ml:455:10>>*/ return _A_;
-      var param = next;
-     }
-     /*<<hashtbl.ml:456:44>>*/ }
-    function add_seq(tbl, i){
-     function _z_(param){
-       /*<<hashtbl.ml:459:15>>*/ var v = param[2], k = param[1];
-       /*<<hashtbl.ml:459:29>>*/ return add(tbl, k, v);
-      /*<<hashtbl.ml:459:41>>*/ }
-      /*<<hashtbl.ml:459:6>>*/ return  /*<<hashtbl.ml:459:6>>*/ caml_call2
-             (Stdlib_Seq[4], _z_, i);
-     /*<<hashtbl.ml:459:43>>*/ }
-    function replace_seq(tbl, i){
-     function _y_(param){
-       /*<<hashtbl.ml:462:15>>*/ var v = param[2], k = param[1];
-       /*<<hashtbl.ml:462:29>>*/ return replace(tbl, k, v);
-      /*<<hashtbl.ml:462:45>>*/ }
-      /*<<hashtbl.ml:462:6>>*/ return  /*<<hashtbl.ml:462:6>>*/ caml_call2
-             (Stdlib_Seq[4], _y_, i);
-     /*<<hashtbl.ml:462:47>>*/ }
-    function of_seq(i){
-      /*<<hashtbl.ml:465:6>>*/  /*<<hashtbl.ml:465:16>>*/ var
-      tbl = create(0, 16);
-      /*<<hashtbl.ml:466:6>>*/ replace_seq(tbl, i);
-      /*<<hashtbl.ml:466:6>>*/ return tbl;
-     /*<<hashtbl.ml:467:9>>*/ }
-     /*<<hashtbl.ml:347:2>>*/ return [0,
-            create,
-            clear,
-            reset,
-            copy,
-            add,
-            remove,
-            find,
-            find_opt,
-            find_all,
-            replace,
-            mem,
-            iter,
-            filter_map_inplace,
-            fold,
-            length,
-            stats,
-            to_seq,
-            to_seq_keys,
-            to_seq_values,
-            add_seq,
-            replace_seq,
-            of_seq];
-   }
-   function Make(H){
-    var equal = H[1];
-    function seeded_hash(seed, x){
-      /*<<hashtbl.ml:484:41>>*/ return  /*<<hashtbl.ml:484:41>>*/ caml_call1
-             (H[2], x);
-     /*<<hashtbl.ml:484:49>>*/ }
-    var
-     include = MakeSeeded([0, equal, seeded_hash]),
-     clear = include[2],
-     reset = include[3],
-     copy = include[4],
-     add = include[5],
-     remove = include[6],
-     find = include[7],
-     find_opt = include[8],
-     find_all = include[9],
-     replace = include[10],
-     mem = include[11],
-     iter = include[12],
-     filter_map_inplace = include[13],
-     fold = include[14],
-     length = include[15],
-     stats = include[16],
-     to_seq = include[17],
-     to_seq_keys = include[18],
-     to_seq_values = include[19],
-     add_seq = include[20],
-     replace_seq = include[21],
-     _x_ = include[1];
-    function create(sz){
-      /*<<hashtbl.ml:486:20>>*/ return  /*<<hashtbl.ml:486:20>>*/ caml_call2
-             (_x_, _d_, sz);
-     /*<<hashtbl.ml:486:43>>*/ }
-    function of_seq(i){
-      /*<<hashtbl.ml:488:6>>*/  /*<<hashtbl.ml:488:16>>*/ var
-      tbl = create(16);
-      /*<<hashtbl.ml:489:6>>*/  /*<<hashtbl.ml:489:6>>*/ caml_call2
-      (replace_seq, tbl, i);
-      /*<<hashtbl.ml:489:6>>*/ return tbl;
-     /*<<hashtbl.ml:490:9>>*/ }
-     /*<<hashtbl.ml:480:2>>*/ return [0,
-            create,
-            clear,
-            reset,
-            copy,
-            add,
-            remove,
-            find,
-            find_opt,
-            find_all,
-            replace,
-            mem,
-            iter,
-            filter_map_inplace,
-            fold,
-            length,
-            stats,
-            to_seq,
-            to_seq_keys,
-            to_seq_values,
-            add_seq,
-            replace_seq,
-            of_seq];
-   }
-   function hash(x){
-     /*<<hashtbl.ml:500:13>>*/ return  /*<<hashtbl.ml:500:13>>*/ caml_hash
-            (10, 100, 0, x);
-    /*<<hashtbl.ml:500:41>>*/ }
-   function hash_param(n1, n2, x){
-     /*<<hashtbl.ml:501:25>>*/ return  /*<<hashtbl.ml:501:25>>*/ caml_hash
-            (n1, n2, 0, x);
-    /*<<hashtbl.ml:501:52>>*/ }
-   function seeded_hash(seed, x){
-     /*<<hashtbl.ml:502:25>>*/ return  /*<<hashtbl.ml:502:25>>*/ caml_hash
-            (10, 100, seed, x);
-    /*<<hashtbl.ml:502:56>>*/ }
-   function key_index(h, key){
-     /*<<hashtbl.ml:505:2>>*/ return 4 <= h.length - 1
-            ?  /*<<hashtbl.ml:506:7>>*/ caml_hash
-              (10, 100, h[3], key)
-             & (h[2].length - 1 - 1 | 0)
-            :  /*<<hashtbl.ml:507:7>>*/ caml_call1
-              (Stdlib[1], cst_Hashtbl_unsupported_hash_t);
-    /*<<hashtbl.ml:507:59>>*/ }
-   function add(h, key, data){
-     /*<<hashtbl.ml:510:2>>*/ var
-      /*<<hashtbl.ml:510:10>>*/ i = key_index(h, key),
-      /*<<hashtbl.ml:511:19>>*/ bucket =
-       [0, key, data, caml_check_bound(h[2], i)[1 + i]];
-     /*<<hashtbl.ml:512:2>>*/ caml_check_bound(h[2], i)[1 + i] = bucket;
-    h[1] = h[1] + 1 | 0;
-    var _w_ = h[2].length - 1 << 1 < h[1] ? 1 : 0;
-    return _w_ ? resize(key_index, h) : _w_;
-    /*<<hashtbl.ml:514:63>>*/ }
-   function remove(h, key){
-     /*<<hashtbl.ml:530:2>>*/ var
-      /*<<hashtbl.ml:530:10>>*/ i = key_index(h, key),
-      /*<<hashtbl.ml:531:30>>*/ c = caml_check_bound(h[2], i)[1 + i],
-     prec$0 = 0,
-     prec = c;
-    for(;;){
-     if(! prec)  /*<<hashtbl.ml:518:6>>*/ return 0;
-     var k = prec[1], next = prec[3];
-      /*<<hashtbl.ml:520:9>>*/ if
-      (0 ===  /*<<hashtbl.ml:520:9>>*/ caml_compare(k, key)){
-      h[1] = h[1] - 1 | 0;
-      return prec$0
-              ? (prec$0[3] = next, 0)
-              : (caml_check_bound(h[2], i)[1 + i] = next, 0);
-     }
-     var prec$0 = prec, prec = next;
-    }
-    /*<<hashtbl.ml:531:40>>*/ }
-   function find(h, key){
-     /*<<hashtbl.ml:540:2>>*/ var
-      /*<<hashtbl.ml:540:16>>*/ _v_ = key_index(h, key),
-      /*<<hashtbl.ml:540:8>>*/ match = caml_check_bound(h[2], _v_)[1 + _v_];
-    if(! match)
-      /*<<hashtbl.ml:541:13>>*/ throw  /*<<hashtbl.ml:541:13>>*/ caml_maybe_attach_backtrace
-            (Stdlib[8], 1);
-    var k1 = match[1], d1 = match[2], next1 = match[3];
-     /*<<hashtbl.ml:543:9>>*/ if
-     (0 ===  /*<<hashtbl.ml:543:9>>*/ caml_compare(key, k1))
-      /*<<hashtbl.ml:543:33>>*/ return d1;
-    if(! next1)
-      /*<<hashtbl.ml:545:17>>*/ throw  /*<<hashtbl.ml:545:17>>*/ caml_maybe_attach_backtrace
-            (Stdlib[8], 1);
-    var k2 = next1[1], d2 = next1[2], next2 = next1[3];
-     /*<<hashtbl.ml:547:13>>*/ if
-     (0 ===  /*<<hashtbl.ml:547:13>>*/ caml_compare(key, k2))
-      /*<<hashtbl.ml:547:37>>*/ return d2;
-    if(! next2)
-      /*<<hashtbl.ml:549:21>>*/ throw  /*<<hashtbl.ml:549:21>>*/ caml_maybe_attach_backtrace
-            (Stdlib[8], 1);
-    var k3 = next2[1], d3 = next2[2], next3 = next2[3];
-     /*<<hashtbl.ml:551:17>>*/ if
-     (0 ===  /*<<hashtbl.ml:551:17>>*/ caml_compare(key, k3))
-      /*<<hashtbl.ml:551:41>>*/ return d3;
-    var param = next3;
-    for(;;){
-     if(! param)
-       /*<<hashtbl.ml:535:6>>*/ throw  /*<<hashtbl.ml:535:6>>*/ caml_maybe_attach_backtrace
-             (Stdlib[8], 1);
-     var k = param[1], data = param[2], next = param[3];
-      /*<<hashtbl.ml:537:9>>*/ if
-      (0 ===  /*<<hashtbl.ml:537:9>>*/ caml_compare(key, k))
-       /*<<hashtbl.ml:537:32>>*/ return data;
-     var param = next;
-    }
-    /*<<hashtbl.ml:551:67>>*/ }
-   function find_opt(h, key){
-     /*<<hashtbl.ml:560:2>>*/ var
-      /*<<hashtbl.ml:560:16>>*/ _u_ = key_index(h, key),
-      /*<<hashtbl.ml:560:8>>*/ match = caml_check_bound(h[2], _u_)[1 + _u_];
-    if(! match)  /*<<hashtbl.ml:561:13>>*/ return 0;
-    var k1 = match[1], d1 = match[2], next1 = match[3];
-     /*<<hashtbl.ml:563:9>>*/ if
-     (0 ===  /*<<hashtbl.ml:563:9>>*/ caml_compare(key, k1))
-      /*<<hashtbl.ml:563:33>>*/ return [0, d1];
-    if(! next1)  /*<<hashtbl.ml:565:17>>*/ return 0;
-    var k2 = next1[1], d2 = next1[2], next2 = next1[3];
-     /*<<hashtbl.ml:567:13>>*/ if
-     (0 ===  /*<<hashtbl.ml:567:13>>*/ caml_compare(key, k2))
-      /*<<hashtbl.ml:567:37>>*/ return [0, d2];
-    if(! next2)  /*<<hashtbl.ml:569:21>>*/ return 0;
-    var k3 = next2[1], d3 = next2[2], next3 = next2[3];
-     /*<<hashtbl.ml:571:17>>*/ if
-     (0 ===  /*<<hashtbl.ml:571:17>>*/ caml_compare(key, k3))
-      /*<<hashtbl.ml:571:41>>*/ return [0, d3];
-    var param = next3;
-    for(;;){
-     if(! param)  /*<<hashtbl.ml:555:6>>*/ return 0;
-     var k = param[1], data = param[2], next = param[3];
-      /*<<hashtbl.ml:557:9>>*/ if
-      (0 ===  /*<<hashtbl.ml:557:9>>*/ caml_compare(key, k))
-       /*<<hashtbl.ml:557:32>>*/ return [0, data];
-     var param = next;
-    }
-    /*<<hashtbl.ml:571:76>>*/ }
-   function find_all(h, key){
-    function find_in_bucket(param){
-      /*<<hashtbl.ml:574:27>>*/ var param$0 = param;
-      /*<<hashtbl.ml:574:27>>*/ for(;;){
-      if(! param$0)  /*<<hashtbl.ml:576:6>>*/ return 0;
-      var k = param$0[1], data = param$0[2], next = param$0[3];
-       /*<<hashtbl.ml:578:9>>*/ if
-       (0 ===  /*<<hashtbl.ml:578:9>>*/ caml_compare(k, key))
-        /*<<hashtbl.ml:579:11>>*/ return [0, data, find_in_bucket(next)];
-      var param$0 = next;
-     }
-     /*<<hashtbl.ml:580:30>>*/ }
-     /*<<hashtbl.ml:581:25>>*/  /*<<hashtbl.ml:581:25>>*/ var
-     _t_ = key_index(h, key);
-     /*<<hashtbl.ml:581:17>>*/ return find_in_bucket
-            (caml_check_bound(h[2], _t_)[1 + _t_]);
-    /*<<hashtbl.ml:581:41>>*/ }
-   function replace(h, key, data){
-     /*<<hashtbl.ml:592:2>>*/ var
-      /*<<hashtbl.ml:592:10>>*/ i = key_index(h, key),
-      /*<<hashtbl.ml:593:10>>*/ l = caml_check_bound(h[2], i)[1 + i],
-     slot = l;
-    for(;;){
-     if(slot){
-      var k = slot[1], next = slot[3];
-       /*<<hashtbl.ml:587:9>>*/ if
-       (0 !==  /*<<hashtbl.ml:587:9>>*/ caml_compare(k, key)){var slot = next; continue;}
-      slot[1] = key;
-      slot[2] = data;
-      var _q_ = 0;
-     }
-     else
-      var _q_ = 1;
-      /*<<hashtbl.ml:594:5>>*/ if(_q_){
-       /*<<hashtbl.ml:595:4>>*/ caml_check_bound(h[2], i)[1 + i] = [0, key, data, l];
-      h[1] = h[1] + 1 | 0;
-      var _r_ = h[2].length - 1 << 1 < h[1] ? 1 : 0;
-      if(_r_)  /*<<hashtbl.ml:597:47>>*/ return resize(key_index, h);
-      var _s_ = _r_;
-     }
-     else
-      var _s_ = _q_;
-     return _s_;
-    }
-    /*<<hashtbl.ml:598:5>>*/ }
-   function mem(h, key){
-     /*<<hashtbl.ml:601:2>>*/ var
-      /*<<hashtbl.ml:606:24>>*/ _p_ = key_index(h, key),
-     param = caml_check_bound(h[2], _p_)[1 + _p_];
-     /*<<hashtbl.ml:601:26>>*/ for(;;){
-     if(! param)  /*<<hashtbl.ml:603:6>>*/ return 0;
-     var
-      k = param[1],
-      next = param[3],
-      _o_ = 0 ===  /*<<hashtbl.ml:605:6>>*/ caml_compare(k, key) ? 1 : 0;
-     if(_o_) return _o_;
-     var param = next;
-    }
-    /*<<hashtbl.ml:606:40>>*/ }
-   function add_seq(tbl, i){
-    function _n_(param){
-      /*<<hashtbl.ml:609:11>>*/ var v = param[2], k = param[1];
-      /*<<hashtbl.ml:609:25>>*/ return add(tbl, k, v);
-     /*<<hashtbl.ml:609:37>>*/ }
-     /*<<hashtbl.ml:609:2>>*/ return  /*<<hashtbl.ml:609:2>>*/ caml_call2
-            (Stdlib_Seq[4], _n_, i);
-    /*<<hashtbl.ml:609:39>>*/ }
-   function replace_seq(tbl, i){
-    function _m_(param){
-      /*<<hashtbl.ml:612:11>>*/ var v = param[2], k = param[1];
-      /*<<hashtbl.ml:612:25>>*/ return replace(tbl, k, v);
-     /*<<hashtbl.ml:612:41>>*/ }
-     /*<<hashtbl.ml:612:2>>*/ return  /*<<hashtbl.ml:612:2>>*/ caml_call2
-            (Stdlib_Seq[4], _m_, i);
-    /*<<hashtbl.ml:612:43>>*/ }
-   function of_seq(i){
-     /*<<hashtbl.ml:615:2>>*/  /*<<hashtbl.ml:615:12>>*/ var
-     tbl = create(0, 16);
-     /*<<hashtbl.ml:616:2>>*/ replace_seq(tbl, i);
-     /*<<hashtbl.ml:616:2>>*/ return tbl;
-    /*<<hashtbl.ml:617:5>>*/ }
-   function rebuild(opt, h){
-     /*<<hashtbl.ml:620:2>>*/ if(opt)
-     var sth = opt[1], random = sth;
-    else
-     var
-      random =
-         /*<<hashtbl.ml:619:23>>*/ caml_call1(Stdlib_Atomic[2], randomized);
-     /*<<hashtbl.ml:620:10>>*/  /*<<hashtbl.ml:620:10>>*/ var
-     s = power_2_above(16, h[2].length - 1);
-     /*<<hashtbl.ml:621:2>>*/ if(random)
-      /*<<hashtbl.ml:622:37>>*/ var
-       /*<<hashtbl.ml:622:37>>*/ _g_ =
-         /*<<hashtbl.ml:622:37>>*/ caml_call1(Stdlib_Domain[10][2], prng_key),
-      seed =  /*<<hashtbl.ml:622:19>>*/ caml_call1(Stdlib_Random[15][4], _g_);
-    else
-     var seed = 4 <= h.length - 1 ? h[3] : 0;
-     /*<<hashtbl.ml:625:11>>*/ var
-     _h_ = 4 <= h.length - 1 ? h[4] : s,
-      /*<<hashtbl.ml:625:11>>*/ h$0 =
-       [0, h[1],  /*<<hashtbl.ml:627:11>>*/ caml_make_vect(s, 0), seed, _h_],
-     _i_ = h$0[2],
-     _j_ = h[2],
-     _k_ = 0;
-     /*<<hashtbl.ml:631:2>>*/ insert_all_buckets
-     (function(_l_){ /*<<?>>*/ return key_index(h$0, _l_);}, _k_, _j_, _i_);
-     /*<<hashtbl.ml:631:2>>*/ return h$0;
-    /*<<hashtbl.ml:632:4>>*/ }
-   var
-    Stdlib_Hashtbl =
-      [0,
-       create,
-       clear,
-       reset,
-       copy,
-       add,
-       find,
-       find_opt,
-       find_all,
-       mem,
-       remove,
-       replace,
-       iter,
-       filter_map_inplace,
-       fold,
-       length,
-       randomize,
-       is_randomized,
-       rebuild,
-       stats,
-       to_seq,
-       to_seq_keys,
-       to_seq_values,
-       add_seq,
-       replace_seq,
-       of_seq,
-       Make,
-       MakeSeeded,
-       hash,
-       seeded_hash,
-       hash_param,
-       caml_hash];
-   runtime.caml_register_global(16, Stdlib_Hashtbl, "Stdlib__Hashtbl");
-   return;
-   /*<<?>>*/ }
-  (globalThis));
-
-//# unitInfo: Provides: Stdlib__Weak
-//# unitInfo: Requires: Stdlib, Stdlib__Array, Stdlib__Int, Stdlib__Obj, Stdlib__Sys
-(function
-  (globalThis){
-   "use strict";
-   var
-    runtime = globalThis.jsoo_runtime,
-    caml_check_bound = runtime.caml_check_bound,
-    caml_make_vect = runtime.caml_make_vect,
-    caml_maybe_attach_backtrace = runtime.caml_maybe_attach_backtrace,
-    caml_mod = runtime.caml_mod;
-    /*<<?>>*/ function caml_call1(f, a0){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 1
-            ? f(a0)
-            : runtime.caml_call_gen(f, [a0]);
-   }
-    /*<<?>>*/ function caml_call2(f, a0, a1){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 2
-            ? f(a0, a1)
-            : runtime.caml_call_gen(f, [a0, a1]);
-   }
-    /*<<?>>*/ function caml_call3(f, a0, a1, a2){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 3
-            ? f(a0, a1, a2)
-            : runtime.caml_call_gen(f, [a0, a1, a2]);
-   }
-    /*<<?>>*/ function caml_call5(f, a0, a1, a2, a3, a4){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 5
-            ? f(a0, a1, a2, a3, a4)
-            : runtime.caml_call_gen(f, [a0, a1, a2, a3, a4]);
-   }
-   var
-    global_data = runtime.caml_get_global_data(),
-    Stdlib = global_data.Stdlib,
-    Stdlib_Sys = global_data.Stdlib__Sys,
-    Stdlib_Int = global_data.Stdlib__Int,
-    Stdlib_Array = global_data.Stdlib__Array,
-    Stdlib_Obj = global_data.Stdlib__Obj,
-    cst_Weak_Make_hash_bucket_cann = "Weak.Make: hash bucket cannot grow more",
-    cst_Weak_fill = "Weak.fill",
-    cst_Weak_blit = "Weak.blit",
-    cst_Weak_check = "Weak.check",
-    cst_Weak_get_copy = "Weak.get_copy",
-    cst_Weak_get = "Weak.get",
-    cst_Weak_set = "Weak.set",
-    cst_Weak_create = "Weak.create";
-   function create(l){
-     /*<<weak.ml:28:2>>*/ var
-     _W_ = 0 <= l ? 1 : 0,
-     _X_ = _W_ ? l <= Stdlib_Obj[24][15] ? 1 : 0 : _W_;
-    if(1 - _X_)
-      /*<<weak.ml:29:4>>*/  /*<<weak.ml:29:4>>*/ caml_call1
-      (Stdlib[1], cst_Weak_create);
-     /*<<weak.ml:30:2>>*/ return  /*<<weak.ml:30:2>>*/ runtime.caml_weak_create
-            (l);
-    /*<<weak.ml:30:10>>*/ }
-   function length(x){
-     /*<<weak.ml:33:15>>*/ return x.length - 1 - 2 | 0;
-    /*<<weak.ml:33:55>>*/ }
-   function raise_if_invalid_offset(e, o, msg){
-     /*<<weak.ml:36:2>>*/ var
-     _T_ = 0 <= o ? 1 : 0,
-     _U_ = _T_ ? o < length(e) ? 1 : 0 : _T_,
-     _V_ = 1 - _U_;
-    return _V_ ?  /*<<weak.ml:37:4>>*/ caml_call1(Stdlib[1], msg) : _V_;
-    /*<<weak.ml:37:20>>*/ }
-   function set(e, o, x){
-     /*<<weak.ml:42:2>>*/ raise_if_invalid_offset(e, o, cst_Weak_set);
-    if(! x)
-      /*<<weak.ml:44:12>>*/ return  /*<<weak.ml:44:12>>*/ runtime.caml_ephe_unset_key
-             (e, o);
-    var x$0 = x[1];
-     /*<<weak.ml:45:14>>*/ return  /*<<weak.ml:45:14>>*/ runtime.caml_ephe_set_key
-            (e, o, x$0);
-    /*<<weak.ml:45:24>>*/ }
-   function get(e, o){
-     /*<<weak.ml:49:2>>*/ raise_if_invalid_offset(e, o, cst_Weak_get);
-     /*<<weak.ml:50:2>>*/ return  /*<<weak.ml:50:2>>*/ runtime.caml_ephe_get_key
-            (e, o);
-    /*<<weak.ml:50:9>>*/ }
-   function get_copy(e, o){
-     /*<<weak.ml:54:2>>*/ raise_if_invalid_offset(e, o, cst_Weak_get_copy);
-     /*<<weak.ml:55:2>>*/ return  /*<<weak.ml:55:2>>*/ runtime.caml_ephe_get_key_copy
-            (e, o);
-    /*<<weak.ml:55:14>>*/ }
-   function check(e, o){
-     /*<<weak.ml:59:2>>*/ raise_if_invalid_offset(e, o, cst_Weak_check);
-     /*<<weak.ml:60:2>>*/ return  /*<<weak.ml:60:2>>*/ runtime.caml_ephe_check_key
-            (e, o);
-    /*<<weak.ml:60:11>>*/ }
-   function blit(e1, o1, e2, o2, l){
-     /*<<weak.ml:66:2>>*/ if
-     (0 <= l
-      &&
-       0 <= o1
-       && (length(e1) - l | 0) >= o1 && 0 <= o2 && (length(e2) - l | 0) >= o2){
-     var
-      _R_ = 0 !== l ? 1 : 0,
-      _S_ =
-        _R_
-         ?  /*<<weak.ml:69:22>>*/ runtime.caml_ephe_blit_key
-           (e1, o1, e2, o2, l)
-         : _R_;
-      /*<<weak.ml:69:22>>*/ return _S_;
-    }
-     /*<<weak.ml:68:7>>*/ return  /*<<weak.ml:68:7>>*/ caml_call1
-            (Stdlib[1], cst_Weak_blit);
-    /*<<weak.ml:69:40>>*/ }
-   function fill(ar, ofs, len, x){
-     /*<<weak.ml:72:2>>*/ if
-     (0 <= ofs && 0 <= len && (length(ar) - len | 0) >= ofs){
-     var _P_ = (ofs + len | 0) - 1 | 0;
-     if(_P_ >= ofs){
-      var i = ofs;
-      for(;;){
-        /*<<weak.ml:76:6>>*/ set(ar, i, x);
-        /*<<weak.ml:76:6>>*/  /*<<weak.ml:76:6>>*/ var _Q_ = i + 1 | 0;
-       if(_P_ === i) break;
-       var i = _Q_;
-      }
-     }
-     return 0;
-    }
-     /*<<weak.ml:73:7>>*/ throw  /*<<weak.ml:73:7>>*/ caml_maybe_attach_backtrace
-           ([0, Stdlib[6], cst_Weak_fill], 1);
-    /*<<weak.ml:78:5>>*/ }
-   function Make(H){
-     /*<<weak.ml:105:20>>*/  /*<<weak.ml:105:20>>*/ var
-     emptybucket = create(0);
-    function get_index(t, h){
-      /*<<weak.ml:117:22>>*/ return caml_mod(h & Stdlib[19], t[1].length - 1);
-     /*<<weak.ml:117:65>>*/ }
-    var limit = 7;
-    function create$0(sz){
-      /*<<weak.ml:123:4>>*/ var
-      sz$0 = 7 <= sz ? sz : 7,
-      sz$1 = Stdlib_Sys[13] < sz$0 ? Stdlib_Sys[13] : sz$0;
-      /*<<weak.ml:125:4>>*/ return [0,
-              /*<<weak.ml:126:14>>*/ caml_make_vect(sz$1, emptybucket),
-              /*<<weak.ml:127:15>>*/ caml_make_vect(sz$1, [0]),
-             limit,
-             0,
-             0];
-     /*<<weak.ml:131:5>>*/ }
-    function clear(t){
-      /*<<weak.ml:134:4>>*/ var
-      _N_ = t[1].length - 1 - 1 | 0,
-       /*<<weak.ml:134:4>>*/ _M_ = 0;
-     if(_N_ >= 0){
-      var i = _M_;
-      for(;;){
-        /*<<weak.ml:135:6>>*/ caml_check_bound(t[1], i)[1 + i] = emptybucket;
-        /*<<weak.ml:136:6>>*/ caml_check_bound(t[2], i)[1 + i] = [0];
-        /*<<weak.ml:136:6>>*/  /*<<weak.ml:136:6>>*/ var _O_ = i + 1 | 0;
-       if(_N_ === i) break;
-       var i = _O_;
-      }
-     }
-     t[3] = limit;
-     t[4] = 0;
-     return 0;
-     /*<<weak.ml:139:19>>*/ }
-    function fold(f, t, init){
-      /*<<weak.ml:143:4>>*/ var _K_ = t[1], i = 0;
-      /*<<weak.ml:149:21>>*/ function _L_(b, accu$1){
-      var i$0 = i, accu = accu$1;
-       /*<<weak.ml:144:6>>*/ for(;;){
-       if(length(b) <= i$0)  /*<<weak.ml:144:28>>*/ return accu;
-        /*<<weak.ml:145:12>>*/  /*<<weak.ml:145:12>>*/ var
-        match = get(b, i$0);
-       if(match)
-         /*<<weak.ml:146:38>>*/ var
-         v = match[1],
-          /*<<weak.ml:146:38>>*/ accu$0 =
-            /*<<weak.ml:146:38>>*/ caml_call2(f, v, accu),
-         i$1 = i$0 + 1 | 0,
-         i$0 = i$1,
-         accu = accu$0;
-       else
-        var i$2 = i$0 + 1 | 0, i$0 = i$2;
-      }
-     }
-      /*<<weak.ml:149:4>>*/ return  /*<<weak.ml:149:4>>*/ caml_call3
-             (Stdlib_Array[17], _L_, _K_, init);
-     /*<<weak.ml:149:49>>*/ }
-    function iter(f, t){
-      /*<<weak.ml:153:4>>*/ var _I_ = t[1], i = 0;
-      /*<<weak.ml:159:15>>*/ function _J_(b){
-      var i$0 = i;
-       /*<<weak.ml:154:6>>*/ for(;;){
-       if(length(b) <= i$0)  /*<<weak.ml:154:28>>*/ return 0;
-        /*<<weak.ml:155:12>>*/  /*<<weak.ml:155:12>>*/ var
-        match = get(b, i$0);
-       if(match){
-        var v = match[1];
-         /*<<weak.ml:156:18>>*/  /*<<weak.ml:156:18>>*/ caml_call1(f, v);
-        var i$1 = i$0 + 1 | 0, i$0 = i$1;
-       }
-       else
-        var i$2 = i$0 + 1 | 0, i$0 = i$2;
-      }
-     }
-      /*<<weak.ml:159:15>>*/ return  /*<<weak.ml:159:15>>*/ caml_call2
-             (Stdlib_Array[11], _J_, _I_);
-     /*<<weak.ml:159:38>>*/ }
-    function count_bucket(i, b, accu){
-      /*<<weak.ml:173:4>>*/ var i$0 = i, accu$0 = accu;
-      /*<<weak.ml:173:4>>*/ for(;;){
-      if(length(b) <= i$0)  /*<<weak.ml:173:26>>*/ return accu$0;
-       /*<<weak.ml:174:37>>*/ var
-        /*<<weak.ml:174:37>>*/ _H_ = check(b, i$0) ? 1 : 0,
-       accu$1 = accu$0 + _H_ | 0,
-       i$1 = i$0 + 1 | 0,
-       i$0 = i$1,
-       accu$0 = accu$1;
-     }
-     /*<<weak.ml:174:62>>*/ }
-    function count(t){
-      /*<<weak.ml:178:4>>*/ var
-       /*<<weak.ml:178:4>>*/ _B_ = 0,
-      _C_ = t[1],
-      _D_ = 0;
-      /*<<weak.ml:178:21>>*/ function _E_(_F_, _G_){
-       /*<<?>>*/ return count_bucket(_D_, _F_, _G_);
-     }
-      /*<<weak.ml:178:4>>*/ return  /*<<weak.ml:178:4>>*/ caml_call3
-             (Stdlib_Array[17], _E_, _C_, _B_);
-     /*<<weak.ml:178:47>>*/ }
-    function add_aux(t, setter, d, h, index){
-      /*<<weak.ml:238:4>>*/ var
-       /*<<weak.ml:238:17>>*/ bucket$0 =
-        caml_check_bound(t[1], index)[1 + index],
-       /*<<weak.ml:239:17>>*/ hashes =
-        caml_check_bound(t[2], index)[1 + index],
-       /*<<weak.ml:240:13>>*/ sz = length(bucket$0),
-      i$3 = 0;
-      /*<<weak.ml:242:6>>*/ for(;;){
-      if(sz <= i$3){
-        /*<<weak.ml:244:10>>*/  /*<<weak.ml:244:10>>*/ var
-        newsz =
-           /*<<weak.ml:244:10>>*/ caml_call2
-           (Stdlib_Int[10],
-            ((3 * sz | 0) / 2 | 0) + 3 | 0,
-            Stdlib_Sys[13] - 2 | 0);
-       if(newsz <= sz)
-         /*<<weak.ml:246:28>>*/  /*<<weak.ml:246:28>>*/ caml_call1
-         (Stdlib[2], cst_Weak_Make_hash_bucket_cann);
-        /*<<weak.ml:247:24>>*/ var
-         /*<<weak.ml:247:24>>*/ newbucket$0 = create(newsz),
-         /*<<weak.ml:248:24>>*/ newhashes =
-           /*<<weak.ml:248:24>>*/ caml_make_vect(newsz, 0);
-        /*<<weak.ml:249:8>>*/ blit(bucket$0, 0, newbucket$0, 0, sz);
-        /*<<weak.ml:250:8>>*/  /*<<weak.ml:250:8>>*/ caml_call5
-        (Stdlib_Array[8], hashes, 0, newhashes, 0, sz);
-        /*<<weak.ml:251:8>>*/  /*<<weak.ml:251:8>>*/ caml_call3
-        (setter, newbucket$0, sz, d);
-        /*<<weak.ml:252:8>>*/ caml_check_bound(newhashes, sz)[1 + sz] = h;
-        /*<<weak.ml:253:8>>*/ caml_check_bound(t[1], index)[1 + index] = newbucket$0;
-        /*<<weak.ml:254:8>>*/ caml_check_bound(t[2], index)[1 + index] = newhashes;
-       var _x_ = sz <= t[3] ? 1 : 0, _y_ = _x_ ? t[3] < newsz ? 1 : 0 : _x_;
-       if(_y_){
-        t[4] = t[4] + 1 | 0;
-        var i$4 = 0;
-        for(;;){
-          /*<<weak.ml:185:17>>*/ var
-          _n_ = t[5],
-           /*<<weak.ml:185:17>>*/ bucket =
-            caml_check_bound(t[1], _n_)[1 + _n_],
-           /*<<weak.ml:186:4>>*/ _o_ = t[5],
-           /*<<weak.ml:186:18>>*/ hbucket =
-            caml_check_bound(t[2], _o_)[1 + _o_],
-           /*<<weak.ml:187:14>>*/ len = length(bucket),
-          prev_len = (((len - 3 | 0) * 2 | 0) + 2 | 0) / 3 | 0,
-           /*<<weak.ml:189:15>>*/ live = count_bucket(0, bucket, 0);
-         if(live <= prev_len){
-           /*<<weak.ml:201:14>>*/ var
-            /*<<weak.ml:201:14>>*/ j$2 = length(bucket) - 1 | 0,
-           i$0 = 0,
-           j = j$2;
-           /*<<weak.ml:192:8>>*/ for(;;){
-           if(prev_len > j){
-            if(0 === prev_len){
-             var _q_ = t[5];
-              /*<<weak.ml:203:8>>*/ caml_check_bound(t[1], _q_)[1 + _q_] = emptybucket;
-             var _r_ = t[5];
-              /*<<weak.ml:204:8>>*/ caml_check_bound(t[2], _r_)[1 + _r_] = [0];
-            }
-            else{
-              /*<<weak.ml:206:24>>*/  /*<<weak.ml:206:24>>*/ var
-              newbucket = create(prev_len);
-              /*<<weak.ml:207:8>>*/ blit(bucket, 0, newbucket, 0, prev_len);
-             var _u_ = t[5];
-              /*<<weak.ml:208:8>>*/ caml_check_bound(t[1], _u_)[1 + _u_] = newbucket;
-              /*<<weak.ml:209:30>>*/ var
-               /*<<weak.ml:209:30>>*/ _v_ =
-                 /*<<weak.ml:209:30>>*/ caml_call3
-                 (Stdlib_Array[5], hbucket, 0, prev_len),
-              _w_ = t[5];
-              /*<<weak.ml:209:8>>*/ caml_check_bound(t[2], _w_)[1 + _w_] = _v_;
-            }
-            var
-             _s_ = t[3] < len ? 1 : 0,
-             _t_ = _s_ ? prev_len <= t[3] ? 1 : 0 : _s_;
-            if(_t_) t[4] = t[4] - 1 | 0;
-            break;
-           }
-            /*<<weak.ml:193:13>>*/ if(check(bucket, i$0))
-            var i$1 = i$0 + 1 | 0, i$0 = i$1;
-           else if(check(bucket, j)){
-             /*<<weak.ml:195:12>>*/ blit(bucket, j, bucket, i$0, 1);
-             /*<<weak.ml:196:27>>*/  /*<<weak.ml:196:27>>*/ var
-             _p_ = caml_check_bound(hbucket, j)[1 + j];
-             /*<<weak.ml:196:12>>*/ caml_check_bound(hbucket, i$0)[1 + i$0] = _p_;
-             /*<<weak.ml:196:12>>*/ var
-              /*<<weak.ml:196:12>>*/ j$0 = j - 1 | 0,
-             i$2 = i$0 + 1 | 0,
-             i$0 = i$2,
-             j = j$0;
-           }
-           else
-             /*<<weak.ml:198:19>>*/ var
-              /*<<weak.ml:198:19>>*/ j$1 = j - 1 | 0,
-             j = j$1;
-          }
-         }
-         t[5] = caml_mod(t[5] + 1 | 0, t[1].length - 1);
-          /*<<weak.ml:257:38>>*/  /*<<weak.ml:257:38>>*/ var
-          _A_ = i$4 + 1 | 0;
-         if(2 === i$4) break;
-         var i$4 = _A_;
-        }
-       }
-       var _z_ = ((t[1].length - 1) / 2 | 0) < t[4] ? 1 : 0;
-       if(! _z_) return _z_;
-        /*<<weak.ml:181:18>>*/ var
-        oldlen = t[1].length - 1,
-         /*<<weak.ml:181:18>>*/ newlen =
-           /*<<weak.ml:181:18>>*/ caml_call2
-           (Stdlib_Int[10],
-            ((3 * oldlen | 0) / 2 | 0) + 3 | 0,
-            Stdlib_Sys[13]);
-       if(oldlen < newlen){
-         /*<<weak.ml:220:17>>*/ var
-          /*<<weak.ml:220:17>>*/ newt = create$0(newlen),
-         _l_ = t[1],
-         i = 0,
-          /*<<weak.ml:169:16>>*/ _m_ =
-           function(j, ob){
-            var oi = i;
-             /*<<weak.ml:164:6>>*/ for(;;){
-             if(length(ob) <= oi)  /*<<weak.ml:164:28>>*/ return 0;
-             if(check(ob, oi)){
-               /*<<weak.ml:166:20>>*/ var
-                /*<<weak.ml:166:20>>*/ oh = caml_check_bound(t[2], j)[1 + j],
-               setter$0 =
-                 function(oi){
-                  function setter(nb, ni, param){
-                    /*<<weak.ml:222:29>>*/ return blit(ob, oi, nb, ni, 1);
-                   /*<<weak.ml:222:47>>*/ }
-                  return setter;
-                 },
-               setter = setter$0(oi),
-                /*<<weak.ml:223:16>>*/ h = caml_check_bound(oh, oi)[1 + oi];
-               /*<<weak.ml:224:35>>*/ add_aux
-               (newt, setter, 0, h, get_index(newt, h));
-              var i$0 = oi + 1 | 0, oi = i$0;
-             }
-             else
-              var i$1 = oi + 1 | 0, oi = i$1;
-            }
-           };
-         /*<<weak.ml:169:16>>*/  /*<<weak.ml:169:16>>*/ caml_call2
-         (Stdlib_Array[12], _m_, _l_);
-        t[1] = newt[1];
-        t[2] = newt[2];
-        t[3] = newt[3];
-        t[4] = newt[4];
-        t[5] = caml_mod(t[5], newt[1].length - 1);
-        return 0;
-       }
-       t[3] = Stdlib[19];
-       t[4] = 0;
-       return 0;
-      }
-       /*<<weak.ml:260:18>>*/ if(! check(bucket$0, i$3)){
-        /*<<weak.ml:263:8>>*/  /*<<weak.ml:263:8>>*/ caml_call3
-        (setter, bucket$0, i$3, d);
-        /*<<weak.ml:264:8>>*/ caml_check_bound(hashes, i$3)[1 + i$3] = h;
-        /*<<weak.ml:264:8>>*/ return 0;
-      }
-       /*<<weak.ml:260:38>>*/ var
-        /*<<weak.ml:260:38>>*/ i$5 = i$3 + 1 | 0,
-       i$3 = i$5;
-     }
-     /*<<weak.ml:267:10>>*/ }
-    function add(t, d){
-      /*<<weak.ml:271:4>>*/  /*<<weak.ml:271:12>>*/ var
-      h =  /*<<weak.ml:271:12>>*/ caml_call1(H[2], d);
-      /*<<weak.ml:272:29>>*/ return add_aux
-             (t, set, [0, d], h, get_index(t, h));
-     /*<<weak.ml:272:44>>*/ }
-    function find_or(t, d, ifnotfound){
-      /*<<weak.ml:276:4>>*/ var
-       /*<<weak.ml:276:12>>*/ h =  /*<<weak.ml:276:12>>*/ caml_call1(H[2], d),
-       /*<<weak.ml:277:16>>*/ index = get_index(t, h),
-       /*<<weak.ml:278:17>>*/ bucket =
-        caml_check_bound(t[1], index)[1 + index],
-       /*<<weak.ml:279:17>>*/ hashes =
-        caml_check_bound(t[2], index)[1 + index],
-       /*<<weak.ml:280:13>>*/ sz = length(bucket),
-      i = 0;
-      /*<<weak.ml:282:6>>*/ for(;;){
-      if(sz <= i)
-        /*<<weak.ml:277:16>>*/ return  /*<<weak.ml:277:16>>*/ caml_call2
-               (ifnotfound, h, index);
-      if(h === caml_check_bound(hashes, i)[1 + i]){
-        /*<<weak.ml:284:14>>*/  /*<<weak.ml:284:14>>*/ var
-        match = get_copy(bucket, i);
-       if(match){
-        var v = match[1];
-         /*<<weak.ml:285:22>>*/ if
-         ( /*<<weak.ml:285:22>>*/ caml_call2(H[1], v, d)){
-          /*<<weak.ml:286:26>>*/  /*<<weak.ml:286:26>>*/ var
-          match$0 = get(bucket, i);
-         if(match$0){
-          var v$0 = match$0[1];
-           /*<<weak.ml:287:26>>*/ return v$0;
-         }
-          /*<<weak.ml:288:24>>*/ var
-           /*<<weak.ml:288:24>>*/ i$0 = i + 1 | 0,
-          i = i$0;
-         continue;
-        }
-       }
-        /*<<weak.ml:290:15>>*/ var
-         /*<<weak.ml:290:15>>*/ i$1 = i + 1 | 0,
-        i = i$1;
-      }
-      else
-        /*<<weak.ml:291:15>>*/ var
-         /*<<weak.ml:291:15>>*/ i$2 = i + 1 | 0,
-        i = i$2;
-     }
-     /*<<weak.ml:293:10>>*/ }
-    function merge(t, d){
-      /*<<weak.ml:297:4>>*/ return find_or
-             (t,
-              d,
-              function(h, index){
-                /*<<weak.ml:297:32>>*/ add_aux(t, set, [0, d], h, index);
-                /*<<weak.ml:297:4>>*/ return d;
-               /*<<weak.ml:297:65>>*/ });
-     /*<<weak.ml:297:66>>*/ }
-    function find(t, d){
-      /*<<weak.ml:300:17>>*/ return find_or
-             (t,
-              d,
-              function(h, index){
-                /*<<weak.ml:300:47>>*/ throw  /*<<weak.ml:300:47>>*/ caml_maybe_attach_backtrace
-                      (Stdlib[8], 1);
-               /*<<weak.ml:300:62>>*/ });
-     /*<<weak.ml:300:63>>*/ }
-    function find_opt(t, d){
-      /*<<weak.ml:303:4>>*/ var
-       /*<<weak.ml:303:12>>*/ h =  /*<<weak.ml:303:12>>*/ caml_call1(H[2], d),
-       /*<<weak.ml:304:16>>*/ index = get_index(t, h),
-       /*<<weak.ml:305:17>>*/ bucket =
-        caml_check_bound(t[1], index)[1 + index],
-       /*<<weak.ml:306:17>>*/ hashes =
-        caml_check_bound(t[2], index)[1 + index],
-       /*<<weak.ml:307:13>>*/ sz = length(bucket),
-      i = 0;
-      /*<<weak.ml:309:6>>*/ for(;;){
-      if(sz <= i)  /*<<weak.ml:309:22>>*/ return 0;
-      if(h === caml_check_bound(hashes, i)[1 + i]){
-        /*<<weak.ml:311:14>>*/  /*<<weak.ml:311:14>>*/ var
-        match = get_copy(bucket, i);
-       if(match){
-        var v = match[1];
-         /*<<weak.ml:312:22>>*/ if
-         ( /*<<weak.ml:312:22>>*/ caml_call2(H[1], v, d)){
-          /*<<weak.ml:313:26>>*/  /*<<weak.ml:313:26>>*/ var
-          v$0 = get(bucket, i);
-         if(v$0)  /*<<weak.ml:314:31>>*/ return v$0;
-          /*<<weak.ml:315:24>>*/ var
-           /*<<weak.ml:315:24>>*/ i$0 = i + 1 | 0,
-          i = i$0;
-         continue;
-        }
-       }
-        /*<<weak.ml:317:15>>*/ var
-         /*<<weak.ml:317:15>>*/ i$1 = i + 1 | 0,
-        i = i$1;
-      }
-      else
-        /*<<weak.ml:318:15>>*/ var
-         /*<<weak.ml:318:15>>*/ i$2 = i + 1 | 0,
-        i = i$2;
-     }
-     /*<<weak.ml:320:10>>*/ }
-    function find_shadow(t, d, iffound, ifnotfound){
-      /*<<weak.ml:324:4>>*/ var
-       /*<<weak.ml:324:12>>*/ h =  /*<<weak.ml:324:12>>*/ caml_call1(H[2], d),
-       /*<<weak.ml:325:16>>*/ index = get_index(t, h),
-       /*<<weak.ml:326:17>>*/ bucket =
-        caml_check_bound(t[1], index)[1 + index],
-       /*<<weak.ml:327:17>>*/ hashes =
-        caml_check_bound(t[2], index)[1 + index],
-       /*<<weak.ml:328:13>>*/ sz = length(bucket),
-      i = 0;
-      /*<<weak.ml:330:6>>*/ for(;;){
-      if(sz <= i) return ifnotfound;
-      if(h === caml_check_bound(hashes, i)[1 + i]){
-        /*<<weak.ml:332:14>>*/  /*<<weak.ml:332:14>>*/ var
-        match = get_copy(bucket, i);
-       if(match){
-        var v = match[1];
-         /*<<weak.ml:333:22>>*/ if
-         ( /*<<weak.ml:333:22>>*/ caml_call2(H[1], v, d))
-          /*<<weak.ml:333:37>>*/ return  /*<<weak.ml:333:37>>*/ caml_call2
-                 (iffound, bucket, i);
-       }
-        /*<<weak.ml:334:15>>*/ var
-         /*<<weak.ml:334:15>>*/ i$0 = i + 1 | 0,
-        i = i$0;
-      }
-      else
-        /*<<weak.ml:335:15>>*/ var
-         /*<<weak.ml:335:15>>*/ i$1 = i + 1 | 0,
-        i = i$1;
-     }
-     /*<<weak.ml:337:10>>*/ }
-    function remove(t, d){
-      /*<<weak.ml:340:19>>*/  /*<<weak.ml:340:19>>*/ var _k_ = 0;
-      /*<<weak.ml:340:19>>*/ return find_shadow
-             (t,
-              d,
-              function(w, i){
-                /*<<weak.ml:340:47>>*/ return set(w, i, 0);
-               /*<<weak.ml:340:59>>*/ },
-              _k_);
-     /*<<weak.ml:340:63>>*/ }
-    function mem(t, d){
-      /*<<weak.ml:343:16>>*/  /*<<weak.ml:343:16>>*/ var _j_ = 0;
-      /*<<weak.ml:343:16>>*/ return find_shadow
-             (t,
-              d,
-              function(w, i){
-                /*<<weak.ml:343:46>>*/ return 1;
-               /*<<weak.ml:343:50>>*/ },
-              _j_);
-     /*<<weak.ml:343:57>>*/ }
-    function find_all(t, d){
-      /*<<weak.ml:347:4>>*/ var
-       /*<<weak.ml:347:12>>*/ h =  /*<<weak.ml:347:12>>*/ caml_call1(H[2], d),
-       /*<<weak.ml:348:16>>*/ index = get_index(t, h),
-       /*<<weak.ml:349:17>>*/ bucket =
-        caml_check_bound(t[1], index)[1 + index],
-       /*<<weak.ml:350:17>>*/ hashes =
-        caml_check_bound(t[2], index)[1 + index],
-       /*<<weak.ml:351:13>>*/ sz = length(bucket),
-      i = 0,
-      accu = 0;
-      /*<<weak.ml:353:6>>*/ for(;;){
-      if(sz <= i)  /*<<weak.ml:353:22>>*/ return accu;
-      if(h === caml_check_bound(hashes, i)[1 + i]){
-        /*<<weak.ml:355:14>>*/  /*<<weak.ml:355:14>>*/ var
-        match = get_copy(bucket, i);
-       if(match){
-        var v = match[1];
-         /*<<weak.ml:356:22>>*/ if
-         ( /*<<weak.ml:356:22>>*/ caml_call2(H[1], v, d)){
-          /*<<weak.ml:357:26>>*/  /*<<weak.ml:357:26>>*/ var
-          match$0 = get(bucket, i);
-         if(match$0){
-           /*<<weak.ml:358:39>>*/ var
-           v$0 = match$0[1],
-            /*<<weak.ml:358:39>>*/ accu$0 = [0, v$0, accu],
-            /*<<weak.ml:358:39>>*/ i$0 = i + 1 | 0,
-           i = i$0,
-           accu = accu$0;
-          continue;
-         }
-         var i$1 = i + 1 | 0, i = i$1;
-         continue;
-        }
-       }
-       var i$2 = i + 1 | 0, i = i$2;
-      }
-      else
-       var i$3 = i + 1 | 0, i = i$3;
-     }
-     /*<<weak.ml:364:13>>*/ }
-    function stats(t){
-      /*<<weak.ml:368:4>>*/ var
-      len = t[1].length - 1,
-       /*<<weak.ml:369:15>>*/ lens =
-         /*<<weak.ml:369:15>>*/ caml_call2(Stdlib_Array[13], length, t[1]);
-      /*<<weak.ml:370:4>>*/  /*<<weak.ml:370:4>>*/ caml_call2
-      (Stdlib_Array[30], runtime.caml_int_compare, lens);
-     var _a_ = 0;
-     function _b_(_i_, _h_){ /*<<?>>*/ return _i_ + _h_ | 0;}
-      /*<<weak.ml:371:17>>*/ var
-       /*<<weak.ml:371:17>>*/ totlen =
-         /*<<weak.ml:371:17>>*/ caml_call3(Stdlib_Array[15], _b_, _a_, lens),
-       /*<<weak.ml:371:17>>*/ _c_ = len - 1 | 0,
-      _e_ = len / 2 | 0,
-       /*<<weak.ml:372:51>>*/ _d_ = caml_check_bound(lens, _c_)[1 + _c_],
-       /*<<weak.ml:372:37>>*/ _f_ = caml_check_bound(lens, _e_)[1 + _e_],
-       /*<<weak.ml:372:27>>*/ _g_ = caml_check_bound(lens, 0)[1];
-      /*<<weak.ml:372:4>>*/ return [0, len, count(t), totlen, _g_, _f_, _d_];
-     /*<<weak.ml:372:64>>*/ }
-     /*<<weak.ml:101:66>>*/ return [0,
-            create$0,
-            clear,
-            merge,
-            add,
-            remove,
-            find,
-            find_opt,
-            find_all,
-            mem,
-            iter,
-            fold,
-            count,
-            stats];
-   }
-   var
-    Stdlib_Weak =
-      [0, create, length, set, get, get_copy, check, fill, blit, Make];
-   runtime.caml_register_global(13, Stdlib_Weak, "Stdlib__Weak");
-   return;
-   /*<<?>>*/ }
-  (globalThis));
-
-//# unitInfo: Provides: Stdlib__Format
-//# unitInfo: Requires: CamlinternalFormat, Stdlib, Stdlib__Buffer, Stdlib__Bytes, Stdlib__Domain, Stdlib__Int, Stdlib__List, Stdlib__Queue, Stdlib__Stack, Stdlib__String
-(function
-  (globalThis){
-   "use strict";
-   var
-    runtime = globalThis.jsoo_runtime,
-    cst$16 = "",
-    cst$15 = ">",
-    caml_maybe_attach_backtrace = runtime.caml_maybe_attach_backtrace,
-    caml_ml_string_length = runtime.caml_ml_string_length;
-    /*<<?>>*/ function caml_call1(f, a0){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 1
-            ? f(a0)
-            : runtime.caml_call_gen(f, [a0]);
-   }
-    /*<<?>>*/ function caml_call2(f, a0, a1){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 2
-            ? f(a0, a1)
-            : runtime.caml_call_gen(f, [a0, a1]);
-   }
-    /*<<?>>*/ function caml_call3(f, a0, a1, a2){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 3
-            ? f(a0, a1, a2)
-            : runtime.caml_call_gen(f, [a0, a1, a2]);
-   }
-    /*<<?>>*/ function caml_call4(f, a0, a1, a2, a3){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 4
-            ? f(a0, a1, a2, a3)
-            : runtime.caml_call_gen(f, [a0, a1, a2, a3]);
-   }
-   var
-    global_data = runtime.caml_get_global_data(),
-    cst$14 = ".",
-    cst$11 = cst$15,
-    cst$12 = "<\/",
-    cst$13 = cst$16,
-    cst$8 = cst$15,
-    cst$9 = "<",
-    cst$10 = cst$16,
-    cst$7 = "\n",
-    cst$3 = cst$16,
-    cst$4 = cst$16,
-    cst$5 = cst$16,
-    cst$6 = cst$16,
-    cst = cst$16,
-    cst$0 = cst$16,
-    cst$1 = cst$16,
-    cst$2 = cst$16,
-    Stdlib_Queue = global_data.Stdlib__Queue,
-    CamlinternalFormat = global_data.CamlinternalFormat,
-    Stdlib = global_data.Stdlib,
-    Stdlib_String = global_data.Stdlib__String,
-    Stdlib_Domain = global_data.Stdlib__Domain,
-    Stdlib_Buffer = global_data.Stdlib__Buffer,
-    Stdlib_List = global_data.Stdlib__List,
-    Stdlib_Stack = global_data.Stdlib__Stack,
-    Stdlib_Int = global_data.Stdlib__Int,
-    Stdlib_Bytes = global_data.Stdlib__Bytes,
-    _f_ = [3, 0, 3],
-    cst_Format_pp_set_geometry = "Format.pp_set_geometry: ",
-    _e_ = [1, "max_indent < 2"],
-    _c_ = [1, "margin <= max_indent"],
-    _d_ = [0, 0],
-    _b_ = [0, cst$16],
-    _a_ = [0, cst$16, 0, cst$16],
-    cst_Stdlib_Format_String_tag = "Stdlib.Format.String_tag";
-   function id(x){ /*<<format.ml:23:11>>*/ return x; /*<<format.ml:23:12>>*/ }
-    /*<<format.ml:91:13>>*/ var
-     /*<<format.ml:91:13>>*/ String_tag =
-      [248, cst_Stdlib_Format_String_tag, runtime.caml_fresh_oo_id(0)],
-    zero = 0,
-    unknown = -1;
-   function pp_enqueue(state, token){
-     /*<<format.ml:219:2>>*/ state[13] = state[13] + token[3] | 0;
-    return caml_call2(Stdlib_Queue[3], token, state[28]);
-    /*<<format.ml:220:32>>*/ }
-   var pp_infinity = 1000000010;
-   function pp_output_string(state, s){
-     /*<<format.ml:251:31>>*/ return caml_call3
-            (state[17], s, 0, caml_ml_string_length(s));
-    /*<<format.ml:251:72>>*/ }
-   function pp_output_newline(state){
-     /*<<format.ml:252:30>>*/ return  /*<<format.ml:252:30>>*/ caml_call1
-            (state[19], 0);
-    /*<<format.ml:252:53>>*/ }
-   function format_pp_text(state, size, text){
-     /*<<format.ml:258:2>>*/ state[9] = state[9] - size | 0;
-     /*<<format.ml:259:2>>*/ pp_output_string(state, text);
-    state[11] = 0;
-    return 0;
-    /*<<format.ml:260:31>>*/ }
-   function format_string(state, s){
-     /*<<format.ml:264:2>>*/  /*<<format.ml:264:5>>*/ var
-     _bQ_ =  /*<<format.ml:264:5>>*/ runtime.caml_string_notequal(s, cst$16);
-     /*<<format.ml:264:5>>*/ return _bQ_
-            ? format_pp_text(state, caml_ml_string_length(s), s)
-            : _bQ_;
-    /*<<format.ml:264:58>>*/ }
-   function break_new_line(state, param, width){
-    var after = param[3], offset = param[2], before = param[1];
-     /*<<format.ml:268:2>>*/ format_string(state, before);
-     /*<<format.ml:269:2>>*/ pp_output_newline(state);
-    state[11] = 1;
-     /*<<format.ml:273:20>>*/ var
-     indent = (state[6] - width | 0) + offset | 0,
-      /*<<format.ml:273:20>>*/ real_indent =
-        /*<<format.ml:273:20>>*/ caml_call2(Stdlib_Int[10], state[8], indent);
-    state[10] = real_indent;
-    state[9] = state[6] - state[10] | 0;
-    var n = state[10];
-     /*<<format.ml:254:31>>*/  /*<<format.ml:254:31>>*/ caml_call1
-     (state[21], n);
-     /*<<format.ml:276:2>>*/ return format_string(state, after);
-   }
-   function break_line(state, width){
-     /*<<format.ml:281:29>>*/ return break_new_line(state, _a_, width);
-    /*<<format.ml:281:67>>*/ }
-   function break_same_line(state, param){
-    var after = param[3], width = param[2], before = param[1];
-     /*<<format.ml:285:2>>*/ format_string(state, before);
-    state[9] = state[9] - width | 0;
-     /*<<format.ml:253:31>>*/  /*<<format.ml:253:31>>*/ caml_call1
-     (state[20], width);
-     /*<<format.ml:287:2>>*/ return format_string(state, after);
-   }
-   function format_pp_token(state, size$0, param){
-     /*<<?>>*/ if(typeof param === "number")
-     switch(param){
-       case 0:
-         /*<<format.ml:348:16>>*/  /*<<format.ml:348:16>>*/ var
-         match$3 =
-            /*<<format.ml:348:16>>*/ caml_call1(Stdlib_Stack[7], state[3]);
-        if(! match$3)  /*<<format.ml:349:14>>*/ return 0;
-         /*<<format.ml:351:6>>*/ var
-         tabs = match$3[1][1],
-          /*<<format.ml:351:6>>*/ add_tab =
-           function(n, ls){
-             /*<<?>>*/ if(! ls)  /*<<format.ml:352:16>>*/ return [0, n, 0];
-            var l = ls[2], x = ls[1];
-             /*<<format.ml:353:29>>*/ return  /*<<format.ml:353:29>>*/ runtime.caml_lessthan
-                     (n, x)
-                    ? [0, n, ls]
-                    : [0, x, add_tab(n, l)];
-           };
-        tabs[1] = add_tab(state[6] - state[9] | 0, tabs[1]);
-        return 0;
-       case 1:
-         /*<<format.ml:339:4>>*/  /*<<format.ml:339:4>>*/ caml_call1
-         (Stdlib_Stack[5], state[2]);
-         /*<<format.ml:339:4>>*/ return 0;
-       case 2:
-         /*<<format.ml:345:4>>*/  /*<<format.ml:345:4>>*/ caml_call1
-         (Stdlib_Stack[5], state[3]);
-         /*<<format.ml:345:4>>*/ return 0;
-       case 3:
-         /*<<format.ml:378:16>>*/  /*<<format.ml:378:16>>*/ var
-         match$4 =
-            /*<<format.ml:378:16>>*/ caml_call1(Stdlib_Stack[7], state[2]);
-        if(! match$4)
-          /*<<format.ml:379:14>>*/ return pp_output_newline(state);
-        var width$0 = match$4[1][2];
-         /*<<format.ml:380:26>>*/ return break_line(state, width$0);
-       case 4:
-        var _bO_ = state[10] !== (state[6] - state[9] | 0) ? 1 : 0;
-        if(! _bO_) return _bO_;
-         /*<<format.ml:306:8>>*/  /*<<format.ml:306:8>>*/ var
-         match$1 =
-            /*<<format.ml:306:8>>*/ caml_call1(Stdlib_Queue[6], state[28]);
-        if(! match$1)  /*<<format.ml:307:12>>*/ return 0;
-        var match$2 = match$1[1], size = match$2[1], length = match$2[3];
-        state[12] = state[12] - length | 0;
-        state[9] = state[9] + size | 0;
-        return 0;
-       default:
-         /*<<format.ml:419:17>>*/  /*<<format.ml:419:17>>*/ var
-         match$5 =
-            /*<<format.ml:419:17>>*/ caml_call1(Stdlib_Stack[5], state[5]);
-        if(! match$5)  /*<<format.ml:420:15>>*/ return 0;
-         /*<<format.ml:422:20>>*/ var
-         tag_name = match$5[1],
-          /*<<format.ml:422:20>>*/ marker =
-            /*<<format.ml:422:20>>*/ caml_call1(state[25], tag_name);
-         /*<<format.ml:423:7>>*/ return pp_output_string(state, marker);
-     }
-    switch(param[0]){
-      case 0:
-       var s = param[1];
-        /*<<format.ml:323:4>>*/ return format_pp_text(state, size$0, s);
-      case 1:
-        /*<<format.ml:388:4>>*/ var
-        breaks = param[2],
-        fits = param[1],
-         /*<<format.ml:388:4>>*/ off = breaks[2],
-        before = breaks[1],
-         /*<<format.ml:389:16>>*/ match$6 =
-           /*<<format.ml:389:16>>*/ caml_call1(Stdlib_Stack[7], state[2]);
-       if(! match$6)  /*<<format.ml:390:14>>*/ return 0;
-       var
-        match$7 = match$6[1],
-        width$1 = match$7[2],
-        box_type$0 = match$7[1];
-        /*<<format.ml:392:6>>*/ switch(box_type$0){
-         case 0:
-           /*<<format.ml:409:19>>*/ return break_same_line(state, fits);
-         case 1:
-           /*<<format.ml:408:19>>*/ return break_new_line
-                  (state, breaks, width$1);
-         case 2:
-           /*<<format.ml:406:20>>*/ return break_new_line
-                  (state, breaks, width$1);
-         case 3:
-          return state[9] < (size$0 + caml_ml_string_length(before) | 0)
-                  ? break_new_line(state, breaks, width$1)
-                  : break_same_line(state, fits);
-         case 4:
-          return state[11]
-                  ? break_same_line(state, fits)
-                  : state
-                     [9]
-                    < (size$0 + caml_ml_string_length(before) | 0)
-                    ? break_new_line(state, breaks, width$1)
-                    : ((state
-                       [6]
-                      - width$1
-                      | 0)
-                      + off
-                      | 0)
-                      < state[10]
-                      ? break_new_line(state, breaks, width$1)
-                      : break_same_line(state, fits);
-         default:
-           /*<<format.ml:407:19>>*/ return break_same_line(state, fits);
-       }
-      case 2:
-        /*<<format.ml:359:16>>*/ var
-        off$0 = param[2],
-        n = param[1],
-        insertion_point = state[6] - state[9] | 0,
-         /*<<format.ml:359:16>>*/ match$8 =
-           /*<<format.ml:359:16>>*/ caml_call1(Stdlib_Stack[7], state[3]);
-       if(! match$8)  /*<<format.ml:360:14>>*/ return 0;
-        /*<<format.ml:362:6>>*/ var
-        tabs$0 = match$8[1][1],
-         /*<<format.ml:362:6>>*/ match$9 = tabs$0[1];
-       if(match$9){
-        var first = match$9[1], param$0 = tabs$0[1];
-         /*<<format.ml:366:25>>*/ for(;;){
-         if(param$0){
-          var tail = param$0[2], head = param$0[1];
-          if(insertion_point > head){var param$0 = tail; continue;}
-          var _bP_ = head;
-         }
-         else
-          var _bP_ = first;
-         var tab = _bP_;
-         break;
-        }
-       }
-       else
-        var tab = insertion_point;
-       var offset = tab - insertion_point | 0;
-        /*<<format.ml:372:6>>*/ return 0 <= offset
-               ? break_same_line(state, [0, cst$0, offset + n | 0, cst])
-               : break_new_line
-                 (state, [0, cst$2, tab + off$0 | 0, cst$1], state[6]);
-      case 3:
-       var
-        ty = param[2],
-        off$1 = param[1],
-        insertion_point$0 = state[6] - state[9] | 0;
-       if(state[8] < insertion_point$0){
-         /*<<format.ml:295:8>>*/  /*<<format.ml:295:8>>*/ var
-         match =
-            /*<<format.ml:295:8>>*/ caml_call1(Stdlib_Stack[7], state[2]);
-        if(match){
-         var match$0 = match[1], width = match$0[2], box_type = match$0[1];
-         if(state[9] < width && 3 >= box_type - 1 >>> 0)
-           /*<<format.ml:301:51>>*/ break_line(state, width);
-        }
-        else
-          /*<<format.ml:296:12>>*/ pp_output_newline(state);
-       }
-        /*<<format.ml:331:4>>*/ var
-        width$2 = state[9] - off$1 | 0,
-         /*<<format.ml:331:4>>*/ box_type$1 =
-          1 === ty ? 1 : state[9] < size$0 ? ty : 5;
-        /*<<format.ml:336:4>>*/ return  /*<<format.ml:336:4>>*/ caml_call2
-               (Stdlib_Stack[3], [0, box_type$1, width$2], state[2]);
-      case 4:
-       var tbox = param[1];
-        /*<<format.ml:342:4>>*/ return  /*<<format.ml:342:4>>*/ caml_call2
-               (Stdlib_Stack[3], tbox, state[3]);
-      default:
-        /*<<format.ml:414:18>>*/ var
-        tag_name$0 = param[1],
-         /*<<format.ml:414:18>>*/ marker$0 =
-           /*<<format.ml:414:18>>*/ caml_call1(state[24], tag_name$0);
-        /*<<format.ml:415:5>>*/ pp_output_string(state, marker$0);
-       return caml_call2(Stdlib_Stack[3], tag_name$0, state[5]);
-    }
-   }
-   function advance_left(state){
-     /*<<format.ml:431:2>>*/ for(;;){
-      /*<<format.ml:431:8>>*/  /*<<format.ml:431:8>>*/ var
-      match =  /*<<format.ml:431:8>>*/ caml_call1(Stdlib_Queue[9], state[28]);
-     if(! match)  /*<<format.ml:432:12>>*/ return 0;
-      /*<<format.ml:435:7>>*/ var
-      match$0 = match[1],
-      size = match$0[1],
-      length = match$0[3],
-      token = match$0[2],
-      pending_count = state[13] - state[12] | 0,
-       /*<<format.ml:435:7>>*/ _bM_ = 0 <= size ? 1 : 0,
-       /*<<format.ml:435:7>>*/ _bN_ =
-        _bM_ || (state[9] <= pending_count ? 1 : 0);
-     if(! _bN_)  /*<<format.ml:435:7>>*/ return _bN_;
-      /*<<format.ml:436:6>>*/  /*<<format.ml:436:6>>*/ caml_call1
-      (Stdlib_Queue[5], state[28]);
-      /*<<format.ml:437:20>>*/  /*<<format.ml:437:20>>*/ var
-      size$0 = 0 <= size ? size : pp_infinity;
-      /*<<format.ml:438:6>>*/ format_pp_token(state, size$0, token);
-     state[12] = length + state[12] | 0;
-    }
-    /*<<format.ml:441:7>>*/ }
-   function enqueue_advance(state, tok){
-     /*<<format.ml:445:32>>*/ pp_enqueue(state, tok);
-     /*<<format.ml:445:32>>*/ return advance_left(state);
-    /*<<format.ml:445:72>>*/ }
-   function enqueue_string_as(state, size, s){
-     /*<<format.ml:450:2>>*/ return enqueue_advance
-            (state, [0, size, [0, s], size]);
-    /*<<format.ml:450:78>>*/ }
-   function initialize_scan_stack(stack){
-     /*<<format.ml:462:2>>*/  /*<<format.ml:462:2>>*/ caml_call1
-     (Stdlib_Stack[8], stack);
-     /*<<format.ml:463:19>>*/  /*<<format.ml:463:19>>*/ var
-     queue_elem = [0, unknown, _b_, 0];
-     /*<<format.ml:464:2>>*/ return  /*<<format.ml:464:2>>*/ caml_call2
-            (Stdlib_Stack[3], [0, -1, queue_elem], stack);
-    /*<<format.ml:464:50>>*/ }
-   function set_size(state, ty){
-     /*<<format.ml:476:2>>*/  /*<<format.ml:476:8>>*/ var
-     match =  /*<<format.ml:476:8>>*/ caml_call1(Stdlib_Stack[7], state[1]);
-    if(! match)  /*<<format.ml:477:12>>*/ return 0;
-     /*<<format.ml:479:4>>*/ var
-     match$0 = match[1],
-     queue_elem = match$0[2],
-     left_total = match$0[1],
-      /*<<format.ml:479:4>>*/ size = queue_elem[1];
-    if(left_total < state[12]) return initialize_scan_stack(state[1]);
-    var _bI_ = queue_elem[2];
-    if(typeof _bI_ !== "number")
-     switch(_bI_[0]){
-       case 3:
-        var
-         _bK_ = 1 - ty,
-         _bL_ =
-           _bK_
-            ? (queue_elem
-               [1]
-              = state[13] + size | 0,
-               /*<<format.ml:493:10>>*/ caml_call1(Stdlib_Stack[5], state[1]),
-              0)
-            : _bK_;
-         /*<<format.ml:493:10>>*/ return _bL_;
-       case 1:
-       case 2:
-        var
-         _bJ_ =
-           ty
-            ? (queue_elem
-               [1]
-              = state[13] + size | 0,
-               /*<<format.ml:488:10>>*/ caml_call1(Stdlib_Stack[5], state[1]),
-              0)
-            : ty;
-         /*<<format.ml:488:10>>*/ return _bJ_;
-     }
-     /*<<format.ml:497:8>>*/ return 0;
-    /*<<format.ml:497:10>>*/ }
-   function scan_push(state, b, token){
-     /*<<format.ml:503:2>>*/ pp_enqueue(state, token);
-    if(b)  /*<<format.ml:504:12>>*/ set_size(state, 1);
-     /*<<format.ml:505:13>>*/  /*<<format.ml:505:13>>*/ var
-     elem = [0, state[13], token];
-     /*<<format.ml:506:2>>*/ return  /*<<format.ml:506:2>>*/ caml_call2
-            (Stdlib_Stack[3], elem, state[1]);
-    /*<<format.ml:506:37>>*/ }
-   function pp_open_box_gen(state, indent, br_ty){
-     /*<<format.ml:513:2>>*/ state[14] = state[14] + 1 | 0;
-    if(state[14] < state[15]){
-      /*<<format.ml:516:15>>*/ var
-      size = - state[13] | 0,
-       /*<<format.ml:516:15>>*/ elem = [0, size, [3, indent, br_ty], 0];
-      /*<<format.ml:517:4>>*/ return scan_push(state, 0, elem);
-    }
-    var _bH_ = state[14] === state[15] ? 1 : 0;
-    if(! _bH_) return _bH_;
-    var s = state[16];
-     /*<<format.ml:454:2>>*/ return enqueue_string_as
-            (state, caml_ml_string_length(s), s);
-    /*<<format.ml:519:45>>*/ }
-   function pp_close_box(state, param){
-     /*<<format.ml:527:2>>*/ var _bF_ = 1 < state[14] ? 1 : 0;
-    if(_bF_){
-     if(state[14] < state[15]){
-       /*<<format.ml:531:6>>*/ pp_enqueue(state, [0, zero, 1, 0]);
-       /*<<format.ml:532:6>>*/ set_size(state, 1);
-       /*<<format.ml:532:27>>*/ set_size(state, 0);
-     }
-     state[14] = state[14] - 1 | 0;
-     var _bG_ = 0;
-    }
-    else
-     var _bG_ = _bF_;
-    return _bG_;
-    /*<<format.ml:535:5>>*/ }
-   function pp_open_stag(state, tag_name){
-     /*<<format.ml:540:2>>*/ if(state[22]){
-      /*<<format.ml:542:4>>*/  /*<<format.ml:542:4>>*/ caml_call2
-      (Stdlib_Stack[3], tag_name, state[4]);
-      /*<<format.ml:543:4>>*/  /*<<format.ml:543:4>>*/ caml_call1
-      (state[26], tag_name);
-    }
-    var _bE_ = state[23];
-    if(! _bE_) return _bE_;
-     /*<<format.ml:546:16>>*/  /*<<format.ml:546:16>>*/ var
-     token = [5, tag_name];
-     /*<<format.ml:547:21>>*/ return pp_enqueue(state, [0, zero, token, 0]);
-    /*<<format.ml:547:60>>*/ }
-   function pp_close_stag(state, param){
-     /*<<format.ml:552:2>>*/ if(state[23])
-      /*<<format.ml:553:4>>*/ pp_enqueue(state, [0, zero, 5, 0]);
-    var _bC_ = state[22];
-    if(_bC_){
-      /*<<format.ml:555:10>>*/  /*<<format.ml:555:10>>*/ var
-      match =  /*<<format.ml:555:10>>*/ caml_call1(Stdlib_Stack[5], state[4]);
-     if(match){
-      var tag_name = match[1];
-       /*<<format.ml:558:6>>*/ return  /*<<format.ml:558:6>>*/ caml_call1
-              (state[27], tag_name);
-     }
-     var _bD_ = 0;
-    }
-    else
-     var _bD_ = _bC_;
-     /*<<format.ml:556:14>>*/ return _bD_;
-    /*<<format.ml:558:39>>*/ }
-   function pp_set_print_tags(state, b){
-     /*<<format.ml:560:32>>*/ state[22] = b;
-    return 0;
-    /*<<format.ml:560:56>>*/ }
-   function pp_set_mark_tags(state, b){
-     /*<<format.ml:561:31>>*/ state[23] = b;
-    return 0;
-    /*<<format.ml:561:54>>*/ }
-   function pp_get_print_tags(state, param){
-     /*<<format.ml:562:33>>*/ return state[22];
-    /*<<format.ml:562:52>>*/ }
-   function pp_get_mark_tags(state, param){
-     /*<<format.ml:563:32>>*/ return state[23];
-    /*<<format.ml:563:50>>*/ }
-   function pp_set_tags(state, b){
-     /*<<format.ml:565:2>>*/ pp_set_print_tags(state, b);
-     /*<<format.ml:565:2>>*/ return pp_set_mark_tags(state, b);
-    /*<<format.ml:565:53>>*/ }
-   function pp_get_formatter_stag_function(state, param){
-     /*<<format.ml:569:47>>*/ return [0,
-            state[24],
-            state[25],
-            state[26],
-            state[27]];
-    /*<<format.ml:574:1>>*/ }
-   function pp_set_formatter_stag_function(state, param){
-    var pct = param[4], pot = param[3], mct = param[2], mot = param[1];
-    state[24] = mot;
-    state[25] = mct;
-    state[26] = pot;
-    state[27] = pct;
-    return 0;
-   }
-   function pp_rinit(state){
-     /*<<format.ml:591:2>>*/ state[12] = 1;
-    state[13] = 1;
-    caml_call1(Stdlib_Queue[11], state[28]);
-     /*<<format.ml:592:2>>*/ initialize_scan_stack(state[1]);
-     /*<<format.ml:593:2>>*/  /*<<format.ml:593:2>>*/ caml_call1
-     (Stdlib_Stack[8], state[2]);
-     /*<<format.ml:594:2>>*/  /*<<format.ml:594:2>>*/ caml_call1
-     (Stdlib_Stack[8], state[3]);
-     /*<<format.ml:595:2>>*/  /*<<format.ml:595:2>>*/ caml_call1
-     (Stdlib_Stack[8], state[4]);
-     /*<<format.ml:596:2>>*/  /*<<format.ml:596:2>>*/ caml_call1
-     (Stdlib_Stack[8], state[5]);
-    state[10] = 0;
-    state[14] = 0;
-    state[9] = state[6];
-     /*<<format.ml:523:28>>*/ return pp_open_box_gen(state, 0, 3);
-    /*<<format.ml:600:23>>*/ }
-   function pp_flush_queue(state, b){
-     /*<<format.ml:608:2>>*/ var _bA_ = state[4];
-    function _bB_(param){
-      /*<<format.ml:603:23>>*/ return pp_close_stag(state, 0);
-     /*<<format.ml:603:45>>*/ }
-     /*<<format.ml:603:13>>*/  /*<<format.ml:603:13>>*/ caml_call2
-     (Stdlib_Stack[12], _bB_, _bA_);
-     /*<<format.ml:610:4>>*/ for(;;){
-     if(1 >= state[14]){
-      state[13] = pp_infinity;
-       /*<<format.ml:613:2>>*/ advance_left(state);
-      if(b)  /*<<format.ml:614:12>>*/ pp_output_newline(state);
-       /*<<format.ml:614:12>>*/ return pp_rinit(state);
-     }
-      /*<<format.ml:610:4>>*/ pp_close_box(state, 0);
-    }
-    /*<<format.ml:615:16>>*/ }
-   function pp_print_as_size(state, size, s){
-     /*<<format.ml:625:2>>*/ var _bz_ = state[14] < state[15] ? 1 : 0;
-    return _bz_ ? enqueue_string_as(state, size, s) : _bz_;
-    /*<<format.ml:626:37>>*/ }
-   function pp_print_as(state, isize, s){
-     /*<<format.ml:630:2>>*/ return pp_print_as_size(state, isize, s);
-    /*<<format.ml:630:46>>*/ }
-   function pp_print_string(state, s){
-     /*<<format.ml:634:2>>*/ return pp_print_as
-            (state, caml_ml_string_length(s), s);
-    /*<<format.ml:634:39>>*/ }
-   function pp_print_bytes(state, s){
-     /*<<format.ml:637:2>>*/ return pp_print_as
-            (state,
-             runtime.caml_ml_bytes_length(s),
-              /*<<format.ml:637:37>>*/ caml_call1(Stdlib_Bytes[6], s));
-    /*<<format.ml:637:56>>*/ }
-   function pp_print_int(state, i){
-     /*<<format.ml:640:27>>*/ return pp_print_string
-            (state,  /*<<format.ml:640:49>>*/ caml_call1(Stdlib_Int[12], i));
-    /*<<format.ml:640:66>>*/ }
-   function pp_print_float(state, f){
-     /*<<format.ml:643:29>>*/ return pp_print_string
-            (state,  /*<<format.ml:643:51>>*/ caml_call1(Stdlib[35], f));
-    /*<<format.ml:643:70>>*/ }
-   function pp_print_bool(state, b){
-     /*<<format.ml:646:28>>*/ return pp_print_string
-            (state,  /*<<format.ml:646:50>>*/ caml_call1(Stdlib[30], b));
-    /*<<format.ml:646:68>>*/ }
-   function pp_print_char(state, c){
-     /*<<format.ml:650:2>>*/ return pp_print_as
-            (state,
-             1,
-              /*<<format.ml:650:22>>*/ caml_call2(Stdlib_String[1], 1, c));
-    /*<<format.ml:650:39>>*/ }
-   function pp_open_hbox(state, param){
-     /*<<format.ml:654:28>>*/ return pp_open_box_gen(state, 0, 0);
-    /*<<format.ml:654:59>>*/ }
-   function pp_open_vbox(state, indent){
-     /*<<format.ml:655:32>>*/ return pp_open_box_gen(state, indent, 1);
-    /*<<format.ml:655:68>>*/ }
-   function pp_open_hvbox(state, indent){
-     /*<<format.ml:657:33>>*/ return pp_open_box_gen(state, indent, 2);
-    /*<<format.ml:657:70>>*/ }
-   function pp_open_hovbox(state, indent){
-     /*<<format.ml:658:34>>*/ return pp_open_box_gen(state, indent, 3);
-    /*<<format.ml:658:72>>*/ }
-   function pp_open_box(state, indent){
-     /*<<format.ml:659:31>>*/ return pp_open_box_gen(state, indent, 4);
-    /*<<format.ml:659:66>>*/ }
-   function pp_print_newline(state, param){
-     /*<<format.ml:671:2>>*/ pp_flush_queue(state, 1);
-     /*<<format.ml:671:2>>*/ return  /*<<format.ml:671:2>>*/ caml_call1
-            (state[18], 0);
-    /*<<format.ml:671:50>>*/ }
-   function pp_print_flush(state, param){
-     /*<<format.ml:673:2>>*/ pp_flush_queue(state, 0);
-     /*<<format.ml:673:2>>*/ return  /*<<format.ml:673:2>>*/ caml_call1
-            (state[18], 0);
-    /*<<format.ml:673:51>>*/ }
-   function pp_force_newline(state, param){
-     /*<<format.ml:678:2>>*/ var _by_ = state[14] < state[15] ? 1 : 0;
-    return _by_ ? enqueue_advance(state, [0, zero, 3, 0]) : _by_;
-    /*<<format.ml:679:78>>*/ }
-   function pp_print_if_newline(state, param){
-     /*<<format.ml:684:2>>*/ var _bx_ = state[14] < state[15] ? 1 : 0;
-    return _bx_ ? enqueue_advance(state, [0, zero, 4, 0]) : _bx_;
-    /*<<format.ml:686:61>>*/ }
-   function pp_print_custom_break(state, fits, breaks){
-     /*<<format.ml:692:2>>*/ var
-     after = fits[3],
-     width = fits[2],
-     before = fits[1],
-     _bw_ = state[14] < state[15] ? 1 : 0;
-    if(! _bw_) return _bw_;
-     /*<<format.ml:695:25>>*/ var
-     size = - state[13] | 0,
-      /*<<format.ml:695:25>>*/ token = [1, fits, breaks],
-     length =
-       (caml_ml_string_length(before) + width | 0)
-       +  /*<<format.ml:696:4>>*/ caml_ml_string_length(after)
-       | 0,
-      /*<<format.ml:697:15>>*/ elem = [0, size, token, length];
-     /*<<format.ml:698:4>>*/ return scan_push(state, 1, elem);
-    /*<<format.ml:698:29>>*/ }
-   function pp_print_break(state, width, offset){
-     /*<<format.ml:705:2>>*/ return pp_print_custom_break
-            (state, [0, cst$6, width, cst$5], [0, cst$4, offset, cst$3]);
-    /*<<format.ml:706:50>>*/ }
-   function pp_print_space(state, param){
-     /*<<format.ml:714:30>>*/ return pp_print_break(state, 1, 0);
-    /*<<format.ml:714:54>>*/ }
-   function pp_print_cut(state, param){
-     /*<<format.ml:715:28>>*/ return pp_print_break(state, 0, 0);
-    /*<<format.ml:715:52>>*/ }
-   function pp_open_tbox(state, param){
-     /*<<format.ml:720:2>>*/ state[14] = state[14] + 1 | 0;
-    var _bv_ = state[14] < state[15] ? 1 : 0;
-    if(! _bv_) return _bv_;
-     /*<<format.ml:723:15>>*/  /*<<format.ml:723:15>>*/ var
-     elem = [0, zero, [4, [0, [0, 0]]], 0];
-     /*<<format.ml:724:4>>*/ return enqueue_advance(state, elem);
-    /*<<format.ml:724:30>>*/ }
-   function pp_close_tbox(state, param){
-     /*<<format.ml:729:2>>*/ var _bs_ = 1 < state[14] ? 1 : 0;
-    if(_bs_){
-     var _bt_ = state[14] < state[15] ? 1 : 0;
-     if(_bt_){
-       /*<<format.ml:732:16>>*/  /*<<format.ml:732:16>>*/ var
-       elem = [0, zero, 2, 0];
-       /*<<format.ml:733:5>>*/ enqueue_advance(state, elem);
-      state[14] = state[14] - 1 | 0;
-      var _bu_ = 0;
-     }
-     else
-      var _bu_ = _bt_;
-    }
-    else
-     var _bu_ = _bs_;
-    return _bu_;
-    /*<<format.ml:735:5>>*/ }
-   function pp_print_tbreak(state, width, offset){
-     /*<<format.ml:740:2>>*/ var _br_ = state[14] < state[15] ? 1 : 0;
-    if(! _br_) return _br_;
-     /*<<format.ml:742:15>>*/ var
-     size = - state[13] | 0,
-      /*<<format.ml:742:15>>*/ elem = [0, size, [2, width, offset], width];
-     /*<<format.ml:743:4>>*/ return scan_push(state, 1, elem);
-    /*<<format.ml:743:29>>*/ }
-   function pp_print_tab(state, param){
-     /*<<format.ml:746:28>>*/ return pp_print_tbreak(state, 0, 0);
-    /*<<format.ml:746:53>>*/ }
-   function pp_set_tab(state, param){
-     /*<<format.ml:749:2>>*/ var _bq_ = state[14] < state[15] ? 1 : 0;
-    if(! _bq_) return _bq_;
-     /*<<format.ml:750:15>>*/  /*<<format.ml:750:15>>*/ var
-     elem = [0, zero, 0, 0];
-     /*<<format.ml:751:4>>*/ return enqueue_advance(state, elem);
-    /*<<format.ml:751:30>>*/ }
-   function pp_set_max_boxes(state, n){
-     /*<<format.ml:761:31>>*/ var
-     _bo_ = 1 < n ? 1 : 0,
-     _bp_ = _bo_ ? (state[15] = n, 0) : _bo_;
-    return _bp_;
-    /*<<format.ml:761:68>>*/ }
-   function pp_get_max_boxes(state, param){
-     /*<<format.ml:764:32>>*/ return state[15];
-    /*<<format.ml:764:50>>*/ }
-   function pp_over_max_boxes(state, param){
-     /*<<format.ml:766:33>>*/ return state[14] === state[15] ? 1 : 0;
-    /*<<format.ml:766:73>>*/ }
-   function pp_set_ellipsis_text(state, s){
-     /*<<format.ml:769:35>>*/ state[16] = s;
-    return 0;
-    /*<<format.ml:769:57>>*/ }
-   function pp_get_ellipsis_text(state, param){
-     /*<<format.ml:770:36>>*/ return state[16];
-    /*<<format.ml:770:53>>*/ }
-   function pp_limit(n){
-     /*<<format.ml:775:2>>*/ return n < 1000000010 ? n : 1000000009;
-    /*<<format.ml:775:49>>*/ }
-   function pp_set_max_indent(state, n$0){
-     /*<<format.ml:791:2>>*/ var _bn_ = 1 < n$0 ? 1 : 0;
-    if(! _bn_) return _bn_;
-    var n$1 = state[6] - n$0 | 0, _bm_ = 1 <= n$1 ? 1 : 0;
-    if(! _bm_) return _bm_;
-     /*<<format.ml:781:12>>*/  /*<<format.ml:781:12>>*/ var n = pp_limit(n$1);
-    state[7] = n;
-    state[8] = state[6] - state[7] | 0;
-     /*<<format.ml:784:4>>*/ return pp_rinit(state);
-    /*<<format.ml:792:53>>*/ }
-   function pp_get_max_indent(state, param){
-     /*<<format.ml:795:33>>*/ return state[8];
-    /*<<format.ml:795:52>>*/ }
-   function pp_set_margin(state, n){
-     /*<<format.ml:798:2>>*/ var _bk_ = 1 <= n ? 1 : 0;
-    if(! _bk_) return _bk_;
-     /*<<format.ml:799:12>>*/  /*<<format.ml:799:12>>*/ var n$0 = pp_limit(n);
-    state[6] = n$0;
-    if(state[8] <= state[6])
-     var new_max_indent = state[8];
-    else
-      /*<<format.ml:808:15>>*/ var
-       /*<<format.ml:808:15>>*/ _bl_ =
-         /*<<format.ml:808:15>>*/ caml_call2
-         (Stdlib_Int[11], state[6] - state[7] | 0, state[6] / 2 | 0),
-      new_max_indent =
-         /*<<format.ml:808:7>>*/ caml_call2(Stdlib_Int[11], _bl_, 1);
-     /*<<format.ml:811:4>>*/ return pp_set_max_indent(state, new_max_indent);
-    /*<<format.ml:811:42>>*/ }
-   function validate_geometry(param){
-    var margin = param[2], max_indent = param[1];
-     /*<<format.ml:818:2>>*/ return 2 <= max_indent
-            ? margin <= max_indent ? _c_ : _d_
-            : _e_;
-   }
-   function check_geometry(geometry){
-     /*<<format.ml:825:2>>*/ return 0 === validate_geometry(geometry)[0]
-            ? 1
-            : 0;
-    /*<<format.ml:827:20>>*/ }
-   function pp_get_margin(state, param){
-     /*<<format.ml:829:29>>*/ return state[6];
-    /*<<format.ml:829:44>>*/ }
-   function pp_set_full_geometry(state, param){
-    var margin = param[2], max_indent = param[1];
-     /*<<format.ml:832:2>>*/ pp_set_margin(state, margin);
-     /*<<format.ml:833:2>>*/ pp_set_max_indent(state, max_indent);
-     /*<<format.ml:833:2>>*/ return 0;
-   }
-   function pp_set_geometry(state, max_indent, margin){
-     /*<<format.ml:837:2>>*/ var
-      /*<<format.ml:837:17>>*/ geometry = [0, max_indent, margin],
-      /*<<format.ml:838:8>>*/ match = validate_geometry(geometry);
-    if(0 === match[0])
-      /*<<format.ml:842:4>>*/ return pp_set_full_geometry(state, geometry);
-     /*<<format.ml:840:28>>*/ var
-     msg = match[1],
-      /*<<format.ml:840:28>>*/ _bj_ =
-        /*<<format.ml:840:28>>*/ caml_call2
-        (Stdlib[28], cst_Format_pp_set_geometry, msg);
-     /*<<format.ml:840:4>>*/ throw  /*<<format.ml:840:4>>*/ caml_maybe_attach_backtrace
-           ([0, Stdlib[6], _bj_], 1);
-    /*<<format.ml:842:39>>*/ }
-   function pp_safe_set_geometry(state, max_indent, margin){
-     /*<<format.ml:845:2>>*/  /*<<format.ml:845:17>>*/ var
-     geometry = [0, max_indent, margin];
-    return 0 === validate_geometry(geometry)[0]
-            ? pp_set_full_geometry(state, geometry)
-            : 0;
-    /*<<format.ml:850:39>>*/ }
-   function pp_get_geometry(state, param){
-     /*<<format.ml:853:2>>*/ return [0, state[8], state[6]];
-    /*<<format.ml:853:78>>*/ }
-   function pp_update_geometry(state, update){
-     /*<<format.ml:856:2>>*/  /*<<format.ml:856:17>>*/ var
-     geometry = pp_get_geometry(state, 0);
-     /*<<format.ml:857:29>>*/ return pp_set_full_geometry
-            (state,  /*<<format.ml:857:29>>*/ caml_call1(update, geometry));
-    /*<<format.ml:857:46>>*/ }
-   function pp_set_formatter_out_functions(state, param){
-    var j = param[5], i = param[4], h = param[3], g = param[2], f = param[1];
-    state[17] = f;
-    state[18] = g;
-    state[19] = h;
-    state[20] = i;
-    state[21] = j;
-    return 0;
-   }
-   function pp_get_formatter_out_functions(state, param){
-     /*<<format.ml:873:46>>*/ return [0,
-            state[17],
-            state[18],
-            state[19],
-            state[20],
-            state[21]];
-    /*<<format.ml:879:1>>*/ }
-   function pp_set_formatter_output_functi(state, f, g){
-     /*<<format.ml:884:2>>*/ state[17] = f;
-    state[18] = g;
-    return 0;
-    /*<<format.ml:884:51>>*/ }
-   function pp_get_formatter_output_functi(state, param){
-     /*<<format.ml:887:2>>*/ return [0, state[17], state[18]];
-    /*<<format.ml:887:43>>*/ }
-   function display_newline(state, param){
-     /*<<format.ml:891:31>>*/ return  /*<<format.ml:891:31>>*/ caml_call3
-            (state[17], cst$7, 0, 1);
-    /*<<format.ml:891:60>>*/ }
-    /*<<format.ml:894:17>>*/  /*<<format.ml:894:17>>*/ var
-    blank_line =
-       /*<<format.ml:894:17>>*/ caml_call2(Stdlib_String[1], 80, 32);
-   function display_blanks(state, n){
-     /*<<format.ml:896:2>>*/ var n$0 = n;
-     /*<<format.ml:896:2>>*/ for(;;){
-     var _bi_ = 0 < n$0 ? 1 : 0;
-     if(! _bi_) return _bi_;
-     if(80 >= n$0)
-       /*<<format.ml:897:18>>*/ return  /*<<format.ml:897:18>>*/ caml_call3
-              (state[17], blank_line, 0, n$0);
-      /*<<format.ml:899:4>>*/  /*<<format.ml:899:4>>*/ caml_call3
-      (state[17], blank_line, 0, 80);
-      /*<<format.ml:899:4>>*/ var
-       /*<<format.ml:899:4>>*/ n$1 = n$0 - 80 | 0,
-      n$0 = n$1;
-    }
-    /*<<format.ml:901:5>>*/ }
-   function pp_set_formatter_out_channel(state, oc){
-     /*<<format.ml:910:2>>*/ state[17] =
-      /*<<format.ml:910:25>>*/ caml_call1(Stdlib[69], oc);
-    state[18] =
-     function(param){
-       /*<<format.ml:911:35>>*/ return  /*<<format.ml:911:2>>*/ caml_call1
-              (Stdlib[63], oc);
-      /*<<format.ml:911:43>>*/ };
-    state[19] =
-     function(_bh_){ /*<<?>>*/ return display_newline(state, _bh_);};
-    state[20] = function(_bg_){ /*<<?>>*/ return display_blanks(state, _bg_);};
-    state[21] = function(_bf_){ /*<<?>>*/ return display_blanks(state, _bf_);};
-    return 0;
-    /*<<format.ml:914:45>>*/ }
-   function default_pp_mark_open_tag(param){
-     /*<<format.ml:922:31>>*/ if(param[1] !== String_tag)
-      /*<<format.ml:924:9>>*/ return cst$10;
-     /*<<format.ml:923:26>>*/ var
-     s = param[2],
-      /*<<format.ml:923:26>>*/ _be_ =
-        /*<<format.ml:923:26>>*/ caml_call2(Stdlib[28], s, cst$8);
-     /*<<format.ml:923:26>>*/ return  /*<<format.ml:923:26>>*/ caml_call2
-            (Stdlib[28], cst$9, _be_);
-    /*<<format.ml:924:11>>*/ }
-   function default_pp_mark_close_tag(param){
-     /*<<format.ml:925:32>>*/ if(param[1] !== String_tag)
-      /*<<format.ml:927:9>>*/ return cst$13;
-     /*<<format.ml:926:27>>*/ var
-     s = param[2],
-      /*<<format.ml:926:27>>*/ _bd_ =
-        /*<<format.ml:926:27>>*/ caml_call2(Stdlib[28], s, cst$11);
-     /*<<format.ml:926:27>>*/ return  /*<<format.ml:926:27>>*/ caml_call2
-            (Stdlib[28], cst$12, _bd_);
-    /*<<format.ml:927:11>>*/ }
-   function default_pp_print_open_tag(_bc_){ /*<<?>>*/ return 0;}
-   function default_pp_print_close_tag(_bb_){ /*<<?>>*/ return 0;}
-   function pp_make_formatter(f, g, h, i, j){
-     /*<<format.ml:936:17>>*/ var
-      /*<<format.ml:936:17>>*/ pp_queue =
-        /*<<format.ml:936:17>>*/ caml_call1(Stdlib_Queue[2], 0),
-      /*<<format.ml:938:4>>*/ sys_tok = [0, unknown, _f_, 0];
-     /*<<format.ml:939:2>>*/  /*<<format.ml:939:2>>*/ caml_call2
-     (Stdlib_Queue[3], sys_tok, pp_queue);
-     /*<<format.ml:940:19>>*/  /*<<format.ml:940:19>>*/ var
-     scan_stack =  /*<<format.ml:940:19>>*/ caml_call1(Stdlib_Stack[2], 0);
-     /*<<format.ml:941:2>>*/ initialize_scan_stack(scan_stack);
-     /*<<format.ml:942:2>>*/  /*<<format.ml:942:2>>*/ caml_call2
-     (Stdlib_Stack[3], [0, 1, sys_tok], scan_stack);
-     /*<<format.ml:950:20>>*/ var
-     _a9_ = Stdlib[19],
-      /*<<format.ml:950:20>>*/ _a__ =
-        /*<<format.ml:950:20>>*/ caml_call1(Stdlib_Stack[2], 0),
-      /*<<format.ml:949:19>>*/ _a$_ =
-        /*<<format.ml:949:19>>*/ caml_call1(Stdlib_Stack[2], 0),
-      /*<<format.ml:948:20>>*/ _ba_ =
-        /*<<format.ml:948:20>>*/ caml_call1(Stdlib_Stack[2], 0);
-     /*<<format.ml:945:2>>*/ return [0,
-            scan_stack,
-             /*<<format.ml:947:22>>*/ caml_call1(Stdlib_Stack[2], 0),
-            _ba_,
-            _a$_,
-            _a__,
-            78,
-            10,
-            68,
-            78,
-            0,
-            1,
-            1,
-            1,
-            1,
-            _a9_,
-            cst$14,
-            f,
-            g,
-            h,
-            i,
-            j,
-            0,
-            0,
-            default_pp_mark_open_tag,
-            default_pp_mark_close_tag,
-            default_pp_print_open_tag,
-            default_pp_print_close_tag,
-            pp_queue];
-   }
-   function formatter_of_out_functions(out_funs){
-     /*<<format.ml:979:2>>*/ return pp_make_formatter
-            (out_funs[1], out_funs[2], out_funs[3], out_funs[4], out_funs[5]);
-    /*<<format.ml:984:23>>*/ }
-   function make_formatter(output, flush){
-    function _a1_(_a8_){ /*<<?>>*/ return 0;}
-    function _a2_(_a7_){ /*<<?>>*/ return 0;}
-     /*<<format.ml:990:12>>*/  /*<<format.ml:990:12>>*/ var
-     ppf =
-       pp_make_formatter
-        (output, flush, function(_a6_){ /*<<?>>*/ return 0;}, _a2_, _a1_);
-    ppf[19] = function(_a5_){ /*<<?>>*/ return display_newline(ppf, _a5_);};
-    ppf[20] = function(_a4_){ /*<<?>>*/ return display_blanks(ppf, _a4_);};
-    ppf[21] = function(_a3_){ /*<<?>>*/ return display_blanks(ppf, _a3_);};
-     /*<<format.ml:994:2>>*/ return ppf;
-    /*<<format.ml:994:5>>*/ }
-   function formatter_of_out_channel(oc){
-    function _a0_(param){
-      /*<<format.ml:999:50>>*/ return  /*<<format.ml:999:2>>*/ caml_call1
-             (Stdlib[63], oc);
-     /*<<format.ml:999:58>>*/ }
-     /*<<format.ml:999:39>>*/ return make_formatter
-            ( /*<<format.ml:999:17>>*/ caml_call1(Stdlib[69], oc), _a0_);
-    /*<<format.ml:999:59>>*/ }
-   function formatter_of_buffer(b){
-     /*<<format.ml:1004:2>>*/ function _aY_(_aZ_){ /*<<?>>*/ return 0;}
-     /*<<format.ml:1004:42>>*/ return make_formatter
-            ( /*<<format.ml:1004:17>>*/ caml_call1(Stdlib_Buffer[18], b),
-             _aY_);
-    /*<<format.ml:1004:48>>*/ }
-   var pp_buffer_size = 512;
-   function pp_make_buffer(param){
-     /*<<format.ml:1011:24>>*/ return caml_call1
-            (Stdlib_Buffer[1], pp_buffer_size);
-    /*<<format.ml:1011:52>>*/ }
-    /*<<format.ml:1014:13>>*/ var
-     /*<<format.ml:1014:13>>*/ stdbuf = pp_make_buffer(0),
-     /*<<format.ml:1018:20>>*/ std_formatter =
-      formatter_of_out_channel(Stdlib[39]),
-     /*<<format.ml:1019:20>>*/ err_formatter =
-      formatter_of_out_channel(Stdlib[40]),
-     /*<<format.ml:1020:20>>*/ str_formatter = formatter_of_buffer(stdbuf),
-     /*<<format.ml:1025:17>>*/ stdbuf_key =
-       /*<<format.ml:1025:17>>*/ caml_call2
-       (Stdlib_Domain[10][1], 0, pp_make_buffer);
-    /*<<format.ml:1026:8>>*/  /*<<format.ml:1026:8>>*/ caml_call2
-    (Stdlib_Domain[10][3], stdbuf_key, stdbuf);
-   function _g_(param){
-     /*<<format.ml:1029:2>>*/ return formatter_of_buffer
-            ( /*<<format.ml:1029:22>>*/ caml_call1
-              (Stdlib_Domain[10][2], stdbuf_key));
-    /*<<format.ml:1029:42>>*/ }
-    /*<<format.ml:1028:24>>*/  /*<<format.ml:1028:24>>*/ var
-    str_formatter_key =
-       /*<<format.ml:1028:24>>*/ caml_call2(Stdlib_Domain[10][1], 0, _g_);
-    /*<<format.ml:1030:8>>*/  /*<<format.ml:1030:8>>*/ caml_call2
-    (Stdlib_Domain[10][3], str_formatter_key, str_formatter);
-    /*<<format.ml:1030:8>>*/ function buffered_out_string(key, str, ofs, len){
-     /*<<format.ml:1033:2>>*/  /*<<format.ml:1033:23>>*/ var
-     _aX_ =  /*<<format.ml:1033:23>>*/ caml_call1(Stdlib_Domain[10][2], key);
-     /*<<format.ml:1033:2>>*/ return  /*<<format.ml:1033:2>>*/ caml_call4
-            (Stdlib_Buffer[18], _aX_, str, ofs, len);
-    /*<<format.ml:1033:55>>*/ }
-   function buffered_out_flush(oc, key, param){
-     /*<<format.ml:1036:2>>*/ var
-      /*<<format.ml:1036:12>>*/ buf =
-        /*<<format.ml:1036:12>>*/ caml_call1(Stdlib_Domain[10][2], key),
-      /*<<format.ml:1037:12>>*/ len =
-        /*<<format.ml:1037:12>>*/ caml_call1(Stdlib_Buffer[7], buf),
-      /*<<format.ml:1038:12>>*/ str =
-        /*<<format.ml:1038:12>>*/ caml_call1(Stdlib_Buffer[2], buf);
-     /*<<format.ml:1039:2>>*/  /*<<format.ml:1039:2>>*/ caml_call4
-     (Stdlib[69], oc, str, 0, len);
-     /*<<format.ml:1040:2>>*/  /*<<format.ml:1040:2>>*/ caml_call1
-     (Stdlib[63], oc);
-     /*<<format.ml:1040:2>>*/ return  /*<<format.ml:1040:2>>*/ caml_call1
-            (Stdlib_Buffer[8], buf);
-    /*<<format.ml:1041:18>>*/ }
-   function _h_(param){
-     /*<<format.ml:1043:48>>*/ return caml_call1
-            (Stdlib_Buffer[1], pp_buffer_size);
-    /*<<format.ml:1043:76>>*/ }
-    /*<<format.ml:1043:18>>*/  /*<<format.ml:1043:18>>*/ var
-    std_buf_key =
-       /*<<format.ml:1043:18>>*/ caml_call2(Stdlib_Domain[10][1], 0, _h_);
-   function _i_(param){
-     /*<<format.ml:1044:48>>*/ return  /*<<format.ml:1043:18>>*/ caml_call1
-            (Stdlib_Buffer[1], pp_buffer_size);
-    /*<<format.ml:1044:76>>*/ }
-    /*<<format.ml:1044:18>>*/  /*<<format.ml:1044:18>>*/ var
-    err_buf_key =
-       /*<<format.ml:1044:18>>*/ caml_call2(Stdlib_Domain[10][1], 0, _i_);
-   function _j_(param){
-    function _aG_(_aW_){ /*<<?>>*/ return 0;}
-    function _aH_(_aV_){ /*<<?>>*/ return 0;}
-    function _aI_(_aU_){ /*<<?>>*/ return 0;}
-    var _aJ_ = Stdlib[39];
-     /*<<format.ml:1049:6>>*/ function _aK_(_aT_){
-      /*<<?>>*/ return buffered_out_flush(_aJ_, std_buf_key, _aT_);
-    }
-     /*<<format.ml:1048:4>>*/  /*<<format.ml:1048:4>>*/ var
-     ppf =
-       pp_make_formatter
-        (function(_aQ_, _aR_, _aS_){
-           /*<<?>>*/ return buffered_out_string(std_buf_key, _aQ_, _aR_, _aS_);
-         },
-         _aK_,
-         _aI_,
-         _aH_,
-         _aG_);
-    ppf[19] = function(_aP_){ /*<<?>>*/ return display_newline(ppf, _aP_);};
-    ppf[20] = function(_aO_){ /*<<?>>*/ return display_blanks(ppf, _aO_);};
-    ppf[21] = function(_aN_){ /*<<?>>*/ return display_blanks(ppf, _aN_);};
-     /*<<format.ml:1054:17>>*/ function _aL_(_aM_){
-      /*<<?>>*/ return pp_print_flush(ppf, _aM_);
-    }
-     /*<<format.ml:1054:2>>*/  /*<<format.ml:1054:2>>*/ caml_call1
-     (Stdlib_Domain[6], _aL_);
-     /*<<format.ml:1054:2>>*/ return ppf;
-    /*<<format.ml:1055:5>>*/ }
-    /*<<format.ml:1046:24>>*/  /*<<format.ml:1046:24>>*/ var
-    std_formatter_key =
-       /*<<format.ml:1046:24>>*/ caml_call2(Stdlib_Domain[10][1], 0, _j_);
-    /*<<format.ml:1056:8>>*/  /*<<format.ml:1056:8>>*/ caml_call2
-    (Stdlib_Domain[10][3], std_formatter_key, std_formatter);
-   function _k_(param){
-    function _ap_(_aF_){ /*<<?>>*/ return 0;}
-    function _aq_(_aE_){ /*<<?>>*/ return 0;}
-    function _ar_(_aD_){ /*<<?>>*/ return 0;}
-    var _as_ = Stdlib[40];
-     /*<<format.ml:1061:6>>*/ function _at_(_aC_){
-      /*<<?>>*/ return buffered_out_flush(_as_, err_buf_key, _aC_);
-    }
-     /*<<format.ml:1060:4>>*/  /*<<format.ml:1060:4>>*/ var
-     ppf =
-       pp_make_formatter
-        (function(_az_, _aA_, _aB_){
-           /*<<?>>*/ return buffered_out_string(err_buf_key, _az_, _aA_, _aB_);
-         },
-         _at_,
-         _ar_,
-         _aq_,
-         _ap_);
-    ppf[19] = function(_ay_){ /*<<?>>*/ return display_newline(ppf, _ay_);};
-    ppf[20] = function(_ax_){ /*<<?>>*/ return display_blanks(ppf, _ax_);};
-    ppf[21] = function(_aw_){ /*<<?>>*/ return display_blanks(ppf, _aw_);};
-     /*<<format.ml:1066:17>>*/ function _au_(_av_){
-      /*<<?>>*/ return pp_print_flush(ppf, _av_);
-    }
-     /*<<format.ml:1066:2>>*/  /*<<format.ml:1066:2>>*/ caml_call1
-     (Stdlib_Domain[6], _au_);
-     /*<<format.ml:1066:2>>*/ return ppf;
-    /*<<format.ml:1067:5>>*/ }
-    /*<<format.ml:1058:24>>*/  /*<<format.ml:1058:24>>*/ var
-    err_formatter_key =
-       /*<<format.ml:1058:24>>*/ caml_call2(Stdlib_Domain[10][1], 0, _k_);
-    /*<<format.ml:1068:8>>*/  /*<<format.ml:1068:8>>*/ caml_call2
-    (Stdlib_Domain[10][3], err_formatter_key, err_formatter);
-   function get_std_formatter(param){
-     /*<<format.ml:1070:27>>*/ return  /*<<format.ml:1068:8>>*/ caml_call1
-            (Stdlib_Domain[10][2], std_formatter_key);
-    /*<<format.ml:1070:52>>*/ }
-   function get_err_formatter(param){
-     /*<<format.ml:1071:27>>*/ return caml_call1
-            (Stdlib_Domain[10][2], err_formatter_key);
-    /*<<format.ml:1071:52>>*/ }
-   function get_str_formatter(param){
-     /*<<format.ml:1072:27>>*/ return caml_call1
-            (Stdlib_Domain[10][2], str_formatter_key);
-    /*<<format.ml:1072:52>>*/ }
-   function get_stdbuf(param){
-     /*<<format.ml:1073:20>>*/ return caml_call1
-            (Stdlib_Domain[10][2], stdbuf_key);
-    /*<<format.ml:1073:38>>*/ }
-   function flush_buffer_formatter(buf, ppf){
-     /*<<format.ml:1080:2>>*/ pp_flush_queue(ppf, 0);
-     /*<<format.ml:1081:10>>*/  /*<<format.ml:1081:10>>*/ var
-     s =  /*<<format.ml:1081:10>>*/ caml_call1(Stdlib_Buffer[2], buf);
-     /*<<format.ml:1082:2>>*/  /*<<format.ml:1082:2>>*/ caml_call1
-     (Stdlib_Buffer[9], buf);
-     /*<<format.ml:1082:2>>*/ return s;
-    /*<<format.ml:1083:3>>*/ }
-   function flush_str_formatter(param){
-     /*<<format.ml:1087:2>>*/ var
-      /*<<format.ml:1087:15>>*/ stdbuf =
-        /*<<format.ml:1087:15>>*/ caml_call1(Stdlib_Domain[10][2], stdbuf_key),
-      /*<<format.ml:1088:22>>*/ str_formatter =
-        /*<<format.ml:1088:22>>*/ caml_call1
-        (Stdlib_Domain[10][2], str_formatter_key);
-     /*<<format.ml:1089:2>>*/ return flush_buffer_formatter
-            (stdbuf, str_formatter);
-    /*<<format.ml:1089:45>>*/ }
-   function make_synchronized_formatter(output, flush){
-    function _an_(param){
-      /*<<format.ml:1093:4>>*/ var
-       /*<<format.ml:1093:14>>*/ buf =
-         /*<<format.ml:1093:14>>*/ caml_call1
-         (Stdlib_Buffer[1], pp_buffer_size),
-       /*<<format.ml:1094:18>>*/ output$0 =
-         /*<<format.ml:1094:18>>*/ caml_call1(Stdlib_Buffer[18], buf);
-     function flush$0(param){
-       /*<<format.ml:1096:6>>*/  /*<<format.ml:1096:37>>*/ var
-       _ao_ =  /*<<format.ml:1096:37>>*/ caml_call1(Stdlib_Buffer[7], buf);
-       /*<<format.ml:1096:6>>*/  /*<<format.ml:1096:6>>*/ caml_call3
-       (output,
-         /*<<format.ml:1096:13>>*/ caml_call1(Stdlib_Buffer[2], buf),
-        0,
-        _ao_);
-       /*<<format.ml:1097:6>>*/  /*<<format.ml:1097:6>>*/ caml_call1
-       (Stdlib_Buffer[8], buf);
-       /*<<format.ml:1097:6>>*/ return  /*<<format.ml:1097:6>>*/ caml_call1
-              (flush, 0);
-      /*<<format.ml:1098:14>>*/ }
-      /*<<format.ml:1100:4>>*/ return make_formatter(output$0, flush$0);
-     /*<<format.ml:1100:33>>*/ }
-     /*<<format.ml:1092:14>>*/ return  /*<<format.ml:1092:14>>*/ caml_call2
-            (Stdlib_Domain[10][1], 0, _an_);
-    /*<<format.ml:1100:34>>*/ }
-   function synchronized_formatter_of_out_(oc){
-    function _am_(param){
-      /*<<format.ml:1103:63>>*/ return  /*<<format.ml:1103:2>>*/ caml_call1
-             (Stdlib[63], oc);
-     /*<<format.ml:1103:71>>*/ }
-     /*<<format.ml:1103:52>>*/ return make_synchronized_formatter
-            ( /*<<format.ml:1103:30>>*/ caml_call1(Stdlib[69], oc), _am_);
-    /*<<format.ml:1103:72>>*/ }
-   function make_symbolic_output_buffer(param){ /*<<format.ml:1130:2>>*/ return [0, 0];
-    /*<<format.ml:1130:35>>*/ }
-   function clear_symbolic_output_buffer(sob){
-     /*<<format.ml:1133:2>>*/ sob[1] = 0;
-    return 0;
-    /*<<format.ml:1133:36>>*/ }
-   function get_symbolic_output_buffer(sob){
-     /*<<format.ml:1136:2>>*/ return caml_call1(Stdlib_List[9], sob[1]);
-    /*<<format.ml:1136:39>>*/ }
-   function flush_symbolic_output_buffer(sob){
-     /*<<format.ml:1139:2>>*/  /*<<format.ml:1139:14>>*/ var
-     items = get_symbolic_output_buffer(sob);
-     /*<<format.ml:1140:2>>*/ clear_symbolic_output_buffer(sob);
-     /*<<format.ml:1140:2>>*/ return items;
-    /*<<format.ml:1141:7>>*/ }
-   function add_symbolic_output_item(sob, item){
-     /*<<format.ml:1144:2>>*/ sob[1] = [0, item, sob[1]];
-    return 0;
-    /*<<format.ml:1144:70>>*/ }
-   function formatter_of_symbolic_output_b(sob){
-     /*<<format.ml:1158:10>>*/ function f(s, i, n){
-      /*<<format.ml:1152:33>>*/ return add_symbolic_output_item
-             (sob,
-              [0,
-                /*<<format.ml:1152:48>>*/ caml_call3
-                (Stdlib_String[15], s, i, n)]);
-    }
-     /*<<format.ml:1159:10>>*/ function g(_al_){
-      /*<<format.ml:1148:4>>*/ return add_symbolic_output_item(sob, 0);
-    }
-     /*<<format.ml:1160:10>>*/ function h(_ak_){
-      /*<<format.ml:1150:4>>*/ return add_symbolic_output_item(sob, 1);
-    }
-     /*<<format.ml:1161:10>>*/ function i(n){
-      /*<<format.ml:1154:33>>*/ return add_symbolic_output_item(sob, [1, n]);
-    }
-     /*<<format.ml:1162:10>>*/ function j(n){
-      /*<<format.ml:1156:33>>*/ return add_symbolic_output_item(sob, [2, n]);
-    }
-     /*<<format.ml:1163:2>>*/ return pp_make_formatter(f, g, h, i, j);
-    /*<<format.ml:1163:29>>*/ }
-   function open_hbox(v){
-     /*<<format.ml:1172:18>>*/ return pp_open_hbox
-            ( /*<<format.ml:1172:31>>*/ caml_call1
-              (Stdlib_Domain[10][2], std_formatter_key),
-             v);
-    /*<<format.ml:1172:60>>*/ }
-   function open_vbox(v){
-     /*<<format.ml:1173:18>>*/ return pp_open_vbox
-            ( /*<<format.ml:1173:31>>*/ caml_call1
-              (Stdlib_Domain[10][2], std_formatter_key),
-             v);
-    /*<<format.ml:1173:60>>*/ }
-   function open_hvbox(v){
-     /*<<format.ml:1174:19>>*/ return pp_open_hvbox
-            ( /*<<format.ml:1174:33>>*/ caml_call1
-              (Stdlib_Domain[10][2], std_formatter_key),
-             v);
-    /*<<format.ml:1174:62>>*/ }
-   function open_hovbox(v){
-     /*<<format.ml:1175:20>>*/ return pp_open_hovbox
-            ( /*<<format.ml:1175:35>>*/ caml_call1
-              (Stdlib_Domain[10][2], std_formatter_key),
-             v);
-    /*<<format.ml:1175:64>>*/ }
-   function open_box(v){
-     /*<<format.ml:1176:17>>*/ return pp_open_box
-            ( /*<<format.ml:1176:29>>*/ caml_call1
-              (Stdlib_Domain[10][2], std_formatter_key),
-             v);
-    /*<<format.ml:1176:58>>*/ }
-   function close_box(v){
-     /*<<format.ml:1177:18>>*/ return pp_close_box
-            ( /*<<format.ml:1177:31>>*/ caml_call1
-              (Stdlib_Domain[10][2], std_formatter_key),
-             v);
-    /*<<format.ml:1177:60>>*/ }
-   function open_stag(v){
-     /*<<format.ml:1178:18>>*/ return pp_open_stag
-            ( /*<<format.ml:1178:31>>*/ caml_call1
-              (Stdlib_Domain[10][2], std_formatter_key),
-             v);
-    /*<<format.ml:1178:60>>*/ }
-   function close_stag(v){
-     /*<<format.ml:1179:19>>*/ return pp_close_stag
-            ( /*<<format.ml:1179:33>>*/ caml_call1
-              (Stdlib_Domain[10][2], std_formatter_key),
-             v);
-    /*<<format.ml:1179:62>>*/ }
-   function print_as(v, w){
-     /*<<format.ml:1180:19>>*/ return pp_print_as
-            ( /*<<format.ml:1180:31>>*/ caml_call1
-              (Stdlib_Domain[10][2], std_formatter_key),
-             v,
-             w);
-    /*<<format.ml:1180:62>>*/ }
-   function print_string(v){
-     /*<<format.ml:1181:21>>*/ return pp_print_string
-            ( /*<<format.ml:1181:37>>*/ caml_call1
-              (Stdlib_Domain[10][2], std_formatter_key),
-             v);
-    /*<<format.ml:1181:66>>*/ }
-   function print_bytes(v){
-     /*<<format.ml:1182:20>>*/ return pp_print_bytes
-            ( /*<<format.ml:1182:35>>*/ caml_call1
-              (Stdlib_Domain[10][2], std_formatter_key),
-             v);
-    /*<<format.ml:1182:64>>*/ }
-   function print_int(v){
-     /*<<format.ml:1183:18>>*/ return pp_print_int
-            ( /*<<format.ml:1183:31>>*/ caml_call1
-              (Stdlib_Domain[10][2], std_formatter_key),
-             v);
-    /*<<format.ml:1183:60>>*/ }
-   function print_float(v){
-     /*<<format.ml:1184:20>>*/ return pp_print_float
-            ( /*<<format.ml:1184:35>>*/ caml_call1
-              (Stdlib_Domain[10][2], std_formatter_key),
-             v);
-    /*<<format.ml:1184:64>>*/ }
-   function print_char(v){
-     /*<<format.ml:1185:19>>*/ return pp_print_char
-            ( /*<<format.ml:1185:33>>*/ caml_call1
-              (Stdlib_Domain[10][2], std_formatter_key),
-             v);
-    /*<<format.ml:1185:62>>*/ }
-   function print_bool(v){
-     /*<<format.ml:1186:19>>*/ return pp_print_bool
-            ( /*<<format.ml:1186:33>>*/ caml_call1
-              (Stdlib_Domain[10][2], std_formatter_key),
-             v);
-    /*<<format.ml:1186:62>>*/ }
-   function print_break(v, w){
-     /*<<format.ml:1187:22>>*/ return pp_print_break
-            ( /*<<format.ml:1187:37>>*/ caml_call1
-              (Stdlib_Domain[10][2], std_formatter_key),
-             v,
-             w);
-    /*<<format.ml:1187:68>>*/ }
-   function print_cut(v){
-     /*<<format.ml:1188:18>>*/ return pp_print_cut
-            ( /*<<format.ml:1188:31>>*/ caml_call1
-              (Stdlib_Domain[10][2], std_formatter_key),
-             v);
-    /*<<format.ml:1188:60>>*/ }
-   function print_space(v){
-     /*<<format.ml:1189:20>>*/ return pp_print_space
-            ( /*<<format.ml:1189:35>>*/ caml_call1
-              (Stdlib_Domain[10][2], std_formatter_key),
-             v);
-    /*<<format.ml:1189:64>>*/ }
-   function force_newline(v){
-     /*<<format.ml:1190:22>>*/ return pp_force_newline
-            ( /*<<format.ml:1190:39>>*/ caml_call1
-              (Stdlib_Domain[10][2], std_formatter_key),
-             v);
-    /*<<format.ml:1190:68>>*/ }
-   function print_flush(v){
-     /*<<format.ml:1191:20>>*/ return pp_print_flush
-            ( /*<<format.ml:1191:35>>*/ caml_call1
-              (Stdlib_Domain[10][2], std_formatter_key),
-             v);
-    /*<<format.ml:1191:64>>*/ }
-   function print_newline(v){
-     /*<<format.ml:1192:22>>*/ return pp_print_newline
-            ( /*<<format.ml:1192:39>>*/ caml_call1
-              (Stdlib_Domain[10][2], std_formatter_key),
-             v);
-    /*<<format.ml:1192:68>>*/ }
-   function print_if_newline(v){
-     /*<<format.ml:1193:25>>*/ return pp_print_if_newline
-            ( /*<<format.ml:1193:45>>*/ caml_call1
-              (Stdlib_Domain[10][2], std_formatter_key),
-             v);
-    /*<<format.ml:1193:74>>*/ }
-   function open_tbox(v){
-     /*<<format.ml:1195:18>>*/ return pp_open_tbox
-            ( /*<<format.ml:1195:31>>*/ caml_call1
-              (Stdlib_Domain[10][2], std_formatter_key),
-             v);
-    /*<<format.ml:1195:60>>*/ }
-   function close_tbox(v){
-     /*<<format.ml:1196:19>>*/ return pp_close_tbox
-            ( /*<<format.ml:1196:33>>*/ caml_call1
-              (Stdlib_Domain[10][2], std_formatter_key),
-             v);
-    /*<<format.ml:1196:62>>*/ }
-   function print_tbreak(v, w){
-     /*<<format.ml:1197:23>>*/ return pp_print_tbreak
-            ( /*<<format.ml:1197:39>>*/ caml_call1
-              (Stdlib_Domain[10][2], std_formatter_key),
-             v,
-             w);
-    /*<<format.ml:1197:70>>*/ }
-   function set_tab(v){
-     /*<<format.ml:1199:16>>*/ return pp_set_tab
-            ( /*<<format.ml:1199:27>>*/ caml_call1
-              (Stdlib_Domain[10][2], std_formatter_key),
-             v);
-    /*<<format.ml:1199:56>>*/ }
-   function print_tab(v){
-     /*<<format.ml:1200:18>>*/ return pp_print_tab
-            ( /*<<format.ml:1200:31>>*/ caml_call1
-              (Stdlib_Domain[10][2], std_formatter_key),
-             v);
-    /*<<format.ml:1200:60>>*/ }
-   function set_margin(v){
-     /*<<format.ml:1202:19>>*/ return pp_set_margin
-            ( /*<<format.ml:1202:33>>*/ caml_call1
-              (Stdlib_Domain[10][2], std_formatter_key),
-             v);
-    /*<<format.ml:1202:62>>*/ }
-   function get_margin(v){
-     /*<<format.ml:1203:19>>*/ return  /*<<format.ml:1203:33>>*/ caml_call1
-             (Stdlib_Domain[10][2], std_formatter_key)
-            [6];
-    /*<<format.ml:1203:62>>*/ }
-   function set_max_indent(v){
-     /*<<format.ml:1205:23>>*/ return pp_set_max_indent
-            ( /*<<format.ml:1205:41>>*/ caml_call1
-              (Stdlib_Domain[10][2], std_formatter_key),
-             v);
-    /*<<format.ml:1205:70>>*/ }
-   function get_max_indent(v){
-     /*<<format.ml:1206:23>>*/ return  /*<<format.ml:1206:41>>*/ caml_call1
-             (Stdlib_Domain[10][2], std_formatter_key)
-            [8];
-    /*<<format.ml:1206:70>>*/ }
-   function set_geometry(max_indent, margin){
-     /*<<format.ml:1209:2>>*/ return pp_set_geometry
-            ( /*<<format.ml:1209:18>>*/ caml_call1
-              (Stdlib_Domain[10][2], std_formatter_key),
-             max_indent,
-             margin);
-    /*<<format.ml:1209:65>>*/ }
-   function safe_set_geometry(max_indent, margin){
-     /*<<format.ml:1211:2>>*/ return pp_safe_set_geometry
-            ( /*<<format.ml:1211:23>>*/ caml_call1
-              (Stdlib_Domain[10][2], std_formatter_key),
-             max_indent,
-             margin);
-    /*<<format.ml:1211:70>>*/ }
-   function get_geometry(v){
-     /*<<format.ml:1212:21>>*/ return pp_get_geometry
-            ( /*<<format.ml:1212:37>>*/ caml_call1
-              (Stdlib_Domain[10][2], std_formatter_key),
-             v);
-    /*<<format.ml:1212:66>>*/ }
-   function update_geometry(v){
-     /*<<format.ml:1213:24>>*/ return pp_update_geometry
-            ( /*<<format.ml:1213:43>>*/ caml_call1
-              (Stdlib_Domain[10][2], std_formatter_key),
-             v);
-    /*<<format.ml:1213:72>>*/ }
-   function set_max_boxes(v){
-     /*<<format.ml:1215:22>>*/ return pp_set_max_boxes
-            ( /*<<format.ml:1215:39>>*/ caml_call1
-              (Stdlib_Domain[10][2], std_formatter_key),
-             v);
-    /*<<format.ml:1215:68>>*/ }
-   function get_max_boxes(v){
-     /*<<format.ml:1216:22>>*/ return  /*<<format.ml:1216:39>>*/ caml_call1
-             (Stdlib_Domain[10][2], std_formatter_key)
-            [15];
-    /*<<format.ml:1216:68>>*/ }
-   function over_max_boxes(v){
-     /*<<format.ml:1217:23>>*/ return pp_over_max_boxes
-            ( /*<<format.ml:1217:41>>*/ caml_call1
-              (Stdlib_Domain[10][2], std_formatter_key),
-             v);
-    /*<<format.ml:1217:70>>*/ }
-   function set_ellipsis_text(v){
-     /*<<format.ml:1219:26>>*/ return pp_set_ellipsis_text
-            ( /*<<format.ml:1219:47>>*/ caml_call1
-              (Stdlib_Domain[10][2], std_formatter_key),
-             v);
-    /*<<format.ml:1219:76>>*/ }
-   function get_ellipsis_text(v){
-     /*<<format.ml:1220:26>>*/ return  /*<<format.ml:1220:47>>*/ caml_call1
-             (Stdlib_Domain[10][2], std_formatter_key)
-            [16];
-    /*<<format.ml:1220:76>>*/ }
-   function set_formatter_out_channel(v){
-     /*<<format.ml:1223:2>>*/ return pp_set_formatter_out_channel
-            ( /*<<format.ml:1223:31>>*/ caml_call1
-              (Stdlib_Domain[10][2], std_formatter_key),
-             v);
-    /*<<format.ml:1223:60>>*/ }
-   function set_formatter_out_functions(v){
-     /*<<format.ml:1226:2>>*/ return pp_set_formatter_out_functions
-            ( /*<<format.ml:1226:33>>*/ caml_call1
-              (Stdlib_Domain[10][2], std_formatter_key),
-             v);
-    /*<<format.ml:1226:62>>*/ }
-   function get_formatter_out_functions(v){
-     /*<<format.ml:1228:2>>*/ return pp_get_formatter_out_functions
-            ( /*<<format.ml:1228:33>>*/ caml_call1
-              (Stdlib_Domain[10][2], std_formatter_key),
-             v);
-    /*<<format.ml:1228:62>>*/ }
-   function set_formatter_output_functions(v, w){
-     /*<<format.ml:1231:2>>*/ return pp_set_formatter_output_functi
-            ( /*<<format.ml:1231:36>>*/ caml_call1
-              (Stdlib_Domain[10][2], std_formatter_key),
-             v,
-             w);
-    /*<<format.ml:1231:67>>*/ }
-   function get_formatter_output_functions(v){
-     /*<<format.ml:1233:2>>*/ return pp_get_formatter_output_functi
-            ( /*<<format.ml:1233:36>>*/ caml_call1
-              (Stdlib_Domain[10][2], std_formatter_key),
-             v);
-    /*<<format.ml:1233:65>>*/ }
-   function set_formatter_stag_functions(v){
-     /*<<format.ml:1236:2>>*/ return pp_set_formatter_stag_function
-            ( /*<<format.ml:1236:34>>*/ caml_call1
-              (Stdlib_Domain[10][2], std_formatter_key),
-             v);
-    /*<<format.ml:1236:63>>*/ }
-   function get_formatter_stag_functions(v){
-     /*<<format.ml:1238:2>>*/ return pp_get_formatter_stag_function
-            ( /*<<format.ml:1238:34>>*/ caml_call1
-              (Stdlib_Domain[10][2], std_formatter_key),
-             v);
-    /*<<format.ml:1238:63>>*/ }
-   function set_print_tags(v){
-     /*<<format.ml:1240:2>>*/ return pp_set_print_tags
-            ( /*<<format.ml:1240:20>>*/ caml_call1
-              (Stdlib_Domain[10][2], std_formatter_key),
-             v);
-    /*<<format.ml:1240:49>>*/ }
-   function get_print_tags(v){
-     /*<<format.ml:1242:2>>*/ return  /*<<format.ml:1242:20>>*/ caml_call1
-             (Stdlib_Domain[10][2], std_formatter_key)
-            [22];
-    /*<<format.ml:1242:49>>*/ }
-   function set_mark_tags(v){
-     /*<<format.ml:1244:2>>*/ return pp_set_mark_tags
-            ( /*<<format.ml:1244:19>>*/ caml_call1
-              (Stdlib_Domain[10][2], std_formatter_key),
-             v);
-    /*<<format.ml:1244:48>>*/ }
-   function get_mark_tags(v){
-     /*<<format.ml:1246:2>>*/ return  /*<<format.ml:1246:19>>*/ caml_call1
-             (Stdlib_Domain[10][2], std_formatter_key)
-            [23];
-    /*<<format.ml:1246:48>>*/ }
-   function set_tags(v){
-     /*<<format.ml:1248:2>>*/ return pp_set_tags
-            ( /*<<format.ml:1248:14>>*/ caml_call1
-              (Stdlib_Domain[10][2], std_formatter_key),
-             v);
-    /*<<format.ml:1248:43>>*/ }
-   function pp_print_list(opt, pp_v, ppf, param){
-    var opt$0 = opt, param$0 = param;
-    for(;;){
-      /*<<format.ml:1254:58>>*/ if(opt$0)
-      var sth = opt$0[1], pp_sep = sth;
-     else
-      var pp_sep = pp_print_cut;
-      /*<<format.ml:1254:58>>*/ if(! param$0)
-       /*<<format.ml:1255:10>>*/ return 0;
-     var v = param$0[1];
-     if(! param$0[2])
-       /*<<format.ml:1256:11>>*/ return  /*<<format.ml:1256:11>>*/ caml_call2
-              (pp_v, ppf, v);
-     var vs = param$0[2];
-      /*<<format.ml:1258:4>>*/  /*<<format.ml:1258:4>>*/ caml_call2
-      (pp_v, ppf, v);
-      /*<<format.ml:1259:4>>*/  /*<<format.ml:1259:4>>*/ caml_call2
-      (pp_sep, ppf, 0);
-      /*<<format.ml:1260:19>>*/ var
-       /*<<format.ml:1260:19>>*/ opt$1 = [0, pp_sep],
-      opt$0 = opt$1,
-      param$0 = vs;
-    }
-   }
-   function pp_print_seq(opt, pp_v, ppf, seq$1){
-     /*<<format.ml:1272:2>>*/ if(opt)
-     var sth = opt[1], pp_sep = sth;
-    else
-     var pp_sep = pp_print_cut;
-     /*<<format.ml:1272:8>>*/  /*<<format.ml:1272:8>>*/ var
-     match$0 =  /*<<format.ml:1272:8>>*/ caml_call1(seq$1, 0);
-    if(! match$0)  /*<<format.ml:1273:15>>*/ return 0;
-    var seq$2 = match$0[2], v$0 = match$0[1];
-     /*<<format.ml:1275:4>>*/  /*<<format.ml:1275:4>>*/ caml_call2
-     (pp_v, ppf, v$0);
-    var seq = seq$2;
-     /*<<format.ml:1264:2>>*/ for(;;){
-      /*<<format.ml:1264:8>>*/  /*<<format.ml:1264:8>>*/ var
-      match =  /*<<format.ml:1264:8>>*/ caml_call1(seq, 0);
-     if(! match)  /*<<format.ml:1265:15>>*/ return 0;
-     var seq$0 = match[2], v = match[1];
-      /*<<format.ml:1267:4>>*/  /*<<format.ml:1267:4>>*/ caml_call2
-      (pp_sep, ppf, 0);
-      /*<<format.ml:1268:4>>*/  /*<<format.ml:1268:4>>*/ caml_call2
-      (pp_v, ppf, v);
-     var seq = seq$0;
-    }
-    /*<<format.ml:1276:40>>*/ }
-   function pp_print_text(ppf, s){
-     /*<<format.ml:1280:2>>*/ var
-     len = caml_ml_string_length(s),
-      /*<<format.ml:1281:13>>*/ left = [0, 0],
-      /*<<format.ml:1282:14>>*/ right = [0, 0];
-    function flush(param){
-      /*<<format.ml:1284:4>>*/ pp_print_string
-      (ppf,
-        /*<<format.ml:1284:24>>*/ caml_call3
-        (Stdlib_String[15], s, left[1], right[1] - left[1] | 0));
-     right[1]++;
-     left[1] = right[1];
-     return 0;
-     /*<<format.ml:1285:31>>*/ }
-    for(;;){
-     if(right[1] === len){
-      var _aj_ = left[1] !== len ? 1 : 0;
-      return _aj_ ? flush(0) : _aj_;
-     }
-      /*<<format.ml:1288:10>>*/  /*<<format.ml:1288:10>>*/ var
-      match =  /*<<format.ml:1288:10>>*/ runtime.caml_string_get(s, right[1]);
-     if(10 === match){
-       /*<<format.ml:1290:8>>*/ flush(0);
-       /*<<format.ml:1291:8>>*/ pp_force_newline(ppf, 0);
-     }
-     else if(32 === match){
-       /*<<format.ml:1293:8>>*/ flush(0);
-       /*<<format.ml:1293:18>>*/ pp_print_space(ppf, 0);
-     }
-     else
-      right[1]++;
-    }
-    /*<<format.ml:1298:31>>*/ }
-   function pp_print_option(opt, pp_v, ppf, param){
-     /*<<format.ml:1300:56>>*/ if(opt)
-     var sth = opt[1], none = sth;
-    else
-     var
-      none =
-        function(param, _ai_){
-          /*<<format.ml:1300:41>>*/ return 0;
-         /*<<format.ml:1300:43>>*/ };
-     /*<<format.ml:1300:56>>*/ if(! param)
-      /*<<format.ml:1301:10>>*/ return  /*<<format.ml:1301:10>>*/ caml_call2
-             (none, ppf, 0);
-    var v = param[1];
-     /*<<format.ml:1302:12>>*/ return  /*<<format.ml:1302:12>>*/ caml_call2
-            (pp_v, ppf, v);
-   }
-   function pp_print_result(ok, error, ppf, param){
-     /*<<?>>*/ if(0 === param[0]){
-     var v = param[1];
-      /*<<format.ml:1305:10>>*/ return  /*<<format.ml:1305:10>>*/ caml_call2
-             (ok, ppf, v);
-    }
-    var e = param[1];
-     /*<<format.ml:1306:13>>*/ return  /*<<format.ml:1306:13>>*/ caml_call2
-            (error, ppf, e);
-   }
-   function pp_print_either(left, right, ppf, param){
-     /*<<?>>*/ if(0 === param[0]){
-     var l = param[1];
-      /*<<format.ml:1309:19>>*/ return  /*<<format.ml:1309:19>>*/ caml_call2
-             (left, ppf, l);
-    }
-    var r = param[1];
-     /*<<format.ml:1310:20>>*/ return  /*<<format.ml:1310:20>>*/ caml_call2
-            (right, ppf, r);
-   }
-   function compute_tag(output, tag_acc){
-     /*<<format.ml:1315:2>>*/ var
-      /*<<format.ml:1315:12>>*/ buf =
-        /*<<format.ml:1315:12>>*/ caml_call1(Stdlib_Buffer[1], 16),
-      /*<<format.ml:1316:12>>*/ ppf = formatter_of_buffer(buf);
-     /*<<format.ml:1317:2>>*/  /*<<format.ml:1317:2>>*/ caml_call2
-     (output, ppf, tag_acc);
-     /*<<format.ml:1318:2>>*/ pp_print_flush(ppf, 0);
-     /*<<format.ml:1319:12>>*/  /*<<format.ml:1319:12>>*/ var
-     len =  /*<<format.ml:1319:12>>*/ caml_call1(Stdlib_Buffer[7], buf);
-     /*<<format.ml:1320:2>>*/ return 2 <= len
-            ?  /*<<format.ml:1321:7>>*/ caml_call3
-              (Stdlib_Buffer[4], buf, 1, len - 2 | 0)
-            :  /*<<format.ml:1320:18>>*/ caml_call1(Stdlib_Buffer[2], buf);
-    /*<<format.ml:1321:33>>*/ }
-   function output_formatting_lit(ppf, fmting_lit){
-     /*<<format.ml:1334:43>>*/ if(typeof fmting_lit === "number")
-     switch(fmting_lit){
-       case 0:
-         /*<<format.ml:1335:33>>*/ return pp_close_box(ppf, 0);
-       case 1:
-         /*<<format.ml:1336:33>>*/ return pp_close_stag(ppf, 0);
-       case 2:
-         /*<<format.ml:1338:33>>*/ return pp_print_flush(ppf, 0);
-       case 3:
-         /*<<format.ml:1339:33>>*/ return pp_force_newline(ppf, 0);
-       case 4:
-         /*<<format.ml:1340:33>>*/ return pp_print_newline(ppf, 0);
-       case 5:
-         /*<<format.ml:1342:33>>*/ return pp_print_char(ppf, 64);
-       default:  /*<<format.ml:1343:33>>*/ return pp_print_char(ppf, 37);
-     }
-    switch(fmting_lit[0]){
-      case 0:
-       var offset = fmting_lit[3], width = fmting_lit[2];
-        /*<<format.ml:1337:33>>*/ return pp_print_break(ppf, width, offset);
-      case 1:
-        /*<<format.ml:1341:33>>*/ return 0;
-      default:
-       var c = fmting_lit[1];
-        /*<<format.ml:1344:33>>*/ pp_print_char(ppf, 64);
-        /*<<format.ml:1344:33>>*/ return pp_print_char(ppf, c);
-    }
-    /*<<format.ml:1344:75>>*/ }
-   function output_acc(ppf, acc){
-     /*<<format.ml:1350:29>>*/ if(typeof acc === "number")
-      /*<<format.ml:1376:32>>*/ return 0;
-    a:
-    {
-     b:
-     {
-      c:
-      {
-       switch(acc[0]){
-         case 0:
-          var f = acc[2], p = acc[1];
-           /*<<format.ml:1360:4>>*/ output_acc(ppf, p);
-           /*<<format.ml:1360:4>>*/ return output_formatting_lit(ppf, f);
-         case 1:
-          var match = acc[2], p$0 = acc[1];
-          if(0 === match[0]){
-           var acc$0 = match[1];
-            /*<<format.ml:1363:4>>*/ output_acc(ppf, p$0);
-            /*<<format.ml:1364:21>>*/ return pp_open_stag
-                   (ppf, [0, String_tag, compute_tag(output_acc, acc$0)]);
-          }
-          var acc$1 = match[1];
-           /*<<format.ml:1366:4>>*/ output_acc(ppf, p$0);
-           /*<<format.ml:1367:43>>*/ var
-            /*<<format.ml:1367:43>>*/ _$_ = compute_tag(output_acc, acc$1),
-            /*<<format.ml:1367:24>>*/ match$0 =
-              /*<<format.ml:1367:24>>*/ caml_call1
-              (CamlinternalFormat[20], _$_),
-           bty = match$0[2],
-           indent = match$0[1];
-           /*<<format.ml:1368:4>>*/ return pp_open_box_gen(ppf, indent, bty);
-         case 2:
-          var _aa_ = acc[1];
-          if(typeof _aa_ !== "number" && 0 === _aa_[0]){
-           var _ab_ = _aa_[2];
-           if(typeof _ab_ !== "number" && 1 === _ab_[0]){
-            var s$0 = acc[2], size = _ab_[2], p$2 = _aa_[1];
-            break b;
-           }
-          }
-          var s = acc[2], p$1 = _aa_;
-          break a;
-         case 3:
-          var _ac_ = acc[1];
-          if(typeof _ac_ !== "number" && 0 === _ac_[0]){
-           var _ad_ = _ac_[2];
-           if(typeof _ad_ !== "number" && 1 === _ad_[0]){
-            var c$0 = acc[2], size$0 = _ad_[2], p$4 = _ac_[1];
-            break;
-           }
-          }
-          var c = acc[2], p$3 = _ac_;
-          break c;
-         case 4:
-          var _ae_ = acc[1];
-          if(typeof _ae_ !== "number" && 0 === _ae_[0]){
-           var _af_ = _ae_[2];
-           if(typeof _af_ !== "number" && 1 === _af_[0]){
-            var s$0 = acc[2], size = _af_[2], p$2 = _ae_[1];
-            break b;
-           }
-          }
-          var s = acc[2], p$1 = _ae_;
-          break a;
-         case 5:
-          var _ag_ = acc[1];
-          if(typeof _ag_ !== "number" && 0 === _ag_[0]){
-           var _ah_ = _ag_[2];
-           if(typeof _ah_ !== "number" && 1 === _ah_[0]){
-            var c$0 = acc[2], size$0 = _ah_[2], p$4 = _ag_[1];
-            break;
-           }
-          }
-          var c = acc[2], p$3 = _ag_;
-          break c;
-         case 6:
-          var f$0 = acc[2], p$5 = acc[1];
-           /*<<format.ml:1373:32>>*/ output_acc(ppf, p$5);
-           /*<<format.ml:1373:32>>*/ return  /*<<format.ml:1373:32>>*/ caml_call1
-                  (f$0, ppf);
-         case 7:
-          var p$6 = acc[1];
-           /*<<format.ml:1374:32>>*/ output_acc(ppf, p$6);
-           /*<<format.ml:1374:32>>*/ return pp_print_flush(ppf, 0);
-         default:
-          var msg = acc[2], p$7 = acc[1];
-           /*<<format.ml:1375:32>>*/ output_acc(ppf, p$7);
-           /*<<format.ml:1375:32>>*/ return  /*<<format.ml:1375:32>>*/ caml_call1
-                  (Stdlib[1], msg);
-       }
-        /*<<format.ml:1357:4>>*/ output_acc(ppf, p$4);
-        /*<<format.ml:1358:44>>*/ return pp_print_as_size
-               (ppf,
-                size$0,
-                 /*<<format.ml:1358:44>>*/ caml_call2
-                 (Stdlib_String[1], 1, c$0));
-      }
-       /*<<format.ml:1372:32>>*/ output_acc(ppf, p$3);
-       /*<<format.ml:1372:32>>*/ return pp_print_char(ppf, c);
-     }
-      /*<<format.ml:1353:4>>*/ output_acc(ppf, p$2);
-      /*<<format.ml:1353:4>>*/ return pp_print_as_size(ppf, size, s$0);
-    }
-     /*<<format.ml:1370:32>>*/ output_acc(ppf, p$1);
-     /*<<format.ml:1370:32>>*/ return pp_print_string(ppf, s);
-    /*<<format.ml:1376:34>>*/ }
-   function strput_acc(ppf, acc){
-     /*<<format.ml:1382:29>>*/ if(typeof acc === "number")
-      /*<<format.ml:1411:32>>*/ return 0;
-    a:
-    {
-     b:
-     {
-      c:
-      {
-       switch(acc[0]){
-         case 0:
-          var f = acc[2], p = acc[1];
-           /*<<format.ml:1395:4>>*/ strput_acc(ppf, p);
-           /*<<format.ml:1395:4>>*/ return output_formatting_lit(ppf, f);
-         case 1:
-          var match = acc[2], p$0 = acc[1];
-          if(0 === match[0]){
-           var acc$0 = match[1];
-            /*<<format.ml:1398:4>>*/ strput_acc(ppf, p$0);
-            /*<<format.ml:1399:21>>*/ return pp_open_stag
-                   (ppf, [0, String_tag, compute_tag(strput_acc, acc$0)]);
-          }
-          var acc$1 = match[1];
-           /*<<format.ml:1401:4>>*/ strput_acc(ppf, p$0);
-           /*<<format.ml:1402:43>>*/ var
-            /*<<format.ml:1402:43>>*/ _S_ = compute_tag(strput_acc, acc$1),
-            /*<<format.ml:1402:24>>*/ match$0 =
-              /*<<format.ml:1402:24>>*/ caml_call1
-              (CamlinternalFormat[20], _S_),
-           bty = match$0[2],
-           indent = match$0[1];
-           /*<<format.ml:1403:4>>*/ return pp_open_box_gen(ppf, indent, bty);
-         case 2:
-          var _T_ = acc[1];
-          if(typeof _T_ !== "number" && 0 === _T_[0]){
-           var _U_ = _T_[2];
-           if(typeof _U_ !== "number" && 1 === _U_[0]){
-            var s$0 = acc[2], size = _U_[2], p$2 = _T_[1];
-            break b;
-           }
-          }
-          var s = acc[2], p$1 = _T_;
-          break a;
-         case 3:
-          var _V_ = acc[1];
-          if(typeof _V_ !== "number" && 0 === _V_[0]){
-           var _W_ = _V_[2];
-           if(typeof _W_ !== "number" && 1 === _W_[0]){
-            var c$0 = acc[2], size$0 = _W_[2], p$4 = _V_[1];
-            break;
-           }
-          }
-          var c = acc[2], p$3 = _V_;
-          break c;
-         case 4:
-          var _X_ = acc[1];
-          if(typeof _X_ !== "number" && 0 === _X_[0]){
-           var _Y_ = _X_[2];
-           if(typeof _Y_ !== "number" && 1 === _Y_[0]){
-            var s$0 = acc[2], size = _Y_[2], p$2 = _X_[1];
-            break b;
-           }
-          }
-          var s = acc[2], p$1 = _X_;
-          break a;
-         case 5:
-          var _Z_ = acc[1];
-          if(typeof _Z_ !== "number" && 0 === _Z_[0]){
-           var ___ = _Z_[2];
-           if(typeof ___ !== "number" && 1 === ___[0]){
-            var c$0 = acc[2], size$0 = ___[2], p$4 = _Z_[1];
-            break;
-           }
-          }
-          var c = acc[2], p$3 = _Z_;
-          break c;
-         case 6:
-          var p$5 = acc[1];
-          if(typeof p$5 !== "number" && 0 === p$5[0]){
-           var match$1 = p$5[2];
-           if(typeof match$1 !== "number" && 1 === match$1[0]){
-            var f$1 = acc[2], size$1 = match$1[2], p$6 = p$5[1];
-             /*<<format.ml:1392:4>>*/ strput_acc(ppf, p$6);
-             /*<<format.ml:1393:44>>*/ return pp_print_as_size
-                    (ppf, size$1,  /*<<format.ml:1393:44>>*/ caml_call1(f$1, 0));
-           }
-          }
-          var f$0 = acc[2];
-           /*<<format.ml:1408:32>>*/ strput_acc(ppf, p$5);
-           /*<<format.ml:1408:70>>*/ return pp_print_string
-                  (ppf,  /*<<format.ml:1408:70>>*/ caml_call1(f$0, 0));
-         case 7:
-          var p$7 = acc[1];
-           /*<<format.ml:1409:32>>*/ strput_acc(ppf, p$7);
-           /*<<format.ml:1409:32>>*/ return pp_print_flush(ppf, 0);
-         default:
-          var msg = acc[2], p$8 = acc[1];
-           /*<<format.ml:1410:32>>*/ strput_acc(ppf, p$8);
-           /*<<format.ml:1410:32>>*/ return  /*<<format.ml:1410:32>>*/ caml_call1
-                  (Stdlib[1], msg);
-       }
-        /*<<format.ml:1389:4>>*/ strput_acc(ppf, p$4);
-        /*<<format.ml:1390:44>>*/ return pp_print_as_size
-               (ppf,
-                size$0,
-                 /*<<format.ml:1390:44>>*/ caml_call2
-                 (Stdlib_String[1], 1, c$0));
-      }
-       /*<<format.ml:1407:32>>*/ strput_acc(ppf, p$3);
-       /*<<format.ml:1407:32>>*/ return pp_print_char(ppf, c);
-     }
-      /*<<format.ml:1385:4>>*/ strput_acc(ppf, p$2);
-      /*<<format.ml:1385:4>>*/ return pp_print_as_size(ppf, size, s$0);
-    }
-     /*<<format.ml:1405:32>>*/ strput_acc(ppf, p$1);
-     /*<<format.ml:1405:32>>*/ return pp_print_string(ppf, s);
-    /*<<format.ml:1411:34>>*/ }
-   function kfprintf(k, ppf, param){
-     /*<<format.ml:1420:2>>*/ var
-     fmt = param[1],
-      /*<<format.ml:1420:2>>*/ _Q_ = 0;
-    function _R_(acc){
-      /*<<format.ml:1421:16>>*/ output_acc(ppf, acc);
-     return caml_call1(k, ppf);
-     /*<<format.ml:1421:41>>*/ }
-     /*<<format.ml:1420:2>>*/ return  /*<<format.ml:1420:2>>*/ caml_call3
-            (CamlinternalFormat[7], _R_, _Q_, fmt);
-   }
-   function ikfprintf(k, ppf, param){
-    var fmt = param[1];
-     /*<<format.ml:1425:2>>*/ return  /*<<format.ml:1425:2>>*/ caml_call3
-            (CamlinternalFormat[8], k, ppf, fmt);
-   }
-   function ifprintf(ppf, param){
-     /*<<format.ml:1428:2>>*/ var
-     fmt = param[1],
-      /*<<format.ml:1428:2>>*/ _N_ = 0;
-    function _O_(_P_){ /*<<?>>*/ return 0;}
-     /*<<format.ml:1428:2>>*/ return  /*<<format.ml:1428:2>>*/ caml_call3
-            (CamlinternalFormat[8], _O_, _N_, fmt);
-   }
-   function fprintf(ppf){
-    function _K_(_M_){ /*<<?>>*/ return 0;}
-     /*<<format.ml:1430:18>>*/ return function(_L_){
-      /*<<?>>*/ return kfprintf(_K_, ppf, _L_);};
-    /*<<format.ml:1430:37>>*/ }
-   function printf(param){
-     /*<<format.ml:1433:2>>*/ var
-     fmt = param[1],
-      /*<<format.ml:1433:2>>*/ _I_ = 0;
-    function _J_(acc){
-      /*<<format.ml:1434:16>>*/ return output_acc
-             ( /*<<format.ml:1434:27>>*/ caml_call1
-               (Stdlib_Domain[10][2], std_formatter_key),
-              acc);
-     /*<<format.ml:1434:58>>*/ }
-     /*<<format.ml:1433:2>>*/ return  /*<<format.ml:1433:2>>*/ caml_call3
-            (CamlinternalFormat[7], _J_, _I_, fmt);
-   }
-   function eprintf(param){
-     /*<<format.ml:1438:2>>*/ var
-     fmt = param[1],
-      /*<<format.ml:1438:2>>*/ _G_ = 0;
-    function _H_(acc){
-      /*<<format.ml:1439:16>>*/ return output_acc
-             ( /*<<format.ml:1439:27>>*/ caml_call1
-               (Stdlib_Domain[10][2], err_formatter_key),
-              acc);
-     /*<<format.ml:1439:58>>*/ }
-     /*<<format.ml:1438:2>>*/ return  /*<<format.ml:1438:2>>*/ caml_call3
-            (CamlinternalFormat[7], _H_, _G_, fmt);
-   }
-   function kdprintf(k, param){
-     /*<<format.ml:1443:2>>*/ var
-     fmt = param[1],
-      /*<<format.ml:1443:2>>*/ _E_ = 0;
-    function _F_(acc){
-      /*<<format.ml:1444:16>>*/ return  /*<<format.ml:1444:18>>*/ caml_call1
-             (k,
-              function(ppf){
-                /*<<format.ml:1444:30>>*/ return output_acc(ppf, acc);
-               /*<<format.ml:1444:48>>*/ });
-     /*<<format.ml:1444:49>>*/ }
-     /*<<format.ml:1443:2>>*/ return  /*<<format.ml:1443:2>>*/ caml_call3
-            (CamlinternalFormat[7], _F_, _E_, fmt);
-   }
-   function dprintf(fmt){
-     /*<<format.ml:1447:18>>*/ return kdprintf
-            (function(i){
-               /*<<format.ml:1447:37>>*/ return i;
-              /*<<format.ml:1447:38>>*/ },
-             fmt);
-    /*<<format.ml:1447:43>>*/ }
-   function ksprintf(k, param){
-     /*<<format.ml:1450:10>>*/ var
-     fmt = param[1],
-      /*<<format.ml:1450:10>>*/ b = pp_make_buffer(0),
-      /*<<format.ml:1451:12>>*/ ppf = formatter_of_buffer(b);
-    function k$0(acc){
-      /*<<format.ml:1453:4>>*/ strput_acc(ppf, acc);
-      /*<<format.ml:1454:6>>*/ return  /*<<format.ml:1454:6>>*/ caml_call1
-             (k, flush_buffer_formatter(b, ppf));
-     /*<<format.ml:1454:36>>*/ }
-     /*<<format.ml:1455:2>>*/ return  /*<<format.ml:1455:2>>*/ caml_call3
-            (CamlinternalFormat[7], k$0, 0, fmt);
-   }
-   function sprintf(fmt){
-     /*<<format.ml:1458:18>>*/ return ksprintf(id, fmt);
-    /*<<format.ml:1458:33>>*/ }
-   function kasprintf(k, param){
-     /*<<format.ml:1461:10>>*/ var
-     fmt = param[1],
-      /*<<format.ml:1461:10>>*/ b = pp_make_buffer(0),
-      /*<<format.ml:1462:12>>*/ ppf = formatter_of_buffer(b);
-    function k$0(acc){
-      /*<<format.ml:1464:4>>*/ output_acc(ppf, acc);
-      /*<<format.ml:1465:6>>*/ return  /*<<format.ml:1465:6>>*/ caml_call1
-             (k, flush_buffer_formatter(b, ppf));
-     /*<<format.ml:1465:36>>*/ }
-     /*<<format.ml:1466:2>>*/ return  /*<<format.ml:1466:2>>*/ caml_call3
-            (CamlinternalFormat[7], k$0, 0, fmt);
-   }
-   function asprintf(fmt){
-     /*<<format.ml:1469:19>>*/ return kasprintf(id, fmt);
-    /*<<format.ml:1469:35>>*/ }
-   function flush_standard_formatters(param){
-     /*<<format.ml:1474:2>>*/ pp_print_flush
-     ( /*<<format.ml:1474:17>>*/ caml_call1
-       (Stdlib_Domain[10][2], std_formatter_key),
-      0);
-     /*<<format.ml:1474:2>>*/ return pp_print_flush
-            ( /*<<format.ml:1475:17>>*/ caml_call1
-              (Stdlib_Domain[10][2], err_formatter_key),
-             0);
-    /*<<format.ml:1475:47>>*/ }
-    /*<<format.ml:1477:9>>*/  /*<<format.ml:1477:9>>*/ caml_call1
-    (Stdlib[100], flush_standard_formatters);
-   function _l_(param){
-     /*<<format.ml:1480:2>>*/ flush_standard_formatters(0);
-     /*<<format.ml:1481:11>>*/ var
-      /*<<format.ml:1481:11>>*/ fs =
-       pp_get_formatter_out_functions(std_formatter, 0),
-     _m_ = fs[5],
-     _n_ = fs[4],
-     _o_ = fs[3],
-     _p_ = Stdlib[39];
-     /*<<format.ml:1484:25>>*/ function _q_(_D_){
-      /*<<?>>*/ return buffered_out_flush(_p_, std_buf_key, _D_);
-    }
-     /*<<format.ml:1482:2>>*/ pp_set_formatter_out_functions
-     (std_formatter,
-      [0,
-       function(_A_, _B_, _C_){
-         /*<<?>>*/ return buffered_out_string(std_buf_key, _A_, _B_, _C_);
-       },
-       _q_,
-       _o_,
-       _n_,
-       _m_]);
-     /*<<format.ml:1486:11>>*/ var
-      /*<<format.ml:1486:11>>*/ fs$0 =
-       pp_get_formatter_out_functions(err_formatter, 0),
-     _r_ = fs$0[5],
-     _s_ = fs$0[4],
-     _t_ = fs$0[3],
-     _u_ = Stdlib[40];
-     /*<<format.ml:1489:25>>*/ function _v_(_z_){
-      /*<<?>>*/ return buffered_out_flush(_u_, err_buf_key, _z_);
-    }
-     /*<<format.ml:1488:4>>*/ return pp_set_formatter_out_functions
-            (err_formatter,
-             [0,
-              function(_w_, _x_, _y_){
-                /*<<?>>*/ return buffered_out_string
-                       (err_buf_key, _w_, _x_, _y_);
-              },
-              _v_,
-              _t_,
-              _s_,
-              _r_]);
-    /*<<format.ml:1489:71>>*/ }
-    /*<<format.ml:1479:9>>*/  /*<<format.ml:1479:9>>*/ caml_call1
-    (Stdlib_Domain[5], _l_);
-   var
-    Stdlib_Format =
-      [0,
-       pp_open_box,
-       open_box,
-       pp_close_box,
-       close_box,
-       pp_open_hbox,
-       open_hbox,
-       pp_open_vbox,
-       open_vbox,
-       pp_open_hvbox,
-       open_hvbox,
-       pp_open_hovbox,
-       open_hovbox,
-       pp_print_string,
-       print_string,
-       pp_print_bytes,
-       print_bytes,
-       pp_print_as,
-       print_as,
-       pp_print_int,
-       print_int,
-       pp_print_float,
-       print_float,
-       pp_print_char,
-       print_char,
-       pp_print_bool,
-       print_bool,
-       pp_print_space,
-       print_space,
-       pp_print_cut,
-       print_cut,
-       pp_print_break,
-       print_break,
-       pp_print_custom_break,
-       pp_force_newline,
-       force_newline,
-       pp_print_if_newline,
-       print_if_newline,
-       pp_print_flush,
-       print_flush,
-       pp_print_newline,
-       print_newline,
-       pp_set_margin,
-       set_margin,
-       pp_get_margin,
-       get_margin,
-       pp_set_max_indent,
-       set_max_indent,
-       pp_get_max_indent,
-       get_max_indent,
-       check_geometry,
-       pp_set_geometry,
-       set_geometry,
-       pp_safe_set_geometry,
-       safe_set_geometry,
-       pp_update_geometry,
-       update_geometry,
-       pp_get_geometry,
-       get_geometry,
-       pp_set_max_boxes,
-       set_max_boxes,
-       pp_get_max_boxes,
-       get_max_boxes,
-       pp_over_max_boxes,
-       over_max_boxes,
-       pp_open_tbox,
-       open_tbox,
-       pp_close_tbox,
-       close_tbox,
-       pp_set_tab,
-       set_tab,
-       pp_print_tab,
-       print_tab,
-       pp_print_tbreak,
-       print_tbreak,
-       pp_set_ellipsis_text,
-       set_ellipsis_text,
-       pp_get_ellipsis_text,
-       get_ellipsis_text,
-       String_tag,
-       pp_open_stag,
-       open_stag,
-       pp_close_stag,
-       close_stag,
-       pp_set_tags,
-       set_tags,
-       pp_set_print_tags,
-       set_print_tags,
-       pp_set_mark_tags,
-       set_mark_tags,
-       pp_get_print_tags,
-       get_print_tags,
-       pp_get_mark_tags,
-       get_mark_tags,
-       pp_set_formatter_out_channel,
-       set_formatter_out_channel,
-       pp_set_formatter_output_functi,
-       set_formatter_output_functions,
-       pp_get_formatter_output_functi,
-       get_formatter_output_functions,
-       pp_set_formatter_out_functions,
-       set_formatter_out_functions,
-       pp_get_formatter_out_functions,
-       get_formatter_out_functions,
-       pp_set_formatter_stag_function,
-       set_formatter_stag_functions,
-       pp_get_formatter_stag_function,
-       get_formatter_stag_functions,
-       formatter_of_out_channel,
-       synchronized_formatter_of_out_,
-       std_formatter,
-       get_std_formatter,
-       err_formatter,
-       get_err_formatter,
-       formatter_of_buffer,
-       stdbuf,
-       get_stdbuf,
-       str_formatter,
-       get_str_formatter,
-       flush_str_formatter,
-       make_formatter,
-       make_synchronized_formatter,
-       formatter_of_out_functions,
-       make_symbolic_output_buffer,
-       clear_symbolic_output_buffer,
-       get_symbolic_output_buffer,
-       flush_symbolic_output_buffer,
-       add_symbolic_output_item,
-       formatter_of_symbolic_output_b,
-       pp_print_list,
-       pp_print_seq,
-       pp_print_text,
-       pp_print_option,
-       pp_print_result,
-       pp_print_either,
-       fprintf,
-       printf,
-       eprintf,
-       sprintf,
-       asprintf,
-       dprintf,
-       ifprintf,
-       kfprintf,
-       kdprintf,
-       ikfprintf,
-       ksprintf,
-       kasprintf];
-   runtime.caml_register_global(35, Stdlib_Format, "Stdlib__Format");
-   return;
-   /*<<?>>*/ }
-  (globalThis));
-
-//# unitInfo: Provides: Stdlib__Scanf
-//# unitInfo: Requires: Assert_failure, CamlinternalFormat, CamlinternalFormatBasics, Stdlib, Stdlib__Buffer, Stdlib__Bytes, Stdlib__Int, Stdlib__Printf, Stdlib__String
-(function
-  (globalThis){
-   "use strict";
-   var
-    runtime = globalThis.jsoo_runtime,
-    cst$5 = '"',
-    cst$6 = "-",
-    cst_character = "character ",
-    cst_scanf_ml = "scanf.ml",
-    cst_scanf_bad_conversion$3 = 'scanf: bad conversion "%*"',
-    cst_scanning_of = "scanning of ",
-    caml_bytes_get = runtime.caml_bytes_get,
-    caml_int_of_string = runtime.caml_int_of_string,
-    caml_maybe_attach_backtrace = runtime.caml_maybe_attach_backtrace,
-    caml_ml_string_length = runtime.caml_ml_string_length,
-    caml_string_get = runtime.caml_string_get,
-    caml_string_notequal = runtime.caml_string_notequal,
-    caml_trampoline = runtime.caml_trampoline,
-    caml_trampoline_return = runtime.caml_trampoline_return,
-    caml_wrap_exception = runtime.caml_wrap_exception;
-    /*<<?>>*/ function caml_call1(f, a0){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 1
-            ? f(a0)
-            : runtime.caml_call_gen(f, [a0]);
-   }
-    /*<<?>>*/ function caml_call2(f, a0, a1){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 2
-            ? f(a0, a1)
-            : runtime.caml_call_gen(f, [a0, a1]);
-   }
-    /*<<?>>*/ function caml_call3(f, a0, a1, a2){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 3
-            ? f(a0, a1, a2)
-            : runtime.caml_call_gen(f, [a0, a1, a2]);
-   }
-    /*<<?>>*/ function caml_call4(f, a0, a1, a2, a3){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 4
-            ? f(a0, a1, a2, a3)
-            : runtime.caml_call_gen(f, [a0, a1, a2, a3]);
-   }
-   var
-    global_data = runtime.caml_get_global_data(),
-    cst$3 = cst$5,
-    cst$4 = cst$5,
-    cst$1 = cst$5,
-    cst$2 = cst$5,
-    cst$0 = cst$5,
-    cst = cst$6,
-    CamlinternalFormat = global_data.CamlinternalFormat,
-    CamlinternalFormatBasics = global_data.CamlinternalFormatBasics,
-    Stdlib_String = global_data.Stdlib__String,
-    Stdlib = global_data.Stdlib,
-    Assert_failure = global_data.Assert_failure,
-    Stdlib_Printf = global_data.Stdlib__Printf,
-    Stdlib_Int = global_data.Stdlib__Int,
-    Stdlib_Buffer = global_data.Stdlib__Buffer,
-    _r_ = [0, 91],
-    _q_ = [0, 123],
-    cst_end_of_input_not_found = "end of input not found",
-    cst_scanf_bad_conversion_a = 'scanf: bad conversion "%a"',
-    cst_scanf_bad_conversion_t = 'scanf: bad conversion "%t"',
-    cst_scanf_missing_reader = "scanf: missing reader",
-    _s_ = [0, cst_scanf_ml, 1414, 13],
-    cst_scanf_bad_conversion_custo =
-      'scanf: bad conversion "%?" (custom converter)',
-    cst_scanf_bad_conversion = cst_scanf_bad_conversion$3,
-    cst_scanf_bad_conversion$0 = cst_scanf_bad_conversion$3,
-    cst_scanf_bad_conversion$1 = 'scanf: bad conversion "%-"',
-    cst_scanf_bad_conversion$2 = cst_scanf_bad_conversion$3,
-    _t_ = [0, [3, 0, [10, 0]], "%S%!"],
-    cst_in_format = ' in format "',
-    _p_ = [0, 37, ""],
-    _o_ =
-      [0,
-       [11,
-        "scanf: bad input at char number ",
-        [4, 3, 0, 0, [11, ": ", [2, 0, 0]]]],
-       "scanf: bad input at char number %i: %s"],
-    _n_ =
-      [0,
-       [11, "the character ", [1, [11, " cannot start a boolean", 0]]],
-       "the character %C cannot start a boolean"],
-    _m_ =
-      [0,
-       [11, "bad character hexadecimal encoding \\", [0, [0, 0]]],
-       "bad character hexadecimal encoding \\%c%c"],
-    _l_ =
-      [0,
-       [11, "bad character decimal encoding \\", [0, [0, [0, 0]]]],
-       "bad character decimal encoding \\%c%c%c"],
-    cst_an = "an",
-    cst_x = "x",
-    cst_nfinity = "nfinity",
-    cst_digits = "digits",
-    _k_ =
-      [0,
-       [11,
-        cst_character,
-        [1, [11, " is not a valid ", [2, 0, [11, " digit", 0]]]]],
-       "character %C is not a valid %s digit"],
-    cst_decimal_digits = "decimal digits",
-    _j_ =
-      [0,
-       [11, cst_character, [1, [11, " is not a decimal digit", 0]]],
-       "character %C is not a decimal digit"],
-    cst_0b = "0b",
-    cst_0o = "0o",
-    cst_0u = "0u",
-    cst_0x = "0x",
-    _i_ = [0, cst_scanf_ml, 516, 9],
-    _h_ =
-      [0,
-       [11, "invalid boolean '", [2, 0, [12, 39, 0]]],
-       "invalid boolean '%s'"],
-    _g_ =
-      [0,
-       [11, "looking for ", [1, [11, ", found ", [1, 0]]]],
-       "looking for %C, found %C"],
-    cst_not_a_valid_float_in_hexad =
-      "not a valid float in hexadecimal notation",
-    cst_no_dot_or_exponent_part_fo =
-      "no dot or exponent part found in float token",
-    _f_ =
-      [0,
-       [11,
-        cst_scanning_of,
-        [2,
-         0,
-         [11,
-          " failed: premature end of file occurred before end of token",
-          0]]],
-       "scanning of %s failed: premature end of file occurred before end of token"],
-    _e_ =
-      [0,
-       [11,
-        cst_scanning_of,
-        [2,
-         0,
-         [11, " failed: the specified length was too short for token", 0]]],
-       "scanning of %s failed: the specified length was too short for token"],
-    _d_ =
-      [0,
-       [11, "illegal escape character ", [1, 0]],
-       "illegal escape character %C"],
-    cst_unnamed_function = "unnamed function",
-    cst_unnamed_character_string = "unnamed character string",
-    cst_unnamed_Stdlib_input_chann = "unnamed Stdlib input channel",
-    cst_Stdlib_Scanf_Scan_failure = "Stdlib.Scanf.Scan_failure",
-    cst_binary = "binary",
-    cst_octal = "octal",
-    cst_hexadecimal = "hexadecimal",
-    cst_a_Char = "a Char",
-    cst_a_String = "a String",
-    null_char = 0;
-   function next_char(ib){
-     /*<<scanf.ml:165:4>>*/ try{
-      /*<<scanf.ml:166:14>>*/  /*<<scanf.ml:166:14>>*/ var
-      c =  /*<<scanf.ml:166:14>>*/ caml_call1(ib[7], 0);
-     ib[2] = c;
-     ib[3] = 1;
-     ib[4] = ib[4] + 1 | 0;
-     if(10 === c) ib[5] = ib[5] + 1 | 0;
-      /*<<scanf.ml:171:6>>*/ return c;
-    }
-    catch(_bb_){
-     var _ba_ = caml_wrap_exception(_bb_);
-     if(_ba_ !== Stdlib[12]) throw caml_maybe_attach_backtrace(_ba_, 0);
-     ib[2] = null_char;
-     ib[3] = 0;
-     ib[1] = 1;
-      /*<<scanf.ml:177:6>>*/ return null_char;
-    }
-    /*<<scanf.ml:177:7>>*/ }
-   function peek_char(ib){
-     /*<<scanf.ml:181:4>>*/ return ib[3] ? ib[2] : next_char(ib);
-    /*<<scanf.ml:183:21>>*/ }
-   function checked_peek_char(ib){
-     /*<<scanf.ml:192:4>>*/  /*<<scanf.ml:192:12>>*/ var c = peek_char(ib);
-    if(ib[1])
-      /*<<scanf.ml:193:22>>*/ throw  /*<<scanf.ml:193:22>>*/ caml_maybe_attach_backtrace
-            (Stdlib[12], 1);
-     /*<<scanf.ml:194:4>>*/ return c;
-    /*<<scanf.ml:194:5>>*/ }
-   function end_of_input(ib){
-     /*<<scanf.ml:198:4>>*/ peek_char(ib);
-    return ib[1];
-    /*<<scanf.ml:199:13>>*/ }
-   function beginning_of_input(ib){
-     /*<<scanf.ml:204:30>>*/ return 0 === ib[4] ? 1 : 0;
-    /*<<scanf.ml:204:50>>*/ }
-   function name_of_input(ib){
-     /*<<scanf.ml:207:4>>*/ var match = ib[9];
-    if(typeof match === "number")
-     return 0 === match ? cst_unnamed_function : cst_unnamed_character_string;
-    if(0 === match[0])
-      /*<<scanf.ml:208:26>>*/ return cst_unnamed_Stdlib_input_chann;
-    var fname = match[1];
-     /*<<scanf.ml:209:32>>*/ return fname;
-    /*<<scanf.ml:211:47>>*/ }
-   function char_count(ib){
-     /*<<scanf.ml:215:4>>*/ return ib[3] ? ib[4] - 1 | 0 : ib[4];
-    /*<<scanf.ml:217:25>>*/ }
-   function invalidate_current_char(ib){
-     /*<<scanf.ml:224:35>>*/ ib[3] = 0;
-    return 0;
-    /*<<scanf.ml:224:71>>*/ }
-   function token_string(ib){
-     /*<<scanf.ml:227:4>>*/ var
-     token_buffer = ib[8],
-      /*<<scanf.ml:228:14>>*/ tok =
-        /*<<scanf.ml:228:14>>*/ caml_call1(Stdlib_Buffer[2], token_buffer);
-     /*<<scanf.ml:229:4>>*/  /*<<scanf.ml:229:4>>*/ caml_call1
-     (Stdlib_Buffer[8], token_buffer);
-    ib[6] = ib[6] + 1 | 0;
-     /*<<scanf.ml:231:4>>*/ return tok;
-    /*<<scanf.ml:231:7>>*/ }
-   function skip_char(width, ib){
-     /*<<scanf.ml:237:4>>*/ invalidate_current_char(ib);
-     /*<<scanf.ml:237:4>>*/ return width;
-    /*<<scanf.ml:238:9>>*/ }
-   function ignore_char(width, ib){
-     /*<<scanf.ml:241:29>>*/ return skip_char(width - 1 | 0, ib);
-    /*<<scanf.ml:241:53>>*/ }
-   function store_char(width, ib, c){
-     /*<<scanf.ml:244:4>>*/  /*<<scanf.ml:244:4>>*/ caml_call2
-     (Stdlib_Buffer[12], ib[8], c);
-     /*<<scanf.ml:244:4>>*/ return ignore_char(width, ib);
-    /*<<scanf.ml:245:24>>*/ }
-   var default_token_buffer_size = 1024;
-   function create(iname, next){
-     /*<<scanf.ml:250:26>>*/ return [0,
-            0,
-            null_char,
-            0,
-            0,
-            0,
-            0,
-            next,
-             /*<<scanf.ml:258:22>>*/ caml_call1
-             (Stdlib_Buffer[1], default_token_buffer_size),
-            iname];
-    /*<<scanf.ml:260:3>>*/ }
-   function from_string(s){
-     /*<<scanf.ml:264:4>>*/ var
-      /*<<scanf.ml:264:12>>*/ i = [0, 0],
-      /*<<scanf.ml:265:4>>*/ len =
-        /*<<scanf.ml:265:4>>*/ caml_ml_string_length(s);
-    function next(param){
-      /*<<scanf.ml:267:6>>*/ if(len <= i[1])
-       /*<<scanf.ml:267:24>>*/ throw  /*<<scanf.ml:267:24>>*/ caml_maybe_attach_backtrace
-             (Stdlib[12], 1);
-      /*<<scanf.ml:268:14>>*/  /*<<scanf.ml:268:14>>*/ var
-      c =  /*<<scanf.ml:268:14>>*/ caml_string_get(s, i[1]);
-      /*<<scanf.ml:269:6>>*/ i[1]++;
-      /*<<scanf.ml:270:6>>*/ return c;
-     /*<<scanf.ml:270:7>>*/ }
-     /*<<scanf.ml:271:4>>*/ return create(1, next);
-    /*<<scanf.ml:271:27>>*/ }
-   var _a_ = 0;
-    /*<<scanf.ml:274:22>>*/ function from_function(_a$_){
-     /*<<?>>*/ return create(_a_, _a$_);
-   }
-    /*<<scanf.ml:274:22>>*/  /*<<scanf.ml:274:22>>*/ var len = 1024;
-   function scan_close_at_end(ic){
-     /*<<scanf.ml:320:29>>*/  /*<<scanf.ml:320:29>>*/ caml_call1
-     (Stdlib[93], ic);
-     /*<<scanf.ml:320:49>>*/ throw  /*<<scanf.ml:320:49>>*/ caml_maybe_attach_backtrace
-           (Stdlib[12], 1);
-    /*<<scanf.ml:320:66>>*/ }
-   function scan_raise_at_end(ic){
-     /*<<scanf.ml:324:30>>*/ throw  /*<<scanf.ml:324:30>>*/ caml_maybe_attach_backtrace
-           (Stdlib[12], 1);
-    /*<<scanf.ml:324:47>>*/ }
-   function from_ic(scan_close_ic, iname, ic){
-     /*<<scanf.ml:327:4>>*/ var
-      /*<<scanf.ml:328:14>>*/ buf =
-        /*<<scanf.ml:328:14>>*/ runtime.caml_create_bytes(1024),
-      /*<<scanf.ml:329:12>>*/ i = [0, 0],
-      /*<<scanf.ml:330:14>>*/ lim = [0, 0],
-      /*<<scanf.ml:331:14>>*/ eof = [0, 0];
-    function next(param){
-      /*<<scanf.ml:333:6>>*/ if(i[1] < lim[1]){
-       /*<<scanf.ml:333:38>>*/  /*<<scanf.ml:333:38>>*/ var
-       c =  /*<<scanf.ml:333:38>>*/ caml_bytes_get(buf, i[1]);
-       /*<<scanf.ml:333:58>>*/ i[1]++;
-       /*<<scanf.ml:333:66>>*/ return c;
-     }
-     if(eof[1])
-       /*<<scanf.ml:334:19>>*/ throw  /*<<scanf.ml:334:19>>*/ caml_maybe_attach_backtrace
-             (Stdlib[12], 1);
-     lim[1] =  /*<<scanf.ml:335:15>>*/ caml_call4(Stdlib[84], ic, buf, 0, len);
-     return 0 === lim[1]
-             ? (eof[1] = 1, caml_call1(scan_close_ic, ic))
-             : (i[1] = 1,  /*<<scanf.ml:338:10>>*/ caml_bytes_get(buf, 0));
-     /*<<scanf.ml:340:9>>*/ }
-     /*<<scanf.ml:341:4>>*/ return create(iname, next);
-    /*<<scanf.ml:341:21>>*/ }
-    /*<<scanf.ml:363:4>>*/  /*<<scanf.ml:363:4>>*/ var
-    stdin = from_ic(scan_raise_at_end, [1, cst, Stdlib[38]], Stdlib[38]);
-   function open_in_file(open_in, fname){
-     /*<<scanf.ml:367:4>>*/ if(! caml_string_notequal(fname, cst$6))
-      /*<<scanf.ml:363:4>>*/ return stdin;
-     /*<<scanf.ml:370:15>>*/  /*<<scanf.ml:370:15>>*/ var
-     ic =  /*<<scanf.ml:370:15>>*/ caml_call1(open_in, fname);
-    return from_ic(scan_close_at_end, [1, fname, ic], ic);
-    /*<<scanf.ml:371:53>>*/ }
-   var _b_ = Stdlib[79];
-    /*<<scanf.ml:374:16>>*/ function open_in(_a__){
-     /*<<?>>*/ return open_in_file(_b_, _a__);
-   }
-    /*<<scanf.ml:374:16>>*/  /*<<scanf.ml:374:16>>*/ var _c_ = Stdlib[80];
-    /*<<scanf.ml:375:20>>*/ function open_in_bin(_a9_){
-     /*<<?>>*/ return open_in_file(_c_, _a9_);
-   }
-   function from_channel(ic){
-     /*<<scanf.ml:381:4>>*/ return from_ic(scan_raise_at_end, [0, ic], ic);
-    /*<<scanf.ml:381:45>>*/ }
-   function close_in(ib){
-     /*<<scanf.ml:385:4>>*/ var match = ib[9];
-    if(typeof match === "number")  /*<<scanf.ml:389:37>>*/ return 0;
-    if(0 === match[0]){
-     var ic = match[1];
-      /*<<scanf.ml:387:6>>*/ return  /*<<scanf.ml:387:6>>*/ caml_call1
-             (Stdlib[93], ic);
-    }
-    var ic$0 = match[2];
-     /*<<scanf.ml:388:32>>*/ return  /*<<scanf.ml:388:32>>*/ caml_call1
-            (Stdlib[93], ic$0);
-    /*<<scanf.ml:389:39>>*/ }
-    /*<<scanf.ml:403:0>>*/  /*<<scanf.ml:403:0>>*/ var
-    Scan_failure =
-      [248, cst_Stdlib_Scanf_Scan_failure, runtime.caml_fresh_oo_id(0)];
-   function bad_input(s){
-     /*<<scanf.ml:405:18>>*/ throw  /*<<scanf.ml:405:18>>*/ caml_maybe_attach_backtrace
-           ([0, Scan_failure, s], 1);
-    /*<<scanf.ml:405:40>>*/ }
-   function bad_input_escape(c){
-     /*<<scanf.ml:408:2>>*/ return bad_input
-            ( /*<<scanf.ml:408:12>>*/ caml_call2(Stdlib_Printf[4], _d_, c));
-    /*<<scanf.ml:408:60>>*/ }
-   function bad_token_length(message){
-     /*<<scanf.ml:412:2>>*/ return bad_input
-            ( /*<<scanf.ml:413:4>>*/ caml_call2
-              (Stdlib_Printf[4], _e_, message));
-    /*<<scanf.ml:416:15>>*/ }
-   function bad_float(param){
-     /*<<scanf.ml:428:2>>*/ return bad_input(cst_no_dot_or_exponent_part_fo);
-    /*<<scanf.ml:428:58>>*/ }
-   function bad_hex_float(param){
-     /*<<scanf.ml:432:2>>*/ return bad_input(cst_not_a_valid_float_in_hexad);
-    /*<<scanf.ml:432:55>>*/ }
-   function character_mismatch(c, ci){
-     /*<<scanf.ml:440:2>>*/ return bad_input
-            ( /*<<scanf.ml:436:2>>*/ caml_call3(Stdlib_Printf[4], _g_, c, ci));
-    /*<<scanf.ml:440:41>>*/ }
-   function check_this_char(ib, c){
-     /*<<scanf.ml:474:2>>*/  /*<<scanf.ml:474:11>>*/ var
-     ci = checked_peek_char(ib);
-    return ci === c ? invalidate_current_char(ib) : character_mismatch(c, ci);
-    /*<<scanf.ml:476:25>>*/ }
-   function check_char(ib, c$0){
-     /*<<scanf.ml:468:2>>*/ if(10 === c$0){
-      /*<<scanf.ml:479:11>>*/  /*<<scanf.ml:479:11>>*/ var
-      ci = checked_peek_char(ib);
-      /*<<scanf.ml:480:2>>*/ return 10 === ci
-             ? invalidate_current_char(ib)
-             : 13
-               === ci
-               ? (invalidate_current_char(ib), check_this_char(ib, 10))
-               : character_mismatch(10, ci);
-    }
-    if(32 !== c$0)  /*<<scanf.ml:471:9>>*/ return check_this_char(ib, c$0);
-     /*<<scanf.ml:444:2>>*/ for(;;){
-      /*<<scanf.ml:444:10>>*/ var
-       /*<<scanf.ml:444:10>>*/ c = peek_char(ib),
-       /*<<scanf.ml:445:9>>*/ _a7_ = 1 - ib[1];
-     if(! _a7_)  /*<<scanf.ml:445:9>>*/ return _a7_;
-      /*<<scanf.ml:445:32>>*/  /*<<scanf.ml:445:32>>*/ var _a8_ = c - 9 | 0;
-     a:
-     {
-      if(4 < _a8_ >>> 0){
-       if(23 === _a8_) break a;
-      }
-      else if(1 < _a8_ - 2 >>> 0) break a;
-       /*<<scanf.ml:449:11>>*/ return 0;
-     }
-      /*<<scanf.ml:448:6>>*/ invalidate_current_char(ib);
-    }
-    /*<<scanf.ml:471:29>>*/ }
-   function token_char(ib){
-     /*<<scanf.ml:488:20>>*/ return  /*<<scanf.ml:488:20>>*/ caml_string_get
-            (token_string(ib), 0);
-    /*<<scanf.ml:488:43>>*/ }
-   function token_bool(ib){
-     /*<<scanf.ml:493:2>>*/  /*<<scanf.ml:493:8>>*/ var s = token_string(ib);
-    return caml_string_notequal(s, "false")
-            ? caml_string_notequal
-               (s, "true")
-              ? bad_input
-                ( /*<<scanf.ml:496:19>>*/ caml_call2(Stdlib_Printf[4], _h_, s))
-              : 1
-            : 0;
-    /*<<scanf.ml:496:60>>*/ }
-   function integer_conversion_of_char(param){
-     /*<<scanf.ml:509:33>>*/  /*<<scanf.ml:509:33>>*/ var
-     switcher = param - 88 | 0;
-    if(32 >= switcher >>> 0)
-     switch(switcher){
-       case 10:
-         /*<<scanf.ml:510:11>>*/ return 0;
-       case 12:
-         /*<<scanf.ml:511:11>>*/ return 1;
-       case 17:
-         /*<<scanf.ml:512:11>>*/ return 2;
-       case 23:
-         /*<<scanf.ml:513:11>>*/ return 3;
-       case 29:
-         /*<<scanf.ml:514:11>>*/ return 4;
-       case 0:
-       case 32:
-         /*<<scanf.ml:515:17>>*/ return 5;
-     }
-     /*<<scanf.ml:516:9>>*/ throw  /*<<scanf.ml:516:9>>*/ caml_maybe_attach_backtrace
-           ([0, Assert_failure, _i_], 1);
-    /*<<scanf.ml:516:21>>*/ }
-   function token_int_literal(conv, ib){
-     /*<<scanf.ml:523:2>>*/ switch(conv){
-      case 0:
-        /*<<scanf.ml:529:29>>*/ var
-         /*<<scanf.ml:529:29>>*/ _a3_ = token_string(ib),
-        tok =  /*<<scanf.ml:529:22>>*/ caml_call2(Stdlib[28], cst_0b, _a3_);
-       break;
-      case 3:
-        /*<<scanf.ml:527:29>>*/ var
-         /*<<scanf.ml:527:29>>*/ _a4_ = token_string(ib),
-        tok =  /*<<scanf.ml:527:22>>*/ caml_call2(Stdlib[28], cst_0o, _a4_);
-       break;
-      case 4:
-        /*<<scanf.ml:526:29>>*/ var
-         /*<<scanf.ml:526:29>>*/ _a5_ = token_string(ib),
-        tok =  /*<<scanf.ml:526:22>>*/ caml_call2(Stdlib[28], cst_0u, _a5_);
-       break;
-      case 5:
-        /*<<scanf.ml:528:29>>*/ var
-         /*<<scanf.ml:528:29>>*/ _a6_ = token_string(ib),
-        tok =  /*<<scanf.ml:528:22>>*/ caml_call2(Stdlib[28], cst_0x, _a6_);
-       break;
-      default: var tok = token_string(ib);
-    }
-     /*<<scanf.ml:530:2>>*/  /*<<scanf.ml:530:2>>*/ var
-     l =  /*<<scanf.ml:530:2>>*/ caml_ml_string_length(tok);
-     /*<<scanf.ml:531:14>>*/ if
-     (0 !== l && 43 ===  /*<<scanf.ml:531:14>>*/ caml_string_get(tok, 0))
-      /*<<scanf.ml:531:43>>*/ return  /*<<scanf.ml:531:43>>*/ caml_call3
-             (Stdlib_String[15], tok, 1, l - 1 | 0);
-     /*<<scanf.ml:531:34>>*/ return tok;
-    /*<<scanf.ml:531:67>>*/ }
-   function token_float(ib){
-     /*<<scanf.ml:539:21>>*/ return  /*<<scanf.ml:539:21>>*/ runtime.caml_float_of_string
-            (token_string(ib));
-    /*<<scanf.ml:539:56>>*/ }
-   function scan_decimal_digit_star(width, ib){
-     /*<<scanf.ml:575:2>>*/ var width$0 = width;
-     /*<<scanf.ml:575:2>>*/ for(;;){
-     if(0 === width$0)  /*<<scanf.ml:575:20>>*/ return width$0;
-      /*<<scanf.ml:576:10>>*/  /*<<scanf.ml:576:10>>*/ var c = peek_char(ib);
-      /*<<scanf.ml:577:5>>*/ if(ib[1])
-       /*<<scanf.ml:577:26>>*/ return width$0;
-     if(58 <= c){
-      if(95 === c){
-        /*<<scanf.ml:583:16>>*/ var
-         /*<<scanf.ml:583:16>>*/ width$1 = ignore_char(width$0, ib),
-        width$0 = width$1;
-       continue;
-      }
-     }
-     else if(48 <= c){
-       /*<<scanf.ml:580:16>>*/ var
-        /*<<scanf.ml:580:16>>*/ width$2 = store_char(width$0, ib, c),
-       width$0 = width$2;
-      continue;
-     }
-      /*<<scanf.ml:585:9>>*/ return width$0;
-    }
-    /*<<scanf.ml:585:14>>*/ }
-   function scan_decimal_digit_plus(width, ib){
-     /*<<scanf.ml:589:2>>*/ if(0 === width)
-      /*<<scanf.ml:589:20>>*/ return bad_token_length(cst_decimal_digits);
-     /*<<scanf.ml:590:10>>*/  /*<<scanf.ml:590:10>>*/ var
-     c = checked_peek_char(ib);
-    if(9 < c - 48 >>> 0)
-      /*<<scanf.ml:596:14>>*/ return bad_input
-             ( /*<<scanf.ml:596:14>>*/ caml_call2(Stdlib_Printf[4], _j_, c));
-     /*<<scanf.ml:593:16>>*/  /*<<scanf.ml:593:16>>*/ var
-     width$0 = store_char(width, ib, c);
-     /*<<scanf.ml:594:4>>*/ return scan_decimal_digit_star(width$0, ib);
-    /*<<scanf.ml:596:70>>*/ }
-   function scan_digit_plus(basis, digitp, width$2, ib){
-     /*<<scanf.ml:620:2>>*/ if(0 === width$2)
-      /*<<scanf.ml:620:20>>*/ return bad_token_length(cst_digits);
-     /*<<scanf.ml:621:10>>*/  /*<<scanf.ml:621:10>>*/ var
-     c$0 = checked_peek_char(ib);
-     /*<<scanf.ml:622:5>>*/ if
-     (!  /*<<scanf.ml:622:5>>*/ caml_call1(digitp, c$0))
-      /*<<scanf.ml:626:14>>*/ return bad_input
-             ( /*<<scanf.ml:626:14>>*/ caml_call3
-               (Stdlib_Printf[4], _k_, c$0, basis));
-     /*<<scanf.ml:623:16>>*/ var
-      /*<<scanf.ml:623:16>>*/ width$3 = store_char(width$2, ib, c$0),
-     width = width$3;
-     /*<<scanf.ml:603:4>>*/ for(;;){
-     if(0 === width)  /*<<scanf.ml:603:22>>*/ return width;
-      /*<<scanf.ml:604:12>>*/  /*<<scanf.ml:604:12>>*/ var c = peek_char(ib);
-      /*<<scanf.ml:605:7>>*/ if(ib[1])  /*<<scanf.ml:605:28>>*/ return width;
-      /*<<scanf.ml:607:13>>*/ if
-      ( /*<<scanf.ml:607:13>>*/ caml_call1(digitp, c))
-       /*<<scanf.ml:608:18>>*/ var
-        /*<<scanf.ml:608:18>>*/ width$0 = store_char(width, ib, c),
-       width = width$0;
-     else{
-      if(95 !== c)  /*<<scanf.ml:613:11>>*/ return width;
-       /*<<scanf.ml:611:18>>*/ var
-        /*<<scanf.ml:611:18>>*/ width$1 = ignore_char(width, ib),
-       width = width$1;
-     }
-    }
-    /*<<scanf.ml:626:77>>*/ }
-   function is_binary_digit(param){
-     /*<<scanf.ml:629:22>>*/ return 1 < param - 48 >>> 0 ? 0 : 1;
-    /*<<scanf.ml:631:14>>*/ }
-    /*<<scanf.ml:634:22>>*/ function scan_binary_int(_a1_, _a2_){
-     /*<<?>>*/ return scan_digit_plus(cst_binary, is_binary_digit, _a1_, _a2_);
-   }
-   function is_octal_digit(param){
-     /*<<scanf.ml:636:21>>*/ return 7 < param - 48 >>> 0 ? 0 : 1;
-    /*<<scanf.ml:638:14>>*/ }
-    /*<<scanf.ml:641:21>>*/ function scan_octal_int(_aZ_, _a0_){
-     /*<<?>>*/ return scan_digit_plus(cst_octal, is_octal_digit, _aZ_, _a0_);
-   }
-   function is_hexa_digit(param){
-     /*<<scanf.ml:643:20>>*/  /*<<scanf.ml:643:20>>*/ var
-     _aY_ = param - 48 | 0;
-    a:
-    {
-     if(22 < _aY_ >>> 0){
-      if(5 < _aY_ - 49 >>> 0) break a;
-     }
-     else if(6 >= _aY_ - 10 >>> 0) break a;
-      /*<<scanf.ml:644:44>>*/ return 1;
-    }
-     /*<<scanf.ml:645:9>>*/ return 0;
-    /*<<scanf.ml:645:14>>*/ }
-    /*<<scanf.ml:648:27>>*/ function scan_hexadecimal_int(_aW_, _aX_){
-     /*<<?>>*/ return scan_digit_plus
-            (cst_hexadecimal, is_hexa_digit, _aW_, _aX_);
-   }
-   function scan_sign(width, ib){
-     /*<<scanf.ml:654:2>>*/ var
-      /*<<scanf.ml:654:10>>*/ c = checked_peek_char(ib),
-      /*<<scanf.ml:654:10>>*/ switcher = c - 43 | 0;
-    if(2 >= switcher >>> 0)
-     switch(switcher){
-       case 0:
-         /*<<scanf.ml:656:11>>*/ return store_char(width, ib, c);
-       case 1: break;
-       default:  /*<<scanf.ml:657:11>>*/ return store_char(width, ib, c);
-     }
-     /*<<scanf.ml:658:9>>*/ return width;
-    /*<<scanf.ml:658:14>>*/ }
-   function scan_optionally_signed_decimal(width, ib){
-     /*<<scanf.ml:662:2>>*/  /*<<scanf.ml:662:14>>*/ var
-     width$0 = scan_sign(width, ib);
-     /*<<scanf.ml:663:2>>*/ return scan_decimal_digit_plus(width$0, ib);
-    /*<<scanf.ml:663:36>>*/ }
-   function scan_int_conversion(conv, width$1, ib){
-     /*<<scanf.ml:691:2>>*/ switch(conv){
-      case 0:
-        /*<<scanf.ml:692:20>>*/ return scan_binary_int(width$1, ib);
-      case 1:
-        /*<<scanf.ml:693:20>>*/ return scan_optionally_signed_decimal
-               (width$1, ib);
-      case 2:
-        /*<<scanf.ml:686:14>>*/ var
-         /*<<scanf.ml:686:14>>*/ width$0 = scan_sign(width$1, ib),
-         /*<<scanf.ml:671:8>>*/ c = checked_peek_char(ib);
-       if(48 !== c)
-         /*<<scanf.ml:682:9>>*/ return scan_decimal_digit_plus(width$0, ib);
-        /*<<scanf.ml:673:16>>*/  /*<<scanf.ml:673:16>>*/ var
-        width = store_char(width$0, ib, c);
-        /*<<scanf.ml:674:4>>*/ if(0 === width)
-         /*<<scanf.ml:674:22>>*/ return width;
-        /*<<scanf.ml:675:12>>*/  /*<<scanf.ml:675:12>>*/ var
-        c$0 = peek_char(ib);
-        /*<<scanf.ml:676:7>>*/ if(ib[1])
-         /*<<scanf.ml:676:28>>*/ return width;
-       a:
-       {
-        if(99 <= c$0){
-         if(111 === c$0)
-           /*<<scanf.ml:679:13>>*/ return scan_octal_int
-                  (store_char(width, ib, c$0), ib);
-         if(120 === c$0) break a;
-        }
-        else{
-         if(88 === c$0) break a;
-         if(98 <= c$0)
-           /*<<scanf.ml:680:13>>*/ return scan_binary_int
-                  (store_char(width, ib, c$0), ib);
-        }
-         /*<<scanf.ml:681:11>>*/ return scan_decimal_digit_star(width, ib);
-       }
-        /*<<scanf.ml:678:19>>*/ return scan_hexadecimal_int
-               (store_char(width, ib, c$0), ib);
-      case 3:
-        /*<<scanf.ml:695:20>>*/ return scan_octal_int(width$1, ib);
-      case 4:
-        /*<<scanf.ml:696:20>>*/ return scan_decimal_digit_plus(width$1, ib);
-      default:
-        /*<<scanf.ml:697:20>>*/ return scan_hexadecimal_int(width$1, ib);
-    }
-    /*<<scanf.ml:697:49>>*/ }
-   function scan_fractional_part(width, ib){
-     /*<<scanf.ml:704:2>>*/ if(0 === width)
-      /*<<scanf.ml:704:20>>*/ return width;
-     /*<<scanf.ml:705:10>>*/  /*<<scanf.ml:705:10>>*/ var c = peek_char(ib);
-     /*<<scanf.ml:706:5>>*/ return ib[1]
-            ? width
-            : 9
-              < c - 48 >>> 0
-              ? width
-              : scan_decimal_digit_star(store_char(width, ib, c), ib);
-    /*<<scanf.ml:710:14>>*/ }
-   function scan_exponent_part(width, ib){
-     /*<<scanf.ml:715:2>>*/ if(0 === width)
-      /*<<scanf.ml:715:20>>*/ return width;
-     /*<<scanf.ml:716:10>>*/  /*<<scanf.ml:716:10>>*/ var c = peek_char(ib);
-     /*<<scanf.ml:717:5>>*/ if(ib[1])  /*<<scanf.ml:717:26>>*/ return width;
-    if(69 !== c && 101 !== c)  /*<<scanf.ml:721:9>>*/ return width;
-     /*<<scanf.ml:720:4>>*/ return scan_optionally_signed_decimal
-            (store_char(width, ib, c), ib);
-    /*<<scanf.ml:721:14>>*/ }
-   function scan_float(width$1, precision, ib){
-     /*<<scanf.ml:765:2>>*/ var
-      /*<<scanf.ml:729:14>>*/ width = scan_sign(width$1, ib),
-      /*<<scanf.ml:730:2>>*/ width$0 = scan_decimal_digit_star(width, ib);
-     /*<<scanf.ml:766:2>>*/ if(0 === width$0)
-      /*<<scanf.ml:766:20>>*/ return [0, width$0, precision];
-     /*<<scanf.ml:767:10>>*/  /*<<scanf.ml:767:10>>*/ var c = peek_char(ib);
-     /*<<scanf.ml:768:5>>*/ if(ib[1])
-      /*<<scanf.ml:768:26>>*/ return [0, width$0, precision];
-    if(46 !== c)
-      /*<<scanf.ml:776:4>>*/ return [0,
-             scan_exponent_part(width$0, ib),
-             precision];
-     /*<<scanf.ml:771:16>>*/ var
-      /*<<scanf.ml:771:16>>*/ width$2 = store_char(width$0, ib, c),
-      /*<<scanf.ml:772:20>>*/ precision$0 =
-        /*<<scanf.ml:772:20>>*/ caml_call2(Stdlib_Int[10], width$2, precision),
-     width$3 =
-       width$2 - (precision$0 - scan_fractional_part(precision$0, ib) | 0) | 0;
-     /*<<scanf.ml:774:4>>*/ return [0,
-            scan_exponent_part(width$3, ib),
-            precision$0];
-    /*<<scanf.ml:776:42>>*/ }
-   function check_case_insensitive_string(width, ib, error, str){
-     /*<<scanf.ml:780:2>>*/ function lowercase(c){
-      /*<<scanf.ml:781:4>>*/ return 25 < c - 65 >>> 0
-             ? c
-             : caml_call1(Stdlib[29], (c - 65 | 0) + 97 | 0);
-     /*<<scanf.ml:784:12>>*/ }
-     /*<<scanf.ml:785:2>>*/ var
-      /*<<scanf.ml:785:2>>*/ len =
-        /*<<scanf.ml:785:2>>*/ caml_ml_string_length(str),
-      /*<<scanf.ml:786:14>>*/ width$0 = [0, width],
-      /*<<scanf.ml:787:2>>*/ _aT_ = len - 1 | 0,
-      /*<<scanf.ml:786:14>>*/ _aS_ = 0;
-    if(_aT_ >= 0){
-     var i = _aS_;
-     for(;;){
-       /*<<scanf.ml:788:12>>*/ var
-        /*<<scanf.ml:788:12>>*/ c = peek_char(ib),
-        /*<<scanf.ml:789:22>>*/ _aU_ =
-         lowercase( /*<<scanf.ml:789:32>>*/ caml_string_get(str, i));
-      if(lowercase(c) !== _aU_)
-        /*<<scanf.ml:789:45>>*/  /*<<scanf.ml:789:45>>*/ caml_call1(error, 0);
-      if(0 === width$0[1])
-        /*<<scanf.ml:790:23>>*/  /*<<scanf.ml:790:23>>*/ caml_call1(error, 0);
-      width$0[1] = store_char(width$0[1], ib, c);
-       /*<<scanf.ml:787:2>>*/  /*<<scanf.ml:787:2>>*/ var _aV_ = i + 1 | 0;
-      if(_aT_ === i) break;
-      var i = _aV_;
-     }
-    }
-    return width$0[1];
-    /*<<scanf.ml:793:8>>*/ }
-   function scan_hex_float(width, precision, ib){
-     /*<<scanf.ml:797:2>>*/ var
-     _aF_ = 0 === width ? 1 : 0,
-     _aG_ = _aF_ || end_of_input(ib);
-     /*<<scanf.ml:797:18>>*/ if(_aG_)
-      /*<<scanf.ml:797:48>>*/ bad_hex_float(0);
-     /*<<scanf.ml:798:14>>*/ var
-      /*<<scanf.ml:798:14>>*/ width$0 = scan_sign(width, ib),
-     _aH_ = 0 === width$0 ? 1 : 0,
-     _aI_ = _aH_ || end_of_input(ib);
-     /*<<scanf.ml:799:18>>*/ if(_aI_)
-      /*<<scanf.ml:799:48>>*/ bad_hex_float(0);
-     /*<<scanf.ml:800:8>>*/  /*<<scanf.ml:800:8>>*/ var c = peek_char(ib);
-    a:
-    {
-     if(78 <= c){
-       /*<<scanf.ml:800:8>>*/  /*<<scanf.ml:800:8>>*/ var
-       switcher = c - 79 | 0;
-      if(30 < switcher >>> 0){
-       if(32 <= switcher) break a;
-        /*<<scanf.ml:830:16>>*/ var
-         /*<<scanf.ml:830:16>>*/ width$1 = store_char(width$0, ib, c),
-        _aJ_ = 0 === width$1 ? 1 : 0,
-        _aK_ = _aJ_ || end_of_input(ib);
-        /*<<scanf.ml:831:20>>*/ if(_aK_)
-         /*<<scanf.ml:831:50>>*/ bad_hex_float(0);
-        /*<<scanf.ml:831:50>>*/ return check_case_insensitive_string
-               (width$1, ib, bad_hex_float, cst_an);
-      }
-      if(26 !== switcher) break a;
-     }
-     else{
-      if(48 === c){
-        /*<<scanf.ml:802:16>>*/ var
-         /*<<scanf.ml:802:16>>*/ width$3 = store_char(width$0, ib, c),
-        _aN_ = 0 === width$3 ? 1 : 0,
-        _aO_ = _aN_ || end_of_input(ib);
-        /*<<scanf.ml:803:20>>*/ if(_aO_)
-         /*<<scanf.ml:803:50>>*/ bad_hex_float(0);
-        /*<<scanf.ml:804:16>>*/  /*<<scanf.ml:804:16>>*/ var
-        width$4 =
-          check_case_insensitive_string(width$3, ib, bad_hex_float, cst_x);
-        /*<<scanf.ml:805:20>>*/ if(0 !== width$4 && ! end_of_input(ib)){
-         /*<<scanf.ml:806:24>>*/  /*<<scanf.ml:806:24>>*/ var
-         _aP_ = peek_char(ib) - 46 | 0;
-        b:
-        {
-         c:
-         {
-          if(34 < _aP_ >>> 0){
-           if(66 === _aP_) break c;
-          }
-          else if(32 < _aP_ - 1 >>> 0) break c;
-          var width$5 = scan_hexadecimal_int(width$4, ib);
-          break b;
-         }
-         var width$5 = width$4;
-        }
-         /*<<scanf.ml:809:22>>*/ if(0 !== width$5 && ! end_of_input(ib)){
-          /*<<scanf.ml:810:26>>*/  /*<<scanf.ml:810:26>>*/ var
-          c$0 = peek_char(ib);
-         if(46 === c$0){
-           /*<<scanf.ml:812:24>>*/  /*<<scanf.ml:812:24>>*/ var
-           width$6 = store_char(width$5, ib, c$0);
-          b:
-          {
-            /*<<scanf.ml:813:28>>*/ if(0 !== width$6 && ! end_of_input(ib)){
-             /*<<scanf.ml:814:20>>*/  /*<<scanf.ml:814:20>>*/ var
-             match = peek_char(ib);
-            c:
-            {
-             if(80 !== match && 112 !== match){
-               /*<<scanf.ml:817:32>>*/ var
-                /*<<scanf.ml:817:32>>*/ precision$0 =
-                  /*<<scanf.ml:817:32>>*/ caml_call2
-                  (Stdlib_Int[10], width$6, precision),
-               width$10 =
-                 width$6
-                 - (precision$0 - scan_hexadecimal_int(precision$0, ib) | 0)
-                 | 0;
-              break c;
-             }
-             var width$10 = width$6;
-            }
-            var width$7 = width$10;
-            break b;
-           }
-           var width$7 = width$6;
-          }
-          var width$8 = width$7;
-         }
-         else
-          var width$8 = width$5;
-          /*<<scanf.ml:821:24>>*/ if(0 !== width$8 && ! end_of_input(ib)){
-           /*<<scanf.ml:822:16>>*/  /*<<scanf.ml:822:16>>*/ var
-           c$1 = peek_char(ib);
-          if(80 !== c$1 && 112 !== c$1)
-            /*<<scanf.ml:827:17>>*/ return width$8;
-           /*<<scanf.ml:824:24>>*/ var
-            /*<<scanf.ml:824:24>>*/ width$9 = store_char(width$8, ib, c$1),
-           _aQ_ = 0 === width$9 ? 1 : 0,
-           _aR_ = _aQ_ || end_of_input(ib);
-           /*<<scanf.ml:825:28>>*/ if(_aR_)
-            /*<<scanf.ml:825:58>>*/ bad_hex_float(0);
-           /*<<scanf.ml:825:58>>*/ return scan_optionally_signed_decimal
-                  (width$9, ib);
-         }
-          /*<<scanf.ml:821:54>>*/ return width$8;
-        }
-         /*<<scanf.ml:809:52>>*/ return width$5;
-       }
-        /*<<scanf.ml:805:50>>*/ return width$4;
-      }
-      if(73 !== c) break a;
-     }
-      /*<<scanf.ml:834:16>>*/ var
-       /*<<scanf.ml:834:16>>*/ width$2 = store_char(width$0, ib, c),
-      _aL_ = 0 === width$2 ? 1 : 0,
-      _aM_ = _aL_ || end_of_input(ib);
-      /*<<scanf.ml:835:20>>*/ if(_aM_)
-       /*<<scanf.ml:835:50>>*/ bad_hex_float(0);
-      /*<<scanf.ml:835:50>>*/ return check_case_insensitive_string
-             (width$2, ib, bad_hex_float, cst_nfinity);
-    }
-     /*<<scanf.ml:837:9>>*/ return bad_hex_float(0);
-    /*<<scanf.ml:837:25>>*/ }
-   function scan_caml_float_rest(width, precision, ib){
-     /*<<scanf.ml:841:2>>*/ var
-     _aB_ = 0 === width ? 1 : 0,
-     _aC_ = _aB_ || end_of_input(ib);
-     /*<<scanf.ml:841:18>>*/ if(_aC_)  /*<<scanf.ml:841:48>>*/ bad_float(0);
-     /*<<scanf.ml:842:14>>*/ var
-      /*<<scanf.ml:842:14>>*/ width$0 = scan_decimal_digit_star(width, ib),
-     _aD_ = 0 === width$0 ? 1 : 0,
-     _aE_ = _aD_ || end_of_input(ib);
-     /*<<scanf.ml:843:18>>*/ if(_aE_)  /*<<scanf.ml:843:48>>*/ bad_float(0);
-     /*<<scanf.ml:844:10>>*/ var
-      /*<<scanf.ml:844:10>>*/ c = peek_char(ib),
-      /*<<scanf.ml:844:10>>*/ switcher = c - 69 | 0;
-    if(32 < switcher >>> 0){
-     if(-23 === switcher){
-       /*<<scanf.ml:847:16>>*/ var
-        /*<<scanf.ml:847:16>>*/ width$1 = store_char(width$0, ib, c),
-        /*<<scanf.ml:850:20>>*/ precision$0 =
-          /*<<scanf.ml:850:20>>*/ caml_call2
-          (Stdlib_Int[10], width$1, precision),
-        /*<<scanf.ml:853:26>>*/ width_precision =
-         scan_fractional_part(precision$0, ib),
-       frac_width = precision$0 - width_precision | 0,
-       width$2 = width$1 - frac_width | 0;
-       /*<<scanf.ml:859:4>>*/ return scan_exponent_part(width$2, ib);
-     }
-    }
-    else if(30 < switcher - 1 >>> 0)
-      /*<<scanf.ml:861:4>>*/ return scan_exponent_part(width$0, ib);
-     /*<<scanf.ml:862:9>>*/ return bad_float(0);
-    /*<<scanf.ml:862:21>>*/ }
-   function scan_caml_float(width, precision, ib){
-     /*<<scanf.ml:866:2>>*/ var
-     _an_ = 0 === width ? 1 : 0,
-     _ao_ = _an_ || end_of_input(ib);
-     /*<<scanf.ml:866:18>>*/ if(_ao_)  /*<<scanf.ml:866:48>>*/ bad_float(0);
-     /*<<scanf.ml:867:14>>*/ var
-      /*<<scanf.ml:867:14>>*/ width$0 = scan_sign(width, ib),
-     _ap_ = 0 === width$0 ? 1 : 0,
-     _aq_ = _ap_ || end_of_input(ib);
-     /*<<scanf.ml:868:18>>*/ if(_aq_)  /*<<scanf.ml:868:48>>*/ bad_float(0);
-     /*<<scanf.ml:869:8>>*/  /*<<scanf.ml:869:8>>*/ var c = peek_char(ib);
-    if(49 <= c){
-     if(58 > c){
-       /*<<scanf.ml:903:16>>*/ var
-        /*<<scanf.ml:903:16>>*/ width$1 = store_char(width$0, ib, c),
-       _ar_ = 0 === width$1 ? 1 : 0,
-       _as_ = _ar_ || end_of_input(ib);
-       /*<<scanf.ml:904:20>>*/ if(_as_)  /*<<scanf.ml:904:50>>*/ bad_float(0);
-       /*<<scanf.ml:904:50>>*/ return scan_caml_float_rest
-              (width$1, precision, ib);
-     }
-    }
-    else if(48 <= c){
-      /*<<scanf.ml:871:16>>*/ var
-       /*<<scanf.ml:871:16>>*/ width$2 = store_char(width$0, ib, c),
-      _at_ = 0 === width$2 ? 1 : 0,
-      _au_ = _at_ || end_of_input(ib);
-      /*<<scanf.ml:872:20>>*/ if(_au_)  /*<<scanf.ml:872:50>>*/ bad_float(0);
-      /*<<scanf.ml:873:10>>*/  /*<<scanf.ml:873:10>>*/ var
-      c$0 = peek_char(ib);
-     if(88 !== c$0 && 120 !== c$0)
-       /*<<scanf.ml:900:6>>*/ return scan_caml_float_rest
-              (width$2, precision, ib);
-      /*<<scanf.ml:875:18>>*/ var
-       /*<<scanf.ml:875:18>>*/ width$3 = store_char(width$2, ib, c$0),
-      _av_ = 0 === width$3 ? 1 : 0,
-      _aw_ = _av_ || end_of_input(ib);
-      /*<<scanf.ml:876:22>>*/ if(_aw_)  /*<<scanf.ml:876:52>>*/ bad_float(0);
-      /*<<scanf.ml:877:18>>*/ var
-       /*<<scanf.ml:877:18>>*/ width$4 = scan_hexadecimal_int(width$3, ib),
-      _ax_ = 0 === width$4 ? 1 : 0,
-      _ay_ = _ax_ || end_of_input(ib);
-      /*<<scanf.ml:878:22>>*/ if(_ay_)  /*<<scanf.ml:878:52>>*/ bad_float(0);
-      /*<<scanf.ml:879:24>>*/ var
-       /*<<scanf.ml:879:24>>*/ c$1 = peek_char(ib),
-       /*<<scanf.ml:879:24>>*/ switcher = c$1 - 80 | 0;
-     a:
-     {
-      b:
-      {
-       if(32 < switcher >>> 0){
-        if(-34 === switcher){
-          /*<<scanf.ml:881:22>>*/  /*<<scanf.ml:881:22>>*/ var
-          width$5 = store_char(width$4, ib, c$1);
-         c:
-         {
-           /*<<scanf.ml:882:26>>*/ if(0 !== width$5 && ! end_of_input(ib)){
-            /*<<scanf.ml:883:18>>*/  /*<<scanf.ml:883:18>>*/ var
-            match = peek_char(ib);
-           d:
-           {
-            if(80 !== match && 112 !== match){
-              /*<<scanf.ml:886:30>>*/ var
-               /*<<scanf.ml:886:30>>*/ precision$0 =
-                 /*<<scanf.ml:886:30>>*/ caml_call2
-                 (Stdlib_Int[10], width$5, precision),
-              width$10 =
-                width$5
-                - (precision$0 - scan_hexadecimal_int(precision$0, ib) | 0)
-                | 0;
-             break d;
-            }
-            var width$10 = width$5;
-           }
-           var width$6 = width$10;
-           break c;
-          }
-          var width$6 = width$5;
-         }
-         var width$7 = width$6;
-         break b;
-        }
-       }
-       else if(30 < switcher - 1 >>> 0){var width$7 = width$4; break b;}
-       var width$8 = bad_float(0);
-       break a;
-      }
-      var width$8 = width$7;
-     }
-      /*<<scanf.ml:891:22>>*/ if(0 !== width$8 && ! end_of_input(ib)){
-       /*<<scanf.ml:892:14>>*/  /*<<scanf.ml:892:14>>*/ var
-       c$2 = peek_char(ib);
-      if(80 !== c$2 && 112 !== c$2)  /*<<scanf.ml:897:15>>*/ return width$8;
-       /*<<scanf.ml:894:22>>*/ var
-        /*<<scanf.ml:894:22>>*/ width$9 = store_char(width$8, ib, c$2),
-       _az_ = 0 === width$9 ? 1 : 0,
-       _aA_ = _az_ || end_of_input(ib);
-       /*<<scanf.ml:895:26>>*/ if(_aA_)
-        /*<<scanf.ml:895:56>>*/ bad_hex_float(0);
-       /*<<scanf.ml:895:56>>*/ return scan_optionally_signed_decimal
-              (width$9, ib);
-     }
-      /*<<scanf.ml:891:52>>*/ return width$8;
-    }
-     /*<<scanf.ml:910:9>>*/ return bad_float(0);
-    /*<<scanf.ml:910:21>>*/ }
-   function scan_string(stp, width, ib){
-     /*<<scanf.ml:920:2>>*/ var width$0 = width;
-     /*<<scanf.ml:921:4>>*/ for(;;){
-     if(0 === width$0)  /*<<scanf.ml:921:22>>*/ return width$0;
-      /*<<scanf.ml:922:12>>*/  /*<<scanf.ml:922:12>>*/ var c = peek_char(ib);
-      /*<<scanf.ml:923:7>>*/ if(ib[1])
-       /*<<scanf.ml:923:28>>*/ return width$0;
-     if(! stp){
-       /*<<scanf.ml:928:8>>*/  /*<<scanf.ml:928:8>>*/ var _am_ = c - 9 | 0;
-      a:
-      {
-       if(4 < _am_ >>> 0){
-        if(23 === _am_) break a;
-       }
-       else if(1 < _am_ - 2 >>> 0) break a;
-        /*<<scanf.ml:930:20>>*/ var
-         /*<<scanf.ml:930:20>>*/ width$2 = store_char(width$0, ib, c),
-        width$0 = width$2;
-       continue;
-      }
-       /*<<scanf.ml:929:38>>*/ return width$0;
-     }
-     var c$0 = stp[1];
-     if(c === c$0)  /*<<scanf.ml:920:2>>*/ return skip_char(width$0, ib);
-      /*<<scanf.ml:926:23>>*/ var
-       /*<<scanf.ml:926:23>>*/ width$1 = store_char(width$0, ib, c),
-      width$0 = width$1;
-    }
-    /*<<scanf.ml:931:12>>*/ }
-   function hexadecimal_value_of_char(c){
-     /*<<scanf.ml:969:2>>*/ return 97 <= c
-            ? c - 87 | 0
-            : 65 <= c ? c - 55 | 0 : c - 48 | 0;
-    /*<<scanf.ml:979:23>>*/ }
-   function check_next_char(message, width, ib){
-     /*<<scanf.ml:995:2>>*/ if(0 === width)
-      /*<<scanf.ml:995:20>>*/ return bad_token_length(message);
-     /*<<scanf.ml:996:10>>*/  /*<<scanf.ml:996:10>>*/ var c = peek_char(ib);
-     /*<<scanf.ml:997:5>>*/ return ib[1]
-            ? bad_input
-              ( /*<<scanf.ml:421:4>>*/ caml_call2
-                (Stdlib_Printf[4], _f_, message))
-            : c;
-    /*<<scanf.ml:998:3>>*/ }
-    /*<<scanf.ml:1001:31>>*/ function check_next_char_for_char(_ak_, _al_){
-     /*<<?>>*/ return check_next_char(cst_a_Char, _ak_, _al_);
-   }
-    /*<<scanf.ml:1002:33>>*/ function check_next_char_for_string(_ai_, _aj_){
-     /*<<?>>*/ return check_next_char(cst_a_String, _ai_, _aj_);
-   }
-   function scan_backslash_char(width, ib){
-     /*<<scanf.ml:1005:2>>*/  /*<<scanf.ml:1005:8>>*/ var
-     c0 = check_next_char_for_char(width, ib);
-    a:
-    {
-     if(40 <= c0){
-      if(58 > c0){
-       if(48 > c0) break a;
-        /*<<scanf.ml:1015:13>>*/ var
-        get_digit$0 =
-          function(param){
-            /*<<scanf.ml:1010:6>>*/  /*<<scanf.ml:1010:14>>*/ var
-            c = next_char(ib);
-           return 9 < c - 48 >>> 0 ? bad_input_escape(c) : c;
-           /*<<scanf.ml:1013:31>>*/ },
-         /*<<scanf.ml:1015:13>>*/ c1$0 = get_digit$0(0),
-         /*<<scanf.ml:1016:13>>*/ c2$0 = get_digit$0(0),
-        c =
-          ((100 * (c0 - 48 | 0) | 0) + (10 * (c1$0 - 48 | 0) | 0) | 0)
-          + (c2$0 - 48 | 0)
-          | 0;
-       b:
-       {
-        if(0 <= c && 255 >= c){
-         var _ag_ =  /*<<scanf.ml:963:2>>*/ caml_call1(Stdlib[29], c);
-         break b;
-        }
-        var
-         _ag_ =
-           bad_input
-            ( /*<<scanf.ml:961:6>>*/ caml_call4
-              (Stdlib_Printf[4], _l_, c0, c1$0, c2$0));
-       }
-        /*<<scanf.ml:1017:39>>*/ return store_char(width - 2 | 0, ib, _ag_);
-      }
-       /*<<scanf.ml:1005:8>>*/  /*<<scanf.ml:1005:8>>*/ var
-       switcher = c0 - 92 | 0;
-      if(28 < switcher >>> 0) break a;
-      switch(switcher){
-        case 28:
-          /*<<scanf.ml:1024:13>>*/ var
-          get_digit =
-            function(param){
-              /*<<scanf.ml:1020:6>>*/ var
-               /*<<scanf.ml:1020:14>>*/ c = next_char(ib),
-               /*<<scanf.ml:1020:14>>*/ _ah_ = c - 48 | 0;
-             a:
-             {
-              if(22 < _ah_ >>> 0){
-               if(5 < _ah_ - 49 >>> 0) break a;
-              }
-              else if(6 >= _ah_ - 10 >>> 0) break a;
-               /*<<scanf.ml:1022:53>>*/ return c;
-             }
-              /*<<scanf.ml:1023:13>>*/ return bad_input_escape(c);
-             /*<<scanf.ml:1023:31>>*/ },
-           /*<<scanf.ml:1024:13>>*/ c1 = get_digit(0),
-           /*<<scanf.ml:1025:13>>*/ c2 = get_digit(0),
-           /*<<scanf.ml:985:9>>*/ _ad_ = hexadecimal_value_of_char(c2),
-          c$0 = (16 * hexadecimal_value_of_char(c1) | 0) + _ad_ | 0;
-         b:
-         {
-          if(0 <= c$0 && 255 >= c$0){
-           var _af_ =  /*<<scanf.ml:989:2>>*/ caml_call1(Stdlib[29], c$0);
-           break b;
-          }
-          var
-           _af_ =
-             bad_input
-              ( /*<<scanf.ml:988:6>>*/ caml_call3
-                (Stdlib_Printf[4], _m_, c1, c2));
-         }
-          /*<<scanf.ml:1026:39>>*/ return store_char(width - 2 | 0, ib, _af_);
-        case 0:
-        case 6:
-        case 18:
-        case 22:
-        case 24: break;
-        default: break a;
-      }
-     }
-     else if(34 !== c0 && 39 > c0) break a;
-     b:
-     {
-      if(110 <= c0){
-       if(117 > c0)
-        switch(c0 - 110 | 0){
-          case 0:
-           var _ae_ = 10; break b;
-          case 4:
-           var _ae_ = 13; break b;
-          case 6:
-           var _ae_ = 9; break b;
-        }
-      }
-      else if(98 === c0){var _ae_ = 8; break b;}
-      var _ae_ = c0;
-     }
-      /*<<scanf.ml:1007:33>>*/ return store_char(width, ib, _ae_);
-    }
-     /*<<scanf.ml:1028:4>>*/ return bad_input_escape(c0);
-    /*<<scanf.ml:1028:22>>*/ }
-   function scan_caml_string(width, ib){
-    function find_stop$0(counter, width){
-      /*<<scanf.ml:1063:4>>*/ var width$0 = width;
-      /*<<scanf.ml:1063:4>>*/ for(;;){
-       /*<<scanf.ml:1063:10>>*/  /*<<scanf.ml:1063:10>>*/ var
-       c = check_next_char_for_string(width$0, ib);
-      if(34 === c)  /*<<scanf.ml:1057:2>>*/ return ignore_char(width$0, ib);
-      if(92 === c){
-        /*<<scanf.ml:1065:29>>*/ var
-         /*<<scanf.ml:1065:29>>*/ width$1 = ignore_char(width$0, ib),
-         /*<<scanf.ml:1069:10>>*/ match =
-          check_next_char_for_string(width$1, ib);
-       if(10 === match){
-         /*<<scanf.ml:1071:26>>*/  /*<<scanf.ml:1071:26>>*/ var
-         _ab_ = ignore_char(width$1, ib);
-         /*<<scanf.ml:1071:26>>*/ if(counter >= 50)
-          /*<<scanf.ml:1071:26>>*/ return  /*<<scanf.ml:1071:26>>*/ caml_trampoline_return
-                 (skip_spaces, [0, _ab_]);
-        var counter$0 = counter + 1 | 0;
-         /*<<scanf.ml:1071:26>>*/ return skip_spaces(counter$0, _ab_);
-       }
-       if(13 === match){
-         /*<<scanf.ml:1070:27>>*/  /*<<scanf.ml:1070:27>>*/ var
-         width$3 = ignore_char(width$1, ib);
-        if(10 === check_next_char_for_string(width$3, ib)){
-          /*<<scanf.ml:1076:26>>*/  /*<<scanf.ml:1076:26>>*/ var
-          _ac_ = ignore_char(width$3, ib);
-          /*<<scanf.ml:1076:26>>*/ if(counter >= 50)
-           /*<<scanf.ml:1076:26>>*/ return  /*<<scanf.ml:1076:26>>*/ caml_trampoline_return
-                  (skip_spaces, [0, _ac_]);
-         var counter$1 = counter + 1 | 0;
-          /*<<scanf.ml:1076:26>>*/ return skip_spaces(counter$1, _ac_);
-        }
-         /*<<scanf.ml:1077:21>>*/ var
-          /*<<scanf.ml:1077:21>>*/ width$5 = store_char(width$3, ib, 13),
-         width$0 = width$5;
-       }
-       else
-         /*<<scanf.ml:1072:21>>*/ var
-          /*<<scanf.ml:1072:21>>*/ width$4 = scan_backslash_char(width$1, ib),
-         width$0 = width$4;
-      }
-      else
-        /*<<scanf.ml:1066:21>>*/ var
-         /*<<scanf.ml:1066:21>>*/ width$2 = store_char(width$0, ib, c),
-        width$0 = width$2;
-     }
-     /*<<scanf.ml:1066:53>>*/ }
-    function skip_spaces(counter, width){
-      /*<<scanf.ml:1080:4>>*/ var width$0 = width;
-      /*<<scanf.ml:1080:4>>*/ for(;;){
-      if(32 !== check_next_char_for_string(width$0, ib)){
-        /*<<scanf.ml:1082:11>>*/ if(counter >= 50)
-         /*<<scanf.ml:1082:11>>*/ return  /*<<scanf.ml:1082:11>>*/ caml_trampoline_return
-                (find_stop$0, [0, width$0]);
-       var counter$0 = counter + 1 | 0;
-        /*<<scanf.ml:1082:11>>*/ return find_stop$0(counter$0, width$0);
-      }
-       /*<<scanf.ml:1081:25>>*/ var
-        /*<<scanf.ml:1081:25>>*/ width$1 = ignore_char(width$0, ib),
-       width$0 = width$1;
-     }
-     /*<<scanf.ml:1082:26>>*/ }
-    function find_stop(width){
-      /*<<?>>*/ return caml_trampoline(find_stop$0(0, width));
-    }
-     /*<<scanf.ml:1058:10>>*/  /*<<scanf.ml:1058:10>>*/ var
-     c = checked_peek_char(ib);
-    return 34 === c
-            ? find_stop(ignore_char(width, ib))
-            : character_mismatch(34, c);
-    /*<<scanf.ml:1084:18>>*/ }
-   function scan_chars_in_char_set(char_set, scan_indic, width, ib){
-    function scan_chars(i, stp){
-      /*<<scanf.ml:1104:4>>*/ var i$0 = i;
-      /*<<scanf.ml:1104:4>>*/ for(;;){
-       /*<<scanf.ml:1104:12>>*/ var
-        /*<<scanf.ml:1104:12>>*/ c = peek_char(ib),
-       _Z_ = 0 < i$0 ? 1 : 0;
-      if(_Z_){
-        /*<<scanf.ml:1105:20>>*/  /*<<scanf.ml:1105:20>>*/ var
-        ___ = 1 - ib[1];
-       if(___)
-         /*<<scanf.ml:1106:7>>*/ var
-          /*<<scanf.ml:1106:7>>*/ _$_ =
-            /*<<scanf.ml:1106:7>>*/ caml_call2
-            (CamlinternalFormat[1], char_set, c),
-          /*<<scanf.ml:1106:7>>*/ _aa_ = _$_ ? c !== stp ? 1 : 0 : _$_;
-       else
-        var _aa_ = ___;
-      }
-      else
-       var _aa_ = _Z_;
-      if(! _aa_) return _aa_;
-       /*<<scanf.ml:1108:14>>*/ store_char(Stdlib[19], ib, c);
-      var i$1 = i$0 - 1 | 0, i$0 = i$1;
-     }
-     /*<<scanf.ml:1109:28>>*/ }
-    if(! scan_indic)  /*<<scanf.ml:1111:12>>*/ return scan_chars(width, -1);
-    var c = scan_indic[1];
-     /*<<scanf.ml:1113:4>>*/ scan_chars(width, c);
-     /*<<scanf.ml:1114:11>>*/  /*<<scanf.ml:1114:11>>*/ var _Y_ = 1 - ib[1];
-    if(! _Y_)  /*<<scanf.ml:1114:11>>*/ return _Y_;
-     /*<<scanf.ml:1115:15>>*/  /*<<scanf.ml:1115:15>>*/ var
-     ci = peek_char(ib);
-    return c === ci ? invalidate_current_char(ib) : character_mismatch(c, ci);
-    /*<<scanf.ml:1118:34>>*/ }
-   function scanf_bad_input(ib, x){
-     /*<<?>>*/ if(x[1] === Scan_failure)
-     var s = x[2];
-    else{
-     if(x[1] !== Stdlib[7])
-       /*<<scanf.ml:1126:9>>*/ throw  /*<<scanf.ml:1126:9>>*/ caml_maybe_attach_backtrace
-             (x, 1);
-     var s = x[2];
-    }
-     /*<<scanf.ml:1124:12>>*/  /*<<scanf.ml:1124:12>>*/ var
-     i = char_count(ib);
-     /*<<scanf.ml:1125:14>>*/ return bad_input
-            ( /*<<scanf.ml:1125:14>>*/ caml_call3(Stdlib_Printf[4], _o_, i, s));
-   }
-   function width_of_pad_opt(pad_opt){
-     /*<<scanf.ml:1138:31>>*/ if(! pad_opt)
-      /*<<scanf.ml:1139:12>>*/ return Stdlib[19];
-    var width = pad_opt[1];
-     /*<<scanf.ml:1140:18>>*/ return width;
-    /*<<scanf.ml:1140:23>>*/ }
-   function stopper_of_formatting_lit(fmting){
-     /*<<scanf.ml:1144:2>>*/ if(6 === fmting)
-      /*<<scanf.ml:1144:35>>*/ return _p_;
-     /*<<scanf.ml:1145:14>>*/ var
-      /*<<scanf.ml:1145:14>>*/ str =
-        /*<<scanf.ml:1145:14>>*/ caml_call1(CamlinternalFormat[17], fmting),
-      /*<<scanf.ml:1146:14>>*/ stp =
-        /*<<scanf.ml:1146:14>>*/ caml_string_get(str, 1),
-      /*<<scanf.ml:1147:18>>*/ sub_str =
-        /*<<scanf.ml:1147:18>>*/ caml_call3
-        (Stdlib_String[15],
-         str,
-         2,
-          /*<<scanf.ml:1147:4>>*/ caml_ml_string_length(str) - 2 | 0);
-     /*<<scanf.ml:1148:4>>*/ return [0, stp, sub_str];
-    /*<<scanf.ml:1148:16>>*/ }
-   function take_format_readers$0(counter, k, fmt){
-     /*<<scanf.ml:1161:13>>*/ var fmt$0 = fmt;
-     /*<<scanf.ml:1161:13>>*/ for(;;){
-     if(typeof fmt$0 === "number")
-       /*<<scanf.ml:1198:40>>*/ return  /*<<scanf.ml:1198:40>>*/ caml_call1
-              (k, 0);
-     switch(fmt$0[0]){
-       case 0:
-        var rest = fmt$0[1], fmt$0 = rest; break;
-       case 1:
-        var rest$0 = fmt$0[1], fmt$0 = rest$0; break;
-       case 2:
-        var rest$1 = fmt$0[2], fmt$0 = rest$1; break;
-       case 3:
-        var rest$2 = fmt$0[2], fmt$0 = rest$2; break;
-       case 4:
-        var rest$3 = fmt$0[4], fmt$0 = rest$3; break;
-       case 5:
-        var rest$4 = fmt$0[4], fmt$0 = rest$4; break;
-       case 6:
-        var rest$5 = fmt$0[4], fmt$0 = rest$5; break;
-       case 7:
-        var rest$6 = fmt$0[4], fmt$0 = rest$6; break;
-       case 8:
-        var rest$7 = fmt$0[4], fmt$0 = rest$7; break;
-       case 9:
-        var rest$8 = fmt$0[2], fmt$0 = rest$8; break;
-       case 10:
-        var rest$9 = fmt$0[1], fmt$0 = rest$9; break;
-       case 11:
-        var rest$10 = fmt$0[2], fmt$0 = rest$10; break;
-       case 12:
-        var rest$11 = fmt$0[2], fmt$0 = rest$11; break;
-       case 13:
-        var rest$12 = fmt$0[3], fmt$0 = rest$12; break;
-       case 14:
-         /*<<scanf.ml:1195:44>>*/ var
-         rest$13 = fmt$0[3],
-         fmtty = fmt$0[2],
-          /*<<scanf.ml:1195:44>>*/ _V_ =
-            /*<<scanf.ml:1195:44>>*/ caml_call1(CamlinternalFormat[21], fmtty),
-          /*<<scanf.ml:1195:33>>*/ _W_ =
-            /*<<scanf.ml:1195:33>>*/ caml_call1
-            (CamlinternalFormatBasics[2], _V_);
-         /*<<scanf.ml:1195:5>>*/ if(counter >= 50)
-          /*<<scanf.ml:1195:5>>*/ return  /*<<scanf.ml:1195:5>>*/ caml_trampoline_return
-                 (take_fmtty_format_readers$0, [0, k, _W_, rest$13]);
-        var counter$0 = counter + 1 | 0;
-         /*<<scanf.ml:1195:5>>*/ return take_fmtty_format_readers$0
-                (counter$0, k, _W_, rest$13);
-       case 15:
-        var rest$14 = fmt$0[1], fmt$0 = rest$14; break;
-       case 16:
-        var rest$15 = fmt$0[1], fmt$0 = rest$15; break;
-       case 17:
-        var rest$16 = fmt$0[2], fmt$0 = rest$16; break;
-       case 18:
-        var _X_ = fmt$0[1];
-        if(0 === _X_[0])
-          /*<<scanf.ml:1189:28>>*/ var
-          rest$17 = fmt$0[2],
-          fmt$1 = _X_[1][1],
-           /*<<scanf.ml:1189:28>>*/ fmt$2 =
-             /*<<scanf.ml:1189:28>>*/ caml_call2
-             (CamlinternalFormatBasics[3], fmt$1, rest$17),
-          fmt$0 = fmt$2;
-        else
-          /*<<scanf.ml:1191:28>>*/ var
-          rest$18 = fmt$0[2],
-          fmt$3 = _X_[1][1],
-           /*<<scanf.ml:1191:28>>*/ fmt$4 =
-             /*<<scanf.ml:1191:28>>*/ caml_call2
-             (CamlinternalFormatBasics[3], fmt$3, rest$18),
-          fmt$0 = fmt$4;
-        break;
-       case 19:
-        var fmt_rest = fmt$0[1];
-         /*<<scanf.ml:1163:4>>*/ return function(reader){
-         function new_k(readers_rest){
-           /*<<scanf.ml:1164:31>>*/ return  /*<<scanf.ml:1164:33>>*/ caml_call1
-                  (k, [0, reader, readers_rest]);
-          /*<<scanf.ml:1164:62>>*/ }
-          /*<<scanf.ml:1165:6>>*/ return take_format_readers(new_k, fmt_rest); /*<<scanf.ml:1165:40>>*/ };
-       case 20:
-        var rest$19 = fmt$0[3], fmt$0 = rest$19; break;
-       case 21:
-        var rest$20 = fmt$0[2], fmt$0 = rest$20; break;
-       case 22:
-        var rest$21 = fmt$0[1], fmt$0 = rest$21; break;
-       case 23:
-        var rest$22 = fmt$0[2], ign = fmt$0[1];
-        if(typeof ign === "number")
-         switch(ign){
-           case 0:
-            var fmt$0 = rest$22; break;
-           case 1:
-            var fmt$0 = rest$22; break;
-           case 2:
-             /*<<scanf.ml:1236:4>>*/ return function(reader){
-             function new_k(readers_rest){
-               /*<<scanf.ml:1237:31>>*/ return  /*<<scanf.ml:1237:33>>*/ caml_call1
-                      (k, [0, reader, readers_rest]);
-              /*<<scanf.ml:1237:62>>*/ }
-              /*<<scanf.ml:1238:6>>*/ return take_format_readers
-                     (new_k, rest$22); /*<<scanf.ml:1238:35>>*/ };
-           default: var fmt$0 = rest$22;
-         }
-        else
-         switch(ign[0]){
-           case 0:
-            var fmt$0 = rest$22; break;
-           case 1:
-            var fmt$0 = rest$22; break;
-           case 2:
-            var fmt$0 = rest$22; break;
-           case 3:
-            var fmt$0 = rest$22; break;
-           case 4:
-            var fmt$0 = rest$22; break;
-           case 5:
-            var fmt$0 = rest$22; break;
-           case 6:
-            var fmt$0 = rest$22; break;
-           case 7:
-            var fmt$0 = rest$22; break;
-           case 8:
-            var fmt$0 = rest$22; break;
-           case 9:
-            var fmtty$0 = ign[2];
-             /*<<scanf.ml:1250:39>>*/ if(counter >= 50)
-              /*<<scanf.ml:1250:39>>*/ return  /*<<scanf.ml:1250:39>>*/ caml_trampoline_return
-                     (take_fmtty_format_readers$0, [0, k, fmtty$0, rest$22]);
-            var counter$1 = counter + 1 | 0;
-             /*<<scanf.ml:1250:39>>*/ return take_fmtty_format_readers$0
-                    (counter$1, k, fmtty$0, rest$22);
-           case 10:
-            var fmt$0 = rest$22; break;
-           default: var fmt$0 = rest$22;
-         }
-        break;
-       default: var rest$23 = fmt$0[3], fmt$0 = rest$23;
-     }
-    }
-    /*<<scanf.ml:1198:45>>*/ }
-   function take_fmtty_format_readers$0(counter, k, fmtty, fmt){
-     /*<<scanf.ml:1204:19>>*/ var fmtty$0 = fmtty;
-     /*<<scanf.ml:1204:19>>*/ for(;;){
-     if(typeof fmtty$0 === "number"){
-       /*<<scanf.ml:1225:35>>*/ if(counter >= 50)
-        /*<<scanf.ml:1225:35>>*/ return  /*<<scanf.ml:1225:35>>*/ caml_trampoline_return
-               (take_format_readers$0, [0, k, fmt]);
-      var counter$0 = counter + 1 | 0;
-       /*<<scanf.ml:1225:35>>*/ return take_format_readers$0
-              (counter$0, k, fmt);
-     }
-     switch(fmtty$0[0]){
-       case 0:
-        var fmtty$1 = fmtty$0[1], fmtty$0 = fmtty$1; break;
-       case 1:
-        var fmtty$2 = fmtty$0[1], fmtty$0 = fmtty$2; break;
-       case 2:
-        var fmtty$3 = fmtty$0[1], fmtty$0 = fmtty$3; break;
-       case 3:
-        var fmtty$4 = fmtty$0[1], fmtty$0 = fmtty$4; break;
-       case 4:
-        var fmtty$5 = fmtty$0[1], fmtty$0 = fmtty$5; break;
-       case 5:
-        var fmtty$6 = fmtty$0[1], fmtty$0 = fmtty$6; break;
-       case 6:
-        var fmtty$7 = fmtty$0[1], fmtty$0 = fmtty$7; break;
-       case 7:
-        var fmtty$8 = fmtty$0[1], fmtty$0 = fmtty$8; break;
-       case 8:
-        var fmtty$9 = fmtty$0[2], fmtty$0 = fmtty$9; break;
-       case 9:
-         /*<<scanf.ml:1227:19>>*/ var
-         rest = fmtty$0[3],
-         ty2 = fmtty$0[2],
-         ty1 = fmtty$0[1],
-          /*<<scanf.ml:1227:19>>*/ _U_ =
-            /*<<scanf.ml:1227:19>>*/ caml_call1(CamlinternalFormat[21], ty1),
-          /*<<scanf.ml:1227:13>>*/ ty =
-            /*<<scanf.ml:1227:13>>*/ caml_call2
-            (CamlinternalFormat[22], _U_, ty2),
-          /*<<scanf.ml:1228:32>>*/ fmtty$10 =
-            /*<<scanf.ml:1228:32>>*/ caml_call2
-            (CamlinternalFormatBasics[1], ty, rest),
-         fmtty$0 = fmtty$10;
-        break;
-       case 10:
-        var fmtty$11 = fmtty$0[1], fmtty$0 = fmtty$11; break;
-       case 11:
-        var fmtty$12 = fmtty$0[1], fmtty$0 = fmtty$12; break;
-       case 12:
-        var fmtty$13 = fmtty$0[1], fmtty$0 = fmtty$13; break;
-       case 13:
-        var fmt_rest = fmtty$0[1];
-         /*<<scanf.ml:1206:4>>*/ return function(reader){
-         function new_k(readers_rest){
-           /*<<scanf.ml:1207:31>>*/ return  /*<<scanf.ml:1207:33>>*/ caml_call1
-                  (k, [0, reader, readers_rest]);
-          /*<<scanf.ml:1207:62>>*/ }
-          /*<<scanf.ml:1208:6>>*/ return take_fmtty_format_readers
-                 (new_k, fmt_rest, fmt); /*<<scanf.ml:1208:50>>*/ };
-       default:
-        var fmt_rest$0 = fmtty$0[1];
-         /*<<scanf.ml:1210:4>>*/ return function(reader){
-         function new_k(readers_rest){
-           /*<<scanf.ml:1211:31>>*/ return  /*<<scanf.ml:1211:33>>*/ caml_call1
-                  (k, [0, reader, readers_rest]);
-          /*<<scanf.ml:1211:62>>*/ }
-          /*<<scanf.ml:1212:6>>*/ return take_fmtty_format_readers
-                 (new_k, fmt_rest$0, fmt); /*<<scanf.ml:1212:50>>*/ };
-     }
-    }
-    /*<<scanf.ml:1228:58>>*/ }
-   function take_format_readers(k, fmt){
-     /*<<?>>*/ return caml_trampoline(take_format_readers$0(0, k, fmt));
-   }
-   function take_fmtty_format_readers(k, fmtty, fmt){
-     /*<<?>>*/ return caml_trampoline
-            (take_fmtty_format_readers$0(0, k, fmtty, fmt));
-   }
-   function pad_prec_scanf(ib, fmt, readers, pad, prec, scan, token){
-     /*<<scanf.ml:1429:42>>*/ if(typeof pad === "number"){
-     if(typeof prec !== "number"){
-      var p = prec[1];
-       /*<<scanf.ml:1435:12>>*/  /*<<scanf.ml:1435:12>>*/ caml_call3
-       (scan, Stdlib[19], p, ib);
-       /*<<scanf.ml:1436:12>>*/  /*<<scanf.ml:1436:12>>*/ var
-       x$0 =  /*<<scanf.ml:1436:12>>*/ caml_call1(token, ib);
-       /*<<scanf.ml:1437:4>>*/ return [0, x$0, make_scanf(ib, fmt, readers)];
-     }
-     if(prec)
-       /*<<scanf.ml:1453:4>>*/ return  /*<<scanf.ml:1453:4>>*/ caml_call1
-              (Stdlib[1], cst_scanf_bad_conversion);
-      /*<<scanf.ml:1431:12>>*/  /*<<scanf.ml:1431:12>>*/ caml_call3
-      (scan, Stdlib[19], Stdlib[19], ib);
-      /*<<scanf.ml:1432:12>>*/  /*<<scanf.ml:1432:12>>*/ var
-      x =  /*<<scanf.ml:1432:12>>*/ caml_call1(token, ib);
-      /*<<scanf.ml:1433:4>>*/ return [0, x, make_scanf(ib, fmt, readers)];
-    }
-    if(0 !== pad[0])
-      /*<<scanf.ml:1451:4>>*/ return  /*<<scanf.ml:1451:4>>*/ caml_call1
-             (Stdlib[1], cst_scanf_bad_conversion$2);
-    if(! pad[1])
-      /*<<scanf.ml:1447:4>>*/ return  /*<<scanf.ml:1447:4>>*/ caml_call1
-             (Stdlib[1], cst_scanf_bad_conversion$1);
-    var w = pad[2];
-    if(typeof prec !== "number"){
-     var p$0 = prec[1];
-      /*<<scanf.ml:1443:12>>*/  /*<<scanf.ml:1443:12>>*/ caml_call3
-      (scan, w, p$0, ib);
-      /*<<scanf.ml:1444:12>>*/  /*<<scanf.ml:1444:12>>*/ var
-      x$2 =  /*<<scanf.ml:1444:12>>*/ caml_call1(token, ib);
-      /*<<scanf.ml:1445:4>>*/ return [0, x$2, make_scanf(ib, fmt, readers)];
-    }
-    if(prec)
-      /*<<scanf.ml:1449:4>>*/ return  /*<<scanf.ml:1449:4>>*/ caml_call1
-             (Stdlib[1], cst_scanf_bad_conversion$0);
-     /*<<scanf.ml:1439:12>>*/  /*<<scanf.ml:1439:12>>*/ caml_call3
-     (scan, w, Stdlib[19], ib);
-     /*<<scanf.ml:1440:12>>*/  /*<<scanf.ml:1440:12>>*/ var
-     x$1 =  /*<<scanf.ml:1440:12>>*/ caml_call1(token, ib);
-     /*<<scanf.ml:1441:4>>*/ return [0, x$1, make_scanf(ib, fmt, readers)];
-    /*<<scanf.ml:1453:46>>*/ }
-   function make_scanf(ib, fmt, readers){
-     /*<<scanf.ml:1266:22>>*/ var fmt$0 = fmt;
-     /*<<scanf.ml:1266:22>>*/ for(;;){
-     if(typeof fmt$0 === "number")  /*<<scanf.ml:1418:4>>*/ return 0;
-     switch(fmt$0[0]){
-       case 0:
-        var rest = fmt$0[1];
-         /*<<scanf.ml:939:31>>*/ store_char(0, ib, checked_peek_char(ib));
-         /*<<scanf.ml:1269:12>>*/  /*<<scanf.ml:1269:12>>*/ var
-         c$1 = token_char(ib);
-         /*<<scanf.ml:1270:4>>*/ return [0,
-                c$1,
-                make_scanf(ib, rest, readers)];
-       case 1:
-         /*<<scanf.ml:1272:4>>*/ var
-         rest$0 = fmt$0[1],
-          /*<<scanf.ml:1272:4>>*/ width$0 = 0,
-         find_stop =
-           function(width){
-             /*<<scanf.ml:1047:4>>*/  /*<<scanf.ml:1047:10>>*/ var
-             c = check_next_char_for_char(width, ib);
-            return 39 === c
-                    ? ignore_char(width, ib)
-                    : character_mismatch(39, c);
-            /*<<scanf.ml:1049:36>>*/ },
-          /*<<scanf.ml:1035:10>>*/ c = checked_peek_char(ib);
-        if(39 === c){
-          /*<<scanf.ml:1036:24>>*/ var
-           /*<<scanf.ml:1036:24>>*/ width = ignore_char(width$0, ib),
-           /*<<scanf.ml:1040:10>>*/ c$0 = check_next_char_for_char(width, ib);
-         if(92 === c$0)
-           /*<<scanf.ml:1042:16>>*/ find_stop
-           (scan_backslash_char(ignore_char(width, ib), ib));
-         else
-           /*<<scanf.ml:1044:16>>*/ find_stop(store_char(width, ib, c$0));
-        }
-        else
-          /*<<scanf.ml:1037:11>>*/ character_mismatch(39, c);
-         /*<<scanf.ml:1273:12>>*/  /*<<scanf.ml:1273:12>>*/ var
-         c$2 = token_char(ib);
-         /*<<scanf.ml:1274:4>>*/ return [0,
-                c$2,
-                make_scanf(ib, rest$0, readers)];
-       case 2:
-        var pad = fmt$0[1], match = fmt$0[2];
-        if(typeof match !== "number")
-         switch(match[0]){
-           case 17:
-             /*<<scanf.ml:1277:19>>*/ var
-             rest$2 = match[2],
-             fmting_lit = match[1],
-              /*<<scanf.ml:1277:19>>*/ match$0 =
-               stopper_of_formatting_lit(fmting_lit),
-             str = match$0[2],
-             stp = match$0[1],
-             scan$0 =
-               function(width, param, ib){
-                 /*<<scanf.ml:1278:26>>*/ return scan_string
-                        ([0, stp], width, ib);
-                /*<<scanf.ml:1278:57>>*/ },
-              /*<<scanf.ml:1279:19>>*/ str_rest = [11, str, rest$2];
-             /*<<scanf.ml:1280:4>>*/ return pad_prec_scanf
-                    (ib, str_rest, readers, pad, 0, scan$0, token_string);
-           case 18:
-            var _G_ = match[1];
-            if(0 === _G_[0]){
-              /*<<scanf.ml:1282:4>>*/ var
-              rest$3 = match[2],
-              fmt$1 = _G_[1][1],
-               /*<<scanf.ml:1282:4>>*/ scan$1 =
-                function(width, param, ib){
-                  /*<<scanf.ml:1282:26>>*/ return scan_string(_q_, width, ib);
-                 /*<<scanf.ml:1282:57>>*/ };
-              /*<<scanf.ml:1283:4>>*/ return pad_prec_scanf
-                     (ib,
-                       /*<<scanf.ml:1283:22>>*/ caml_call2
-                       (CamlinternalFormatBasics[3], fmt$1, rest$3),
-                      readers,
-                      pad,
-                      0,
-                      scan$1,
-                      token_string);
-            }
-             /*<<scanf.ml:1286:4>>*/ var
-             rest$4 = match[2],
-             fmt$2 = _G_[1][1],
-              /*<<scanf.ml:1286:4>>*/ scan$2 =
-               function(width, param, ib){
-                 /*<<scanf.ml:1286:26>>*/ return scan_string(_r_, width, ib);
-                /*<<scanf.ml:1286:57>>*/ };
-             /*<<scanf.ml:1287:4>>*/ return pad_prec_scanf
-                    (ib,
-                      /*<<scanf.ml:1287:22>>*/ caml_call2
-                      (CamlinternalFormatBasics[3], fmt$2, rest$4),
-                     readers,
-                     pad,
-                     0,
-                     scan$2,
-                     token_string);
-         }
-         /*<<scanf.ml:1290:4>>*/ var
-         rest$1 = fmt$0[2],
-          /*<<scanf.ml:1290:4>>*/ scan =
-           function(width, param, ib){
-             /*<<scanf.ml:1290:26>>*/ return scan_string(0, width, ib);
-            /*<<scanf.ml:1290:51>>*/ };
-         /*<<scanf.ml:1291:4>>*/ return pad_prec_scanf
-                (ib, rest$1, readers, pad, 0, scan, token_string);
-       case 3:
-         /*<<scanf.ml:1294:4>>*/ var
-         rest$5 = fmt$0[2],
-         pad$0 = fmt$0[1],
-          /*<<scanf.ml:1294:4>>*/ scan$3 =
-           function(width, param, ib){
-             /*<<scanf.ml:1294:26>>*/ return scan_caml_string(width, ib);
-            /*<<scanf.ml:1294:51>>*/ };
-         /*<<scanf.ml:1295:4>>*/ return pad_prec_scanf
-                (ib, rest$5, readers, pad$0, 0, scan$3, token_string);
-       case 4:
-         /*<<scanf.ml:1297:12>>*/ var
-         rest$6 = fmt$0[4],
-         prec = fmt$0[3],
-         pad$1 = fmt$0[2],
-         iconv = fmt$0[1],
-          /*<<scanf.ml:1297:12>>*/ conv =
-           integer_conversion_of_char
-            ( /*<<scanf.ml:1297:39>>*/ caml_call1
-              (CamlinternalFormat[16], iconv)),
-         scan$4 =
-           function(width, param, ib){
-             /*<<scanf.ml:1298:26>>*/ return scan_int_conversion
-                    (conv, width, ib);
-            /*<<scanf.ml:1298:56>>*/ };
-         /*<<scanf.ml:1299:49>>*/ return pad_prec_scanf
-                (ib,
-                 rest$6,
-                 readers,
-                 pad$1,
-                 prec,
-                 scan$4,
-                 function(ib){
-                   /*<<scanf.ml:537:24>>*/ return  /*<<scanf.ml:537:24>>*/ caml_int_of_string
-                          (token_int_literal(conv, ib));
-                 });
-       case 5:
-         /*<<scanf.ml:1301:12>>*/ var
-         rest$7 = fmt$0[4],
-         prec$0 = fmt$0[3],
-         pad$2 = fmt$0[2],
-         iconv$0 = fmt$0[1],
-          /*<<scanf.ml:1301:12>>*/ conv$0 =
-           integer_conversion_of_char
-            ( /*<<scanf.ml:1301:39>>*/ caml_call1
-              (CamlinternalFormat[16], iconv$0)),
-         scan$5 =
-           function(width, param, ib){
-             /*<<scanf.ml:1302:26>>*/ return scan_int_conversion
-                    (conv$0, width, ib);
-            /*<<scanf.ml:1302:56>>*/ };
-         /*<<scanf.ml:1303:49>>*/ return pad_prec_scanf
-                (ib,
-                 rest$7,
-                 readers,
-                 pad$2,
-                 prec$0,
-                 scan$5,
-                 function(ib){
-                   /*<<scanf.ml:558:26>>*/ return  /*<<scanf.ml:558:26>>*/ caml_int_of_string
-                          (token_int_literal(conv$0, ib));
-                 });
-       case 6:
-         /*<<scanf.ml:1305:12>>*/ var
-         rest$8 = fmt$0[4],
-         prec$1 = fmt$0[3],
-         pad$3 = fmt$0[2],
-         iconv$1 = fmt$0[1],
-          /*<<scanf.ml:1305:12>>*/ conv$1 =
-           integer_conversion_of_char
-            ( /*<<scanf.ml:1305:39>>*/ caml_call1
-              (CamlinternalFormat[16], iconv$1)),
-         scan$6 =
-           function(width, param, ib){
-             /*<<scanf.ml:1306:26>>*/ return scan_int_conversion
-                    (conv$1, width, ib);
-            /*<<scanf.ml:1306:56>>*/ };
-         /*<<scanf.ml:1307:49>>*/ return pad_prec_scanf
-                (ib,
-                 rest$8,
-                 readers,
-                 pad$3,
-                 prec$1,
-                 scan$6,
-                 function(ib){
-                   /*<<scanf.ml:557:30>>*/ return  /*<<scanf.ml:557:30>>*/ caml_int_of_string
-                          (token_int_literal(conv$1, ib));
-                 });
-       case 7:
-         /*<<scanf.ml:1309:12>>*/ var
-         rest$9 = fmt$0[4],
-         prec$2 = fmt$0[3],
-         pad$4 = fmt$0[2],
-         iconv$2 = fmt$0[1],
-          /*<<scanf.ml:1309:12>>*/ conv$2 =
-           integer_conversion_of_char
-            ( /*<<scanf.ml:1309:39>>*/ caml_call1
-              (CamlinternalFormat[16], iconv$2)),
-         scan$7 =
-           function(width, param, ib){
-             /*<<scanf.ml:1310:26>>*/ return scan_int_conversion
-                    (conv$2, width, ib);
-            /*<<scanf.ml:1310:56>>*/ };
-         /*<<scanf.ml:1311:49>>*/ return pad_prec_scanf
-                (ib,
-                 rest$9,
-                 readers,
-                 pad$4,
-                 prec$2,
-                 scan$7,
-                 function(ib){
-                   /*<<scanf.ml:559:26>>*/ return  /*<<scanf.ml:559:26>>*/ runtime.caml_int64_of_string
-                          (token_int_literal(conv$2, ib));
-                 });
-       case 8:
-        switch(fmt$0[1][2]){
-          case 5:
-          case 8:
-           var rest$11 = fmt$0[4], prec$4 = fmt$0[3], pad$6 = fmt$0[2];
-            /*<<scanf.ml:1313:4>>*/ return pad_prec_scanf
-                   (ib,
-                    rest$11,
-                    readers,
-                    pad$6,
-                    prec$4,
-                    scan_caml_float,
-                    token_float);
-          case 6:
-          case 7:
-           var rest$12 = fmt$0[4], prec$5 = fmt$0[3], pad$7 = fmt$0[2];
-            /*<<scanf.ml:1318:4>>*/ return pad_prec_scanf
-                   (ib,
-                    rest$12,
-                    readers,
-                    pad$7,
-                    prec$5,
-                    scan_hex_float,
-                    token_float);
-          default:
-           var rest$10 = fmt$0[4], prec$3 = fmt$0[3], pad$5 = fmt$0[2];
-            /*<<scanf.ml:1316:4>>*/ return pad_prec_scanf
-                   (ib,
-                    rest$10,
-                    readers,
-                    pad$5,
-                    prec$3,
-                    scan_float,
-                    token_float);
-        }
-       case 9:
-         /*<<scanf.ml:1320:4>>*/ var
-         rest$13 = fmt$0[2],
-         pad$8 = fmt$0[1],
-          /*<<scanf.ml:1320:4>>*/ scan$8 =
-           function(param, _T_, ib){
-             /*<<scanf.ml:1320:22>>*/ var
-              /*<<scanf.ml:1089:10>>*/ c = checked_peek_char(ib),
-              /*<<scanf.ml:1090:2>>*/ m =
-               102 === c
-                ? 5
-                : 116
-                  === c
-                  ? 4
-                  : bad_input
-                    ( /*<<scanf.ml:1096:8>>*/ caml_call2
-                      (Stdlib_Printf[4], _n_, c));
-             /*<<scanf.ml:1097:2>>*/ return scan_string(0, m, ib);
-            /*<<scanf.ml:1320:34>>*/ };
-         /*<<scanf.ml:1321:4>>*/ return pad_prec_scanf
-                (ib, rest$13, readers, pad$8, 0, scan$8, token_bool);
-       case 10:
-        var rest$14 = fmt$0[1];
-         /*<<scanf.ml:1337:7>>*/ if(! end_of_input(ib))
-          /*<<scanf.ml:1338:9>>*/ return bad_input(cst_end_of_input_not_found);
-        var fmt$0 = rest$14;
-        break;
-       case 11:
-         /*<<scanf.ml:1341:16>>*/ var
-         rest$15 = fmt$0[2],
-         str$0 = fmt$0[1],
-          /*<<scanf.ml:1341:16>>*/ _H_ =
-           function(_S_){ /*<<?>>*/ return check_char(ib, _S_);};
-         /*<<scanf.ml:1341:4>>*/  /*<<scanf.ml:1341:4>>*/ caml_call2
-         (Stdlib_String[29], _H_, str$0);
-        var fmt$0 = rest$15;
-        break;
-       case 12:
-        var rest$16 = fmt$0[2], chr = fmt$0[1];
-         /*<<scanf.ml:1344:4>>*/ check_char(ib, chr);
-        var fmt$0 = rest$16;
-        break;
-       case 13:
-        var rest$17 = fmt$0[3], fmtty = fmt$0[2], pad_opt = fmt$0[1];
-         /*<<scanf.ml:1348:12>>*/ scan_caml_string
-         (width_of_pad_opt(pad_opt), ib);
-         /*<<scanf.ml:1349:12>>*/  /*<<scanf.ml:1349:12>>*/ var
-         s = token_string(ib);
-         /*<<scanf.ml:1350:4>>*/ try{
-          /*<<scanf.ml:1351:10>>*/ var
-           /*<<scanf.ml:1351:10>>*/ _I_ =
-             /*<<scanf.ml:1351:10>>*/ caml_call2
-             (CamlinternalFormat[14], s, fmtty),
-          fmt$3 = _I_;
-        }
-        catch(exn$0){
-         var exn = caml_wrap_exception(exn$0);
-         if(exn[1] !== Stdlib[7]) throw caml_maybe_attach_backtrace(exn, 0);
-         var msg = exn[2], fmt$3 = bad_input(msg);
-        }
-         /*<<scanf.ml:1354:4>>*/ return [0,
-                fmt$3,
-                make_scanf(ib, rest$17, readers)];
-       case 14:
-        var rest$18 = fmt$0[3], fmtty$0 = fmt$0[2], pad_opt$0 = fmt$0[1];
-         /*<<scanf.ml:1356:12>>*/ scan_caml_string
-         (width_of_pad_opt(pad_opt$0), ib);
-         /*<<scanf.ml:1357:12>>*/  /*<<scanf.ml:1357:12>>*/ var
-         s$0 = token_string(ib);
-        try{
-          /*<<scanf.ml:1375:36>>*/ var
-          fmt$6 =
-             /*<<scanf.ml:1360:26>>*/ caml_call2
-              (CamlinternalFormat[13], 0, s$0)
-             [1],
-          fmt$7 =
-             /*<<scanf.ml:1361:27>>*/ caml_call2
-              (CamlinternalFormat[13], 0, s$0)
-             [1],
-           /*<<scanf.ml:1375:36>>*/ _K_ =
-             /*<<scanf.ml:1375:36>>*/ caml_call1
-             (CamlinternalFormat[21], fmtty$0),
-           /*<<scanf.ml:1375:25>>*/ _L_ =
-             /*<<scanf.ml:1375:25>>*/ caml_call1
-             (CamlinternalFormatBasics[2], _K_),
-           /*<<scanf.ml:1375:8>>*/ fmt$8 =
-             /*<<scanf.ml:1375:8>>*/ caml_call2
-             (CamlinternalFormat[12], fmt$7, _L_),
-           /*<<scanf.ml:1374:24>>*/ _M_ =
-             /*<<scanf.ml:1374:24>>*/ caml_call1
-             (CamlinternalFormatBasics[2], fmtty$0),
-           /*<<scanf.ml:1374:8>>*/ _N_ =
-             /*<<scanf.ml:1374:8>>*/ caml_call2
-             (CamlinternalFormat[12], fmt$6, _M_),
-          fmt$5 = fmt$8,
-          fmt$4 = _N_;
-        }
-        catch(exn){
-         var exn$0 = caml_wrap_exception(exn);
-         if(exn$0[1] !== Stdlib[7])
-          throw caml_maybe_attach_backtrace(exn$0, 0);
-         var
-          msg$0 = exn$0[2],
-          _J_ = bad_input(msg$0),
-          fmt$5 = _J_[2],
-          fmt$4 = _J_[1];
-        }
-         /*<<scanf.ml:1378:4>>*/ return [0,
-                [0, fmt$4, s$0],
-                make_scanf
-                 (ib,
-                   /*<<scanf.ml:1379:24>>*/ caml_call2
-                   (CamlinternalFormatBasics[3], fmt$5, rest$18),
-                  readers)];
-       case 15:
-         /*<<scanf.ml:1323:4>>*/ return  /*<<scanf.ml:1323:4>>*/ caml_call1
-                (Stdlib[1], cst_scanf_bad_conversion_a);
-       case 16:
-         /*<<scanf.ml:1325:4>>*/ return  /*<<scanf.ml:1325:4>>*/ caml_call1
-                (Stdlib[1], cst_scanf_bad_conversion_t);
-       case 17:
-         /*<<scanf.ml:1401:32>>*/ var
-         rest$19 = fmt$0[2],
-         formatting_lit = fmt$0[1],
-          /*<<scanf.ml:1401:32>>*/ _O_ =
-            /*<<scanf.ml:1401:32>>*/ caml_call1
-            (CamlinternalFormat[17], formatting_lit),
-          /*<<scanf.ml:1401:16>>*/ _P_ =
-           function(_R_){ /*<<?>>*/ return check_char(ib, _R_);};
-         /*<<scanf.ml:1401:4>>*/  /*<<scanf.ml:1401:4>>*/ caml_call2
-         (Stdlib_String[29], _P_, _O_);
-        var fmt$0 = rest$19;
-        break;
-       case 18:
-        var _Q_ = fmt$0[1];
-        if(0 === _Q_[0]){
-         var rest$20 = fmt$0[2], fmt$9 = _Q_[1][1];
-          /*<<scanf.ml:1404:4>>*/ check_char(ib, 64);
-          /*<<scanf.ml:1404:23>>*/ check_char(ib, 123);
-          /*<<scanf.ml:1405:18>>*/ var
-           /*<<scanf.ml:1405:18>>*/ fmt$10 =
-             /*<<scanf.ml:1405:18>>*/ caml_call2
-             (CamlinternalFormatBasics[3], fmt$9, rest$20),
-          fmt$0 = fmt$10;
-        }
-        else{
-         var rest$21 = fmt$0[2], fmt$11 = _Q_[1][1];
-          /*<<scanf.ml:1407:4>>*/ check_char(ib, 64);
-          /*<<scanf.ml:1407:23>>*/ check_char(ib, 91);
-          /*<<scanf.ml:1408:18>>*/ var
-           /*<<scanf.ml:1408:18>>*/ fmt$12 =
-             /*<<scanf.ml:1408:18>>*/ caml_call2
-             (CamlinternalFormatBasics[3], fmt$11, rest$21),
-          fmt$0 = fmt$12;
-        }
-        break;
-       case 19:
-        var fmt_rest = fmt$0[1];
-         /*<<scanf.ml:1329:4>>*/ if(! readers)
-          /*<<scanf.ml:1334:8>>*/ return  /*<<scanf.ml:1334:8>>*/ caml_call1
-                 (Stdlib[1], cst_scanf_missing_reader);
-         /*<<scanf.ml:1331:16>>*/ var
-         readers_rest = readers[2],
-         reader = readers[1],
-          /*<<scanf.ml:1331:16>>*/ x =
-            /*<<scanf.ml:1331:16>>*/ caml_call1(reader, ib);
-         /*<<scanf.ml:1332:8>>*/ return [0,
-                x,
-                make_scanf(ib, fmt_rest, readers_rest)];
-       case 20:
-        var width_opt = fmt$0[1], match$1 = fmt$0[3];
-        if(typeof match$1 !== "number" && 17 === match$1[0]){
-          /*<<scanf.ml:1382:19>>*/ var
-          rest$23 = match$1[2],
-          fmting_lit$0 = match$1[1],
-          char_set$0 = fmt$0[2],
-           /*<<scanf.ml:1382:19>>*/ match$2 =
-            stopper_of_formatting_lit(fmting_lit$0),
-          str$1 = match$2[2],
-          stp$0 = match$2[1],
-           /*<<scanf.ml:1383:16>>*/ width$2 = width_of_pad_opt(width_opt);
-          /*<<scanf.ml:1384:4>>*/ scan_chars_in_char_set
-          (char_set$0, [0, stp$0], width$2, ib);
-          /*<<scanf.ml:1385:12>>*/ var
-           /*<<scanf.ml:1385:12>>*/ s$2 = token_string(ib),
-           /*<<scanf.ml:1386:19>>*/ str_rest$0 = [11, str$1, rest$23];
-          /*<<scanf.ml:1387:4>>*/ return [0,
-                 s$2,
-                 make_scanf(ib, str_rest$0, readers)];
-        }
-         /*<<scanf.ml:1389:16>>*/ var
-         rest$22 = fmt$0[3],
-         char_set = fmt$0[2],
-          /*<<scanf.ml:1389:16>>*/ width$1 = width_of_pad_opt(width_opt);
-         /*<<scanf.ml:1390:4>>*/ scan_chars_in_char_set
-         (char_set, 0, width$1, ib);
-         /*<<scanf.ml:1391:12>>*/  /*<<scanf.ml:1391:12>>*/ var
-         s$1 = token_string(ib);
-         /*<<scanf.ml:1392:4>>*/ return [0,
-                s$1,
-                make_scanf(ib, rest$22, readers)];
-       case 21:
-        var rest$24 = fmt$0[2], counter = fmt$0[1];
-        switch(counter){
-          case 0:
-           var count = ib[5]; break;
-          case 1:
-           var count = char_count(ib); break;
-          default: var count = ib[6];
-        }
-         /*<<scanf.ml:1395:4>>*/ return [0,
-                count,
-                make_scanf(ib, rest$24, readers)];
-       case 22:
-         /*<<scanf.ml:1397:12>>*/ var
-         rest$25 = fmt$0[1],
-          /*<<scanf.ml:1397:12>>*/ c$3 = checked_peek_char(ib);
-         /*<<scanf.ml:1398:4>>*/ return [0,
-                c$3,
-                make_scanf(ib, rest$25, readers)];
-       case 23:
-         /*<<scanf.ml:1412:16>>*/ var
-         rest$26 = fmt$0[2],
-         ign = fmt$0[1],
-         fmt$13 =
-            /*<<scanf.ml:1411:32>>*/ caml_call2
-             (CamlinternalFormat[6], ign, rest$26)
-            [1],
-          /*<<scanf.ml:1412:16>>*/ match$3 = make_scanf(ib, fmt$13, readers);
-        if(! match$3)
-          /*<<scanf.ml:1414:13>>*/ throw  /*<<scanf.ml:1414:13>>*/ caml_maybe_attach_backtrace
-                ([0, Assert_failure, _s_], 1);
-        var arg_rest = match$3[2];
-         /*<<scanf.ml:1413:28>>*/ return arg_rest;
-       default:
-         /*<<scanf.ml:1327:4>>*/ return  /*<<scanf.ml:1327:4>>*/ caml_call1
-                (Stdlib[1], cst_scanf_bad_conversion_custo);
-     }
-    }
-    /*<<scanf.ml:1418:7>>*/ }
-   function kscanf_gen(ib, ef, af, param){
-    var str = param[2], fmt = param[1];
-    function k(readers, f$1){
-      /*<<scanf.ml:1465:4>>*/ caml_call1(Stdlib_Buffer[9], ib[8]);
-      /*<<scanf.ml:1465:4>>*/ try{
-       /*<<scanf.ml:1466:10>>*/  /*<<scanf.ml:1466:10>>*/ var
-       args$1 = make_scanf(ib, fmt, readers);
-     }
-     catch(exc$0){
-      var exc = caml_wrap_exception(exc$0);
-      if
-       (exc[1] !== Scan_failure && exc[1] !== Stdlib[7] && exc !== Stdlib[12]){
-       if(exc[1] !== Stdlib[6]) throw caml_maybe_attach_backtrace(exc, 0);
-        /*<<scanf.ml:1470:45>>*/ var
-        msg = exc[2],
-         /*<<scanf.ml:1470:45>>*/ _C_ =
-           /*<<scanf.ml:1470:45>>*/ caml_call1(Stdlib_String[24], str),
-         /*<<scanf.ml:1470:45>>*/ _D_ =
-           /*<<scanf.ml:1470:45>>*/ caml_call2(Stdlib[28], _C_, cst$0),
-         /*<<scanf.ml:1470:27>>*/ _E_ =
-           /*<<scanf.ml:1470:27>>*/ caml_call2(Stdlib[28], cst_in_format, _D_),
-         /*<<scanf.ml:1470:20>>*/ _F_ =
-           /*<<scanf.ml:1470:20>>*/ caml_call2(Stdlib[28], msg, _E_);
-        /*<<scanf.ml:1470:20>>*/ return  /*<<scanf.ml:1470:20>>*/ caml_call1
-               (Stdlib[1], _F_);
-      }
-       /*<<scanf.ml:1468:8>>*/ return  /*<<scanf.ml:1468:8>>*/ caml_call2
-              (ef, ib, exc);
-     }
-     var f = f$1, args = args$1;
-      /*<<scanf.ml:1460:18>>*/ for(;;){
-      if(! args)
-        /*<<scanf.ml:1472:11>>*/ return  /*<<scanf.ml:1472:11>>*/ caml_call1
-               (af, f);
-       /*<<scanf.ml:1461:27>>*/ var
-       args$0 = args[2],
-       x = args[1],
-        /*<<scanf.ml:1461:27>>*/ f$0 =
-          /*<<scanf.ml:1461:27>>*/ caml_call1(f, x),
-       f = f$0,
-       args = args$0;
-     }
-     /*<<scanf.ml:1472:25>>*/ }
-     /*<<scanf.ml:1474:2>>*/ return take_format_readers(k, fmt);
-   }
-   function kscanf(ib, ef, fmt){
-     /*<<scanf.ml:1477:2>>*/ return kscanf_gen
-            (ib,
-             ef,
-             function(x){
-               /*<<scanf.ml:1477:29>>*/ return x;
-              /*<<scanf.ml:1477:30>>*/ },
-             fmt);
-    /*<<scanf.ml:1477:35>>*/ }
-   function kscanf_opt(ib, fmt){
-    function _A_(x){
-      /*<<scanf.ml:1480:44>>*/ return [0, x];
-     /*<<scanf.ml:1480:50>>*/ }
-     /*<<scanf.ml:1480:2>>*/ return kscanf_gen
-            (ib,
-             function(param, _B_){
-               /*<<scanf.ml:1480:28>>*/ return 0;
-              /*<<scanf.ml:1480:32>>*/ },
-             _A_,
-             fmt);
-    /*<<scanf.ml:1480:55>>*/ }
-   function bscanf(ib, fmt){
-     /*<<scanf.ml:1485:20>>*/ return kscanf(ib, scanf_bad_input, fmt);
-    /*<<scanf.ml:1485:50>>*/ }
-   function bscanf_opt(ib, fmt){
-     /*<<scanf.ml:1486:24>>*/ return kscanf_opt(ib, fmt);
-    /*<<scanf.ml:1486:41>>*/ }
-   function ksscanf(s, ef, fmt){
-     /*<<scanf.ml:1488:23>>*/ return kscanf(from_string(s), ef, fmt);
-    /*<<scanf.ml:1488:62>>*/ }
-   function sscanf(s, fmt){
-     /*<<scanf.ml:1489:19>>*/ return kscanf
-            (from_string(s), scanf_bad_input, fmt);
-    /*<<scanf.ml:1489:71>>*/ }
-   function sscanf_opt(s, fmt){
-     /*<<scanf.ml:1490:23>>*/ return kscanf_opt(from_string(s), fmt);
-    /*<<scanf.ml:1490:62>>*/ }
-   function scanf(fmt){
-     /*<<scanf.ml:1492:16>>*/ return kscanf(stdin, scanf_bad_input, fmt);
-    /*<<scanf.ml:1492:57>>*/ }
-   function scanf_opt(fmt){
-     /*<<scanf.ml:1493:20>>*/ return kscanf_opt(stdin, fmt);
-    /*<<scanf.ml:1493:49>>*/ }
-   function bscanf_format(ib, format, f){
-     /*<<scanf.ml:1502:4>>*/ scan_caml_string(Stdlib[19], ib);
-     /*<<scanf.ml:1503:14>>*/  /*<<scanf.ml:1503:14>>*/ var
-     str = token_string(ib);
-     /*<<scanf.ml:1504:4>>*/ try{
-      /*<<scanf.ml:1505:10>>*/ var
-       /*<<scanf.ml:1505:10>>*/ _z_ =
-         /*<<scanf.ml:1505:10>>*/ caml_call2
-         (CamlinternalFormat[15], str, format),
-      fmt = _z_;
-    }
-    catch(exn$0){
-     var exn = caml_wrap_exception(exn$0);
-     if(exn[1] !== Stdlib[7]) throw caml_maybe_attach_backtrace(exn, 0);
-     var msg = exn[2], fmt = bad_input(msg);
-    }
-     /*<<scanf.ml:1507:4>>*/ return  /*<<scanf.ml:1507:4>>*/ caml_call1
-            (f, fmt);
-    /*<<scanf.ml:1507:10>>*/ }
-   function sscanf_format(s, format, f){
-     /*<<scanf.ml:1513:20>>*/ return bscanf_format(from_string(s), format, f);
-    /*<<scanf.ml:1513:67>>*/ }
-   function format_from_string(s, fmt){
-     /*<<scanf.ml:1517:2>>*/ function _w_(x){
-      /*<<scanf.ml:1517:63>>*/ return x;
-     /*<<scanf.ml:1517:64>>*/ }
-     /*<<scanf.ml:1517:24>>*/ var
-      /*<<scanf.ml:1517:24>>*/ _x_ =
-        /*<<scanf.ml:1517:24>>*/ caml_call1(Stdlib_String[24], s),
-      /*<<scanf.ml:1517:24>>*/ _y_ =
-        /*<<scanf.ml:1517:24>>*/ caml_call2(Stdlib[28], _x_, cst$1);
-     /*<<scanf.ml:1517:53>>*/ return sscanf_format
-            ( /*<<scanf.ml:1517:16>>*/ caml_call2(Stdlib[28], cst$2, _y_),
-             fmt,
-             _w_);
-    /*<<scanf.ml:1517:65>>*/ }
-   function unescaped(s){
-     /*<<scanf.ml:1521:2>>*/ function _u_(x){
-      /*<<scanf.ml:1521:44>>*/ return x;
-     /*<<scanf.ml:1521:45>>*/ }
-     /*<<scanf.ml:1521:17>>*/  /*<<scanf.ml:1521:17>>*/ var
-     _v_ =  /*<<scanf.ml:1521:17>>*/ caml_call2(Stdlib[28], s, cst$3);
-     /*<<scanf.ml:1521:34>>*/ return  /*<<scanf.ml:1521:34>>*/ caml_call1
-            (sscanf
-              ( /*<<scanf.ml:1521:9>>*/ caml_call2(Stdlib[28], cst$4, _v_),
-               _t_),
-             _u_);
-    /*<<scanf.ml:1521:46>>*/ }
-   var
-    Stdlib_Scanf =
-      [0,
-       [0,
-        stdin,
-        open_in,
-        open_in_bin,
-        close_in,
-        open_in,
-        open_in_bin,
-        from_string,
-        from_function,
-        from_channel,
-        end_of_input,
-        beginning_of_input,
-        name_of_input],
-       Scan_failure,
-       bscanf,
-       bscanf_opt,
-       sscanf,
-       sscanf_opt,
-       scanf,
-       scanf_opt,
-       kscanf,
-       ksscanf,
-       bscanf_format,
-       sscanf_format,
-       format_from_string,
-       unescaped];
-   runtime.caml_register_global(64, Stdlib_Scanf, "Stdlib__Scanf");
-   return;
-   /*<<?>>*/ }
-  (globalThis));
-
-//# unitInfo: Provides: Stdlib__Callback
-//# unitInfo: Requires: Stdlib, Stdlib__Obj
-(function
-  (globalThis){
-   "use strict";
-   var
-    runtime = globalThis.jsoo_runtime,
-    caml_register_named_value = runtime.caml_register_named_value,
-    global_data = runtime.caml_get_global_data(),
-    Stdlib_Obj = global_data.Stdlib__Obj,
-    register = caml_register_named_value;
-   function register_exception(name, exn){
-     /*<<callback.ml:25:2>>*/ var
-     _a_ = Stdlib_Obj[10],
-     slot =
-        /*<<callback.ml:26:16>>*/ runtime.caml_obj_tag(exn) === _a_
-        ? exn
-        : exn[1];
-     /*<<callback.ml:27:2>>*/ return  /*<<callback.ml:27:2>>*/ caml_register_named_value
-            (name, slot);
-    /*<<callback.ml:27:32>>*/ }
-   var Stdlib_Callback = [0, register, register_exception];
-   runtime.caml_register_global(1, Stdlib_Callback, "Stdlib__Callback");
-   return;
-   /*<<?>>*/ }
-  (globalThis));
-
-//# unitInfo: Provides: CamlinternalOO
-//# unitInfo: Requires: Assert_failure, Stdlib, Stdlib__Array, Stdlib__List, Stdlib__Map, Stdlib__Obj, Stdlib__Sys
-(function
-  (globalThis){
-   "use strict";
-   var
-    runtime = globalThis.jsoo_runtime,
-    cst_camlinternalOO_ml = "camlinternalOO.ml",
-    caml_check_bound = runtime.caml_check_bound,
-    caml_div = runtime.caml_div,
-    caml_get_public_method = runtime.caml_get_public_method,
-    caml_make_vect = runtime.caml_make_vect,
-    caml_maybe_attach_backtrace = runtime.caml_maybe_attach_backtrace,
-    caml_obj_block = runtime.caml_obj_block,
-    caml_set_oo_id = runtime.caml_set_oo_id,
-    caml_string_compare = runtime.caml_string_compare,
-    caml_wrap_exception = runtime.caml_wrap_exception;
-    /*<<?>>*/ function caml_call1(f, a0){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 1
-            ? f(a0)
-            : runtime.caml_call_gen(f, [a0]);
-   }
-    /*<<?>>*/ function caml_call2(f, a0, a1){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 2
-            ? f(a0, a1)
-            : runtime.caml_call_gen(f, [a0, a1]);
-   }
-    /*<<?>>*/ function caml_call3(f, a0, a1, a2){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 3
-            ? f(a0, a1, a2)
-            : runtime.caml_call_gen(f, [a0, a1, a2]);
-   }
-    /*<<?>>*/ function caml_call5(f, a0, a1, a2, a3, a4){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 5
-            ? f(a0, a1, a2, a3, a4)
-            : runtime.caml_call_gen(f, [a0, a1, a2, a3, a4]);
-   }
-   var
-    global_data = runtime.caml_get_global_data(),
-    Assert_failure = global_data.Assert_failure,
-    Stdlib_Sys = global_data.Stdlib__Sys,
-    Stdlib_Obj = global_data.Stdlib__Obj,
-    Stdlib = global_data.Stdlib,
-    Stdlib_Array = global_data.Stdlib__Array,
-    Stdlib_List = global_data.Stdlib__List,
-    Stdlib_Map = global_data.Stdlib__Map,
-    _g_ = [0, cst_camlinternalOO_ml, 439, 17],
-    _f_ = [0, cst_camlinternalOO_ml, 421, 13],
-    _e_ = [0, cst_camlinternalOO_ml, 418, 13],
-    _d_ = [0, cst_camlinternalOO_ml, 415, 13],
-    _c_ = [0, cst_camlinternalOO_ml, 412, 13],
-    _b_ = [0, cst_camlinternalOO_ml, 409, 13],
-    _a_ = [0, cst_camlinternalOO_ml, 281, 50];
-   function copy(o){
-     /*<<camlinternalOO.ml:25:2>>*/  /*<<camlinternalOO.ml:25:19>>*/ var
-     o$0 =  /*<<camlinternalOO.ml:25:19>>*/ o.slice();
-     /*<<camlinternalOO.ml:26:2>>*/ return  /*<<camlinternalOO.ml:26:2>>*/ caml_set_oo_id
-            (o$0);
-    /*<<camlinternalOO.ml:26:10>>*/ }
-    /*<<camlinternalOO.ml:38:13>>*/ var
-     /*<<camlinternalOO.ml:38:13>>*/ params = [0, 1, 1, 1, 3, 16],
-     /*<<camlinternalOO.ml:38:13>>*/ initial_object_size = 2,
-    dummy_item = 0;
-   function public_method_label(s){
-     /*<<camlinternalOO.ml:71:2>>*/ var
-      /*<<camlinternalOO.ml:71:13>>*/ accu = [0, 0],
-     _aE_ = runtime.caml_ml_string_length(s) - 1 | 0,
-      /*<<camlinternalOO.ml:71:13>>*/ _aD_ = 0;
-    if(_aE_ >= 0){
-     var i = _aD_;
-     for(;;){
-       /*<<camlinternalOO.ml:73:36>>*/  /*<<camlinternalOO.ml:73:36>>*/ var
-       _aF_ =  /*<<camlinternalOO.ml:73:36>>*/ runtime.caml_string_get(s, i);
-      accu[1] = (223 * accu[1] | 0) + _aF_ | 0;
-       /*<<camlinternalOO.ml:72:2>>*/  /*<<camlinternalOO.ml:72:2>>*/ var
-       _aG_ = i + 1 | 0;
-      if(_aE_ === i) break;
-      var i = _aG_;
-     }
-    }
-    accu[1] = accu[1] & 2147483647;
-    var tag = 1073741823 < accu[1] ? accu[1] + 2147483648 | 0 : accu[1];
-     /*<<camlinternalOO.ml:80:2>>*/ return tag;
-    /*<<camlinternalOO.ml:80:11>>*/ }
-    /*<<camlinternalOO.ml:109:2>>*/ var
-    compare = caml_string_compare,
-    Vars = caml_call1(Stdlib_Map[1], [0, compare]),
-    compare$0 = caml_string_compare,
-    Meths = caml_call1(Stdlib_Map[1], [0, compare$0]),
-    compare$1 = runtime.caml_int_compare,
-    Labs = caml_call1(Stdlib_Map[1], [0, compare$1]),
-     /*<<camlinternalOO.ml:109:2>>*/ dummy_table =
-      [0, 0, [0, dummy_item], Meths[1], Labs[1], 0, 0, Vars[1], 0],
-     /*<<camlinternalOO.ml:118:18>>*/ table_count = [0, 0],
-     /*<<camlinternalOO.ml:121:27>>*/ dummy_met =
-       /*<<camlinternalOO.ml:121:27>>*/ caml_obj_block(0, 0);
-   function fit_size(n){
-     /*<<camlinternalOO.ml:126:2>>*/ return 2 < n
-            ? fit_size((n + 1 | 0) / 2 | 0) * 2 | 0
-            : n;
-    /*<<camlinternalOO.ml:127:24>>*/ }
-   function new_table(pub_labels){
-     /*<<camlinternalOO.ml:130:2>>*/ table_count[1]++;
-     /*<<camlinternalOO.ml:132:16>>*/ var
-     len = pub_labels.length - 1,
-      /*<<camlinternalOO.ml:132:16>>*/ methods =
-        /*<<camlinternalOO.ml:132:16>>*/ caml_make_vect
-        ((len * 2 | 0) + 2 | 0, dummy_met);
-     /*<<camlinternalOO.ml:133:2>>*/ caml_check_bound(methods, 0)[1] = len;
-    var
-     _aw_ = Stdlib_Sys[9],
-     _ax_ =
-       ( /*<<camlinternalOO.ml:134:24>>*/ runtime.caml_mul
-        (fit_size(len), _aw_)
-       / 8
-       | 0)
-       - 1
-       | 0;
-     /*<<camlinternalOO.ml:134:2>>*/ caml_check_bound(methods, 1)[2] = _ax_;
-     /*<<camlinternalOO.ml:134:2>>*/ var
-     _az_ = len - 1 | 0,
-      /*<<camlinternalOO.ml:134:2>>*/ _ay_ = 0;
-    if(_az_ >= 0){
-     var i = _ay_;
-     for(;;){
-       /*<<camlinternalOO.ml:135:51>>*/ var
-       _aB_ = (i * 2 | 0) + 3 | 0,
-        /*<<camlinternalOO.ml:135:51>>*/ _aA_ =
-         caml_check_bound(pub_labels, i)[1 + i];
-       /*<<camlinternalOO.ml:135:26>>*/ caml_check_bound(methods, _aB_)
-       [1 + _aB_]
-      = _aA_;
-       /*<<camlinternalOO.ml:135:26>>*/  /*<<camlinternalOO.ml:135:26>>*/ var
-       _aC_ = i + 1 | 0;
-      if(_az_ === i) break;
-      var i = _aC_;
-     }
-    }
-     /*<<camlinternalOO.ml:136:2>>*/ return [0,
-            initial_object_size,
-            methods,
-            Meths[1],
-            Labs[1],
-            0,
-            0,
-            Vars[1],
-            0];
-    /*<<camlinternalOO.ml:143:32>>*/ }
-   function resize(array, new_size){
-     /*<<camlinternalOO.ml:146:2>>*/ var
-     old_size = array[2].length - 1,
-     _au_ = old_size < new_size ? 1 : 0;
-    if(_au_){
-      /*<<camlinternalOO.ml:148:19>>*/  /*<<camlinternalOO.ml:148:19>>*/ var
-      new_buck =
-         /*<<camlinternalOO.ml:148:19>>*/ caml_make_vect(new_size, dummy_met);
-      /*<<camlinternalOO.ml:149:4>>*/  /*<<camlinternalOO.ml:149:4>>*/ caml_call5
-      (Stdlib_Array[8], array[2], 0, new_buck, 0, old_size);
-     array[2] = new_buck;
-     var _av_ = 0;
-    }
-    else
-     var _av_ = _au_;
-    return _av_;
-    /*<<camlinternalOO.ml:151:4>>*/ }
-    /*<<camlinternalOO.ml:159:19>>*/ var
-     /*<<camlinternalOO.ml:159:19>>*/ method_count = [0, 0],
-     /*<<camlinternalOO.ml:160:21>>*/ inst_var_count = [0, 0];
-   function new_method(table){
-     /*<<camlinternalOO.ml:166:2>>*/ var index = table[2].length - 1;
-     /*<<camlinternalOO.ml:167:2>>*/ resize(table, index + 1 | 0);
-     /*<<camlinternalOO.ml:167:2>>*/ return index;
-    /*<<camlinternalOO.ml:168:7>>*/ }
-   function get_method_label(table, name){
-     /*<<camlinternalOO.ml:171:2>>*/ try{
-      /*<<camlinternalOO.ml:172:4>>*/  /*<<camlinternalOO.ml:172:4>>*/ var
-      _as_ =
-         /*<<camlinternalOO.ml:172:4>>*/ caml_call2(Meths[28], name, table[3]);
-      /*<<camlinternalOO.ml:172:4>>*/ return _as_;
-    }
-    catch(_at_){
-     var _ar_ = caml_wrap_exception(_at_);
-     if(_ar_ !== Stdlib[8]) throw caml_maybe_attach_backtrace(_ar_, 0);
-      /*<<camlinternalOO.ml:174:16>>*/  /*<<camlinternalOO.ml:174:16>>*/ var
-      label = new_method(table);
-     table[3] =
-       /*<<camlinternalOO.ml:175:29>>*/ caml_call3
-       (Meths[4], name, label, table[3]);
-     table[4] =
-       /*<<camlinternalOO.ml:176:30>>*/ caml_call3
-       (Labs[4], label, 1, table[4]);
-      /*<<camlinternalOO.ml:177:4>>*/ return label;
-    }
-    /*<<camlinternalOO.ml:177:9>>*/ }
-   function get_method_labels(table, names){
-     /*<<camlinternalOO.ml:180:12>>*/ function _ap_(_aq_){
-      /*<<?>>*/ return get_method_label(table, _aq_);
-    }
-     /*<<camlinternalOO.ml:180:2>>*/ return  /*<<camlinternalOO.ml:180:2>>*/ caml_call2
-            (Stdlib_Array[13], _ap_, names);
-    /*<<camlinternalOO.ml:180:42>>*/ }
-   function set_method(table, label, element){
-     /*<<camlinternalOO.ml:183:2>>*/ method_count[1]++;
-     /*<<camlinternalOO.ml:184:5>>*/ return  /*<<camlinternalOO.ml:184:5>>*/ caml_call2
-             (Labs[28], label, table[4])
-            ? (resize
-               (table, label + 1 | 0),
-              caml_check_bound(table[2], label)[1 + label] = element,
-              0)
-            : (table[6] = [0, [0, label, element], table[6]], 0);
-    /*<<camlinternalOO.ml:187:64>>*/ }
-   function get_method(table, label){
-     /*<<camlinternalOO.ml:190:2>>*/ try{
-      /*<<camlinternalOO.ml:190:6>>*/  /*<<camlinternalOO.ml:190:6>>*/ var
-      _an_ =
-         /*<<camlinternalOO.ml:190:6>>*/ caml_call2
-         (Stdlib_List[46], label, table[6]);
-      /*<<camlinternalOO.ml:190:6>>*/ return _an_;
-    }
-    catch(_ao_){
-     var _am_ = caml_wrap_exception(_ao_);
-     if(_am_ === Stdlib[8])
-       /*<<camlinternalOO.ml:191:20>>*/ return caml_check_bound
-               (table[2], label)
-              [1 + label];
-     throw caml_maybe_attach_backtrace(_am_, 0);
-    }
-    /*<<camlinternalOO.ml:191:41>>*/ }
-   function to_list(arr){
-     /*<<camlinternalOO.ml:194:2>>*/ return 0 === arr
-            ? 0
-            :  /*<<camlinternalOO.ml:194:33>>*/ caml_call1
-              (Stdlib_Array[9], arr);
-    /*<<camlinternalOO.ml:194:50>>*/ }
-   function narrow(table, vars, virt_meths, concr_meths){
-     /*<<camlinternalOO.ml:197:2>>*/ var
-      /*<<camlinternalOO.ml:197:13>>*/ vars$0 = to_list(vars),
-      /*<<camlinternalOO.ml:198:19>>*/ virt_meths$0 = to_list(virt_meths),
-      /*<<camlinternalOO.ml:199:20>>*/ concr_meths$0 = to_list(concr_meths);
-     /*<<camlinternalOO.ml:200:32>>*/ function _X_(_al_){
-      /*<<?>>*/ return get_method_label(table, _al_);
-    }
-     /*<<camlinternalOO.ml:200:23>>*/  /*<<camlinternalOO.ml:200:23>>*/ var
-     virt_meth_labs =
-        /*<<camlinternalOO.ml:200:23>>*/ caml_call2
-        (Stdlib_List[19], _X_, virt_meths$0);
-     /*<<camlinternalOO.ml:201:33>>*/ function _Y_(_ak_){
-      /*<<?>>*/ return get_method_label(table, _ak_);
-    }
-     /*<<camlinternalOO.ml:201:24>>*/  /*<<camlinternalOO.ml:201:24>>*/ var
-     concr_meth_labs =
-        /*<<camlinternalOO.ml:201:24>>*/ caml_call2
-        (Stdlib_List[19], _Y_, concr_meths$0);
-    table[5] =
-     [0,
-      [0, table[3], table[4], table[6], table[7], virt_meth_labs, vars$0],
-      table[5]];
-    var _Z_ = Vars[1], ___ = table[7];
-    function _$_(lab, info, tvars){
-      /*<<camlinternalOO.ml:209:8>>*/ return  /*<<camlinternalOO.ml:209:11>>*/ caml_call2
-              (Stdlib_List[36], lab, vars$0)
-             ?  /*<<camlinternalOO.ml:209:34>>*/ caml_call3
-               (Vars[4], lab, info, tvars)
-             : tvars;
-     /*<<camlinternalOO.ml:209:68>>*/ }
-    table[7] =
-      /*<<camlinternalOO.ml:207:4>>*/ caml_call3(Vars[13], _$_, ___, _Z_);
-     /*<<camlinternalOO.ml:211:16>>*/ var
-      /*<<camlinternalOO.ml:211:16>>*/ by_name = [0, Meths[1]],
-      /*<<camlinternalOO.ml:212:17>>*/ by_label = [0, Labs[1]];
-    function _aa_(met, label){
-      /*<<camlinternalOO.ml:215:7>>*/ by_name[1] =
-       /*<<camlinternalOO.ml:215:18>>*/ caml_call3
-       (Meths[4], met, label, by_name[1]);
-     var _af_ = by_label[1];
-     try{
-       /*<<camlinternalOO.ml:218:17>>*/ var
-        /*<<camlinternalOO.ml:218:17>>*/ _ai_ =
-          /*<<camlinternalOO.ml:218:17>>*/ caml_call2
-          (Labs[28], label, table[4]),
-       _ah_ = _ai_;
-     }
-     catch(_aj_){
-      var _ag_ = caml_wrap_exception(_aj_);
-      if(_ag_ !== Stdlib[8]) throw caml_maybe_attach_backtrace(_ag_, 0);
-      var _ah_ = 1;
-     }
-     by_label[1] =
-       /*<<camlinternalOO.ml:217:10>>*/ caml_call3(Labs[4], label, _ah_, _af_);
-     return 0;
-     /*<<camlinternalOO.ml:219:21>>*/ }
-     /*<<camlinternalOO.ml:213:2>>*/  /*<<camlinternalOO.ml:213:2>>*/ caml_call3
-     (Stdlib_List[27], _aa_, concr_meths$0, concr_meth_labs);
-    function _ab_(met, label){
-      /*<<camlinternalOO.ml:223:7>>*/ by_name[1] =
-       /*<<camlinternalOO.ml:223:18>>*/ caml_call3
-       (Meths[4], met, label, by_name[1]);
-     by_label[1] =
-       /*<<camlinternalOO.ml:224:19>>*/ caml_call3
-       (Labs[4], label, 0, by_label[1]);
-     return 0;
-     /*<<camlinternalOO.ml:224:49>>*/ }
-     /*<<camlinternalOO.ml:221:2>>*/  /*<<camlinternalOO.ml:221:2>>*/ caml_call3
-     (Stdlib_List[27], _ab_, virt_meths$0, virt_meth_labs);
-    table[3] = by_name[1];
-    table[4] = by_label[1];
-     /*<<camlinternalOO.ml:228:2>>*/ var
-      /*<<camlinternalOO.ml:228:2>>*/ _ac_ = 0,
-     _ad_ = table[6];
-    function _ae_(met, hm){
-      /*<<camlinternalOO.ml:230:7>>*/ var lab = met[1];
-      /*<<camlinternalOO.ml:231:13>>*/ return  /*<<camlinternalOO.ml:231:13>>*/ caml_call2
-              (Stdlib_List[36], lab, virt_meth_labs)
-             ? hm
-             : [0, met, hm];
-     /*<<camlinternalOO.ml:231:62>>*/ }
-    table[6] =
-      /*<<camlinternalOO.ml:229:5>>*/ caml_call3
-      (Stdlib_List[26], _ae_, _ad_, _ac_);
-    return 0;
-    /*<<camlinternalOO.ml:233:9>>*/ }
-   function widen(table){
-     /*<<camlinternalOO.ml:236:2>>*/ var
-      /*<<camlinternalOO.ml:237:4>>*/ match =
-        /*<<camlinternalOO.ml:237:4>>*/ caml_call1(Stdlib_List[5], table[5]),
-     vars = match[6],
-     virt_meths = match[5],
-     saved_vars = match[4],
-     saved_hidden_meths = match[3],
-     by_label = match[2],
-     by_name = match[1];
-    table[5] =
-      /*<<camlinternalOO.ml:239:27>>*/ caml_call1(Stdlib_List[6], table[5]);
-    function _T_(s, v){
-      /*<<camlinternalOO.ml:242:19>>*/  /*<<camlinternalOO.ml:242:30>>*/ var
-      _W_ =
-         /*<<camlinternalOO.ml:242:30>>*/ caml_call2(Vars[28], v, table[7]);
-      /*<<camlinternalOO.ml:242:19>>*/ return  /*<<camlinternalOO.ml:242:19>>*/ caml_call3
-             (Vars[4], v, _W_, s);
-     /*<<camlinternalOO.ml:242:56>>*/ }
-    table[7] =
-      /*<<camlinternalOO.ml:241:5>>*/ caml_call3
-      (Stdlib_List[25], _T_, saved_vars, vars);
-    table[3] = by_name;
-    table[4] = by_label;
-    var _U_ = table[6];
-    function _V_(met, hm){
-      /*<<camlinternalOO.ml:248:7>>*/ var lab = met[1];
-      /*<<camlinternalOO.ml:249:13>>*/ return  /*<<camlinternalOO.ml:249:13>>*/ caml_call2
-              (Stdlib_List[36], lab, virt_meths)
-             ? hm
-             : [0, met, hm];
-     /*<<camlinternalOO.ml:249:58>>*/ }
-    table[6] =
-      /*<<camlinternalOO.ml:247:5>>*/ caml_call3
-      (Stdlib_List[26], _V_, _U_, saved_hidden_meths);
-    return 0;
-    /*<<camlinternalOO.ml:251:25>>*/ }
-   function new_variable(table, name){
-     /*<<camlinternalOO.ml:259:2>>*/ try{
-      /*<<camlinternalOO.ml:259:6>>*/  /*<<camlinternalOO.ml:259:6>>*/ var
-      _R_ =
-         /*<<camlinternalOO.ml:259:6>>*/ caml_call2(Vars[28], name, table[7]);
-      /*<<camlinternalOO.ml:259:6>>*/ return _R_;
-    }
-    catch(_S_){
-     var _Q_ = caml_wrap_exception(_S_);
-     if(_Q_ !== Stdlib[8]) throw caml_maybe_attach_backtrace(_Q_, 0);
-     var index = table[1];
-     table[1] = index + 1 | 0;
-      /*<<camlinternalOO.ml:262:7>>*/ if
-      ( /*<<camlinternalOO.ml:262:7>>*/ runtime.caml_string_notequal(name, ""))
-      table[7] =
-        /*<<camlinternalOO.ml:262:37>>*/ caml_call3
-        (Vars[4], name, index, table[7]);
-      /*<<camlinternalOO.ml:263:4>>*/ return index;
-    }
-    /*<<camlinternalOO.ml:263:9>>*/ }
-   function to_array(arr){
-     /*<<camlinternalOO.ml:266:2>>*/ return  /*<<camlinternalOO.ml:266:5>>*/ runtime.caml_equal
-             (arr, 0)
-            ? [0]
-            : arr;
-    /*<<camlinternalOO.ml:266:41>>*/ }
-   function new_methods_variables(table, meths, vals){
-     /*<<camlinternalOO.ml:269:2>>*/ var
-      /*<<camlinternalOO.ml:269:14>>*/ meths$0 = to_array(meths),
-      /*<<camlinternalOO.ml:270:2>>*/ nmeths = meths$0.length - 1,
-     nvals = vals.length - 1,
-      /*<<camlinternalOO.ml:271:12>>*/ res =
-        /*<<camlinternalOO.ml:271:12>>*/ caml_make_vect(nmeths + nvals | 0, 0),
-      /*<<camlinternalOO.ml:272:2>>*/ _I_ = nmeths - 1 | 0,
-      /*<<camlinternalOO.ml:271:12>>*/ _H_ = 0;
-    if(_I_ >= 0){
-     var i$0 = _H_;
-     for(;;){
-       /*<<camlinternalOO.ml:273:15>>*/  /*<<camlinternalOO.ml:273:15>>*/ var
-       _O_ = get_method_label(table, caml_check_bound(meths$0, i$0)[1 + i$0]);
-       /*<<camlinternalOO.ml:273:4>>*/ caml_check_bound(res, i$0)[1 + i$0] = _O_;
-       /*<<camlinternalOO.ml:273:4>>*/  /*<<camlinternalOO.ml:273:4>>*/ var
-       _P_ = i$0 + 1 | 0;
-      if(_I_ === i$0) break;
-      var i$0 = _P_;
-     }
-    }
-     /*<<camlinternalOO.ml:275:2>>*/ var
-     _K_ = nvals - 1 | 0,
-      /*<<camlinternalOO.ml:275:2>>*/ _J_ = 0;
-    if(_K_ >= 0){
-     var i = _J_;
-     for(;;){
-       /*<<camlinternalOO.ml:276:22>>*/ var
-       _M_ = i + nmeths | 0,
-        /*<<camlinternalOO.ml:276:22>>*/ _L_ =
-         new_variable(table, caml_check_bound(vals, i)[1 + i]);
-       /*<<camlinternalOO.ml:276:4>>*/ caml_check_bound(res, _M_)[1 + _M_] = _L_;
-       /*<<camlinternalOO.ml:276:4>>*/  /*<<camlinternalOO.ml:276:4>>*/ var
-       _N_ = i + 1 | 0;
-      if(_K_ === i) break;
-      var i = _N_;
-     }
-    }
-     /*<<camlinternalOO.ml:278:2>>*/ return res;
-    /*<<camlinternalOO.ml:278:5>>*/ }
-   function get_variable(table, name){
-     /*<<camlinternalOO.ml:281:2>>*/ try{
-      /*<<camlinternalOO.ml:281:6>>*/  /*<<camlinternalOO.ml:281:6>>*/ var
-      _F_ =
-         /*<<camlinternalOO.ml:281:6>>*/ caml_call2(Vars[28], name, table[7]);
-      /*<<camlinternalOO.ml:281:6>>*/ return _F_;
-    }
-    catch(_G_){
-     var _E_ = caml_wrap_exception(_G_);
-     if(_E_ === Stdlib[8])
-       /*<<camlinternalOO.ml:281:50>>*/ throw  /*<<camlinternalOO.ml:281:50>>*/ caml_maybe_attach_backtrace
-             ([0, Assert_failure, _a_], 1);
-     throw caml_maybe_attach_backtrace(_E_, 0);
-    }
-    /*<<camlinternalOO.ml:281:62>>*/ }
-   function get_variables(table, names){
-     /*<<camlinternalOO.ml:284:12>>*/ function _C_(_D_){
-      /*<<?>>*/ return get_variable(table, _D_);
-    }
-     /*<<camlinternalOO.ml:284:2>>*/ return  /*<<camlinternalOO.ml:284:2>>*/ caml_call2
-            (Stdlib_Array[13], _C_, names);
-    /*<<camlinternalOO.ml:284:38>>*/ }
-   function add_initializer(table, f){
-     /*<<camlinternalOO.ml:287:2>>*/ table[8] = [0, f, table[8]];
-    return 0;
-    /*<<camlinternalOO.ml:287:45>>*/ }
-   function create_table(public_methods){
-     /*<<camlinternalOO.ml:301:2>>*/ if(0 === public_methods)
-      /*<<camlinternalOO.ml:301:46>>*/ return new_table([0]);
-     /*<<camlinternalOO.ml:303:13>>*/ var
-      /*<<camlinternalOO.ml:303:13>>*/ tags =
-        /*<<camlinternalOO.ml:303:13>>*/ caml_call2
-        (Stdlib_Array[13], public_method_label, public_methods),
-      /*<<camlinternalOO.ml:304:14>>*/ table = new_table(tags);
-    function _B_(i, met){
-      /*<<camlinternalOO.ml:307:6>>*/ var lab = (i * 2 | 0) + 2 | 0;
-     table[3] =
-       /*<<camlinternalOO.ml:308:32>>*/ caml_call3
-       (Meths[4], met, lab, table[3]);
-     table[4] =
-       /*<<camlinternalOO.ml:309:32>>*/ caml_call3(Labs[4], lab, 1, table[4]);
-     return 0;
-     /*<<camlinternalOO.ml:309:72>>*/ }
-     /*<<camlinternalOO.ml:305:2>>*/  /*<<camlinternalOO.ml:305:2>>*/ caml_call2
-     (Stdlib_Array[12], _B_, public_methods);
-     /*<<camlinternalOO.ml:305:2>>*/ return table;
-    /*<<camlinternalOO.ml:311:7>>*/ }
-   function init_class(table){
-     /*<<camlinternalOO.ml:314:2>>*/ inst_var_count[1] =
-     (inst_var_count[1] + table[1] | 0) - 1 | 0;
-    table[8] =
-      /*<<camlinternalOO.ml:315:24>>*/ caml_call1(Stdlib_List[9], table[8]);
-     /*<<camlinternalOO.ml:316:2>>*/  /*<<camlinternalOO.ml:316:2>>*/ var
-     _A_ = Stdlib_Sys[9];
-    return resize
-            (table,
-             3 + caml_div(caml_check_bound(table[2], 1)[2] * 16 | 0, _A_) | 0);
-    /*<<camlinternalOO.ml:316:65>>*/ }
-   function inherits(cla, vals, virt_meths, concr_meths, param, top){
-    var env = param[4], super$0 = param[2];
-     /*<<camlinternalOO.ml:319:2>>*/ narrow
-     (cla, vals, virt_meths, concr_meths);
-    var
-     init =
-       top
-        ?  /*<<camlinternalOO.ml:321:16>>*/ caml_call2(super$0, cla, env)
-        :  /*<<camlinternalOO.ml:321:44>>*/ caml_call1(super$0, cla);
-     /*<<camlinternalOO.ml:322:2>>*/ widen(cla);
-     /*<<camlinternalOO.ml:322:2>>*/ var
-      /*<<camlinternalOO.ml:322:2>>*/ _s_ = 0,
-      /*<<camlinternalOO.ml:328:7>>*/ _t_ = to_array(concr_meths);
-    function _u_(nm){
-      /*<<camlinternalOO.ml:327:18>>*/ return get_method
-             (cla, get_method_label(cla, nm));
-     /*<<camlinternalOO.ml:327:75>>*/ }
-     /*<<camlinternalOO.ml:325:41>>*/ var
-     _v_ =
-       [0,
-         /*<<camlinternalOO.ml:326:5>>*/ caml_call2
-         (Stdlib_Array[13], _u_, _t_),
-        _s_],
-      /*<<camlinternalOO.ml:325:41>>*/ _w_ = to_array(vals);
-     /*<<camlinternalOO.ml:325:22>>*/ function _x_(_z_){
-      /*<<?>>*/ return get_variable(cla, _z_);
-    }
-     /*<<camlinternalOO.ml:324:4>>*/  /*<<camlinternalOO.ml:324:4>>*/ var
-     _y_ =
-       [0,
-        [0, init],
-        [0,
-          /*<<camlinternalOO.ml:325:12>>*/ caml_call2
-          (Stdlib_Array[13], _x_, _w_),
-         _v_]];
-     /*<<camlinternalOO.ml:324:4>>*/ return  /*<<camlinternalOO.ml:324:4>>*/ caml_call1
-            (Stdlib_Array[4], _y_);
-   }
-   function make_class(pub_meths, class_init){
-     /*<<camlinternalOO.ml:331:2>>*/ var
-      /*<<camlinternalOO.ml:331:14>>*/ table = create_table(pub_meths),
-      /*<<camlinternalOO.ml:332:17>>*/ env_init =
-        /*<<camlinternalOO.ml:332:17>>*/ caml_call1(class_init, table);
-     /*<<camlinternalOO.ml:333:2>>*/ init_class(table);
-     /*<<camlinternalOO.ml:334:2>>*/ return [0,
-             /*<<camlinternalOO.ml:334:3>>*/ caml_call1(env_init, 0),
-            class_init,
-            env_init,
-            0];
-    /*<<camlinternalOO.ml:334:59>>*/ }
-   function make_class_store(pub_meths, class_init, init_table){
-     /*<<camlinternalOO.ml:340:2>>*/ var
-      /*<<camlinternalOO.ml:340:14>>*/ table = create_table(pub_meths),
-      /*<<camlinternalOO.ml:341:17>>*/ env_init =
-        /*<<camlinternalOO.ml:341:17>>*/ caml_call1(class_init, table);
-     /*<<camlinternalOO.ml:342:2>>*/ init_class(table);
-    init_table[2] = class_init;
-    init_table[1] = env_init;
-    return 0;
-    /*<<camlinternalOO.ml:344:33>>*/ }
-   function dummy_class(loc){
-    function undef(param){
-      /*<<camlinternalOO.ml:347:23>>*/ throw  /*<<camlinternalOO.ml:347:23>>*/ caml_maybe_attach_backtrace
-            ([0, Stdlib[15], loc], 1);
-     /*<<camlinternalOO.ml:347:61>>*/ }
-     /*<<camlinternalOO.ml:348:2>>*/ return [0, undef, undef, undef, 0];
-    /*<<camlinternalOO.ml:348:45>>*/ }
-   function create_object(table){
-     /*<<camlinternalOO.ml:354:2>>*/  /*<<camlinternalOO.ml:354:12>>*/ var
-     obj =
-        /*<<camlinternalOO.ml:354:12>>*/ caml_obj_block
-        (Stdlib_Obj[10], table[1]);
-     /*<<camlinternalOO.ml:356:2>>*/ obj[1] = table[2];
-     /*<<camlinternalOO.ml:357:10>>*/ return  /*<<camlinternalOO.ml:357:10>>*/ caml_set_oo_id
-            (obj);
-    /*<<camlinternalOO.ml:357:22>>*/ }
-   function create_object_opt(obj_0, table){
-     /*<<camlinternalOO.ml:360:2>>*/ if(obj_0)
-      /*<<camlinternalOO.ml:360:35>>*/ return obj_0;
-     /*<<camlinternalOO.ml:362:14>>*/  /*<<camlinternalOO.ml:362:14>>*/ var
-     obj =
-        /*<<camlinternalOO.ml:362:14>>*/ caml_obj_block
-        (Stdlib_Obj[10], table[1]);
-     /*<<camlinternalOO.ml:364:4>>*/ obj[1] = table[2];
-     /*<<camlinternalOO.ml:365:12>>*/ return  /*<<camlinternalOO.ml:365:12>>*/ caml_set_oo_id
-            (obj);
-    /*<<camlinternalOO.ml:366:5>>*/ }
-   function iter_f(obj, param){
-    var param$0 = param;
-    for(;;){
-     if(! param$0)  /*<<camlinternalOO.ml:370:12>>*/ return 0;
-     var l = param$0[2], f = param$0[1];
-      /*<<camlinternalOO.ml:371:12>>*/  /*<<camlinternalOO.ml:371:12>>*/ caml_call1
-      (f, obj);
-     var param$0 = l;
-    }
-   }
-   function run_initializers(obj, table){
-     /*<<camlinternalOO.ml:374:2>>*/ var
-     inits = table[8],
-     _r_ = 0 !== inits ? 1 : 0;
-    return _r_ ? iter_f(obj, inits) : _r_;
-    /*<<camlinternalOO.ml:376:20>>*/ }
-   function run_initializers_opt(obj_0, obj, table){
-     /*<<camlinternalOO.ml:379:2>>*/ if(obj_0)
-      /*<<camlinternalOO.ml:379:35>>*/ return obj;
-    var inits = table[8];
-    if(0 !== inits)  /*<<camlinternalOO.ml:381:24>>*/ iter_f(obj, inits);
-     /*<<camlinternalOO.ml:381:24>>*/ return obj;
-    /*<<camlinternalOO.ml:383:5>>*/ }
-   function create_object_and_run_initiali(obj_0, table){
-     /*<<camlinternalOO.ml:386:2>>*/ if(obj_0)
-      /*<<camlinternalOO.ml:386:35>>*/ return obj_0;
-     /*<<camlinternalOO.ml:387:14>>*/  /*<<camlinternalOO.ml:387:14>>*/ var
-     obj = create_object(table);
-     /*<<camlinternalOO.ml:388:4>>*/ run_initializers(obj, table);
-     /*<<camlinternalOO.ml:388:4>>*/ return obj;
-    /*<<camlinternalOO.ml:390:5>>*/ }
-   function get_data(param){
-     /*<<camlinternalOO.ml:417:15>>*/ if(param)
-      /*<<camlinternalOO.ml:419:19>>*/ return param[2];
-     /*<<camlinternalOO.ml:418:13>>*/ throw  /*<<camlinternalOO.ml:418:13>>*/ caml_maybe_attach_backtrace
-           ([0, Assert_failure, _e_], 1);
-    /*<<camlinternalOO.ml:419:30>>*/ }
-   function build_path(n, keys, tables){
-     /*<<camlinternalOO.ml:425:2>>*/ var
-      /*<<camlinternalOO.ml:425:17>>*/ res = [0, 0, 0, 0],
-      /*<<camlinternalOO.ml:426:10>>*/ r = [0, res],
-      /*<<camlinternalOO.ml:426:10>>*/ _o_ = 0;
-    if(n >= 0){
-     var i = _o_;
-     for(;;){
-      var _p_ = r[1];
-      r[1] = [0, caml_check_bound(keys, i)[1 + i], _p_, 0];
-       /*<<camlinternalOO.ml:427:2>>*/  /*<<camlinternalOO.ml:427:2>>*/ var
-       _q_ = i + 1 | 0;
-      if(n === i) break;
-      var i = _q_;
-     }
-    }
-    var v = r[1];
-    if(! tables)
-      /*<<camlinternalOO.ml:409:13>>*/ throw  /*<<camlinternalOO.ml:409:13>>*/ caml_maybe_attach_backtrace
-            ([0, Assert_failure, _b_], 1);
-    tables[2] = v;
-     /*<<camlinternalOO.ml:430:2>>*/ return res;
-    /*<<camlinternalOO.ml:431:5>>*/ }
-   function lookup_tables(root, keys){
-     /*<<camlinternalOO.ml:453:2>>*/  /*<<camlinternalOO.ml:453:8>>*/ var
-     root_data = get_data(root);
-    if(! root_data)
-      /*<<camlinternalOO.ml:457:4>>*/ return build_path
-             (keys.length - 1 - 1 | 0, keys, root);
-    var i$1 = keys.length - 1 - 1 | 0, i = i$1, tables$0 = root_data;
-     /*<<camlinternalOO.ml:434:2>>*/ for(;;){
-     if(0 > i)  /*<<camlinternalOO.ml:434:16>>*/ return tables$0;
-      /*<<camlinternalOO.ml:435:12>>*/ var
-       /*<<camlinternalOO.ml:435:12>>*/ key = caml_check_bound(keys, i)[1 + i],
-      tables$1 = tables$0;
-      /*<<camlinternalOO.ml:437:4>>*/ for(;;){
-      if(! tables$1)
-        /*<<camlinternalOO.ml:415:13>>*/ throw  /*<<camlinternalOO.ml:415:13>>*/ caml_maybe_attach_backtrace
-              ([0, Assert_failure, _d_], 1);
-      if(tables$1[1] === key){
-        /*<<camlinternalOO.ml:438:12>>*/  /*<<camlinternalOO.ml:438:12>>*/ var
-        tables_data = get_data(tables$1);
-       if(! tables_data)
-         /*<<camlinternalOO.ml:439:17>>*/ throw  /*<<camlinternalOO.ml:439:17>>*/ caml_maybe_attach_backtrace
-               ([0, Assert_failure, _g_], 1);
-       var i$0 = i - 1 | 0, i = i$0, tables$0 = tables_data;
-       break;
-      }
-      if(! tables$1)
-        /*<<camlinternalOO.ml:421:13>>*/ throw  /*<<camlinternalOO.ml:421:13>>*/ caml_maybe_attach_backtrace
-              ([0, Assert_failure, _f_], 1);
-       /*<<camlinternalOO.ml:422:19>>*/  /*<<camlinternalOO.ml:422:19>>*/ var
-       tables = tables$1[3];
-      if(! tables){
-        /*<<camlinternalOO.ml:446:35>>*/  /*<<camlinternalOO.ml:446:35>>*/ var
-        next = [0, key, 0, 0];
-       if(! tables$1)
-         /*<<camlinternalOO.ml:412:13>>*/ throw  /*<<camlinternalOO.ml:412:13>>*/ caml_maybe_attach_backtrace
-               ([0, Assert_failure, _c_], 1);
-       tables$1[3] = next;
-        /*<<camlinternalOO.ml:447:10>>*/ return build_path
-               (i - 1 | 0, keys, next);
-      }
-      var tables$1 = tables;
-     }
-    }
-    /*<<camlinternalOO.ml:457:48>>*/ }
-   function new_cache(table){
-     /*<<camlinternalOO.ml:509:2>>*/  /*<<camlinternalOO.ml:509:10>>*/ var
-     n = new_method(table);
-    a:
-    {
-     if(0 !== (n % 2 | 0)){
-      var _n_ = Stdlib_Sys[9];
-      if
-       ((2 + caml_div(caml_check_bound(table[2], 1)[2] * 16 | 0, _n_) | 0)
-        >= n){
-       var n$0 = new_method(table);
-       break a;
-      }
-     }
-     var n$0 = n;
-    }
-     /*<<camlinternalOO.ml:514:2>>*/ caml_check_bound(table[2], n$0)[1 + n$0]
-    = 0;
-     /*<<camlinternalOO.ml:514:2>>*/ return n$0;
-    /*<<camlinternalOO.ml:515:3>>*/ }
-   function set_methods(table, methods){
-     /*<<camlinternalOO.ml:600:2>>*/ var
-     len = methods.length - 1,
-      /*<<camlinternalOO.ml:600:44>>*/ i = [0, 0];
-    for(;;){
-     if(i[1] >= len) return 0;
-      /*<<camlinternalOO.ml:602:16>>*/ var
-      _h_ = i[1],
-       /*<<camlinternalOO.ml:602:16>>*/ label =
-        caml_check_bound(methods, _h_)[1 + _h_],
-      next =
-        function(param){
-          /*<<camlinternalOO.ml:545:16>>*/ i[1]++;
-         var _m_ = i[1];
-          /*<<camlinternalOO.ml:545:30>>*/ return caml_check_bound
-                  (methods, _m_)
-                 [1 + _m_];
-         /*<<camlinternalOO.ml:545:38>>*/ },
-       /*<<camlinternalOO.ml:546:8>>*/ clo = next(0);
-     if(typeof clo === "number")
-      switch(clo){
-        case 0:
-          /*<<camlinternalOO.ml:547:28>>*/ var
-           /*<<camlinternalOO.ml:547:28>>*/ x = next(0),
-          clo$0 =
-            function(x){
-               /*<<?>>*/ return function(obj){
-                /*<<camlinternalOO.ml:461:35>>*/ return x; /*<<camlinternalOO.ml:461:36>>*/ };
-             }
-             (x);
-         break;
-        case 1:
-          /*<<camlinternalOO.ml:548:24>>*/ var
-           /*<<camlinternalOO.ml:548:24>>*/ n = next(0),
-          clo$0 =
-            function(n){
-               /*<<?>>*/ return function(obj){
-                /*<<camlinternalOO.ml:462:34>>*/ return obj[1 + n]; /*<<camlinternalOO.ml:462:56>>*/ };
-             }
-             (n);
-         break;
-        case 2:
-          /*<<camlinternalOO.ml:549:24>>*/ var
-           /*<<camlinternalOO.ml:549:24>>*/ e = next(0),
-           /*<<camlinternalOO.ml:549:42>>*/ n$0 = next(0),
-          clo$0 =
-            function(e, n){
-               /*<<?>>*/ return function(obj){
-                /*<<camlinternalOO.ml:465:4>>*/ return obj[1 + e][1 + n]; /*<<camlinternalOO.ml:465:65>>*/ };
-             }
-             (e, n$0);
-         break;
-        case 3:
-          /*<<camlinternalOO.ml:550:24>>*/ var
-           /*<<camlinternalOO.ml:550:24>>*/ n$1 = next(0),
-          clo$0 =
-            function(n){
-               /*<<?>>*/ return function(obj){
-                /*<<camlinternalOO.ml:466:34>>*/ return  /*<<camlinternalOO.ml:466:34>>*/ caml_call1
-                       (obj[1][1 + n], obj); /*<<camlinternalOO.ml:466:48>>*/ };
-             }
-             (n$1);
-         break;
-        case 4:
-          /*<<camlinternalOO.ml:551:24>>*/ var
-           /*<<camlinternalOO.ml:551:24>>*/ n$2 = next(0),
-          clo$0 =
-            function(n){
-               /*<<?>>*/ return function(obj, x){
-                /*<<camlinternalOO.ml:467:36>>*/ obj[1 + n] = x;
-               return 0; /*<<camlinternalOO.ml:467:60>>*/ };
-             }
-             (n$2);
-         break;
-        case 5:
-          /*<<camlinternalOO.ml:552:24>>*/ var
-           /*<<camlinternalOO.ml:552:24>>*/ f = next(0),
-           /*<<camlinternalOO.ml:552:42>>*/ x$0 = next(0),
-          clo$0 =
-            function(f, x){
-               /*<<?>>*/ return function(obj){
-                /*<<camlinternalOO.ml:468:37>>*/ return  /*<<camlinternalOO.ml:468:20>>*/ caml_call1
-                       (f, x); /*<<camlinternalOO.ml:468:40>>*/ };
-             }
-             (f, x$0);
-         break;
-        case 6:
-          /*<<camlinternalOO.ml:553:24>>*/ var
-           /*<<camlinternalOO.ml:553:24>>*/ f$0 = next(0),
-           /*<<camlinternalOO.ml:553:42>>*/ n$3 = next(0),
-          clo$0 =
-            function(f, n){
-               /*<<?>>*/ return function(obj){
-                /*<<camlinternalOO.ml:469:36>>*/ return caml_call1
-                       (f, obj[1 + n]); /*<<camlinternalOO.ml:469:62>>*/ };
-             }
-             (f$0, n$3);
-         break;
-        case 7:
-          /*<<camlinternalOO.ml:555:14>>*/ var
-           /*<<camlinternalOO.ml:555:14>>*/ f$1 = next(0),
-           /*<<camlinternalOO.ml:555:33>>*/ e$0 = next(0),
-           /*<<camlinternalOO.ml:555:51>>*/ n$4 = next(0),
-          clo$0 =
-            function(f, e, n){
-               /*<<?>>*/ return function(obj){
-                /*<<camlinternalOO.ml:472:4>>*/ return caml_call1
-                       (f, obj[1 + e][1 + n]); /*<<camlinternalOO.ml:472:69>>*/ };
-             }
-             (f$1, e$0, n$4);
-         break;
-        case 8:
-          /*<<camlinternalOO.ml:557:24>>*/ var
-           /*<<camlinternalOO.ml:557:24>>*/ f$2 = next(0),
-           /*<<camlinternalOO.ml:557:42>>*/ n$5 = next(0),
-          clo$0 =
-            function(f, n){
-               /*<<?>>*/ return function(obj){
-                /*<<camlinternalOO.ml:473:36>>*/ return  /*<<camlinternalOO.ml:473:38>>*/ caml_call1
-                       (f,
-                         /*<<camlinternalOO.ml:473:38>>*/ caml_call1
-                         (obj[1][1 + n], obj)); /*<<camlinternalOO.ml:473:54>>*/ };
-             }
-             (f$2, n$5);
-         break;
-        case 9:
-          /*<<camlinternalOO.ml:559:14>>*/ var
-           /*<<camlinternalOO.ml:559:14>>*/ f$3 = next(0),
-           /*<<camlinternalOO.ml:559:32>>*/ x$1 = next(0),
-           /*<<camlinternalOO.ml:559:50>>*/ y = next(0),
-          clo$0 =
-            function(f, x, y){
-               /*<<?>>*/ return function(obj){
-                /*<<camlinternalOO.ml:474:45>>*/ return  /*<<camlinternalOO.ml:474:28>>*/ caml_call2
-                       (f, x, y); /*<<camlinternalOO.ml:474:50>>*/ };
-             }
-             (f$3, x$1, y);
-         break;
-        case 10:
-          /*<<camlinternalOO.ml:562:14>>*/ var
-           /*<<camlinternalOO.ml:562:14>>*/ f$4 = next(0),
-           /*<<camlinternalOO.ml:562:32>>*/ x$2 = next(0),
-           /*<<camlinternalOO.ml:562:50>>*/ n$6 = next(0),
-          clo$0 =
-            function(f, x, n){
-               /*<<?>>*/ return function(obj){
-                /*<<camlinternalOO.ml:475:44>>*/ return caml_call2
-                       (f, x, obj[1 + n]); /*<<camlinternalOO.ml:475:72>>*/ };
-             }
-             (f$4, x$2, n$6);
-         break;
-        case 11:
-          /*<<camlinternalOO.ml:565:14>>*/ var
-           /*<<camlinternalOO.ml:565:14>>*/ f$5 = next(0),
-           /*<<camlinternalOO.ml:565:32>>*/ x$3 = next(0),
-           /*<<camlinternalOO.ml:565:50>>*/ e$1 = next(0),
-           /*<<camlinternalOO.ml:565:69>>*/ n$7 = next(0),
-          clo$0 =
-            function(f, x, e, n){
-               /*<<?>>*/ return function(obj){
-                /*<<camlinternalOO.ml:481:4>>*/ return caml_call2
-                       (f, x, obj[1 + e][1 + n]); /*<<camlinternalOO.ml:481:71>>*/ };
-             }
-             (f$5, x$3, e$1, n$7);
-         break;
-        case 12:
-          /*<<camlinternalOO.ml:568:14>>*/ var
-           /*<<camlinternalOO.ml:568:14>>*/ f$6 = next(0),
-           /*<<camlinternalOO.ml:568:32>>*/ x$4 = next(0),
-           /*<<camlinternalOO.ml:568:50>>*/ n$8 = next(0),
-          clo$0 =
-            function(f, x, n){
-               /*<<?>>*/ return function(obj){
-                /*<<camlinternalOO.ml:476:43>>*/ return  /*<<camlinternalOO.ml:476:47>>*/ caml_call2
-                       (f,
-                        x,
-                         /*<<camlinternalOO.ml:476:47>>*/ caml_call1
-                         (obj[1][1 + n], obj)); /*<<camlinternalOO.ml:476:63>>*/ };
-             }
-             (f$6, x$4, n$8);
-         break;
-        case 13:
-          /*<<camlinternalOO.ml:571:14>>*/ var
-           /*<<camlinternalOO.ml:571:14>>*/ f$7 = next(0),
-           /*<<camlinternalOO.ml:571:32>>*/ n$9 = next(0),
-           /*<<camlinternalOO.ml:571:50>>*/ x$5 = next(0),
-          clo$0 =
-            function(f, n, x){
-               /*<<?>>*/ return function(obj){
-                /*<<camlinternalOO.ml:477:42>>*/ return  /*<<camlinternalOO.ml:477:26>>*/ caml_call2
-                       (f, obj[1 + n], x); /*<<camlinternalOO.ml:477:70>>*/ };
-             }
-             (f$7, n$9, x$5);
-         break;
-        case 14:
-          /*<<camlinternalOO.ml:574:14>>*/ var
-           /*<<camlinternalOO.ml:574:14>>*/ f$8 = next(0),
-           /*<<camlinternalOO.ml:574:32>>*/ e$2 = next(0),
-           /*<<camlinternalOO.ml:574:51>>*/ n$10 = next(0),
-           /*<<camlinternalOO.ml:574:69>>*/ x$6 = next(0),
-          clo$0 =
-            function(f, e, n, x){
-               /*<<?>>*/ return function(obj){
-                /*<<camlinternalOO.ml:484:4>>*/ return  /*<<camlinternalOO.ml:483:2>>*/ caml_call2
-                       (f, obj[1 + e][1 + n], x); /*<<camlinternalOO.ml:484:71>>*/ };
-             }
-             (f$8, e$2, n$10, x$6);
-         break;
-        case 15:
-          /*<<camlinternalOO.ml:577:14>>*/ var
-           /*<<camlinternalOO.ml:577:14>>*/ f$9 = next(0),
-           /*<<camlinternalOO.ml:577:32>>*/ n$11 = next(0),
-           /*<<camlinternalOO.ml:577:50>>*/ x$7 = next(0),
-          clo$0 =
-            function(f, n, x){
-               /*<<?>>*/ return function(obj){
-                /*<<camlinternalOO.ml:478:43>>*/ return  /*<<camlinternalOO.ml:478:27>>*/ caml_call2
-                       (f,
-                         /*<<camlinternalOO.ml:478:45>>*/ caml_call1
-                         (obj[1][1 + n], obj),
-                        x); /*<<camlinternalOO.ml:478:63>>*/ };
-             }
-             (f$9, n$11, x$7);
-         break;
-        case 16:
-          /*<<camlinternalOO.ml:580:14>>*/ var
-           /*<<camlinternalOO.ml:580:14>>*/ n$12 = next(0),
-           /*<<camlinternalOO.ml:580:32>>*/ x$8 = next(0),
-          clo$0 =
-            function(n, x){
-               /*<<?>>*/ return function(obj){
-                /*<<camlinternalOO.ml:485:41>>*/ return  /*<<camlinternalOO.ml:485:25>>*/ caml_call2
-                       (obj[1][1 + n], obj, x); /*<<camlinternalOO.ml:485:68>>*/ };
-             }
-             (n$12, x$8);
-         break;
-        case 17:
-          /*<<camlinternalOO.ml:582:14>>*/ var
-           /*<<camlinternalOO.ml:582:14>>*/ n$13 = next(0),
-           /*<<camlinternalOO.ml:582:32>>*/ m = next(0),
-          clo$0 =
-            function(n, m){
-               /*<<?>>*/ return function(obj){
-                /*<<camlinternalOO.ml:487:18>>*/ return caml_call2
-                       (obj[1][1 + n], obj, obj[1 + m]); /*<<camlinternalOO.ml:487:68>>*/ };
-             }
-             (n$13, m);
-         break;
-        case 18:
-          /*<<camlinternalOO.ml:584:14>>*/ var
-           /*<<camlinternalOO.ml:584:14>>*/ n$14 = next(0),
-           /*<<camlinternalOO.ml:584:32>>*/ e$3 = next(0),
-           /*<<camlinternalOO.ml:584:50>>*/ m$0 = next(0),
-          clo$0 =
-            function(n, e, m){
-               /*<<?>>*/ return function(obj){
-                /*<<camlinternalOO.ml:489:18>>*/ return caml_call2
-                       (obj[1][1 + n], obj, obj[1 + e][1 + m]); /*<<camlinternalOO.ml:490:69>>*/ };
-             }
-             (n$14, e$3, m$0);
-         break;
-        case 19:
-          /*<<camlinternalOO.ml:587:14>>*/ var
-           /*<<camlinternalOO.ml:587:14>>*/ n$15 = next(0),
-           /*<<camlinternalOO.ml:587:32>>*/ m$1 = next(0),
-          clo$0 =
-            function(n, m){
-               /*<<?>>*/ return function(obj){
-                /*<<camlinternalOO.ml:492:18>>*/  /*<<camlinternalOO.ml:492:44>>*/ var
-                _k_ =
-                   /*<<camlinternalOO.ml:492:44>>*/ caml_call1
-                   (obj[1][1 + m], obj);
-                /*<<camlinternalOO.ml:492:44>>*/ return  /*<<camlinternalOO.ml:492:44>>*/ caml_call2
-                       (obj[1][1 + n], obj, _k_); /*<<camlinternalOO.ml:492:60>>*/ };
-             }
-             (n$15, m$1);
-         break;
-        case 20:
-          /*<<camlinternalOO.ml:589:14>>*/ var
-           /*<<camlinternalOO.ml:589:14>>*/ m$2 = next(0),
-           /*<<camlinternalOO.ml:589:32>>*/ x$9 = next(0);
-          /*<<camlinternalOO.ml:589:57>>*/ new_cache(table);
-         var
-          clo$0 =
-            function(m, x){
-               /*<<?>>*/ return function(obj){
-                /*<<camlinternalOO.ml:494:18>>*/ return  /*<<camlinternalOO.ml:494:2>>*/ caml_call1
-                       (caml_get_public_method(x, m, 0), x); /*<<camlinternalOO.ml:494:58>>*/ };
-             }
-             (m$2, x$9);
-         break;
-        case 21:
-          /*<<camlinternalOO.ml:591:14>>*/ var
-           /*<<camlinternalOO.ml:591:14>>*/ m$3 = next(0),
-           /*<<camlinternalOO.ml:591:32>>*/ n$16 = next(0);
-          /*<<camlinternalOO.ml:591:56>>*/ new_cache(table);
-         var
-          clo$0 =
-            function(m, n){
-               /*<<?>>*/ return function(obj){
-                /*<<camlinternalOO.ml:497:4>>*/ var _j_ = obj[1 + n];
-               return caml_call1(caml_get_public_method(_j_, m, 0), _j_); /*<<camlinternalOO.ml:498:32>>*/ };
-             }
-             (m$3, n$16);
-         break;
-        case 22:
-          /*<<camlinternalOO.ml:593:14>>*/ var
-           /*<<camlinternalOO.ml:593:14>>*/ m$4 = next(0),
-           /*<<camlinternalOO.ml:593:32>>*/ e$4 = next(0),
-           /*<<camlinternalOO.ml:593:50>>*/ n$17 = next(0);
-          /*<<camlinternalOO.ml:594:21>>*/ new_cache(table);
-         var
-          clo$0 =
-            function(m, e, n){
-               /*<<?>>*/ return function(obj){
-                /*<<camlinternalOO.ml:501:4>>*/ var _i_ = obj[1 + e][1 + n];
-               return caml_call1(caml_get_public_method(_i_, m, 0), _i_); /*<<camlinternalOO.ml:504:34>>*/ };
-             }
-             (m$4, e$4, n$17);
-         break;
-        default:
-          /*<<camlinternalOO.ml:596:14>>*/ var
-           /*<<camlinternalOO.ml:596:14>>*/ m$5 = next(0),
-           /*<<camlinternalOO.ml:596:32>>*/ n$18 = next(0);
-          /*<<camlinternalOO.ml:596:57>>*/ new_cache(table);
-         var
-          clo$0 =
-            function(m, n){
-               /*<<?>>*/ return function(obj){
-                /*<<camlinternalOO.ml:507:4>>*/  /*<<camlinternalOO.ml:507:14>>*/ var
-                _l_ =
-                   /*<<camlinternalOO.ml:507:14>>*/ caml_call1
-                   (obj[1][1 + n], obj);
-                /*<<camlinternalOO.ml:507:14>>*/ return  /*<<camlinternalOO.ml:507:14>>*/ caml_call1
-                       (caml_get_public_method(_l_, m, 0), _l_); /*<<camlinternalOO.ml:507:59>>*/ };
-             }
-             (m$5, n$18);
-      }
-     else
-      var clo$0 = clo;
-      /*<<camlinternalOO.ml:603:4>>*/ set_method(table, label, clo$0);
-     i[1]++;
-    }
-    /*<<camlinternalOO.ml:605:6>>*/ }
-   function stats(param){
-     /*<<camlinternalOO.ml:613:2>>*/ return [0,
-            table_count[1],
-            method_count[1],
-            inst_var_count[1]];
-    /*<<camlinternalOO.ml:614:59>>*/ }
-   var
-    CamlinternalOO =
-      [0,
-       public_method_label,
-       new_method,
-       new_variable,
-       new_methods_variables,
-       get_variable,
-       get_variables,
-       get_method_label,
-       get_method_labels,
-       get_method,
-       set_method,
-       set_methods,
-       narrow,
-       widen,
-       add_initializer,
-       dummy_table,
-       create_table,
-       init_class,
-       inherits,
-       make_class,
-       make_class_store,
-       dummy_class,
-       copy,
-       create_object,
-       create_object_opt,
-       run_initializers,
-       run_initializers_opt,
-       create_object_and_run_initiali,
-       lookup_tables,
-       params,
-       stats];
-   runtime.caml_register_global(17, CamlinternalOO, "CamlinternalOO");
-   return;
-   /*<<?>>*/ }
-  (globalThis));
-
-//# unitInfo: Provides: Stdlib__Oo
-//# unitInfo: Requires: CamlinternalOO
-(function
-  (globalThis){
-   "use strict";
-   var
-    runtime = globalThis.jsoo_runtime,
-    global_data = runtime.caml_get_global_data(),
-    CamlinternalOO = global_data.CamlinternalOO,
-    copy = CamlinternalOO[22],
-    new_method = CamlinternalOO[1],
-    public_method_label = CamlinternalOO[1],
-    Stdlib_Oo = [0, copy, new_method, public_method_label];
-   runtime.caml_register_global(1, Stdlib_Oo, "Stdlib__Oo");
-   return;
-   /*<<?>>*/ }
-  (globalThis));
-
-//# unitInfo: Provides: CamlinternalMod
-//# unitInfo: Requires: Assert_failure, CamlinternalLazy, CamlinternalOO, Stdlib, Stdlib__Obj
-(function
-  (globalThis){
-   "use strict";
-   var
-    runtime = globalThis.jsoo_runtime,
-    cst_camlinternalMod_ml = "camlinternalMod.ml",
-    caml_check_bound = runtime.caml_check_bound,
-    caml_maybe_attach_backtrace = runtime.caml_maybe_attach_backtrace,
-    caml_obj_tag = runtime.caml_obj_tag;
-    /*<<?>>*/ function caml_call1(f, a0){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 1
-            ? f(a0)
-            : runtime.caml_call_gen(f, [a0]);
-   }
-   var
-    global_data = runtime.caml_get_global_data(),
-    Stdlib = global_data.Stdlib,
-    CamlinternalLazy = global_data.CamlinternalLazy,
-    CamlinternalOO = global_data.CamlinternalOO,
-    Assert_failure = global_data.Assert_failure,
-    _a_ = [0, cst_camlinternalMod_ml, 72, 5],
-    _b_ = [0, cst_camlinternalMod_ml, 81, 2],
-    cst_CamlinternalMod_update_mod =
-      "CamlinternalMod.update_mod: not a module",
-    cst_CamlinternalMod_init_mod_n = "CamlinternalMod.init_mod: not a module";
-   function init_mod_block(loc, comps$0){
-     /*<<camlinternalMod.ml:52:2>>*/ var
-     length = comps$0.length - 1,
-      /*<<camlinternalMod.ml:53:13>>*/ modu =
-        /*<<camlinternalMod.ml:53:13>>*/ runtime.caml_obj_block(0, length),
-      /*<<camlinternalMod.ml:54:2>>*/ _h_ = length - 1 | 0,
-      /*<<camlinternalMod.ml:53:13>>*/ _g_ = 0;
-    if(_h_ >= 0){
-     var i = _g_;
-     for(;;){
-       /*<<camlinternalMod.ml:55:30>>*/  /*<<camlinternalMod.ml:55:30>>*/ var
-       shape = caml_check_bound(comps$0, i)[1 + i];
-      if(typeof shape === "number")
-       switch(shape){
-         case 0:
-          var
-           fn$0 =
-             function(i){
-              function fn(x){
-                /*<<camlinternalMod.ml:28:9>>*/  /*<<camlinternalMod.ml:28:38>>*/ var
-                fn$0 = modu[1 + i];
-               if(fn === fn$0)
-                 /*<<camlinternalMod.ml:30:11>>*/ throw  /*<<camlinternalMod.ml:30:11>>*/ caml_maybe_attach_backtrace
-                       ([0, Stdlib[15], loc], 1);
-                /*<<camlinternalMod.ml:32:11>>*/ return  /*<<camlinternalMod.ml:32:11>>*/ caml_call1
-                       (fn$0, x);
-               /*<<camlinternalMod.ml:32:16>>*/ }
-              return fn;
-             },
-           fn = fn$0(i),
-           init = fn;
-          break;
-         case 1:
-          var l = [];
-          runtime.caml_update_dummy
-           (l,
-            [246,
-             function(l, i){
-                /*<<?>>*/ return function(param){
-                 /*<<camlinternalMod.ml:37:28>>*/  /*<<camlinternalMod.ml:37:28>>*/ var
-                 l$0 = modu[1 + i];
-                if(l === l$0)
-                  /*<<camlinternalMod.ml:39:13>>*/ throw  /*<<camlinternalMod.ml:39:13>>*/ caml_maybe_attach_backtrace
-                        ([0, Stdlib[15], loc], 1);
-                var _j_ = caml_obj_tag(l$0);
-                if(250 === _j_) return l$0[1];
-                if(246 !== _j_ && 244 !== _j_)
-                  /*<<camlinternalMod.ml:41:13>>*/ return l$0;
-                 /*<<camlinternalMod.ml:41:13>>*/ return  /*<<camlinternalMod.ml:41:13>>*/ caml_call1
-                        (CamlinternalLazy[2], l$0);};
-              }
-              (l, i)]);
-          var init = l;
-          break;
-         default:
-          var
-           init =
-              /*<<camlinternalMod.ml:44:16>>*/ caml_call1
-              (CamlinternalOO[21], loc);
-       }
-      else if(0 === shape[0])
-       var comps = shape[1], init = init_mod_block(loc, comps);
-      else
-       var v = shape[1], init = v;
-       /*<<camlinternalMod.ml:49:2>>*/ modu[1 + i] = init;
-       /*<<camlinternalMod.ml:55:4>>*/  /*<<camlinternalMod.ml:55:4>>*/ var
-       _i_ = i + 1 | 0;
-      if(_h_ === i) break;
-      var i = _i_;
-     }
-    }
-     /*<<camlinternalMod.ml:57:2>>*/ return modu;
-    /*<<camlinternalMod.ml:57:6>>*/ }
-   function init_mod(loc, shape){
-     /*<<camlinternalMod.ml:60:2>>*/ if
-     (typeof shape !== "number" && 0 === shape[0]){
-     var comps = shape[1];
-      /*<<camlinternalMod.ml:62:5>>*/ return init_mod_block(loc, comps);
-    }
-     /*<<camlinternalMod.ml:63:9>>*/ return  /*<<camlinternalMod.ml:63:9>>*/ caml_call1
-            (Stdlib[2], cst_CamlinternalMod_init_mod_n);
-    /*<<camlinternalMod.ml:63:58>>*/ }
-   function update_mod_block(comps$0, modu, n){
-     /*<<camlinternalMod.ml:81:2>>*/ if
-     (0 ===  /*<<camlinternalMod.ml:81:10>>*/ caml_obj_tag(n)
-      && comps$0.length - 1 <= n.length - 1){
-      /*<<camlinternalMod.ml:82:2>>*/ var
-      _e_ = comps$0.length - 1 - 1 | 0,
-       /*<<camlinternalMod.ml:82:2>>*/ _d_ = 0;
-     if(_e_ >= 0){
-      var i = _d_;
-      for(;;){
-        /*<<camlinternalMod.ml:83:35>>*/ var
-         /*<<camlinternalMod.ml:83:35>>*/ n$0 = n[1 + i],
-         /*<<camlinternalMod.ml:83:25>>*/ shape =
-          caml_check_bound(comps$0, i)[1 + i];
-       a:
-       if(typeof shape === "number"){
-        if(2 === shape){
-         if
-          (0 ===  /*<<camlinternalMod.ml:72:13>>*/ caml_obj_tag(n$0)
-           && 4 === n$0.length - 1){
-           /*<<camlinternalMod.ml:73:14>>*/ var
-            /*<<camlinternalMod.ml:73:14>>*/ cl = modu[1 + i],
-           j = 0;
-          for(;;){
-            /*<<camlinternalMod.ml:75:7>>*/ cl[1 + j] = n$0[1 + j];
-            /*<<camlinternalMod.ml:75:7>>*/  /*<<camlinternalMod.ml:75:7>>*/ var
-            _c_ = j + 1 | 0;
-           if(3 === j) break a;
-           var j = _c_;
-          }
-         }
-          /*<<camlinternalMod.ml:72:5>>*/ throw  /*<<camlinternalMod.ml:72:5>>*/ caml_maybe_attach_backtrace
-                ([0, Assert_failure, _a_], 1);
-        }
-         /*<<camlinternalMod.ml:68:5>>*/ modu[1 + i] = n$0;
-       }
-       else if(0 === shape[0]){
-        var comps = shape[1];
-         /*<<camlinternalMod.ml:78:5>>*/ update_mod_block
-         (comps, modu[1 + i], n$0);
-       }
-        /*<<camlinternalMod.ml:83:4>>*/  /*<<camlinternalMod.ml:83:4>>*/ var
-        _f_ = i + 1 | 0;
-       if(_e_ === i) break;
-       var i = _f_;
-      }
-     }
-     return 0;
-    }
-     /*<<camlinternalMod.ml:81:2>>*/ throw  /*<<camlinternalMod.ml:81:2>>*/ caml_maybe_attach_backtrace
-           ([0, Assert_failure, _b_], 1);
-    /*<<camlinternalMod.ml:84:6>>*/ }
-   function update_mod(shape, o, n){
-     /*<<camlinternalMod.ml:87:2>>*/ if
-     (typeof shape !== "number" && 0 === shape[0]){
-     var comps = shape[1];
-      /*<<camlinternalMod.ml:89:5>>*/ return update_mod_block(comps, o, n);
-    }
-     /*<<camlinternalMod.ml:90:9>>*/ return  /*<<camlinternalMod.ml:90:9>>*/ caml_call1
-            (Stdlib[2], cst_CamlinternalMod_update_mod);
-    /*<<camlinternalMod.ml:90:60>>*/ }
-   var CamlinternalMod = [0, init_mod, update_mod];
-   runtime.caml_register_global(8, CamlinternalMod, "CamlinternalMod");
-   return;
-   /*<<?>>*/ }
-  (globalThis));
-
-//# unitInfo: Provides: Stdlib__Ephemeron
-//# unitInfo: Requires: CamlinternalLazy, Stdlib, Stdlib__Array, Stdlib__Hashtbl, Stdlib__Int, Stdlib__List, Stdlib__Obj, Stdlib__Random, Stdlib__Seq, Stdlib__Sys
-(function
-  (globalThis){
-   "use strict";
-   var
-    runtime = globalThis.jsoo_runtime,
-    caml_check_bound = runtime.caml_check_bound,
-    caml_make_vect = runtime.caml_make_vect,
-    caml_maybe_attach_backtrace = runtime.caml_maybe_attach_backtrace,
-    caml_wrap_exception = runtime.caml_wrap_exception;
-    /*<<?>>*/ function caml_call1(f, a0){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 1
-            ? f(a0)
-            : runtime.caml_call_gen(f, [a0]);
-   }
-    /*<<?>>*/ function caml_call2(f, a0, a1){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 2
-            ? f(a0, a1)
-            : runtime.caml_call_gen(f, [a0, a1]);
-   }
-    /*<<?>>*/ function caml_call3(f, a0, a1, a2){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 3
-            ? f(a0, a1, a2)
-            : runtime.caml_call_gen(f, [a0, a1, a2]);
-   }
-   var
-    global_data = runtime.caml_get_global_data(),
-    Stdlib_List = global_data.Stdlib__List,
-    Stdlib = global_data.Stdlib,
-    Stdlib_Obj = global_data.Stdlib__Obj,
-    Stdlib_Sys = global_data.Stdlib__Sys,
-    Stdlib_Seq = global_data.Stdlib__Seq,
-    Stdlib_Int = global_data.Stdlib__Int,
-    Stdlib_Array = global_data.Stdlib__Array,
-    Stdlib_Hashtbl = global_data.Stdlib__Hashtbl,
-    CamlinternalLazy = global_data.CamlinternalLazy,
-    Stdlib_Random = global_data.Stdlib__Random,
-    _c_ = [0, 0],
-    _b_ = [0, 0],
-    _a_ = [0, 0];
-   function MakeSeeded(H){
-     /*<<ephemeron.ml:105:20>>*/  /*<<ephemeron.ml:105:20>>*/ var
-     prng =
-       [246,
-        function(_aM_){ /*<<?>>*/ return caml_call1(Stdlib_Random[15][2], 0);}];
-    function create(opt, initial_size){
-      /*<<ephemeron.ml:108:6>>*/ if(opt)
-      var sth = opt[1], random = sth;
-     else
-      var
-       random =  /*<<ephemeron.ml:107:26>>*/ caml_call1(Stdlib_Hashtbl[17], 0);
-     var x = 16;
-      /*<<ephemeron.ml:101:6>>*/ for(;;){
-      if(initial_size > x && Stdlib_Sys[13] >= (x * 2 | 0)){var x$0 = x * 2 | 0, x = x$0; continue;}
-       /*<<ephemeron.ml:109:6>>*/ if(random){
-       var _aK_ = runtime.caml_obj_tag(prng);
-       a:
-       if(250 === _aK_)
-        var _aL_ = prng[1];
-       else{
-        if(246 !== _aK_ && 244 !== _aK_){var _aL_ = prng; break a;}
-        var _aL_ = caml_call1(CamlinternalLazy[2], prng);
-       }
-       var
-        seed =
-           /*<<ephemeron.ml:109:32>>*/ caml_call1(Stdlib_Random[15][4], _aL_);
-      }
-      else
-       var seed = 0;
-       /*<<ephemeron.ml:110:6>>*/ return [0,
-              0,
-               /*<<ephemeron.ml:110:56>>*/ caml_make_vect(x, 0),
-              seed,
-              x];
-     }
-     /*<<ephemeron.ml:110:76>>*/ }
-    function clear(h){
-      /*<<ephemeron.ml:113:6>>*/ h[1] = 0;
-      /*<<ephemeron.ml:115:6>>*/ var
-      len = h[2].length - 1,
-       /*<<ephemeron.ml:115:6>>*/ _aI_ = len - 1 | 0,
-      _aH_ = 0;
-     if(_aI_ >= 0){
-      var i = _aH_;
-      for(;;){
-        /*<<ephemeron.ml:116:8>>*/ caml_check_bound(h[2], i)[1 + i] = 0;
-        /*<<ephemeron.ml:116:8>>*/  /*<<ephemeron.ml:116:8>>*/ var
-        _aJ_ = i + 1 | 0;
-       if(_aI_ === i) break;
-       var i = _aJ_;
-      }
-     }
-     return 0;
-     /*<<ephemeron.ml:117:10>>*/ }
-    function reset(h){
-      /*<<ephemeron.ml:120:6>>*/ var len = h[2].length - 1;
-     return len === h[4]
-             ? clear(h)
-             : (h
-                [1]
-               = 0,
-               h[2] =  /*<<ephemeron.ml:125:18>>*/ caml_make_vect(h[4], 0),
-               0);
-     /*<<ephemeron.ml:126:9>>*/ }
-    function copy(h){
-      /*<<ephemeron.ml:128:17>>*/ var
-      _aE_ = h[4],
-      _aF_ = h[3],
-       /*<<ephemeron.ml:128:33>>*/ _aG_ =
-         /*<<ephemeron.ml:128:33>>*/ caml_call1(Stdlib_Array[6], h[2]);
-      /*<<ephemeron.ml:128:17>>*/ return [0, h[1], _aG_, _aF_, _aE_];
-     /*<<ephemeron.ml:128:52>>*/ }
-    function key_index(h, hkey){
-      /*<<ephemeron.ml:131:6>>*/ return hkey & (h[2].length - 1 - 1 | 0);
-     /*<<ephemeron.ml:131:41>>*/ }
-    function clean(h){
-     function do_bucket(param){
-       /*<<ephemeron.ml:134:26>>*/ var param$0 = param;
-       /*<<ephemeron.ml:134:26>>*/ for(;;){
-       if(! param$0)  /*<<ephemeron.ml:136:12>>*/ return 0;
-       var hkey = param$0[1], rest = param$0[3], c = param$0[2];
-        /*<<ephemeron.ml:137:36>>*/ if
-        ( /*<<ephemeron.ml:137:36>>*/ caml_call1(H[6], c)){
-        var rest$0 = param$0[3], c$0 = param$0[2];
-         /*<<ephemeron.ml:141:12>>*/ return [0, hkey, c$0, do_bucket(rest$0)];
-       }
-       h[1] = h[1] - 1 | 0;
-       var param$0 = rest;
-      }
-      /*<<ephemeron.ml:141:41>>*/ }
-     var d = h[2], _aC_ = d.length - 1 - 1 | 0, _aB_ = 0;
-     if(_aC_ >= 0){
-      var i = _aB_;
-      for(;;){
-        /*<<ephemeron.ml:145:8>>*/ d[1 + i] =
-        do_bucket(caml_check_bound(d, i)[1 + i]);
-        /*<<ephemeron.ml:145:8>>*/  /*<<ephemeron.ml:145:8>>*/ var
-        _aD_ = i + 1 | 0;
-       if(_aC_ === i) break;
-       var i = _aD_;
-      }
-     }
-     return 0;
-     /*<<ephemeron.ml:146:10>>*/ }
-    function resize(h){
-      /*<<ephemeron.ml:169:6>>*/ var
-      odata = h[2],
-       /*<<ephemeron.ml:170:6>>*/ osize = odata.length - 1,
-      nsize = osize * 2 | 0;
-      /*<<ephemeron.ml:172:6>>*/ clean(h);
-     var
-      _av_ = nsize < Stdlib_Sys[13] ? 1 : 0,
-      _aw_ = _av_ ? (osize >>> 1 | 0) <= h[1] ? 1 : 0 : _av_;
-     if(_aw_){
-       /*<<ephemeron.ml:174:20>>*/  /*<<ephemeron.ml:174:20>>*/ var
-       ndata =  /*<<ephemeron.ml:174:20>>*/ caml_make_vect(nsize, 0);
-      h[2] = ndata;
-       /*<<ephemeron.ml:170:6>>*/ var
-       insert_bucket =
-         function(param){
-           /*<<ephemeron.ml:176:32>>*/ if(! param)
-            /*<<ephemeron.ml:177:21>>*/ return 0;
-          var rest = param[3], data = param[2], hkey = param[1];
-           /*<<ephemeron.ml:179:14>>*/ insert_bucket(rest);
-           /*<<ephemeron.ml:180:25>>*/  /*<<ephemeron.ml:180:25>>*/ var
-           nidx = key_index(h, hkey);
-           /*<<ephemeron.ml:181:14>>*/ ndata[1 + nidx] =
-           [0, hkey, data, caml_check_bound(ndata, nidx)[1 + nidx]];
-           /*<<ephemeron.ml:181:14>>*/ return 0;
-          /*<<ephemeron.ml:181:60>>*/ },
-        /*<<ephemeron.ml:170:6>>*/ _ay_ = osize - 1 | 0,
-        /*<<ephemeron.ml:182:8>>*/ _ax_ = 0;
-      if(_ay_ >= 0){
-       var i = _ax_;
-       for(;;){
-         /*<<ephemeron.ml:183:10>>*/ insert_bucket
-         (caml_check_bound(odata, i)[1 + i]);
-         /*<<ephemeron.ml:183:10>>*/  /*<<ephemeron.ml:183:10>>*/ var
-         _aA_ = i + 1 | 0;
-        if(_ay_ === i) break;
-        var i = _aA_;
-       }
-      }
-      var _az_ = 0;
-     }
-     else
-      var _az_ = _aw_;
-     return _az_;
-     /*<<ephemeron.ml:185:9>>*/ }
-    function add(h, key, info){
-      /*<<ephemeron.ml:188:6>>*/ var
-       /*<<ephemeron.ml:188:17>>*/ hkey =
-         /*<<ephemeron.ml:188:17>>*/ caml_call2(H[2], h[3], key),
-       /*<<ephemeron.ml:189:14>>*/ i = key_index(h, hkey),
-       /*<<ephemeron.ml:190:22>>*/ container =
-         /*<<ephemeron.ml:190:22>>*/ caml_call2(H[1], key, info),
-       /*<<ephemeron.ml:191:19>>*/ bucket =
-        [0, hkey, container, caml_check_bound(h[2], i)[1 + i]];
-      /*<<ephemeron.ml:192:6>>*/ caml_check_bound(h[2], i)[1 + i] = bucket;
-     h[1] = h[1] + 1 | 0;
-     var _au_ = h[2].length - 1 << 1 < h[1] ? 1 : 0;
-     return _au_ ? resize(h) : _au_;
-     /*<<ephemeron.ml:194:57>>*/ }
-    function remove(h, key){
-      /*<<ephemeron.ml:197:6>>*/  /*<<ephemeron.ml:197:17>>*/ var
-      hkey =  /*<<ephemeron.ml:197:17>>*/ caml_call2(H[2], h[3], key);
-     function remove_bucket(param){
-       /*<<ephemeron.ml:198:30>>*/ var param$0 = param;
-       /*<<ephemeron.ml:198:30>>*/ for(;;){
-       if(! param$0)  /*<<ephemeron.ml:199:19>>*/ return 0;
-       var hk = param$0[1], next = param$0[3], c = param$0[2];
-       if(hkey !== hk){
-        var next$0 = param$0[3], c$0 = param$0[2];
-         /*<<ephemeron.ml:210:29>>*/ return [0,
-                hk,
-                c$0,
-                remove_bucket(next$0)];
-       }
-       switch( /*<<ephemeron.ml:201:24>>*/ caml_call2(H[3], c, key)){
-         case 0:
-          h[1] = h[1] - 1 | 0;  /*<<ephemeron.ml:202:45>>*/ return next;
-         case 1:
-           /*<<ephemeron.ml:203:24>>*/ return [0, hk, c, remove_bucket(next)];
-         default: h[1] = h[1] - 1 | 0; var param$0 = next;
-       }
-      }
-      /*<<ephemeron.ml:210:60>>*/ }
-      /*<<ephemeron.ml:211:14>>*/ var
-       /*<<ephemeron.ml:211:14>>*/ i = key_index(h, hkey),
-       /*<<ephemeron.ml:212:20>>*/ _at_ =
-        remove_bucket(caml_check_bound(h[2], i)[1 + i]);
-      /*<<ephemeron.ml:212:6>>*/ caml_check_bound(h[2], i)[1 + i] = _at_;
-      /*<<ephemeron.ml:212:6>>*/ return 0;
-     /*<<ephemeron.ml:212:44>>*/ }
-    function find(h, key){
-      /*<<ephemeron.ml:239:6>>*/ var
-       /*<<ephemeron.ml:239:17>>*/ hkey =
-         /*<<ephemeron.ml:239:17>>*/ caml_call2(H[2], h[3], key),
-       /*<<ephemeron.ml:241:33>>*/ _as_ = key_index(h, hkey),
-      param = caml_check_bound(h[2], _as_)[1 + _as_];
-     for(;;){
-      if(! param)
-        /*<<ephemeron.ml:220:10>>*/ throw  /*<<ephemeron.ml:220:10>>*/ caml_maybe_attach_backtrace
-              (Stdlib[8], 1);
-      var hk = param[1], rest = param[3], c = param[2];
-      if(hkey === hk)
-       switch( /*<<ephemeron.ml:222:22>>*/ caml_call2(H[3], c, key)){
-         case 0:
-           /*<<ephemeron.ml:224:26>>*/  /*<<ephemeron.ml:224:26>>*/ var
-           match =  /*<<ephemeron.ml:224:26>>*/ caml_call1(H[4], c);
-          if(match){var d = match[1];  /*<<ephemeron.ml:229:26>>*/ return d;}
-          var param = rest;
-          break;
-         case 1:
-          var param = rest; break;
-         default: var param = rest;
-       }
-      else
-       var rest$0 = param[3], param = rest$0;
-     }
-     /*<<ephemeron.ml:241:51>>*/ }
-    function find_opt(h, key){
-      /*<<ephemeron.ml:264:6>>*/ var
-       /*<<ephemeron.ml:264:17>>*/ hkey =
-         /*<<ephemeron.ml:264:17>>*/ caml_call2(H[2], h[3], key),
-       /*<<ephemeron.ml:266:37>>*/ _ar_ = key_index(h, hkey),
-      param = caml_check_bound(h[2], _ar_)[1 + _ar_];
-     for(;;){
-      if(! param)  /*<<ephemeron.ml:245:10>>*/ return 0;
-      var hk = param[1], rest = param[3], c = param[2];
-      if(hkey === hk)
-       switch( /*<<ephemeron.ml:247:22>>*/ caml_call2(H[3], c, key)){
-         case 0:
-           /*<<ephemeron.ml:249:26>>*/  /*<<ephemeron.ml:249:26>>*/ var
-           d =  /*<<ephemeron.ml:249:26>>*/ caml_call1(H[4], c);
-          if(d)  /*<<ephemeron.ml:254:31>>*/ return d;
-          var param = rest;
-          break;
-         case 1:
-          var param = rest; break;
-         default: var param = rest;
-       }
-      else
-       var rest$0 = param[3], param = rest$0;
-     }
-     /*<<ephemeron.ml:266:55>>*/ }
-    function find_all(h, key){
-      /*<<ephemeron.ml:269:6>>*/  /*<<ephemeron.ml:269:17>>*/ var
-      hkey =  /*<<ephemeron.ml:269:17>>*/ caml_call2(H[2], h[3], key);
-     function find_in_bucket(param){
-       /*<<ephemeron.ml:270:31>>*/ var param$0 = param;
-       /*<<ephemeron.ml:270:31>>*/ for(;;){
-       if(! param$0)  /*<<ephemeron.ml:271:17>>*/ return 0;
-       var hk = param$0[1], rest = param$0[3], c = param$0[2];
-       if(hkey === hk)
-        switch( /*<<ephemeron.ml:273:22>>*/ caml_call2(H[3], c, key)){
-          case 0:
-            /*<<ephemeron.ml:274:33>>*/  /*<<ephemeron.ml:274:33>>*/ var
-            match =  /*<<ephemeron.ml:274:33>>*/ caml_call1(H[4], c);
-           if(match){
-            var d = match[1];
-             /*<<ephemeron.ml:277:26>>*/ return [0, d, find_in_bucket(rest)];
-           }
-           var param$0 = rest;
-           break;
-          case 1:
-           var param$0 = rest; break;
-          default: var param$0 = rest;
-        }
-       else
-        var rest$0 = param$0[3], param$0 = rest$0;
-      }
-      /*<<ephemeron.ml:284:29>>*/ }
-      /*<<ephemeron.ml:285:29>>*/  /*<<ephemeron.ml:285:29>>*/ var
-      _aq_ = key_index(h, hkey);
-      /*<<ephemeron.ml:285:21>>*/ return find_in_bucket
-             (caml_check_bound(h[2], _aq_)[1 + _aq_]);
-     /*<<ephemeron.ml:285:46>>*/ }
-    function replace(h, key, info){
-      /*<<ephemeron.ml:289:6>>*/ var
-       /*<<ephemeron.ml:289:17>>*/ hkey =
-         /*<<ephemeron.ml:289:17>>*/ caml_call2(H[2], h[3], key),
-       /*<<ephemeron.ml:299:14>>*/ i = key_index(h, hkey),
-       /*<<ephemeron.ml:300:14>>*/ l = caml_check_bound(h[2], i)[1 + i];
-      /*<<ephemeron.ml:301:6>>*/ try{
-      var param = l;
-       /*<<ephemeron.ml:290:31>>*/ for(;;){
-       if(! param)
-         /*<<ephemeron.ml:291:19>>*/ throw  /*<<ephemeron.ml:291:19>>*/ caml_maybe_attach_backtrace
-               (Stdlib[8], 1);
-       var hk = param[1], next = param[3], c = param[2];
-       if(hkey === hk){
-        if(!  /*<<ephemeron.ml:293:24>>*/ caml_call2(H[3], c, key)){
-          /*<<ephemeron.ml:290:6>>*/  /*<<ephemeron.ml:290:6>>*/ var
-          _am_ =  /*<<ephemeron.ml:290:6>>*/ caml_call3(H[5], c, key, info);
-          /*<<ephemeron.ml:302:8>>*/ return _am_;
-        }
-        var param = next;
-       }
-       else
-        var next$0 = param[3], param = next$0;
-      }
-     }
-     catch(_ap_){
-      var _an_ = caml_wrap_exception(_ap_);
-      if(_an_ !== Stdlib[8]) throw caml_maybe_attach_backtrace(_an_, 0);
-       /*<<ephemeron.ml:304:24>>*/  /*<<ephemeron.ml:304:24>>*/ var
-       container =  /*<<ephemeron.ml:304:24>>*/ caml_call2(H[1], key, info);
-       /*<<ephemeron.ml:305:8>>*/ caml_check_bound(h[2], i)[1 + i] = [0, hkey, container, l];
-      h[1] = h[1] + 1 | 0;
-      var _ao_ = h[2].length - 1 << 1 < h[1] ? 1 : 0;
-      return _ao_ ? resize(h) : _ao_;
-     }
-     /*<<ephemeron.ml:307:59>>*/ }
-    function mem(h, key){
-      /*<<ephemeron.ml:310:6>>*/ var
-       /*<<ephemeron.ml:310:17>>*/ hkey =
-         /*<<ephemeron.ml:310:17>>*/ caml_call2(H[2], h[3], key),
-       /*<<ephemeron.ml:320:28>>*/ _al_ = key_index(h, hkey),
-      param = caml_check_bound(h[2], _al_)[1 + _al_];
-      /*<<ephemeron.ml:311:30>>*/ for(;;){
-      if(! param)  /*<<ephemeron.ml:313:10>>*/ return 0;
-      var hk = param[1], rest = param[3], c = param[2];
-      if(hk === hkey){
-       if(!  /*<<ephemeron.ml:315:22>>*/ caml_call2(H[3], c, key))
-         /*<<ephemeron.ml:316:21>>*/ return 1;
-       var param = rest;
-      }
-      else
-       var rest$0 = param[3], param = rest$0;
-     }
-     /*<<ephemeron.ml:320:45>>*/ }
-    function length(h){
-      /*<<ephemeron.ml:322:19>>*/ return h[1];
-     /*<<ephemeron.ml:322:25>>*/ }
-    function bucket_length(accu, param){
-     var accu$0 = accu, param$0 = param;
-     for(;;){
-      if(! param$0)  /*<<ephemeron.ml:325:17>>*/ return accu$0;
-       /*<<ephemeron.ml:326:28>>*/ var
-       rest = param$0[3],
-        /*<<ephemeron.ml:326:28>>*/ accu$1 = accu$0 + 1 | 0,
-       accu$0 = accu$1,
-       param$0 = rest;
-     }
-    }
-    function stats(h){
-      /*<<ephemeron.ml:329:6>>*/ var _af_ = h[2], _ag_ = 0;
-     function _ah_(m, b){
-       /*<<ephemeron.ml:330:36>>*/  /*<<ephemeron.ml:330:46>>*/ var
-       _ak_ = bucket_length(0, b);
-       /*<<ephemeron.ml:330:46>>*/ return  /*<<ephemeron.ml:330:46>>*/ caml_call2
-              (Stdlib_Int[11], m, _ak_);
-      /*<<ephemeron.ml:330:65>>*/ }
-      /*<<ephemeron.ml:330:8>>*/ var
-       /*<<ephemeron.ml:330:8>>*/ mbl =
-         /*<<ephemeron.ml:330:8>>*/ caml_call3
-         (Stdlib_Array[15], _ah_, _ag_, _af_),
-       /*<<ephemeron.ml:331:18>>*/ histo =
-         /*<<ephemeron.ml:331:18>>*/ caml_make_vect(mbl + 1 | 0, 0),
-       /*<<ephemeron.ml:332:6>>*/ _ai_ = h[2];
-     function _aj_(b){
-       /*<<ephemeron.ml:334:11>>*/  /*<<ephemeron.ml:334:19>>*/ var
-       l = bucket_length(0, b);
-       /*<<ephemeron.ml:335:11>>*/ histo[1 + l] =
-       caml_check_bound(histo, l)[1 + l] + 1 | 0;
-       /*<<ephemeron.ml:335:11>>*/ return 0;
-      /*<<ephemeron.ml:335:37>>*/ }
-      /*<<ephemeron.ml:332:6>>*/  /*<<ephemeron.ml:332:6>>*/ caml_call2
-      (Stdlib_Array[11], _aj_, _ai_);
-      /*<<ephemeron.ml:337:6>>*/ return [0, h[1], h[2].length - 1, mbl, histo];
-     /*<<ephemeron.ml:340:34>>*/ }
-    function bucket_length_alive(accu, param){
-     var accu$0 = accu, param$0 = param;
-     for(;;){
-      if(! param$0)  /*<<ephemeron.ml:343:17>>*/ return accu$0;
-      var rest = param$0[3], c = param$0[2];
-       /*<<ephemeron.ml:344:30>>*/ if
-       ( /*<<ephemeron.ml:344:30>>*/ caml_call1(H[6], c))
-       var accu$1 = accu$0 + 1 | 0, accu$0 = accu$1, param$0 = rest;
-      else
-       var rest$0 = param$0[3], param$0 = rest$0;
-     }
-    }
-    function stats_alive(h){
-      /*<<ephemeron.ml:349:6>>*/ var
-       /*<<ephemeron.ml:349:17>>*/ size = [0, 0],
-       /*<<ephemeron.ml:350:6>>*/ _$_ = h[2],
-      _aa_ = 0;
-     function _ab_(m, b){
-       /*<<ephemeron.ml:352:22>>*/  /*<<ephemeron.ml:352:32>>*/ var
-       _ae_ = bucket_length_alive(0, b);
-       /*<<ephemeron.ml:352:32>>*/ return  /*<<ephemeron.ml:352:32>>*/ caml_call2
-              (Stdlib_Int[11], m, _ae_);
-      /*<<ephemeron.ml:352:57>>*/ }
-      /*<<ephemeron.ml:351:8>>*/ var
-       /*<<ephemeron.ml:351:8>>*/ mbl =
-         /*<<ephemeron.ml:351:8>>*/ caml_call3
-         (Stdlib_Array[15], _ab_, _aa_, _$_),
-       /*<<ephemeron.ml:354:18>>*/ histo =
-         /*<<ephemeron.ml:354:18>>*/ caml_make_vect(mbl + 1 | 0, 0),
-       /*<<ephemeron.ml:355:6>>*/ _ac_ = h[2];
-     function _ad_(b){
-       /*<<ephemeron.ml:357:11>>*/  /*<<ephemeron.ml:357:19>>*/ var
-       l = bucket_length_alive(0, b);
-      size[1] = size[1] + l | 0;
-       /*<<ephemeron.ml:359:11>>*/ histo[1 + l] =
-       caml_check_bound(histo, l)[1 + l] + 1 | 0;
-       /*<<ephemeron.ml:359:11>>*/ return 0;
-      /*<<ephemeron.ml:359:37>>*/ }
-      /*<<ephemeron.ml:355:6>>*/  /*<<ephemeron.ml:355:6>>*/ caml_call2
-      (Stdlib_Array[11], _ad_, _ac_);
-      /*<<ephemeron.ml:361:6>>*/ return [0,
-             size[1],
-             h[2].length - 1,
-             mbl,
-             histo];
-     /*<<ephemeron.ml:364:34>>*/ }
-    function add_seq(tbl, i){
-     function ___(param){
-       /*<<ephemeron.ml:367:15>>*/ var v = param[2], k = param[1];
-       /*<<ephemeron.ml:367:29>>*/ return add(tbl, k, v);
-      /*<<ephemeron.ml:367:41>>*/ }
-      /*<<ephemeron.ml:367:6>>*/ return  /*<<ephemeron.ml:367:6>>*/ caml_call2
-             (Stdlib_Seq[4], ___, i);
-     /*<<ephemeron.ml:367:43>>*/ }
-    function replace_seq(tbl, i){
-     function _Z_(param){
-       /*<<ephemeron.ml:370:15>>*/ var v = param[2], k = param[1];
-       /*<<ephemeron.ml:370:29>>*/ return replace(tbl, k, v);
-      /*<<ephemeron.ml:370:45>>*/ }
-      /*<<ephemeron.ml:370:6>>*/ return  /*<<ephemeron.ml:370:6>>*/ caml_call2
-             (Stdlib_Seq[4], _Z_, i);
-     /*<<ephemeron.ml:370:47>>*/ }
-    function of_seq(i){
-      /*<<ephemeron.ml:373:6>>*/  /*<<ephemeron.ml:373:16>>*/ var
-      tbl = create(0, 16);
-      /*<<ephemeron.ml:374:6>>*/ replace_seq(tbl, i);
-      /*<<ephemeron.ml:374:6>>*/ return tbl;
-     /*<<ephemeron.ml:375:9>>*/ }
-     /*<<ephemeron.ml:82:4>>*/ return [0,
-            create,
-            clear,
-            reset,
-            copy,
-            add,
-            remove,
-            find,
-            find_opt,
-            find_all,
-            replace,
-            mem,
-            length,
-            stats,
-            add_seq,
-            replace_seq,
-            of_seq,
-            clean,
-            stats_alive];
-   }
-   function create(param){
-     /*<<ephemeron.ml:394:30>>*/ return  /*<<ephemeron.ml:394:30>>*/ caml_call1
-            (Stdlib_Obj[24][1], 1);
-    /*<<ephemeron.ml:394:45>>*/ }
-   function get_key(t){
-     /*<<ephemeron.ml:396:42>>*/ return  /*<<ephemeron.ml:396:50>>*/ caml_call2
-            (Stdlib_Obj[24][3], t, 0);
-    /*<<ephemeron.ml:396:70>>*/ }
-   function set_key(t, k){
-     /*<<ephemeron.ml:397:44>>*/ return  /*<<ephemeron.ml:397:44>>*/ caml_call3
-            (Stdlib_Obj[24][5], t, 0, k);
-    /*<<ephemeron.ml:397:75>>*/ }
-   function check_key(t){
-     /*<<ephemeron.ml:398:39>>*/ return  /*<<ephemeron.ml:398:39>>*/ caml_call2
-            (Stdlib_Obj[24][7], t, 0);
-    /*<<ephemeron.ml:398:59>>*/ }
-   function get_data(t){
-     /*<<ephemeron.ml:400:43>>*/ return  /*<<ephemeron.ml:400:51>>*/ caml_call1
-            (Stdlib_Obj[24][9], t);
-    /*<<ephemeron.ml:400:70>>*/ }
-   function set_data(t, d){
-     /*<<ephemeron.ml:401:45>>*/ return  /*<<ephemeron.ml:401:45>>*/ caml_call2
-            (Stdlib_Obj[24][11], t, d);
-    /*<<ephemeron.ml:401:75>>*/ }
-   function make(key, data){
-     /*<<ephemeron.ml:405:4>>*/  /*<<ephemeron.ml:405:14>>*/ var
-     eph = create(0);
-     /*<<ephemeron.ml:406:4>>*/ set_data(eph, data);
-     /*<<ephemeron.ml:407:4>>*/ set_key(eph, key);
-     /*<<ephemeron.ml:407:4>>*/ return eph;
-    /*<<ephemeron.ml:408:7>>*/ }
-   function query(eph, key){
-     /*<<ephemeron.ml:411:4>>*/  /*<<ephemeron.ml:411:10>>*/ var
-     match = get_key(eph);
-    if(! match)  /*<<ephemeron.ml:412:14>>*/ return 0;
-    var k = match[1];
-    return k === key ? get_data(eph) : 0;
-    /*<<ephemeron.ml:414:20>>*/ }
-   function MakeSeeded$0(H){
-    function create$0(k, d){
-      /*<<ephemeron.ml:421:8>>*/  /*<<ephemeron.ml:421:16>>*/ var
-      c = create(0);
-      /*<<ephemeron.ml:422:8>>*/ set_data(c, d);
-      /*<<ephemeron.ml:423:8>>*/ set_key(c, k);
-      /*<<ephemeron.ml:423:8>>*/ return c;
-     /*<<ephemeron.ml:424:9>>*/ }
-    var seeded_hash = H[2];
-    function equal(c, k){
-      /*<<ephemeron.ml:429:8>>*/  /*<<ephemeron.ml:429:14>>*/ var
-      match = get_key(c);
-     if(! match)  /*<<ephemeron.ml:430:18>>*/ return 2;
-     var k$0 = match[1];
-      /*<<ephemeron.ml:432:15>>*/ return  /*<<ephemeron.ml:432:15>>*/ caml_call2
-              (H[1], k, k$0)
-             ? 0
-             : 1;
-     /*<<ephemeron.ml:432:76>>*/ }
-    function set_key_data(c, k, d){
-      /*<<ephemeron.ml:435:8>>*/  /*<<ephemeron.ml:402:40>>*/ caml_call1
-      (Stdlib_Obj[24][12], c);
-      /*<<ephemeron.ml:436:8>>*/ set_key(c, k);
-      /*<<ephemeron.ml:436:8>>*/ return set_data(c, d);
-     /*<<ephemeron.ml:437:20>>*/ }
-     /*<<ephemeron.ml:417:28>>*/ return MakeSeeded
-            ([0,
-              create$0,
-              seeded_hash,
-              equal,
-              get_data,
-              set_key_data,
-              check_key]);
-   }
-   function Make(H){
-    var equal = H[1];
-    function seeded_hash(seed, x){
-      /*<<ephemeron.ml:446:41>>*/ return  /*<<ephemeron.ml:446:41>>*/ caml_call1
-             (H[2], x);
-     /*<<ephemeron.ml:446:49>>*/ }
-    var
-     include = MakeSeeded$0([0, equal, seeded_hash]),
-     clear = include[2],
-     reset = include[3],
-     copy = include[4],
-     add = include[5],
-     remove = include[6],
-     find = include[7],
-     find_opt = include[8],
-     find_all = include[9],
-     replace = include[10],
-     mem = include[11],
-     length = include[12],
-     stats = include[13],
-     add_seq = include[14],
-     replace_seq = include[15],
-     clean = include[17],
-     stats_alive = include[18],
-     _Y_ = include[1];
-    function create(sz){
-      /*<<ephemeron.ml:448:20>>*/ return  /*<<ephemeron.ml:448:20>>*/ caml_call2
-             (_Y_, _a_, sz);
-     /*<<ephemeron.ml:448:43>>*/ }
-    function of_seq(i){
-      /*<<ephemeron.ml:450:6>>*/  /*<<ephemeron.ml:450:16>>*/ var
-      tbl = create(16);
-      /*<<ephemeron.ml:451:6>>*/  /*<<ephemeron.ml:451:6>>*/ caml_call2
-      (replace_seq, tbl, i);
-      /*<<ephemeron.ml:451:6>>*/ return tbl;
-     /*<<ephemeron.ml:452:9>>*/ }
-     /*<<ephemeron.ml:442:2>>*/ return [0,
-            create,
-            clear,
-            reset,
-            copy,
-            add,
-            remove,
-            find,
-            find_opt,
-            find_all,
-            replace,
-            mem,
-            length,
-            stats,
-            add_seq,
-            replace_seq,
-            of_seq,
-            clean,
-            stats_alive];
-   }
-   function make$0(param){
-     /*<<ephemeron.ml:459:18>>*/ return [0, 0];
-    /*<<ephemeron.ml:459:24>>*/ }
-   function add(b, k, d){
-     /*<<ephemeron.ml:460:20>>*/ var _X_ = b[1];
-    b[1] = [0, make(k, d), _X_];
-    return 0;
-    /*<<ephemeron.ml:460:42>>*/ }
-   function test_key(k, e){
-     /*<<ephemeron.ml:463:6>>*/  /*<<ephemeron.ml:463:12>>*/ var
-     match = get_key(e);
-    if(match){
-     var x = match[1];
-     if(x === k)  /*<<ephemeron.ml:464:30>>*/ return 1;
-    }
-     /*<<ephemeron.ml:465:13>>*/ return 0;
-    /*<<ephemeron.ml:465:18>>*/ }
-   function remove(b, k){
-     /*<<ephemeron.ml:468:6>>*/ var l$0 = b[1], l = l$0, acc = 0;
-     /*<<ephemeron.ml:469:8>>*/ for(;;){
-     if(! l)  /*<<ephemeron.ml:470:16>>*/ return 0;
-     var h = l[1], t = l[2];
-      /*<<ephemeron.ml:471:22>>*/ if(test_key(k, h)){
-      b[1] =  /*<<ephemeron.ml:471:43>>*/ caml_call2(Stdlib_List[12], acc, t);
-      return 0;
-     }
-      /*<<ephemeron.ml:472:27>>*/ var
-      t$0 = l[2],
-       /*<<ephemeron.ml:472:27>>*/ acc$0 = [0, h, acc],
-      l = t$0,
-      acc = acc$0;
-    }
-    /*<<ephemeron.ml:474:16>>*/ }
-   function find(b, k){
-     /*<<ephemeron.ml:477:6>>*/ var _U_ = b[1];
-     /*<<ephemeron.ml:477:26>>*/ function _V_(_W_){
-      /*<<?>>*/ return test_key(k, _W_);
-    }
-     /*<<ephemeron.ml:477:12>>*/  /*<<ephemeron.ml:477:12>>*/ var
-     match =
-        /*<<ephemeron.ml:477:12>>*/ caml_call2(Stdlib_List[39], _V_, _U_);
-    if(! match)  /*<<ephemeron.ml:479:16>>*/ return 0;
-    var e = match[1];
-     /*<<ephemeron.ml:478:18>>*/ return get_data(e);
-    /*<<ephemeron.ml:479:20>>*/ }
-   function length(b){
-     /*<<ephemeron.ml:481:19>>*/ return caml_call1(Stdlib_List[1], b[1]);
-    /*<<ephemeron.ml:481:33>>*/ }
-   function clear(b){
-     /*<<ephemeron.ml:482:18>>*/ b[1] = 0;
-    return 0;
-    /*<<ephemeron.ml:482:25>>*/ }
-   function create$0(param){
-     /*<<ephemeron.ml:491:35>>*/ return  /*<<ephemeron.ml:491:35>>*/ caml_call1
-            (Stdlib_Obj[24][1], 2);
-    /*<<ephemeron.ml:491:50>>*/ }
-   function get_key1(t){
-     /*<<ephemeron.ml:493:49>>*/ return  /*<<ephemeron.ml:493:57>>*/ caml_call2
-            (Stdlib_Obj[24][3], t, 0);
-    /*<<ephemeron.ml:493:77>>*/ }
-   function set_key1(t, k){
-     /*<<ephemeron.ml:495:4>>*/ return  /*<<ephemeron.ml:495:4>>*/ caml_call3
-            (Stdlib_Obj[24][5], t, 0, k);
-    /*<<ephemeron.ml:495:35>>*/ }
-   function get_key2(t){
-     /*<<ephemeron.ml:498:49>>*/ return  /*<<ephemeron.ml:498:57>>*/ caml_call2
-            (Stdlib_Obj[24][3], t, 1);
-    /*<<ephemeron.ml:498:77>>*/ }
-   function set_key2(t, k){
-     /*<<ephemeron.ml:500:4>>*/ return  /*<<ephemeron.ml:500:4>>*/ caml_call3
-            (Stdlib_Obj[24][5], t, 1, k);
-    /*<<ephemeron.ml:500:35>>*/ }
-   function get_data$0(t){
-     /*<<ephemeron.ml:503:48>>*/ return  /*<<ephemeron.ml:503:56>>*/ caml_call1
-            (Stdlib_Obj[24][9], t);
-    /*<<ephemeron.ml:503:75>>*/ }
-   function set_data$0(t, d){
-     /*<<ephemeron.ml:505:4>>*/ return  /*<<ephemeron.ml:505:4>>*/ caml_call2
-            (Stdlib_Obj[24][11], t, d);
-    /*<<ephemeron.ml:505:34>>*/ }
-   function make$1(key1, key2, data){
-     /*<<ephemeron.ml:509:4>>*/  /*<<ephemeron.ml:509:14>>*/ var
-     eph = create$0(0);
-     /*<<ephemeron.ml:510:4>>*/ set_data$0(eph, data);
-     /*<<ephemeron.ml:511:4>>*/ set_key1(eph, key1);
-     /*<<ephemeron.ml:512:4>>*/ set_key2(eph, key2);
-     /*<<ephemeron.ml:514:4>>*/ return eph;
-    /*<<ephemeron.ml:514:7>>*/ }
-   function query$0(eph, key1, key2){
-     /*<<ephemeron.ml:517:4>>*/  /*<<ephemeron.ml:517:10>>*/ var
-     match = get_key1(eph);
-    if(! match)  /*<<ephemeron.ml:518:14>>*/ return 0;
-    var k = match[1];
-    if(k !== key1)  /*<<ephemeron.ml:525:16>>*/ return 0;
-     /*<<ephemeron.ml:520:20>>*/  /*<<ephemeron.ml:520:20>>*/ var
-     match$0 = get_key2(eph);
-    if(! match$0)  /*<<ephemeron.ml:521:18>>*/ return 0;
-    var k$0 = match$0[1];
-    return k$0 === key2 ? get_data$0(eph) : 0;
-    /*<<ephemeron.ml:525:20>>*/ }
-   function MakeSeeded$1(H1, H2){
-    function create(param, d){
-      /*<<ephemeron.ml:534:16>>*/ var
-      k2 = param[2],
-      k1 = param[1],
-       /*<<ephemeron.ml:534:16>>*/ c = create$0(0);
-      /*<<ephemeron.ml:535:8>>*/ set_data$0(c, d);
-      /*<<ephemeron.ml:536:8>>*/ set_key1(c, k1);
-      /*<<ephemeron.ml:536:23>>*/ set_key2(c, k2);
-      /*<<ephemeron.ml:536:23>>*/ return c;
-    }
-    function seeded_hash(seed, param){
-      /*<<ephemeron.ml:539:33>>*/ var
-      k2 = param[2],
-      k1 = param[1],
-       /*<<ephemeron.ml:539:33>>*/ _T_ =
-         /*<<ephemeron.ml:539:33>>*/ caml_call2(H2[2], seed, k2) * 65599 | 0;
-      /*<<ephemeron.ml:539:8>>*/ return  /*<<ephemeron.ml:539:8>>*/ caml_call2
-             (H1[2], seed, k1)
-            + _T_
-            | 0;
-    }
-    function equal(c, param){
-      /*<<ephemeron.ml:541:14>>*/ var
-      k2 = param[2],
-      k1 = param[1],
-       /*<<ephemeron.ml:541:14>>*/ match = get_key1(c),
-       /*<<ephemeron.ml:541:26>>*/ match$0 = get_key2(c);
-     if(match && match$0){
-      var k2$0 = match$0[1], k1$0 = match[1];
-       /*<<ephemeron.ml:544:34>>*/ if
-       ( /*<<ephemeron.ml:544:15>>*/ caml_call2(H1[1], k1, k1$0)
-        &&  /*<<ephemeron.ml:544:34>>*/ caml_call2(H2[1], k2, k2$0))
-        /*<<ephemeron.ml:545:17>>*/ return 0;
-       /*<<ephemeron.ml:545:41>>*/ return 1;
-     }
-      /*<<ephemeron.ml:542:32>>*/ return 2;
-    }
-    function set_key_data(c, param, d){
-     var k2 = param[2], k1 = param[1];
-      /*<<ephemeron.ml:506:45>>*/  /*<<ephemeron.ml:506:45>>*/ caml_call1
-      (Stdlib_Obj[24][12], c);
-      /*<<ephemeron.ml:549:8>>*/ set_key1(c, k1);
-      /*<<ephemeron.ml:549:23>>*/ set_key2(c, k2);
-      /*<<ephemeron.ml:549:23>>*/ return set_data$0(c, d);
-    }
-    function check_key(c){
-      /*<<ephemeron.ml:551:24>>*/  /*<<ephemeron.ml:496:45>>*/ var
-      _S_ =  /*<<ephemeron.ml:496:45>>*/ caml_call2(Stdlib_Obj[24][7], c, 0);
-      /*<<ephemeron.ml:551:24>>*/ return _S_
-             ?  /*<<ephemeron.ml:501:45>>*/ caml_call2
-               (Stdlib_Obj[24][7], c, 1)
-             : _S_;
-     /*<<ephemeron.ml:551:52>>*/ }
-     /*<<ephemeron.ml:530:28>>*/ return MakeSeeded
-            ([0,
-              create,
-              seeded_hash,
-              equal,
-              get_data$0,
-              set_key_data,
-              check_key]);
-   }
-   function Make$0(H1, H2){
-    var equal = H2[1];
-    function seeded_hash(seed, x){
-      /*<<ephemeron.ml:566:43>>*/ return  /*<<ephemeron.ml:566:43>>*/ caml_call1
-             (H2[2], x);
-     /*<<ephemeron.ml:566:52>>*/ }
-     /*<<ephemeron.ml:563:9>>*/ var
-     equal$0 = H1[1],
-      /*<<ephemeron.ml:563:9>>*/ _Q_ = [0, equal, seeded_hash];
-    function seeded_hash$0(seed, x){
-      /*<<ephemeron.ml:561:43>>*/ return  /*<<ephemeron.ml:561:43>>*/ caml_call1
-             (H1[2], x);
-     /*<<ephemeron.ml:561:52>>*/ }
-    var
-     include = MakeSeeded$1([0, equal$0, seeded_hash$0], _Q_),
-     clear = include[2],
-     reset = include[3],
-     copy = include[4],
-     add = include[5],
-     remove = include[6],
-     find = include[7],
-     find_opt = include[8],
-     find_all = include[9],
-     replace = include[10],
-     mem = include[11],
-     length = include[12],
-     stats = include[13],
-     add_seq = include[14],
-     replace_seq = include[15],
-     clean = include[17],
-     stats_alive = include[18],
-     _R_ = include[1];
-    function create(sz){
-      /*<<ephemeron.ml:568:20>>*/ return  /*<<ephemeron.ml:568:20>>*/ caml_call2
-             (_R_, _b_, sz);
-     /*<<ephemeron.ml:568:43>>*/ }
-    function of_seq(i){
-      /*<<ephemeron.ml:570:6>>*/  /*<<ephemeron.ml:570:16>>*/ var
-      tbl = create(16);
-      /*<<ephemeron.ml:571:6>>*/  /*<<ephemeron.ml:571:6>>*/ caml_call2
-      (replace_seq, tbl, i);
-      /*<<ephemeron.ml:571:6>>*/ return tbl;
-     /*<<ephemeron.ml:572:9>>*/ }
-     /*<<ephemeron.ml:556:2>>*/ return [0,
-            create,
-            clear,
-            reset,
-            copy,
-            add,
-            remove,
-            find,
-            find_opt,
-            find_all,
-            replace,
-            mem,
-            length,
-            stats,
-            add_seq,
-            replace_seq,
-            of_seq,
-            clean,
-            stats_alive];
-   }
-   function make$2(param){
-     /*<<ephemeron.ml:579:18>>*/ return [0, 0];
-    /*<<ephemeron.ml:579:24>>*/ }
-   function add$0(b, k1, k2, d){
-     /*<<ephemeron.ml:580:24>>*/ var _P_ = b[1];
-    b[1] = [0, make$1(k1, k2, d), _P_];
-    return 0;
-    /*<<ephemeron.ml:580:50>>*/ }
-   function test_keys(k1, k2, e){
-     /*<<ephemeron.ml:583:6>>*/ var
-      /*<<ephemeron.ml:583:12>>*/ match = get_key1(e),
-      /*<<ephemeron.ml:583:24>>*/ match$0 = get_key2(e);
-    if(match && match$0){
-     var x2 = match$0[1], x1 = match[1];
-     if(x1 === k1 && x2 === k2)  /*<<ephemeron.ml:584:54>>*/ return 1;
-    }
-     /*<<ephemeron.ml:585:13>>*/ return 0;
-    /*<<ephemeron.ml:585:18>>*/ }
-   function remove$0(b, k1, k2){
-     /*<<ephemeron.ml:588:6>>*/ var l$0 = b[1], l = l$0, acc = 0;
-     /*<<ephemeron.ml:589:8>>*/ for(;;){
-     if(! l)  /*<<ephemeron.ml:590:16>>*/ return 0;
-     var h = l[1], t = l[2];
-      /*<<ephemeron.ml:591:22>>*/ if(test_keys(k1, k2, h)){
-      b[1] =  /*<<ephemeron.ml:591:48>>*/ caml_call2(Stdlib_List[12], acc, t);
-      return 0;
-     }
-      /*<<ephemeron.ml:592:27>>*/ var
-      t$0 = l[2],
-       /*<<ephemeron.ml:592:27>>*/ acc$0 = [0, h, acc],
-      l = t$0,
-      acc = acc$0;
-    }
-    /*<<ephemeron.ml:594:16>>*/ }
-   function find$0(b, k1, k2){
-     /*<<ephemeron.ml:597:6>>*/ var _M_ = b[1];
-     /*<<ephemeron.ml:597:26>>*/ function _N_(_O_){
-      /*<<?>>*/ return test_keys(k1, k2, _O_);
-    }
-     /*<<ephemeron.ml:597:12>>*/  /*<<ephemeron.ml:597:12>>*/ var
-     match =
-        /*<<ephemeron.ml:597:12>>*/ caml_call2(Stdlib_List[39], _N_, _M_);
-    if(! match)  /*<<ephemeron.ml:599:16>>*/ return 0;
-    var e = match[1];
-     /*<<ephemeron.ml:598:18>>*/ return get_data$0(e);
-    /*<<ephemeron.ml:599:20>>*/ }
-   function length$0(b){
-     /*<<ephemeron.ml:601:19>>*/ return caml_call1(Stdlib_List[1], b[1]);
-    /*<<ephemeron.ml:601:33>>*/ }
-   function clear$0(b){
-     /*<<ephemeron.ml:602:18>>*/ b[1] = 0;
-    return 0;
-    /*<<ephemeron.ml:602:25>>*/ }
-   function create$1(n){
-     /*<<ephemeron.ml:611:29>>*/ return  /*<<ephemeron.ml:611:29>>*/ caml_call1
-            (Stdlib_Obj[24][1], n);
-    /*<<ephemeron.ml:611:44>>*/ }
-   function length$1(k){
-     /*<<ephemeron.ml:612:35>>*/ return  /*<<ephemeron.ml:612:35>>*/ caml_call1
-            (Stdlib_Obj[24][2], k);
-    /*<<ephemeron.ml:612:50>>*/ }
-   function get_key$0(t, n){
-     /*<<ephemeron.ml:614:50>>*/ return  /*<<ephemeron.ml:614:58>>*/ caml_call2
-            (Stdlib_Obj[24][3], t, n);
-    /*<<ephemeron.ml:614:78>>*/ }
-   function set_key$0(t, n, k){
-     /*<<ephemeron.ml:616:4>>*/ return  /*<<ephemeron.ml:616:4>>*/ caml_call3
-            (Stdlib_Obj[24][5], t, n, k);
-    /*<<ephemeron.ml:616:35>>*/ }
-   function get_data$1(t){
-     /*<<ephemeron.ml:619:43>>*/ return  /*<<ephemeron.ml:619:51>>*/ caml_call1
-            (Stdlib_Obj[24][9], t);
-    /*<<ephemeron.ml:619:70>>*/ }
-   function set_data$1(t, d){
-     /*<<ephemeron.ml:620:45>>*/ return  /*<<ephemeron.ml:620:45>>*/ caml_call2
-            (Stdlib_Obj[24][11], t, d);
-    /*<<ephemeron.ml:620:75>>*/ }
-   function make$3(keys, data){
-     /*<<ephemeron.ml:624:4>>*/ var
-     l = keys.length - 1,
-      /*<<ephemeron.ml:625:14>>*/ eph = create$1(l);
-     /*<<ephemeron.ml:626:4>>*/ set_data$1(eph, data);
-     /*<<ephemeron.ml:626:4>>*/ var
-     _K_ = l - 1 | 0,
-      /*<<ephemeron.ml:626:4>>*/ _J_ = 0;
-    if(_K_ >= 0){
-     var i = _J_;
-     for(;;){
-       /*<<ephemeron.ml:627:26>>*/ set_key$0
-       (eph, i, caml_check_bound(keys, i)[1 + i]);
-       /*<<ephemeron.ml:627:26>>*/  /*<<ephemeron.ml:627:26>>*/ var
-       _L_ = i + 1 | 0;
-      if(_K_ === i) break;
-      var i = _L_;
-     }
-    }
-     /*<<ephemeron.ml:628:4>>*/ return eph;
-    /*<<ephemeron.ml:628:7>>*/ }
-   function query$1(eph, keys){
-     /*<<ephemeron.ml:631:4>>*/  /*<<ephemeron.ml:631:12>>*/ var
-     l = length$1(eph);
-     /*<<ephemeron.ml:632:4>>*/ try{
-     if(l !== keys.length - 1)
-       /*<<ephemeron.ml:633:37>>*/ throw  /*<<ephemeron.ml:633:37>>*/ caml_maybe_attach_backtrace
-             (Stdlib[3], 1);
-      /*<<ephemeron.ml:631:12>>*/ var
-       /*<<ephemeron.ml:631:12>>*/ _F_ = l - 1 | 0,
-       /*<<ephemeron.ml:634:6>>*/ _E_ = 0;
-     if(_F_ >= 0){
-      var i = _E_;
-      for(;;){
-        /*<<ephemeron.ml:635:14>>*/  /*<<ephemeron.ml:635:14>>*/ var
-        match = get_key$0(eph, i);
-       if(! match)
-         /*<<ephemeron.ml:636:18>>*/ throw  /*<<ephemeron.ml:636:18>>*/ caml_maybe_attach_backtrace
-               (Stdlib[3], 1);
-       var k = match[1];
-       if(k !== caml_check_bound(keys, i)[1 + i])
-         /*<<ephemeron.ml:638:20>>*/ throw  /*<<ephemeron.ml:638:20>>*/ caml_maybe_attach_backtrace
-               (Stdlib[3], 1);
-        /*<<ephemeron.ml:634:6>>*/  /*<<ephemeron.ml:634:6>>*/ var
-        _H_ = i + 1 | 0;
-       if(_F_ === i) break;
-       var i = _H_;
-      }
-     }
-      /*<<ephemeron.ml:640:6>>*/  /*<<ephemeron.ml:640:6>>*/ var
-      _G_ = get_data$1(eph);
-      /*<<ephemeron.ml:640:6>>*/ return _G_;
-    }
-    catch(_I_){
-     var _D_ = caml_wrap_exception(_I_);
-     if(_D_ === Stdlib[3])  /*<<ephemeron.ml:641:17>>*/ return 0;
-     throw caml_maybe_attach_backtrace(_D_, 0);
-    }
-    /*<<ephemeron.ml:641:21>>*/ }
-   function MakeSeeded$2(H){
-    function create(k, d){
-      /*<<ephemeron.ml:648:8>>*/  /*<<ephemeron.ml:648:16>>*/ var
-      c = create$1(k.length - 1);
-      /*<<ephemeron.ml:649:8>>*/ set_data$1(c, d);
-      /*<<ephemeron.ml:649:8>>*/ var
-      _B_ = k.length - 1 - 1 | 0,
-       /*<<ephemeron.ml:649:8>>*/ _A_ = 0;
-     if(_B_ >= 0){
-      var i = _A_;
-      for(;;){
-        /*<<ephemeron.ml:651:10>>*/ set_key$0
-        (c, i, caml_check_bound(k, i)[1 + i]);
-        /*<<ephemeron.ml:651:10>>*/  /*<<ephemeron.ml:651:10>>*/ var
-        _C_ = i + 1 | 0;
-       if(_B_ === i) break;
-       var i = _C_;
-      }
-     }
-      /*<<ephemeron.ml:653:8>>*/ return c;
-     /*<<ephemeron.ml:653:9>>*/ }
-    function seeded_hash(seed, k){
-      /*<<ephemeron.ml:655:8>>*/ var
-       /*<<ephemeron.ml:655:16>>*/ h = [0, 0],
-      _w_ = k.length - 1 - 1 | 0,
-       /*<<ephemeron.ml:655:16>>*/ _v_ = 0;
-     if(_w_ >= 0){
-      var i = _v_;
-      for(;;){
-        /*<<ephemeron.ml:657:34>>*/ var
-        _x_ = h[1],
-         /*<<ephemeron.ml:657:34>>*/ _y_ = caml_check_bound(k, i)[1 + i];
-       h[1] =
-        ( /*<<ephemeron.ml:657:15>>*/ caml_call2(H[2], seed, _y_) * 65599 | 0)
-        + _x_
-        | 0;
-        /*<<ephemeron.ml:656:8>>*/  /*<<ephemeron.ml:656:8>>*/ var
-        _z_ = i + 1 | 0;
-       if(_w_ === i) break;
-       var i = _z_;
-      }
-     }
-     return h[1];
-     /*<<ephemeron.ml:659:10>>*/ }
-    function equal(c, k){
-      /*<<ephemeron.ml:661:8>>*/ var
-      len = k.length - 1,
-       /*<<ephemeron.ml:662:19>>*/ len$0 = length$1(c);
-     if(len !== len$0)  /*<<ephemeron.ml:663:28>>*/ return 1;
-      /*<<ephemeron.ml:675:10>>*/ var
-       /*<<ephemeron.ml:675:10>>*/ i$1 = len - 1 | 0,
-      i = i$1;
-      /*<<ephemeron.ml:666:12>>*/ for(;;){
-      if(0 > i)  /*<<ephemeron.ml:666:26>>*/ return 0;
-       /*<<ephemeron.ml:668:20>>*/  /*<<ephemeron.ml:668:20>>*/ var
-       match = get_key$0(c, i);
-      if(! match)  /*<<ephemeron.ml:669:24>>*/ return 2;
-       /*<<ephemeron.ml:671:29>>*/ var
-       ki = match[1],
-        /*<<ephemeron.ml:671:29>>*/ _u_ = caml_check_bound(k, i)[1 + i];
-       /*<<ephemeron.ml:671:21>>*/ if
-       (!  /*<<ephemeron.ml:671:21>>*/ caml_call2(H[1], _u_, ki))
-        /*<<ephemeron.ml:673:23>>*/ return 1;
-       /*<<ephemeron.ml:672:23>>*/ var
-        /*<<ephemeron.ml:672:23>>*/ i$0 = i - 1 | 0,
-       i = i$0;
-     }
-     /*<<ephemeron.ml:675:33>>*/ }
-    function set_key_data(c, k, d){
-      /*<<ephemeron.ml:678:8>>*/  /*<<ephemeron.ml:621:40>>*/ caml_call1
-      (Stdlib_Obj[24][12], c);
-      /*<<ephemeron.ml:678:8>>*/ var
-      _s_ = k.length - 1 - 1 | 0,
-       /*<<ephemeron.ml:678:8>>*/ _r_ = 0;
-     if(_s_ >= 0){
-      var i = _r_;
-      for(;;){
-        /*<<ephemeron.ml:680:10>>*/ set_key$0
-        (c, i, caml_check_bound(k, i)[1 + i]);
-        /*<<ephemeron.ml:680:10>>*/  /*<<ephemeron.ml:680:10>>*/ var
-        _t_ = i + 1 | 0;
-       if(_s_ === i) break;
-       var i = _t_;
-      }
-     }
-      /*<<ephemeron.ml:682:8>>*/ return set_data$1(c, d);
-     /*<<ephemeron.ml:682:20>>*/ }
-    function check_key(c){
-      /*<<ephemeron.ml:684:8>>*/ var
-       /*<<ephemeron.ml:686:17>>*/ i$1 = length$1(c) - 1 | 0,
-      i = i$1;
-      /*<<ephemeron.ml:685:10>>*/ for(;;){
-      var _p_ = i < 0 ? 1 : 0;
-      if(_p_)
-       var _q_ = _p_;
-      else{
-        /*<<ephemeron.ml:617:47>>*/  /*<<ephemeron.ml:617:47>>*/ var
-        _o_ =  /*<<ephemeron.ml:617:47>>*/ caml_call2(Stdlib_Obj[24][7], c, i);
-        /*<<ephemeron.ml:685:20>>*/ if(_o_){
-        var i$0 = i - 1 | 0, i = i$0;
-        continue;
-       }
-       var _q_ = _o_;
-      }
-      return _q_;
-     }
-     /*<<ephemeron.ml:686:30>>*/ }
-     /*<<ephemeron.ml:644:28>>*/ return MakeSeeded
-            ([0,
-              create,
-              seeded_hash,
-              equal,
-              get_data$1,
-              set_key_data,
-              check_key]);
-   }
-   function Make$1(H){
-    var equal = H[1];
-    function seeded_hash(seed, x){
-      /*<<ephemeron.ml:694:41>>*/ return  /*<<ephemeron.ml:694:41>>*/ caml_call1
-             (H[2], x);
-     /*<<ephemeron.ml:694:49>>*/ }
-    var
-     include = MakeSeeded$2([0, equal, seeded_hash]),
-     clear = include[2],
-     reset = include[3],
-     copy = include[4],
-     add = include[5],
-     remove = include[6],
-     find = include[7],
-     find_opt = include[8],
-     find_all = include[9],
-     replace = include[10],
-     mem = include[11],
-     length = include[12],
-     stats = include[13],
-     add_seq = include[14],
-     replace_seq = include[15],
-     clean = include[17],
-     stats_alive = include[18],
-     _n_ = include[1];
-    function create(sz){
-      /*<<ephemeron.ml:696:20>>*/ return  /*<<ephemeron.ml:696:20>>*/ caml_call2
-             (_n_, _c_, sz);
-     /*<<ephemeron.ml:696:43>>*/ }
-    function of_seq(i){
-      /*<<ephemeron.ml:698:6>>*/  /*<<ephemeron.ml:698:16>>*/ var
-      tbl = create(16);
-      /*<<ephemeron.ml:699:6>>*/  /*<<ephemeron.ml:699:6>>*/ caml_call2
-      (replace_seq, tbl, i);
-      /*<<ephemeron.ml:699:6>>*/ return tbl;
-     /*<<ephemeron.ml:700:9>>*/ }
-     /*<<ephemeron.ml:690:2>>*/ return [0,
-            create,
-            clear,
-            reset,
-            copy,
-            add,
-            remove,
-            find,
-            find_opt,
-            find_all,
-            replace,
-            mem,
-            length,
-            stats,
-            add_seq,
-            replace_seq,
-            of_seq,
-            clean,
-            stats_alive];
-   }
-   function make$4(param){
-     /*<<ephemeron.ml:707:18>>*/ return [0, 0];
-    /*<<ephemeron.ml:707:24>>*/ }
-   function add$1(b, k, d){
-     /*<<ephemeron.ml:708:20>>*/ var _m_ = b[1];
-    b[1] = [0, make$3(k, d), _m_];
-    return 0;
-    /*<<ephemeron.ml:708:42>>*/ }
-   function test_keys$0(k, e){
-     /*<<ephemeron.ml:711:6>>*/ try{
-     if(length$1(e) !== k.length - 1)
-       /*<<ephemeron.ml:712:43>>*/ throw  /*<<ephemeron.ml:712:43>>*/ caml_maybe_attach_backtrace
-             (Stdlib[3], 1);
-      /*<<ephemeron.ml:713:8>>*/ var
-      _i_ = k.length - 1 - 1 | 0,
-       /*<<ephemeron.ml:713:8>>*/ _h_ = 0;
-     if(_i_ >= 0){
-      var i = _h_;
-      for(;;){
-        /*<<ephemeron.ml:714:16>>*/  /*<<ephemeron.ml:714:16>>*/ var
-        match = get_key$0(e, i);
-       if(match){
-        var x = match[1];
-        if(x === caml_check_bound(k, i)[1 + i]){
-          /*<<ephemeron.ml:713:8>>*/  /*<<ephemeron.ml:713:8>>*/ var
-          _k_ = i + 1 | 0;
-         if(_i_ === i) break;
-         var i = _k_;
-         continue;
-        }
-       }
-        /*<<ephemeron.ml:716:17>>*/ throw  /*<<ephemeron.ml:716:17>>*/ caml_maybe_attach_backtrace
-              (Stdlib[3], 1);
-      }
-     }
-      /*<<ephemeron.ml:718:8>>*/  /*<<ephemeron.ml:718:8>>*/ var _j_ = 1;
-      /*<<ephemeron.ml:718:8>>*/ return _j_;
-    }
-    catch(_l_){
-     var _g_ = caml_wrap_exception(_l_);
-     if(_g_ === Stdlib[3])  /*<<ephemeron.ml:719:19>>*/ return 0;
-     throw caml_maybe_attach_backtrace(_g_, 0);
-    }
-    /*<<ephemeron.ml:719:24>>*/ }
-   function remove$1(b, k){
-     /*<<ephemeron.ml:722:6>>*/ var l$0 = b[1], l = l$0, acc = 0;
-     /*<<ephemeron.ml:723:8>>*/ for(;;){
-     if(! l)  /*<<ephemeron.ml:724:16>>*/ return 0;
-     var h = l[1], t = l[2];
-      /*<<ephemeron.ml:725:22>>*/ if(test_keys$0(k, h)){
-      b[1] =  /*<<ephemeron.ml:725:44>>*/ caml_call2(Stdlib_List[12], acc, t);
-      return 0;
-     }
-      /*<<ephemeron.ml:726:27>>*/ var
-      t$0 = l[2],
-       /*<<ephemeron.ml:726:27>>*/ acc$0 = [0, h, acc],
-      l = t$0,
-      acc = acc$0;
-    }
-    /*<<ephemeron.ml:728:16>>*/ }
-   function find$1(b, k){
-     /*<<ephemeron.ml:731:6>>*/ var _d_ = b[1];
-     /*<<ephemeron.ml:731:26>>*/ function _e_(_f_){
-      /*<<?>>*/ return test_keys$0(k, _f_);
-    }
-     /*<<ephemeron.ml:731:12>>*/  /*<<ephemeron.ml:731:12>>*/ var
-     match =
-        /*<<ephemeron.ml:731:12>>*/ caml_call2(Stdlib_List[39], _e_, _d_);
-    if(! match)  /*<<ephemeron.ml:733:16>>*/ return 0;
-    var e = match[1];
-     /*<<ephemeron.ml:732:18>>*/ return get_data$1(e);
-    /*<<ephemeron.ml:733:20>>*/ }
-   function length$2(b){
-     /*<<ephemeron.ml:735:19>>*/ return caml_call1(Stdlib_List[1], b[1]);
-    /*<<ephemeron.ml:735:33>>*/ }
-   function clear$1(b){
-     /*<<ephemeron.ml:736:18>>*/ b[1] = 0;
-    return 0;
-    /*<<ephemeron.ml:736:25>>*/ }
-   var
-    Stdlib_Ephemeron =
-      [0,
-       [0,
-        make,
-        query,
-        Make,
-        MakeSeeded$0,
-        [0, make$0, add, remove, find, length, clear]],
-       [0,
-        make$1,
-        query$0,
-        Make$0,
-        MakeSeeded$1,
-        [0, make$2, add$0, remove$0, find$0, length$0, clear$0]],
-       [0,
-        make$3,
-        query$1,
-        Make$1,
-        MakeSeeded$2,
-        [0, make$4, add$1, remove$1, find$1, length$2, clear$1]]];
-   runtime.caml_register_global(13, Stdlib_Ephemeron, "Stdlib__Ephemeron");
-   return;
-   /*<<?>>*/ }
-  (globalThis));
-
-//# unitInfo: Provides: Stdlib__Filename
-//# unitInfo: Requires: Stdlib, Stdlib__Buffer, Stdlib__Domain, Stdlib__List, Stdlib__Printf, Stdlib__Random, Stdlib__String, Stdlib__Sys
-(function
-  (globalThis){
-   "use strict";
-   var
-    runtime = globalThis.jsoo_runtime,
-    cst$19 = "",
-    cst$23 = " ",
-    cst_2$1 = " 2>",
-    cst_2_1$1 = " 2>&1",
-    cst$22 = " <",
-    cst$21 = " >",
-    cst$20 = '"',
-    cst$24 = ".",
-    cst$25 = "..",
-    cst$28 = "../",
-    cst$27 = "./",
-    cst$26 = "/",
-    cst_dev_null = "/dev/null",
-    caml_equal = runtime.caml_equal,
-    caml_maybe_attach_backtrace = runtime.caml_maybe_attach_backtrace,
-    caml_ml_string_length = runtime.caml_ml_string_length,
-    caml_string_equal = runtime.caml_string_equal,
-    caml_string_get = runtime.caml_string_get,
-    caml_string_notequal = runtime.caml_string_notequal,
-    caml_sys_getenv = runtime.caml_sys_getenv,
-    caml_trampoline = runtime.caml_trampoline,
-    caml_trampoline_return = runtime.caml_trampoline_return,
-    caml_wrap_exception = runtime.caml_wrap_exception;
-    /*<<?>>*/ function caml_call1(f, a0){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 1
-            ? f(a0)
-            : runtime.caml_call_gen(f, [a0]);
-   }
-    /*<<?>>*/ function caml_call2(f, a0, a1){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 2
-            ? f(a0, a1)
-            : runtime.caml_call_gen(f, [a0, a1]);
-   }
-    /*<<?>>*/ function caml_call3(f, a0, a1, a2){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 3
-            ? f(a0, a1, a2)
-            : runtime.caml_call_gen(f, [a0, a1, a2]);
-   }
-    /*<<?>>*/ function caml_call4(f, a0, a1, a2, a3){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 4
-            ? f(a0, a1, a2, a3)
-            : runtime.caml_call_gen(f, [a0, a1, a2, a3]);
-   }
-   var
-    global_data = runtime.caml_get_global_data(),
-    cst$18 = cst$19,
-    cst$17 = cst$19,
-    cst$16 = cst$19,
-    cst$8 = cst$21,
-    cst$15 = cst$19,
-    cst$9 = cst$22,
-    cst$14 = cst$19,
-    cst$10 = cst$23,
-    cst$11 = cst$23,
-    cst$12 = cst$20,
-    cst$13 = cst$19,
-    cst$6 = cst$20,
-    cst$7 = cst$20,
-    cst$4 = cst$19,
-    cst = cst$21,
-    cst$3 = cst$19,
-    cst$0 = cst$22,
-    cst$2 = cst$19,
-    cst$1 = cst$23,
-    null$0 = cst_dev_null,
-    current_dir_name = cst$24,
-    parent_dir_name = cst$25,
-    dir_sep = cst$26,
-    quotequote = "'\\''",
-    null$1 = "NUL",
-    current_dir_name$0 = cst$24,
-    parent_dir_name$0 = cst$25,
-    dir_sep$0 = "\\",
-    cst$5 = cst$24,
-    null$2 = cst_dev_null,
-    current_dir_name$1 = cst$24,
-    parent_dir_name$1 = cst$25,
-    dir_sep$1 = cst$26,
-    Stdlib = global_data.Stdlib,
-    Stdlib_Domain = global_data.Stdlib__Domain,
-    Stdlib_Random = global_data.Stdlib__Random,
-    Stdlib_Printf = global_data.Stdlib__Printf,
-    Stdlib_String = global_data.Stdlib__String,
-    Stdlib_List = global_data.Stdlib__List,
-    Stdlib_Buffer = global_data.Stdlib__Buffer,
-    Stdlib_Sys = global_data.Stdlib__Sys,
-    _i_ = [0, 7, 0],
-    _h_ = [0, 1, [0, 3, [0, 5, 0]]],
-    _e_ = [0, [2, 0, [4, 6, [0, 2, 6], 0, [2, 0, 0]]], "%s%06x%s"],
-    cst_Filename_chop_extension = "Filename.chop_extension",
-    cst_Filename_chop_suffix = "Filename.chop_suffix",
-    _c_ = [0, cst$20, 0],
-    cst_2_1$0 = cst_2_1$1,
-    cst_2$0 = cst_2$1,
-    cst_Filename_quote_command_bad = "Filename.quote_command: bad file name ",
-    cst_2_1 = cst_2_1$1,
-    cst_2 = cst_2$1,
-    cst_tmp = "/tmp";
-   function generic_basename(is_dir_sep, current_dir_name, name){
-     /*<<filename.ml:37:2>>*/ if
-     ( /*<<filename.ml:46:5>>*/ caml_string_equal(name, cst$19))
-      /*<<filename.ml:47:7>>*/ return current_dir_name;
-    var n$3 = caml_ml_string_length(name) - 1 | 0, n = n$3;
-     /*<<filename.ml:38:4>>*/ for(;;){
-     if(0 > n)
-       /*<<filename.ml:38:18>>*/ return  /*<<filename.ml:38:18>>*/ caml_call3
-              (Stdlib_String[15], name, 0, 1);
-      /*<<filename.ml:39:12>>*/ if
-      ( /*<<filename.ml:39:12>>*/ caml_call2(is_dir_sep, name, n))
-       /*<<filename.ml:39:35>>*/ var
-        /*<<filename.ml:39:35>>*/ n$0 = n - 1 | 0,
-       n = n$0;
-     else{
-       /*<<filename.ml:40:9>>*/ var
-        /*<<filename.ml:40:9>>*/ p = n + 1 | 0,
-       n$1 = n;
-       /*<<filename.ml:42:4>>*/ for(;;){
-       if(0 > n$1)
-         /*<<filename.ml:42:18>>*/ return  /*<<filename.ml:42:18>>*/ caml_call3
-                (Stdlib_String[15], name, 0, p);
-        /*<<filename.ml:43:12>>*/ if
-        ( /*<<filename.ml:43:12>>*/ caml_call2(is_dir_sep, name, n$1))
-         /*<<filename.ml:37:2>>*/ return  /*<<filename.ml:37:2>>*/ caml_call3
-                (Stdlib_String[15], name, n$1 + 1 | 0, (p - n$1 | 0) - 1 | 0);
-       var n$2 = n$1 - 1 | 0, n$1 = n$2;
-      }
-     }
-    }
-    /*<<filename.ml:48:40>>*/ }
-   function generic_dirname(is_dir_sep, current_dir_name, name){
-     /*<<filename.ml:55:2>>*/ if
-     ( /*<<filename.ml:68:5>>*/ caml_string_equal(name, cst$19))
-      /*<<filename.ml:69:7>>*/ return current_dir_name;
-    var n$5 = caml_ml_string_length(name) - 1 | 0, n = n$5;
-     /*<<filename.ml:56:4>>*/ for(;;){
-     if(0 > n)
-       /*<<filename.ml:56:18>>*/ return  /*<<filename.ml:56:18>>*/ caml_call3
-              (Stdlib_String[15], name, 0, 1);
-      /*<<filename.ml:57:12>>*/ if
-      ( /*<<filename.ml:57:12>>*/ caml_call2(is_dir_sep, name, n))
-       /*<<filename.ml:57:35>>*/ var
-        /*<<filename.ml:57:35>>*/ n$0 = n - 1 | 0,
-       n = n$0;
-     else{
-      var n$1 = n;
-       /*<<filename.ml:60:4>>*/ for(;;){
-       if(0 > n$1) return current_dir_name;
-        /*<<filename.ml:61:12>>*/ if
-        ( /*<<filename.ml:61:12>>*/ caml_call2(is_dir_sep, name, n$1)){
-        var n$3 = n$1;
-         /*<<filename.ml:64:4>>*/ for(;;){
-         if(0 > n$3)
-           /*<<filename.ml:64:18>>*/ return  /*<<filename.ml:64:18>>*/ caml_call3
-                  (Stdlib_String[15], name, 0, 1);
-          /*<<filename.ml:65:12>>*/ if
-          (!  /*<<filename.ml:65:12>>*/ caml_call2(is_dir_sep, name, n$3))
-           /*<<filename.ml:66:9>>*/ return  /*<<filename.ml:66:9>>*/ caml_call3
-                  (Stdlib_String[15], name, 0, n$3 + 1 | 0);
-          /*<<filename.ml:65:35>>*/ var
-           /*<<filename.ml:65:35>>*/ n$4 = n$3 - 1 | 0,
-          n$3 = n$4;
-        }
-       }
-       else
-         /*<<filename.ml:62:9>>*/ var
-          /*<<filename.ml:62:9>>*/ n$2 = n$1 - 1 | 0,
-         n$1 = n$2;
-      }
-     }
-    }
-    /*<<filename.ml:70:44>>*/ }
-   function is_dir_sep(s, i){
-     /*<<filename.ml:96:23>>*/ return 47
-            ===  /*<<filename.ml:96:23>>*/ caml_string_get(s, i)
-            ? 1
-            : 0;
-    /*<<filename.ml:96:34>>*/ }
-   function is_relative(n){
-     /*<<filename.ml:97:22>>*/ var
-     _aK_ = caml_ml_string_length(n) < 1 ? 1 : 0,
-     _aL_ =
-       _aK_
-       || (47 !==  /*<<filename.ml:97:45>>*/ caml_string_get(n, 0) ? 1 : 0);
-    return _aL_;
-    /*<<filename.ml:97:57>>*/ }
-   function is_implicit(n){
-     /*<<filename.ml:99:4>>*/  /*<<filename.ml:99:4>>*/ var
-     _aF_ = is_relative(n);
-     /*<<filename.ml:99:4>>*/ if(_aF_){
-     var
-      _aG_ = caml_ml_string_length(n) < 2 ? 1 : 0,
-      _aH_ =
-        _aG_
-        ||
-          /*<<filename.ml:100:31>>*/ caml_string_notequal
-          ( /*<<filename.ml:100:31>>*/ caml_call3(Stdlib_String[15], n, 0, 2),
-           cst$27);
-      /*<<filename.ml:100:31>>*/ if(_aH_)
-      var
-       _aI_ = caml_ml_string_length(n) < 3 ? 1 : 0,
-       _aJ_ =
-         _aI_
-         ||
-           /*<<filename.ml:101:31>>*/ caml_string_notequal
-           ( /*<<filename.ml:101:31>>*/ caml_call3(Stdlib_String[15], n, 0, 3),
-            cst$28);
-     else
-      var _aJ_ = _aH_;
-    }
-    else
-     var _aJ_ = _aF_;
-     /*<<filename.ml:101:31>>*/ return _aJ_;
-    /*<<filename.ml:101:57>>*/ }
-   function check_suffix(name, suff){
-     /*<<filename.ml:103:4>>*/ return  /*<<filename.ml:103:4>>*/ caml_call2
-            (Stdlib_String[11], suff, name);
-    /*<<filename.ml:103:38>>*/ }
-   function chop_suffix_opt(suffix, filename){
-     /*<<filename.ml:106:4>>*/ var
-     len_s = caml_ml_string_length(suffix),
-     len_f = caml_ml_string_length(filename);
-    if(len_s > len_f)  /*<<filename.ml:114:6>>*/ return 0;
-     /*<<filename.ml:108:14>>*/  /*<<filename.ml:108:14>>*/ var
-     r =
-        /*<<filename.ml:108:14>>*/ caml_call3
-        (Stdlib_String[15], filename, len_f - len_s | 0, len_s);
-     /*<<filename.ml:109:9>>*/ return  /*<<filename.ml:109:9>>*/ caml_string_equal
-             (r, suffix)
-            ? [0,
-               /*<<filename.ml:110:13>>*/ caml_call3
-               (Stdlib_String[15], filename, 0, len_f - len_s | 0)]
-            : 0;
-    /*<<filename.ml:114:10>>*/ }
-   try{
-     /*<<filename.ml:117:8>>*/ var
-      /*<<filename.ml:117:8>>*/ _k_ =
-        /*<<filename.ml:117:8>>*/ caml_sys_getenv("TMPDIR"),
-     temp_dir_name = _k_;
-   }
-   catch(_aE_){
-    var _a_ = caml_wrap_exception(_aE_);
-    if(_a_ !== Stdlib[8]) throw caml_maybe_attach_backtrace(_a_, 0);
-    var temp_dir_name = cst_tmp;
-   }
-    /*<<filename.ml:118:14>>*/ function quote(s){
-     /*<<filename.ml:18:10>>*/ var
-     l = caml_ml_string_length(s),
-      /*<<filename.ml:18:10>>*/ b =
-        /*<<filename.ml:18:10>>*/ caml_call1(Stdlib_Buffer[1], l + 20 | 0);
-     /*<<filename.ml:19:2>>*/  /*<<filename.ml:19:2>>*/ caml_call2
-     (Stdlib_Buffer[12], b, 39);
-     /*<<filename.ml:19:2>>*/ var
-     _aB_ = l - 1 | 0,
-      /*<<filename.ml:19:2>>*/ _aA_ = 0;
-    if(_aB_ >= 0){
-     var i = _aA_;
-     for(;;){
-       /*<<filename.ml:21:7>>*/ if
-       (39 ===  /*<<filename.ml:21:7>>*/ caml_string_get(s, i))
-        /*<<filename.ml:22:9>>*/  /*<<filename.ml:22:9>>*/ caml_call2
-        (Stdlib_Buffer[16], b, quotequote);
-      else{
-        /*<<filename.ml:23:28>>*/  /*<<filename.ml:23:28>>*/ var
-        _aD_ =  /*<<filename.ml:23:28>>*/ caml_string_get(s, i);
-        /*<<filename.ml:23:9>>*/  /*<<filename.ml:23:9>>*/ caml_call2
-        (Stdlib_Buffer[12], b, _aD_);
-      }
-       /*<<filename.ml:23:9>>*/  /*<<filename.ml:23:9>>*/ var
-       _aC_ = i + 1 | 0;
-      if(_aB_ === i) break;
-      var i = _aC_;
-     }
-    }
-     /*<<filename.ml:25:2>>*/  /*<<filename.ml:25:2>>*/ caml_call2
-     (Stdlib_Buffer[12], b, 39);
-     /*<<filename.ml:25:2>>*/ return  /*<<filename.ml:25:2>>*/ caml_call1
-            (Stdlib_Buffer[2], b);
-   }
-   function quote_command(cmd, stdin, stdout, stderr, args){
-     /*<<filename.ml:120:4>>*/ if(stderr){
-     var f = stderr[1];
-      /*<<filename.ml:123:51>>*/ if
-      ( /*<<filename.ml:123:51>>*/ caml_equal(stderr, stdout))
-      var _ap_ = cst_2_1;
-     else
-       /*<<filename.ml:125:61>>*/ var
-        /*<<filename.ml:125:61>>*/ _az_ = quote(f),
-       _ap_ =  /*<<filename.ml:125:53>>*/ caml_call2(Stdlib[28], cst_2, _az_);
-     var _aq_ = _ap_;
-    }
-    else
-     var _aq_ = cst$4;
-    if(stdout)
-      /*<<filename.ml:122:55>>*/ var
-      f$0 = stdout[1],
-       /*<<filename.ml:122:55>>*/ _ar_ = quote(f$0),
-      _as_ =  /*<<filename.ml:122:48>>*/ caml_call2(Stdlib[28], cst, _ar_);
-    else
-     var _as_ = cst$3;
-     /*<<filename.ml:122:6>>*/  /*<<filename.ml:122:6>>*/ var
-     _at_ =  /*<<filename.ml:122:6>>*/ caml_call2(Stdlib[28], _as_, _aq_);
-    if(stdin)
-      /*<<filename.ml:121:55>>*/ var
-      f$1 = stdin[1],
-       /*<<filename.ml:121:55>>*/ _au_ = quote(f$1),
-      _av_ =  /*<<filename.ml:121:48>>*/ caml_call2(Stdlib[28], cst$0, _au_);
-    else
-     var _av_ = cst$2;
-     /*<<filename.ml:121:6>>*/ var
-      /*<<filename.ml:121:6>>*/ _aw_ =
-        /*<<filename.ml:121:6>>*/ caml_call2(Stdlib[28], _av_, _at_),
-      /*<<filename.ml:120:22>>*/ _ax_ =
-        /*<<filename.ml:120:22>>*/ caml_call2
-        (Stdlib_List[19], quote, [0, cmd, args]),
-      /*<<filename.ml:120:4>>*/ _ay_ =
-        /*<<filename.ml:120:4>>*/ caml_call2(Stdlib_String[6], cst$1, _ax_);
-     /*<<filename.ml:121:6>>*/ return  /*<<filename.ml:121:6>>*/ caml_call2
-            (Stdlib[28], _ay_, _aw_);
-    /*<<filename.ml:125:69>>*/ }
-    /*<<filename.ml:126:17>>*/ function basename(_ao_){
-     /*<<?>>*/ return generic_basename(is_dir_sep, current_dir_name, _ao_);
-   }
-    /*<<filename.ml:127:16>>*/ function dirname(_an_){
-     /*<<?>>*/ return generic_dirname(is_dir_sep, current_dir_name, _an_);
-   }
-    /*<<filename.ml:91:24>>*/  /*<<filename.ml:91:24>>*/ var
-    Unix =
-      [0,
-       null$0,
-       current_dir_name,
-       parent_dir_name,
-       dir_sep,
-       is_dir_sep,
-       is_relative,
-       is_implicit,
-       check_suffix,
-       chop_suffix_opt,
-       temp_dir_name,
-       quote,
-       quote_command,
-       basename,
-       dirname];
-   function is_dir_sep$0(s, i){
-     /*<<filename.ml:135:23>>*/ var
-      /*<<filename.ml:135:31>>*/ c =
-        /*<<filename.ml:135:31>>*/ caml_string_get(s, i),
-     _ak_ = 47 === c ? 1 : 0;
-    if(_ak_)
-     var _al_ = _ak_;
-    else
-     var _am_ = 92 === c ? 1 : 0, _al_ = _am_ || (58 === c ? 1 : 0);
-    return _al_;
-    /*<<filename.ml:135:70>>*/ }
-   function is_relative$0(n){
-     /*<<filename.ml:137:4>>*/ var
-     _ae_ = caml_ml_string_length(n) < 1 ? 1 : 0,
-     _af_ =
-       _ae_
-       || (47 !==  /*<<filename.ml:137:28>>*/ caml_string_get(n, 0) ? 1 : 0);
-    if(_af_){
-     var
-      _ag_ = caml_ml_string_length(n) < 1 ? 1 : 0,
-      _ah_ =
-        _ag_
-        || (92 !==  /*<<filename.ml:138:31>>*/ caml_string_get(n, 0) ? 1 : 0);
-     if(_ah_)
-      var
-       _ai_ = caml_ml_string_length(n) < 2 ? 1 : 0,
-       _aj_ =
-         _ai_
-         || (58 !==  /*<<filename.ml:139:31>>*/ caml_string_get(n, 1) ? 1 : 0);
-     else
-      var _aj_ = _ah_;
-    }
-    else
-     var _aj_ = _af_;
-    return _aj_;
-    /*<<filename.ml:139:44>>*/ }
-   function is_implicit$0(n){
-     /*<<filename.ml:141:4>>*/  /*<<filename.ml:141:4>>*/ var
-     _X_ = is_relative$0(n);
-     /*<<filename.ml:141:4>>*/ if(_X_){
-     var
-      _Y_ = caml_ml_string_length(n) < 2 ? 1 : 0,
-      _Z_ =
-        _Y_
-        ||
-          /*<<filename.ml:142:31>>*/ caml_string_notequal
-          ( /*<<filename.ml:142:31>>*/ caml_call3(Stdlib_String[15], n, 0, 2),
-           cst$27);
-      /*<<filename.ml:142:31>>*/ if(_Z_){
-      var
-       ___ = caml_ml_string_length(n) < 2 ? 1 : 0,
-       _$_ =
-         ___
-         ||
-           /*<<filename.ml:143:31>>*/ caml_string_notequal
-           ( /*<<filename.ml:143:31>>*/ caml_call3(Stdlib_String[15], n, 0, 2),
-            ".\\");
-       /*<<filename.ml:143:31>>*/ if(_$_){
-       var
-        _aa_ = caml_ml_string_length(n) < 3 ? 1 : 0,
-        _ab_ =
-          _aa_
-          ||
-            /*<<filename.ml:144:31>>*/ caml_string_notequal
-            ( /*<<filename.ml:144:31>>*/ caml_call3
-              (Stdlib_String[15], n, 0, 3),
-             cst$28);
-        /*<<filename.ml:144:31>>*/ if(_ab_)
-        var
-         _ac_ = caml_ml_string_length(n) < 3 ? 1 : 0,
-         _ad_ =
-           _ac_
-           ||
-             /*<<filename.ml:145:31>>*/ caml_string_notequal
-             ( /*<<filename.ml:145:31>>*/ caml_call3
-               (Stdlib_String[15], n, 0, 3),
-              "..\\");
-       else
-        var _ad_ = _ab_;
-      }
-      else
-       var _ad_ = _$_;
-     }
-     else
-      var _ad_ = _Z_;
-    }
-    else
-     var _ad_ = _X_;
-     /*<<filename.ml:145:31>>*/ return _ad_;
-    /*<<filename.ml:145:58>>*/ }
-   function check_suffix$0(name, suff){
-     /*<<filename.ml:147:3>>*/ var
-     _U_ = caml_ml_string_length(suff) <= caml_ml_string_length(name) ? 1 : 0;
-    if(_U_)
-      /*<<filename.ml:148:12>>*/ var
-       /*<<filename.ml:148:12>>*/ s =
-         /*<<filename.ml:148:12>>*/ caml_call3
-         (Stdlib_String[15],
-          name,
-          caml_ml_string_length(name) - caml_ml_string_length(suff) | 0,
-          caml_ml_string_length(suff)),
-       /*<<filename.ml:150:31>>*/ _V_ =
-         /*<<filename.ml:150:31>>*/ caml_call1(Stdlib_String[26], suff),
-      _W_ =
-         /*<<filename.ml:150:4>>*/ caml_string_equal
-         ( /*<<filename.ml:150:4>>*/ caml_call1(Stdlib_String[26], s), _V_);
-    else
-     var _W_ = _U_;
-     /*<<filename.ml:150:4>>*/ return _W_;
-    /*<<filename.ml:150:59>>*/ }
-   function chop_suffix_opt$0(suffix, filename){
-     /*<<filename.ml:153:4>>*/ var
-     len_s = caml_ml_string_length(suffix),
-     len_f = caml_ml_string_length(filename);
-    if(len_s > len_f)  /*<<filename.ml:161:6>>*/ return 0;
-     /*<<filename.ml:155:14>>*/ var
-      /*<<filename.ml:155:14>>*/ r =
-        /*<<filename.ml:155:14>>*/ caml_call3
-        (Stdlib_String[15], filename, len_f - len_s | 0, len_s),
-      /*<<filename.ml:156:36>>*/ _T_ =
-        /*<<filename.ml:156:36>>*/ caml_call1(Stdlib_String[26], suffix);
-     /*<<filename.ml:156:9>>*/ return  /*<<filename.ml:156:9>>*/ caml_string_equal
-             ( /*<<filename.ml:156:9>>*/ caml_call1(Stdlib_String[26], r),
-              _T_)
-            ? [0,
-               /*<<filename.ml:157:13>>*/ caml_call3
-               (Stdlib_String[15], filename, 0, len_f - len_s | 0)]
-            : 0;
-    /*<<filename.ml:161:10>>*/ }
-   try{
-     /*<<filename.ml:165:8>>*/ var
-      /*<<filename.ml:165:8>>*/ _j_ =
-        /*<<filename.ml:165:8>>*/ caml_sys_getenv("TEMP"),
-     temp_dir_name$0 = _j_;
-   }
-   catch(_S_){
-    var _b_ = caml_wrap_exception(_S_);
-    if(_b_ !== Stdlib[8]) throw caml_maybe_attach_backtrace(_b_, 0);
-    var temp_dir_name$0 = cst$5;
-   }
-   function quote$0(s){
-     /*<<filename.ml:167:4>>*/ var
-     l = caml_ml_string_length(s),
-      /*<<filename.ml:168:12>>*/ b =
-        /*<<filename.ml:168:12>>*/ caml_call1(Stdlib_Buffer[1], l + 20 | 0);
-     /*<<filename.ml:169:4>>*/  /*<<filename.ml:169:4>>*/ caml_call2
-     (Stdlib_Buffer[12], b, 34);
-    function add_bs(n){
-      /*<<filename.ml:186:19>>*/  /*<<filename.ml:186:19>>*/ var _Q_ = 1;
-     if(n >= 1){
-      var j = _Q_;
-      for(;;){
-        /*<<filename.ml:186:38>>*/  /*<<filename.ml:186:38>>*/ caml_call2
-        (Stdlib_Buffer[12], b, 92);
-        /*<<filename.ml:186:38>>*/  /*<<filename.ml:186:38>>*/ var
-        _R_ = j + 1 | 0;
-       if(n === j) break;
-       var j = _R_;
-      }
-     }
-     return 0;
-     /*<<filename.ml:186:66>>*/ }
-    function loop$0(counter, i){
-      /*<<filename.ml:171:6>>*/ var i$0 = i;
-      /*<<filename.ml:171:6>>*/ for(;;){
-      if(i$0 === l)
-        /*<<filename.ml:171:20>>*/ return  /*<<filename.ml:171:20>>*/ caml_call2
-               (Stdlib_Buffer[12], b, 34);
-       /*<<filename.ml:172:12>>*/  /*<<filename.ml:172:12>>*/ var
-       c =  /*<<filename.ml:172:12>>*/ caml_string_get(s, i$0);
-      if(34 === c){
-       var _O_ = 0;
-        /*<<filename.ml:173:16>>*/ if(counter >= 50)
-         /*<<filename.ml:173:16>>*/ return  /*<<filename.ml:173:16>>*/ caml_trampoline_return
-                (loop_bs, [0, _O_, i$0]);
-       var counter$1 = counter + 1 | 0;
-        /*<<filename.ml:173:16>>*/ return loop_bs(counter$1, _O_, i$0);
-      }
-      if(92 === c){
-       var _P_ = 0;
-        /*<<filename.ml:174:16>>*/ if(counter >= 50)
-         /*<<filename.ml:174:16>>*/ return  /*<<filename.ml:174:16>>*/ caml_trampoline_return
-                (loop_bs, [0, _P_, i$0]);
-       var counter$0 = counter + 1 | 0;
-        /*<<filename.ml:174:16>>*/ return loop_bs(counter$0, _P_, i$0);
-      }
-       /*<<filename.ml:175:16>>*/  /*<<filename.ml:175:16>>*/ caml_call2
-       (Stdlib_Buffer[12], b, c);
-       /*<<filename.ml:175:16>>*/ var
-        /*<<filename.ml:175:16>>*/ i$1 = i$0 + 1 | 0,
-       i$0 = i$1;
-     }
-     /*<<filename.ml:175:48>>*/ }
-    function loop_bs(counter, n, i){
-      /*<<filename.ml:177:6>>*/ var n$0 = n, i$0 = i;
-      /*<<filename.ml:177:6>>*/ for(;;){
-      if(i$0 === l){
-        /*<<filename.ml:178:8>>*/  /*<<filename.ml:178:8>>*/ caml_call2
-        (Stdlib_Buffer[12], b, 34);
-        /*<<filename.ml:178:8>>*/ return add_bs(n$0);
-      }
-       /*<<filename.ml:181:14>>*/  /*<<filename.ml:181:14>>*/ var
-       match =  /*<<filename.ml:181:14>>*/ caml_string_get(s, i$0);
-      if(34 === match){
-        /*<<filename.ml:182:18>>*/ add_bs((2 * n$0 | 0) + 1 | 0);
-        /*<<filename.ml:182:34>>*/  /*<<filename.ml:182:34>>*/ caml_call2
-        (Stdlib_Buffer[12], b, 34);
-        /*<<filename.ml:182:34>>*/  /*<<filename.ml:182:34>>*/ var
-        _N_ = i$0 + 1 | 0;
-        /*<<filename.ml:182:34>>*/ if(counter >= 50)
-         /*<<filename.ml:182:34>>*/ return  /*<<filename.ml:182:34>>*/ caml_trampoline_return
-                (loop$0, [0, _N_]);
-       var counter$1 = counter + 1 | 0;
-        /*<<filename.ml:182:34>>*/ return loop$0(counter$1, _N_);
-      }
-      if(92 !== match){
-        /*<<filename.ml:184:18>>*/ add_bs(n$0);
-        /*<<filename.ml:184:18>>*/ if(counter >= 50)
-         /*<<filename.ml:184:18>>*/ return  /*<<filename.ml:184:18>>*/ caml_trampoline_return
-                (loop$0, [0, i$0]);
-       var counter$0 = counter + 1 | 0;
-        /*<<filename.ml:184:18>>*/ return loop$0(counter$0, i$0);
-      }
-       /*<<filename.ml:183:18>>*/ var
-        /*<<filename.ml:183:18>>*/ i$1 = i$0 + 1 | 0,
-       n$1 = n$0 + 1 | 0,
-       n$0 = n$1,
-       i$0 = i$1;
-     }
-     /*<<filename.ml:185:9>>*/ }
-    function loop(i){ /*<<?>>*/ return caml_trampoline(loop$0(0, i));}
-     /*<<filename.ml:188:4>>*/ loop(0);
-     /*<<filename.ml:188:4>>*/ return  /*<<filename.ml:188:4>>*/ caml_call1
-            (Stdlib_Buffer[2], b);
-    /*<<filename.ml:189:21>>*/ }
-   function quote_cmd_filename(f){
-     /*<<filename.ml:222:4>>*/ if
-     (!
-       /*<<filename.ml:222:7>>*/ caml_call2(Stdlib_String[14], f, 34)
-      && !  /*<<filename.ml:222:33>>*/ caml_call2(Stdlib_String[14], f, 37)){
-      /*<<filename.ml:224:12>>*/ if
-      (!  /*<<filename.ml:224:12>>*/ caml_call2(Stdlib_String[14], f, 32))
-       /*<<filename.ml:227:6>>*/ return f;
-      /*<<filename.ml:225:13>>*/  /*<<filename.ml:225:13>>*/ var
-      _M_ =  /*<<filename.ml:225:13>>*/ caml_call2(Stdlib[28], f, cst$6);
-      /*<<filename.ml:225:13>>*/ return  /*<<filename.ml:225:13>>*/ caml_call2
-             (Stdlib[28], cst$7, _M_);
-    }
-     /*<<filename.ml:223:15>>*/  /*<<filename.ml:223:15>>*/ var
-     _L_ =
-        /*<<filename.ml:223:15>>*/ caml_call2
-        (Stdlib[28], cst_Filename_quote_command_bad, f);
-     /*<<filename.ml:223:15>>*/ return  /*<<filename.ml:223:15>>*/ caml_call1
-            (Stdlib[2], _L_);
-    /*<<filename.ml:227:7>>*/ }
-   function quote_command$0(cmd, stdin, stdout, stderr, args){
-     /*<<filename.ml:232:4>>*/ if(stderr){
-     var f = stderr[1];
-      /*<<filename.ml:240:43>>*/ if
-      ( /*<<filename.ml:240:43>>*/ caml_equal(stderr, stdout))
-      var _x_ = cst_2_1$0;
-     else
-       /*<<filename.ml:242:53>>*/ var
-        /*<<filename.ml:242:53>>*/ _J_ = quote_cmd_filename(f),
-       _x_ =  /*<<filename.ml:242:45>>*/ caml_call2(Stdlib[28], cst_2$0, _J_);
-     var _y_ = _x_;
-    }
-    else
-     var _y_ = cst$16;
-    var _z_ = [0, _y_, _c_];
-    if(stdout)
-      /*<<filename.ml:238:55>>*/ var
-      f$0 = stdout[1],
-       /*<<filename.ml:238:55>>*/ _A_ = quote_cmd_filename(f$0),
-      _B_ =  /*<<filename.ml:238:48>>*/ caml_call2(Stdlib[28], cst$8, _A_);
-    else
-     var _B_ = cst$15;
-    var _C_ = [0, _B_, _z_];
-    if(stdin)
-      /*<<filename.ml:237:55>>*/ var
-      f$1 = stdin[1],
-       /*<<filename.ml:237:55>>*/ _D_ = quote_cmd_filename(f$1),
-      _E_ =  /*<<filename.ml:237:48>>*/ caml_call2(Stdlib[28], cst$9, _D_);
-    else
-     var _E_ = cst$14;
-     /*<<filename.ml:236:35>>*/ var
-      /*<<filename.ml:236:35>>*/ _G_ =
-        /*<<filename.ml:236:35>>*/ caml_call2(Stdlib_List[19], quote$0, args),
-      /*<<filename.ml:236:16>>*/ s =
-        /*<<filename.ml:236:16>>*/ caml_call2(Stdlib_String[6], cst$10, _G_),
-      /*<<filename.ml:211:12>>*/ b =
-        /*<<filename.ml:211:12>>*/ caml_call1
-        (Stdlib_Buffer[1], caml_ml_string_length(s) + 20 | 0),
-     _F_ = [0, _E_, _C_];
-    function _w_(c){
-      /*<<filename.ml:214:8>>*/ a:
-     {
-      if(62 <= c){
-       var _K_ = c - 63 | 0;
-       if(60 < _K_ >>> 0){if(62 <= _K_) break a;} else if(31 !== _K_) break a;
-      }
-      else
-       if(42 <= c){
-        if(60 !== c) break a;
-       }
-       else{
-        if(33 > c) break a;
-        switch(c - 33 | 0){case 2:case 3:case 6: break a;
-        }
-       }
-       /*<<filename.ml:216:12>>*/  /*<<filename.ml:216:12>>*/ caml_call2
-       (Stdlib_Buffer[12], b, 94);
-       /*<<filename.ml:216:12>>*/ return  /*<<filename.ml:216:12>>*/ caml_call2
-              (Stdlib_Buffer[12], b, c);
-     }
-      /*<<filename.ml:218:12>>*/ return  /*<<filename.ml:218:12>>*/ caml_call2
-             (Stdlib_Buffer[12], b, c);
-     /*<<filename.ml:218:31>>*/ }
-     /*<<filename.ml:212:4>>*/  /*<<filename.ml:212:4>>*/ caml_call2
-     (Stdlib_String[29], _w_, s);
-     /*<<filename.ml:232:21>>*/ var
-     _H_ =
-       [0,
-        cst$11,
-        [0,  /*<<filename.ml:212:4>>*/ caml_call1(Stdlib_Buffer[2], b), _F_]],
-      /*<<filename.ml:232:21>>*/ _I_ =
-       [0, cst$12, [0, quote_cmd_filename(cmd), _H_]];
-     /*<<filename.ml:232:21>>*/ return  /*<<filename.ml:232:21>>*/ caml_call2
-            (Stdlib_String[6], cst$13, _I_);
-    /*<<filename.ml:244:5>>*/ }
-   function drive_and_path(s){
-     /*<<filename.ml:252:4>>*/ var
-     _s_ = 2 <=  /*<<filename.ml:250:4>>*/ caml_ml_string_length(s) ? 1 : 0;
-    if(_s_){
-      /*<<filename.ml:250:38>>*/  /*<<filename.ml:250:38>>*/ var
-      param =  /*<<filename.ml:250:38>>*/ caml_string_get(s, 0);
-     a:
-     {
-      b:
-      {
-       if(91 <= param){
-        if(25 < param - 97 >>> 0) break b;
-       }
-       else if(65 > param) break b;
-       var _t_ = 1;
-       break a;
-      }
-      var _t_ = 0;
-     }
-      /*<<filename.ml:250:28>>*/  /*<<filename.ml:250:28>>*/ var
-      _u_ =
-        _t_
-         ? 58 ===  /*<<filename.ml:250:47>>*/ caml_string_get(s, 1) ? 1 : 0
-         : _t_;
-    }
-    else
-     var _u_ = _s_;
-     /*<<filename.ml:252:7>>*/ if(! _u_)
-      /*<<filename.ml:254:9>>*/ return [0, cst$17, s];
-     /*<<filename.ml:253:28>>*/  /*<<filename.ml:253:28>>*/ var
-     _v_ =
-        /*<<filename.ml:253:28>>*/ caml_call3
-        (Stdlib_String[15], s, 2, caml_ml_string_length(s) - 2 | 0);
-     /*<<filename.ml:253:9>>*/ return [0,
-             /*<<filename.ml:253:10>>*/ caml_call3(Stdlib_String[15], s, 0, 2),
-            _v_];
-    /*<<filename.ml:254:16>>*/ }
-   function dirname$0(s){
-     /*<<filename.ml:256:4>>*/ var
-      /*<<filename.ml:256:24>>*/ match = drive_and_path(s),
-     path = match[2],
-     drive = match[1],
-      /*<<filename.ml:257:14>>*/ dir =
-       generic_dirname(is_dir_sep$0, current_dir_name$0, path);
-     /*<<filename.ml:258:4>>*/ return  /*<<filename.ml:258:4>>*/ caml_call2
-            (Stdlib[28], drive, dir);
-    /*<<filename.ml:258:15>>*/ }
-   function basename$0(s){
-     /*<<filename.ml:260:4>>*/ var path = drive_and_path(s)[2];
-     /*<<filename.ml:261:4>>*/ return generic_basename
-            (is_dir_sep$0, current_dir_name$0, path);
-    /*<<filename.ml:261:53>>*/ }
-    /*<<filename.ml:130:25>>*/  /*<<filename.ml:130:25>>*/ var
-    Win32 =
-      [0,
-       null$1,
-       current_dir_name$0,
-       parent_dir_name$0,
-       dir_sep$0,
-       is_dir_sep$0,
-       is_relative$0,
-       is_implicit$0,
-       check_suffix$0,
-       chop_suffix_opt$0,
-       temp_dir_name$0,
-       quote$0,
-       quote_command$0,
-       basename$0,
-       dirname$0];
-    /*<<filename.ml:277:17>>*/ function basename$1(_r_){
-     /*<<?>>*/ return generic_basename(is_dir_sep$0, current_dir_name$1, _r_);
-   }
-    /*<<filename.ml:278:16>>*/ function dirname$1(_q_){
-     /*<<?>>*/ return generic_dirname(is_dir_sep$0, current_dir_name$1, _q_);
-   }
-    /*<<filename.ml:264:26>>*/ var
-     /*<<filename.ml:264:26>>*/ Cygwin =
-      [0,
-       null$2,
-       current_dir_name$1,
-       parent_dir_name$1,
-       dir_sep$1,
-       is_dir_sep$0,
-       is_relative$0,
-       is_implicit$0,
-       check_suffix$0,
-       chop_suffix_opt$0,
-       temp_dir_name,
-       quote,
-       quote_command,
-       basename$1,
-       dirname$1],
-    _d_ = Stdlib_Sys[4],
-    Sysdeps =
-      caml_string_notequal(_d_, "Cygwin")
-       ? caml_string_notequal(_d_, "Win32") ? Unix : Win32
-       : Cygwin,
-    null$3 = Sysdeps[1],
-    current_dir_name$2 = Sysdeps[2],
-    parent_dir_name$2 = Sysdeps[3],
-    dir_sep$2 = Sysdeps[4],
-    is_dir_sep$1 = Sysdeps[5],
-    is_relative$1 = Sysdeps[6],
-    is_implicit$1 = Sysdeps[7],
-    check_suffix$1 = Sysdeps[8],
-    chop_suffix_opt$1 = Sysdeps[9],
-    temp_dir_name$1 = Sysdeps[10],
-    quote$1 = Sysdeps[11],
-    quote_command$1 = Sysdeps[12],
-    basename$2 = Sysdeps[13],
-    dirname$2 = Sysdeps[14];
-   function concat(dirname, filename){
-     /*<<filename.ml:290:2>>*/ var l = caml_ml_string_length(dirname);
-     /*<<filename.ml:291:14>>*/ if
-     (0 !== l && ! is_dir_sep$1(dirname, l - 1 | 0)){
-      /*<<filename.ml:293:17>>*/  /*<<filename.ml:293:17>>*/ var
-      _p_ =
-         /*<<filename.ml:293:17>>*/ caml_call2
-         (Stdlib[28], dir_sep$2, filename);
-      /*<<filename.ml:293:17>>*/ return  /*<<filename.ml:293:17>>*/ caml_call2
-             (Stdlib[28], dirname, _p_);
-    }
-     /*<<filename.ml:292:7>>*/ return  /*<<filename.ml:292:7>>*/ caml_call2
-            (Stdlib[28], dirname, filename);
-    /*<<filename.ml:293:35>>*/ }
-   function chop_suffix(name, suff){
-     /*<<filename.ml:296:2>>*/ return check_suffix$1(name, suff)
-            ? caml_call3
-              (Stdlib_String[15],
-               name,
-               0,
-               caml_ml_string_length(name) - caml_ml_string_length(suff) | 0)
-            :  /*<<filename.ml:298:7>>*/ caml_call1
-              (Stdlib[1], cst_Filename_chop_suffix);
-    /*<<filename.ml:298:41>>*/ }
-   function extension_len(name){
-     /*<<filename.ml:301:2>>*/ var
-     i$3 = caml_ml_string_length(name) - 1 | 0,
-     i0 = i$3;
-     /*<<filename.ml:307:4>>*/ for(;;){
-      /*<<filename.ml:307:16>>*/ if(0 <= i0 && ! is_dir_sep$1(name, i0)){
-       /*<<filename.ml:308:12>>*/ if
-       (46 !==  /*<<filename.ml:308:12>>*/ caml_string_get(name, i0)){
-        /*<<filename.ml:309:9>>*/ var
-         /*<<filename.ml:309:9>>*/ i$2 = i0 - 1 | 0,
-        i0 = i$2;
-       continue;
-      }
-       /*<<filename.ml:308:32>>*/ var
-        /*<<filename.ml:308:32>>*/ i$1 = i0 - 1 | 0,
-       i = i$1;
-       /*<<filename.ml:302:4>>*/ for(;;){
-        /*<<filename.ml:302:16>>*/ if(0 <= i && ! is_dir_sep$1(name, i)){
-         /*<<filename.ml:303:12>>*/ if
-         (46 !==  /*<<filename.ml:303:12>>*/ caml_string_get(name, i))
-         return caml_ml_string_length(name) - i0 | 0;
-         /*<<filename.ml:303:32>>*/ var
-          /*<<filename.ml:303:32>>*/ i$0 = i - 1 | 0,
-         i = i$0;
-        continue;
-       }
-        /*<<filename.ml:302:39>>*/ return 0;
-      }
-     }
-      /*<<filename.ml:307:39>>*/ return 0;
-    }
-    /*<<filename.ml:311:37>>*/ }
-   function extension(name){
-     /*<<filename.ml:314:2>>*/  /*<<filename.ml:314:10>>*/ var
-     l = extension_len(name);
-     /*<<filename.ml:315:2>>*/ return 0 === l
-            ? cst$18
-            :  /*<<filename.ml:315:24>>*/ caml_call3
-              (Stdlib_String[15],
-               name,
-               caml_ml_string_length(name) - l | 0,
-               l);
-    /*<<filename.ml:315:66>>*/ }
-   function chop_extension(name){
-     /*<<filename.ml:318:2>>*/  /*<<filename.ml:318:10>>*/ var
-     l = extension_len(name);
-     /*<<filename.ml:319:2>>*/ return 0 === l
-            ?  /*<<filename.ml:319:16>>*/ caml_call1
-              (Stdlib[1], cst_Filename_chop_extension)
-            : caml_call3
-              (Stdlib_String[15],
-               name,
-               0,
-               caml_ml_string_length(name) - l | 0);
-    /*<<filename.ml:320:49>>*/ }
-   function remove_extension(name){
-     /*<<filename.ml:323:2>>*/  /*<<filename.ml:323:10>>*/ var
-     l = extension_len(name);
-     /*<<filename.ml:324:2>>*/ return 0 === l
-            ? name
-            : caml_call3
-              (Stdlib_String[15],
-               name,
-               0,
-               caml_ml_string_length(name) - l | 0);
-    /*<<filename.ml:324:68>>*/ }
-    /*<<filename.ml:330:2>>*/  /*<<filename.ml:330:2>>*/ var
-    prng_key =
-       /*<<filename.ml:330:2>>*/ caml_call2
-       (Stdlib_Domain[10][1], 0, Stdlib_Random[15][2]);
-   function temp_file_name(temp_dir, prefix, suffix){
-     /*<<filename.ml:333:2>>*/ var
-      /*<<filename.ml:333:21>>*/ random_state =
-        /*<<filename.ml:333:21>>*/ caml_call1(Stdlib_Domain[10][2], prng_key),
-      /*<<filename.ml:334:12>>*/ rnd =
-        /*<<filename.ml:334:12>>*/ caml_call1
-        (Stdlib_Random[15][4], random_state)
-       & 16777215;
-     /*<<filename.ml:335:18>>*/ return concat
-            (temp_dir,
-              /*<<filename.ml:335:18>>*/ caml_call4
-              (Stdlib_Printf[4], _e_, prefix, rnd, suffix));
-    /*<<filename.ml:335:63>>*/ }
-   function _f_(param){
-     /*<<filename.ml:338:58>>*/ return temp_dir_name$1;
-    /*<<filename.ml:338:71>>*/ }
-    /*<<filename.ml:338:40>>*/ var
-     /*<<filename.ml:338:40>>*/ _g_ =
-      [0, function(_o_){ /*<<?>>*/ return _o_;}],
-     /*<<filename.ml:338:2>>*/ current_temp_dir_name =
-       /*<<filename.ml:338:2>>*/ caml_call2(Stdlib_Domain[10][1], _g_, _f_);
-   function set_temp_dir_name(s){
-     /*<<filename.ml:340:26>>*/ return  /*<<filename.ml:340:26>>*/ caml_call2
-            (Stdlib_Domain[10][3], current_temp_dir_name, s);
-    /*<<filename.ml:340:64>>*/ }
-   function get_temp_dir_name(param){
-     /*<<filename.ml:341:27>>*/ return caml_call1
-            (Stdlib_Domain[10][2], current_temp_dir_name);
-    /*<<filename.ml:341:63>>*/ }
-   function temp_file(opt, prefix, suffix){
-     /*<<filename.ml:344:2>>*/ if(opt)
-     var sth = opt[1], temp_dir = sth;
-    else
-     var
-      temp_dir =
-         /*<<filename.ml:343:27>>*/ caml_call1
-         (Stdlib_Domain[10][2], current_temp_dir_name);
-    var counter = 0;
-     /*<<filename.ml:345:4>>*/ for(;;){
-      /*<<filename.ml:345:15>>*/  /*<<filename.ml:345:15>>*/ var
-      name = temp_file_name(temp_dir, prefix, suffix);
-      /*<<filename.ml:346:4>>*/ try{
-       /*<<filename.ml:347:6>>*/  /*<<filename.ml:347:6>>*/ runtime.caml_sys_close
-       ( /*<<filename.ml:347:16>>*/ runtime.caml_sys_open(name, _h_, 384));
-       /*<<filename.ml:347:6>>*/ return name;
-     }
-     catch(e$0){
-      var e = caml_wrap_exception(e$0);
-      if(e[1] !== Stdlib[11]) throw caml_maybe_attach_backtrace(e, 0);
-      if(1000 <= counter)
-        /*<<filename.ml:350:30>>*/ throw  /*<<filename.ml:350:30>>*/ caml_maybe_attach_backtrace
-              (e, 0);
-       /*<<filename.ml:350:43>>*/ var
-        /*<<filename.ml:350:43>>*/ counter$0 = counter + 1 | 0,
-       counter = counter$0;
-     }
-    }
-    /*<<filename.ml:351:15>>*/ }
-   function open_temp_file(opt, _m_, _l_, prefix, suffix){
-     /*<<filename.ml:356:2>>*/ if(opt)
-     var sth = opt[1], mode = sth;
-    else
-     var mode = _i_;
-     /*<<filename.ml:356:2>>*/ if(_m_)
-     var sth$0 = _m_[1], perms = sth$0;
-    else
-     var perms = 384;
-     /*<<filename.ml:356:2>>*/ if(_l_)
-     var sth$1 = _l_[1], temp_dir = sth$1;
-    else
-     var
-      temp_dir =
-         /*<<filename.ml:354:17>>*/ caml_call1
-         (Stdlib_Domain[10][2], current_temp_dir_name);
-    var counter = 0;
-     /*<<filename.ml:357:4>>*/ for(;;){
-      /*<<filename.ml:357:15>>*/  /*<<filename.ml:357:15>>*/ var
-      name = temp_file_name(temp_dir, prefix, suffix);
-      /*<<filename.ml:358:4>>*/ try{
-       /*<<filename.ml:359:6>>*/  /*<<filename.ml:359:6>>*/ var
-       _n_ =
-         [0,
-          name,
-           /*<<filename.ml:360:7>>*/ caml_call3
-           (Stdlib[62], [0, 1, [0, 3, [0, 5, mode]]], perms, name)];
-       /*<<filename.ml:359:6>>*/ return _n_;
-     }
-     catch(e$0){
-      var e = caml_wrap_exception(e$0);
-      if(e[1] !== Stdlib[11]) throw caml_maybe_attach_backtrace(e, 0);
-      if(1000 <= counter)
-        /*<<filename.ml:362:30>>*/ throw  /*<<filename.ml:362:30>>*/ caml_maybe_attach_backtrace
-              (e, 0);
-       /*<<filename.ml:362:43>>*/ var
-        /*<<filename.ml:362:43>>*/ counter$0 = counter + 1 | 0,
-       counter = counter$0;
-     }
-    }
-    /*<<filename.ml:363:15>>*/ }
-   var
-    Stdlib_Filename =
-      [0,
-       current_dir_name$2,
-       parent_dir_name$2,
-       dir_sep$2,
-       concat,
-       is_relative$1,
-       is_implicit$1,
-       check_suffix$1,
-       chop_suffix,
-       chop_suffix_opt$1,
-       extension,
-       remove_extension,
-       chop_extension,
-       basename$2,
-       dirname$2,
-       null$3,
-       temp_file,
-       open_temp_file,
-       get_temp_dir_name,
-       set_temp_dir_name,
-       quote$1,
-       quote_command$1];
-   runtime.caml_register_global(65, Stdlib_Filename, "Stdlib__Filename");
-   return;
-   /*<<?>>*/ }
-  (globalThis));
-
-//# unitInfo: Provides: Stdlib__Complex
-//# unitInfo: Requires: Stdlib, Stdlib__Float
-(function
-  (globalThis){
-   "use strict";
-   var
-    runtime = globalThis.jsoo_runtime,
-    zero = [254, 0., 0.],
-    one = [254, 1., 0.],
-    i = [254, 0., 1.],
-    _a_ = [254, 0., 0.];
-   function add(x, y){
-     /*<<complex.ml:24:14>>*/ return [254, x[1] + y[1], x[2] + y[2]];
-    /*<<complex.ml:24:54>>*/ }
-   function sub(x, y){
-     /*<<complex.ml:26:14>>*/ return [254, x[1] - y[1], x[2] - y[2]];
-    /*<<complex.ml:26:54>>*/ }
-   function neg(x){
-     /*<<complex.ml:28:12>>*/ return [254, - x[1], - x[2]];
-    /*<<complex.ml:28:42>>*/ }
-   function conj(x){
-     /*<<complex.ml:30:13>>*/ return [254, x[1], - x[2]];
-    /*<<complex.ml:30:40>>*/ }
-   function mul(x, y){
-     /*<<complex.ml:32:14>>*/ return [254,
-            x[1] * y[1] - x[2] * y[2],
-            x[1] * y[2] + x[2] * y[1]];
-    /*<<complex.ml:33:51>>*/ }
-   function div(x, y){
-     /*<<complex.ml:36:2>>*/ if
-     ( /*<<complex.ml:36:23>>*/ Math.abs(y[2])
-      <=  /*<<complex.ml:36:5>>*/ Math.abs(y[1])){
-      /*<<complex.ml:37:12>>*/ var
-       /*<<complex.ml:37:12>>*/ r = y[2] / y[1],
-       /*<<complex.ml:38:12>>*/ d = y[1] + r * y[2];
-      /*<<complex.ml:39:4>>*/ return [254,
-             (x[1] + r * x[2]) / d,
-             (x[2] - r * x[1]) / d];
-    }
-     /*<<complex.ml:42:12>>*/ var
-      /*<<complex.ml:42:12>>*/ r$0 = y[1] / y[2],
-      /*<<complex.ml:43:12>>*/ d$0 = y[2] + r$0 * y[1];
-     /*<<complex.ml:44:4>>*/ return [254,
-            (r$0 * x[1] + x[2]) / d$0,
-            (r$0 * x[2] - x[1]) / d$0];
-    /*<<complex.ml:45:37>>*/ }
-   function inv(x){
-     /*<<complex.ml:47:12>>*/ return div(one, x);
-    /*<<complex.ml:47:21>>*/ }
-   function norm2(x){
-     /*<<complex.ml:49:14>>*/ return x[1] * x[1] + x[2] * x[2];
-    /*<<complex.ml:49:42>>*/ }
-   function norm(x){
-     /*<<complex.ml:51:13>>*/ return  /*<<complex.ml:51:13>>*/ runtime.caml_hypot_float
-            (x[1], x[2]);
-    /*<<complex.ml:51:34>>*/ }
-   function arg(x){
-     /*<<complex.ml:53:12>>*/ return  /*<<complex.ml:53:12>>*/ Math.atan2
-            (x[2], x[1]);
-    /*<<complex.ml:53:27>>*/ }
-   function polar(n, a){
-     /*<<complex.ml:55:16>>*/ return [254,
-             /*<<complex.ml:55:23>>*/ Math.cos(a) * n,
-             /*<<complex.ml:55:40>>*/ Math.sin(a) * n];
-    /*<<complex.ml:55:52>>*/ }
-   function sqrt(x){
-     /*<<complex.ml:58:2>>*/ if(x[1] == 0. && x[2] == 0.)
-      /*<<complex.ml:58:35>>*/ return _a_;
-     /*<<complex.ml:60:12>>*/ var
-      /*<<complex.ml:60:12>>*/ r =  /*<<complex.ml:60:12>>*/ Math.abs(x[1]),
-      /*<<complex.ml:60:35>>*/ i =  /*<<complex.ml:60:35>>*/ Math.abs(x[2]);
-    if(i <= r)
-      /*<<complex.ml:63:16>>*/ var
-       /*<<complex.ml:63:16>>*/ q = i / r,
-      w =
-         /*<<complex.ml:64:8>>*/ Math.sqrt(r)
-        *
-          /*<<complex.ml:64:19>>*/ Math.sqrt
-          (0.5 * (1. +  /*<<complex.ml:64:39>>*/ Math.sqrt(1. + q * q)));
-    else
-      /*<<complex.ml:66:16>>*/ var
-       /*<<complex.ml:66:16>>*/ q$0 = r / i,
-      w =
-         /*<<complex.ml:67:8>>*/ Math.sqrt(i)
-        *
-          /*<<complex.ml:67:19>>*/ Math.sqrt
-          (0.5 * (q$0 +  /*<<complex.ml:67:37>>*/ Math.sqrt(1. + q$0 * q$0)));
-    if(0. <= x[1])  /*<<complex.ml:70:9>>*/ return [254, w, 0.5 * x[2] / w];
-    var w$0 = 0. <= x[2] ? w : - w;
-     /*<<complex.ml:71:9>>*/ return [254, 0.5 * i / w, w$0];
-    /*<<complex.ml:72:5>>*/ }
-   function exp(x){
-     /*<<complex.ml:75:2>>*/  /*<<complex.ml:75:10>>*/ var
-     e =  /*<<complex.ml:75:10>>*/ Math.exp(x[1]);
-     /*<<complex.ml:75:22>>*/ return [254,
-            e *  /*<<complex.ml:75:34>>*/ Math.cos(x[2]),
-            e *  /*<<complex.ml:75:54>>*/ Math.sin(x[2])];
-    /*<<complex.ml:75:64>>*/ }
-   function log(x){
-     /*<<complex.ml:77:12>>*/  /*<<complex.ml:77:38>>*/ var
-     _b_ =  /*<<complex.ml:77:38>>*/ Math.atan2(x[2], x[1]);
-     /*<<complex.ml:77:12>>*/ return [254,
-             /*<<complex.ml:77:19>>*/ Math.log(norm(x)),
-            _b_];
-    /*<<complex.ml:77:55>>*/ }
-   function pow(x, y){
-     /*<<complex.ml:79:14>>*/ return exp(mul(y, log(x)));
-    /*<<complex.ml:79:33>>*/ }
-   var
-    Stdlib_Complex =
-      [0,
-       zero,
-       one,
-       i,
-       neg,
-       conj,
-       add,
-       sub,
-       mul,
-       inv,
-       div,
-       sqrt,
-       norm2,
-       norm,
-       arg,
-       polar,
-       exp,
-       log,
-       pow];
-   runtime.caml_register_global(15, Stdlib_Complex, "Stdlib__Complex");
-   return;
-   /*<<?>>*/ }
-  (globalThis));
-
-//# unitInfo: Provides: Stdlib__ArrayLabels
-//# unitInfo: Requires: Stdlib__Array
-(function
-  (globalThis){
-   "use strict";
-   var
-    runtime = globalThis.jsoo_runtime,
-    global_data = runtime.caml_get_global_data(),
-    Stdlib_Array = global_data.Stdlib__Array,
-    init = Stdlib_Array[1],
-    make_matrix = Stdlib_Array[2],
-    append = Stdlib_Array[3],
-    concat = Stdlib_Array[4],
-    sub = Stdlib_Array[5],
-    copy = Stdlib_Array[6],
-    fill = Stdlib_Array[7],
-    blit = Stdlib_Array[8],
-    to_list = Stdlib_Array[9],
-    of_list = Stdlib_Array[10],
-    iter = Stdlib_Array[11],
-    iteri = Stdlib_Array[12],
-    map = Stdlib_Array[13],
-    mapi = Stdlib_Array[14],
-    fold_left = Stdlib_Array[15],
-    fold_left_map = Stdlib_Array[16],
-    fold_right = Stdlib_Array[17],
-    iter2 = Stdlib_Array[18],
-    map2 = Stdlib_Array[19],
-    for_all = Stdlib_Array[20],
-    exists = Stdlib_Array[21],
-    for_all2 = Stdlib_Array[22],
-    exists2 = Stdlib_Array[23],
-    mem = Stdlib_Array[24],
-    memq = Stdlib_Array[25],
-    find_opt = Stdlib_Array[26],
-    find_map = Stdlib_Array[27],
-    split = Stdlib_Array[28],
-    combine = Stdlib_Array[29],
-    sort = Stdlib_Array[30],
-    stable_sort = Stdlib_Array[31],
-    fast_sort = Stdlib_Array[32],
-    to_seq = Stdlib_Array[33],
-    to_seqi = Stdlib_Array[34],
-    of_seq = Stdlib_Array[35],
-    Floatarray = Stdlib_Array[36],
-    Stdlib_ArrayLabels =
-      [0,
-       init,
-       make_matrix,
-       append,
-       concat,
-       sub,
-       copy,
-       fill,
-       blit,
-       to_list,
-       of_list,
-       iter,
-       iteri,
-       map,
-       mapi,
-       fold_left,
-       fold_left_map,
-       fold_right,
-       iter2,
-       map2,
-       for_all,
-       exists,
-       for_all2,
-       exists2,
-       mem,
-       memq,
-       find_opt,
-       find_map,
-       split,
-       combine,
-       sort,
-       stable_sort,
-       fast_sort,
-       to_seq,
-       to_seqi,
-       of_seq,
-       Floatarray];
-   runtime.caml_register_global(1, Stdlib_ArrayLabels, "Stdlib__ArrayLabels");
-   return;
-   /*<<?>>*/ }
-  (globalThis));
-
-//# unitInfo: Provides: Stdlib__ListLabels
-//# unitInfo: Requires: Stdlib__List
-(function
-  (globalThis){
-   "use strict";
-   var
-    runtime = globalThis.jsoo_runtime,
-    global_data = runtime.caml_get_global_data(),
-    Stdlib_List = global_data.Stdlib__List,
-    length = Stdlib_List[1],
-    compare_lengths = Stdlib_List[2],
-    compare_length_with = Stdlib_List[3],
-    cons = Stdlib_List[4],
-    hd = Stdlib_List[5],
-    tl = Stdlib_List[6],
-    nth = Stdlib_List[7],
-    nth_opt = Stdlib_List[8],
-    rev = Stdlib_List[9],
-    init = Stdlib_List[10],
-    append = Stdlib_List[11],
-    rev_append = Stdlib_List[12],
-    concat = Stdlib_List[13],
-    flatten = Stdlib_List[14],
-    equal = Stdlib_List[15],
-    compare = Stdlib_List[16],
-    iter = Stdlib_List[17],
-    iteri = Stdlib_List[18],
-    map = Stdlib_List[19],
-    mapi = Stdlib_List[20],
-    rev_map = Stdlib_List[21],
-    filter_map = Stdlib_List[22],
-    concat_map = Stdlib_List[23],
-    fold_left_map = Stdlib_List[24],
-    fold_left = Stdlib_List[25],
-    fold_right = Stdlib_List[26],
-    iter2 = Stdlib_List[27],
-    map2 = Stdlib_List[28],
-    rev_map2 = Stdlib_List[29],
-    fold_left2 = Stdlib_List[30],
-    fold_right2 = Stdlib_List[31],
-    for_all = Stdlib_List[32],
-    exists = Stdlib_List[33],
-    for_all2 = Stdlib_List[34],
-    exists2 = Stdlib_List[35],
-    mem = Stdlib_List[36],
-    memq = Stdlib_List[37],
-    find = Stdlib_List[38],
-    find_opt = Stdlib_List[39],
-    find_map = Stdlib_List[40],
-    filter = Stdlib_List[41],
-    find_all = Stdlib_List[42],
-    filteri = Stdlib_List[43],
-    partition = Stdlib_List[44],
-    partition_map = Stdlib_List[45],
-    assoc = Stdlib_List[46],
-    assoc_opt = Stdlib_List[47],
-    assq = Stdlib_List[48],
-    assq_opt = Stdlib_List[49],
-    mem_assoc = Stdlib_List[50],
-    mem_assq = Stdlib_List[51],
-    remove_assoc = Stdlib_List[52],
-    remove_assq = Stdlib_List[53],
-    split = Stdlib_List[54],
-    combine = Stdlib_List[55],
-    sort = Stdlib_List[56],
-    stable_sort = Stdlib_List[57],
-    fast_sort = Stdlib_List[58],
-    sort_uniq = Stdlib_List[59],
-    merge = Stdlib_List[60],
-    to_seq = Stdlib_List[61],
-    of_seq = Stdlib_List[62],
-    Stdlib_ListLabels =
-      [0,
-       length,
-       compare_lengths,
-       compare_length_with,
-       cons,
-       hd,
-       tl,
-       nth,
-       nth_opt,
-       rev,
-       init,
-       append,
-       rev_append,
-       concat,
-       flatten,
-       equal,
-       compare,
-       iter,
-       iteri,
-       map,
-       mapi,
-       rev_map,
-       filter_map,
-       concat_map,
-       fold_left_map,
-       fold_left,
-       fold_right,
-       iter2,
-       map2,
-       rev_map2,
-       fold_left2,
-       fold_right2,
-       for_all,
-       exists,
-       for_all2,
-       exists2,
-       mem,
-       memq,
-       find,
-       find_opt,
-       find_map,
-       filter,
-       find_all,
-       filteri,
-       partition,
-       partition_map,
-       assoc,
-       assoc_opt,
-       assq,
-       assq_opt,
-       mem_assoc,
-       mem_assq,
-       remove_assoc,
-       remove_assq,
-       split,
-       combine,
-       sort,
-       stable_sort,
-       fast_sort,
-       sort_uniq,
-       merge,
-       to_seq,
-       of_seq];
-   runtime.caml_register_global(1, Stdlib_ListLabels, "Stdlib__ListLabels");
-   return;
-   /*<<?>>*/ }
-  (globalThis));
-
-//# unitInfo: Provides: Stdlib__BytesLabels
-//# unitInfo: Requires: Stdlib__Bytes
-(function
-  (globalThis){
-   "use strict";
-   var
-    runtime = globalThis.jsoo_runtime,
-    global_data = runtime.caml_get_global_data(),
-    Stdlib_Bytes = global_data.Stdlib__Bytes,
-    make = Stdlib_Bytes[1],
-    init = Stdlib_Bytes[2],
-    empty = Stdlib_Bytes[3],
-    copy = Stdlib_Bytes[4],
-    of_string = Stdlib_Bytes[5],
-    to_string = Stdlib_Bytes[6],
-    sub = Stdlib_Bytes[7],
-    sub_string = Stdlib_Bytes[8],
-    extend = Stdlib_Bytes[9],
-    fill = Stdlib_Bytes[10],
-    blit = Stdlib_Bytes[11],
-    blit_string = Stdlib_Bytes[12],
-    concat = Stdlib_Bytes[13],
-    cat = Stdlib_Bytes[14],
-    iter = Stdlib_Bytes[15],
-    iteri = Stdlib_Bytes[16],
-    map = Stdlib_Bytes[17],
-    mapi = Stdlib_Bytes[18],
-    fold_left = Stdlib_Bytes[19],
-    fold_right = Stdlib_Bytes[20],
-    for_all = Stdlib_Bytes[21],
-    exists = Stdlib_Bytes[22],
-    trim = Stdlib_Bytes[23],
-    escaped = Stdlib_Bytes[24],
-    index = Stdlib_Bytes[25],
-    index_opt = Stdlib_Bytes[26],
-    rindex = Stdlib_Bytes[27],
-    rindex_opt = Stdlib_Bytes[28],
-    index_from = Stdlib_Bytes[29],
-    index_from_opt = Stdlib_Bytes[30],
-    rindex_from = Stdlib_Bytes[31],
-    rindex_from_opt = Stdlib_Bytes[32],
-    contains = Stdlib_Bytes[33],
-    contains_from = Stdlib_Bytes[34],
-    rcontains_from = Stdlib_Bytes[35],
-    uppercase_ascii = Stdlib_Bytes[36],
-    lowercase_ascii = Stdlib_Bytes[37],
-    capitalize_ascii = Stdlib_Bytes[38],
-    uncapitalize_ascii = Stdlib_Bytes[39],
-    compare = Stdlib_Bytes[40],
-    equal = Stdlib_Bytes[41],
-    starts_with = Stdlib_Bytes[42],
-    ends_with = Stdlib_Bytes[43],
-    unsafe_to_string = Stdlib_Bytes[44],
-    unsafe_of_string = Stdlib_Bytes[45],
-    split_on_char = Stdlib_Bytes[46],
-    to_seq = Stdlib_Bytes[47],
-    to_seqi = Stdlib_Bytes[48],
-    of_seq = Stdlib_Bytes[49],
-    get_utf_8_uchar = Stdlib_Bytes[50],
-    set_utf_8_uchar = Stdlib_Bytes[51],
-    is_valid_utf_8 = Stdlib_Bytes[52],
-    get_utf_16be_uchar = Stdlib_Bytes[53],
-    set_utf_16be_uchar = Stdlib_Bytes[54],
-    is_valid_utf_16be = Stdlib_Bytes[55],
-    get_utf_16le_uchar = Stdlib_Bytes[56],
-    set_utf_16le_uchar = Stdlib_Bytes[57],
-    is_valid_utf_16le = Stdlib_Bytes[58],
-    get_uint8 = Stdlib_Bytes[59],
-    get_int8 = Stdlib_Bytes[60],
-    get_uint16_ne = Stdlib_Bytes[61],
-    get_uint16_be = Stdlib_Bytes[62],
-    get_uint16_le = Stdlib_Bytes[63],
-    get_int16_ne = Stdlib_Bytes[64],
-    get_int16_be = Stdlib_Bytes[65],
-    get_int16_le = Stdlib_Bytes[66],
-    get_int32_ne = Stdlib_Bytes[67],
-    get_int32_be = Stdlib_Bytes[68],
-    get_int32_le = Stdlib_Bytes[69],
-    get_int64_ne = Stdlib_Bytes[70],
-    get_int64_be = Stdlib_Bytes[71],
-    get_int64_le = Stdlib_Bytes[72],
-    set_uint8 = Stdlib_Bytes[73],
-    set_int8 = Stdlib_Bytes[74],
-    set_uint16_ne = Stdlib_Bytes[75],
-    set_uint16_be = Stdlib_Bytes[76],
-    set_uint16_le = Stdlib_Bytes[77],
-    set_int16_ne = Stdlib_Bytes[78],
-    set_int16_be = Stdlib_Bytes[79],
-    set_int16_le = Stdlib_Bytes[80],
-    set_int32_ne = Stdlib_Bytes[81],
-    set_int32_be = Stdlib_Bytes[82],
-    set_int32_le = Stdlib_Bytes[83],
-    set_int64_ne = Stdlib_Bytes[84],
-    set_int64_be = Stdlib_Bytes[85],
-    set_int64_le = Stdlib_Bytes[86],
-    unsafe_escape = Stdlib_Bytes[87],
-    Stdlib_BytesLabels =
-      [0,
-       make,
-       init,
-       empty,
-       copy,
-       of_string,
-       to_string,
-       sub,
-       sub_string,
-       extend,
-       fill,
-       blit,
-       blit_string,
-       concat,
-       cat,
-       iter,
-       iteri,
-       map,
-       mapi,
-       fold_left,
-       fold_right,
-       for_all,
-       exists,
-       trim,
-       escaped,
-       index,
-       index_opt,
-       rindex,
-       rindex_opt,
-       index_from,
-       index_from_opt,
-       rindex_from,
-       rindex_from_opt,
-       contains,
-       contains_from,
-       rcontains_from,
-       uppercase_ascii,
-       lowercase_ascii,
-       capitalize_ascii,
-       uncapitalize_ascii,
-       compare,
-       equal,
-       starts_with,
-       ends_with,
-       unsafe_to_string,
-       unsafe_of_string,
-       split_on_char,
-       to_seq,
-       to_seqi,
-       of_seq,
-       get_utf_8_uchar,
-       set_utf_8_uchar,
-       is_valid_utf_8,
-       get_utf_16be_uchar,
-       set_utf_16be_uchar,
-       is_valid_utf_16be,
-       get_utf_16le_uchar,
-       set_utf_16le_uchar,
-       is_valid_utf_16le,
-       get_uint8,
-       get_int8,
-       get_uint16_ne,
-       get_uint16_be,
-       get_uint16_le,
-       get_int16_ne,
-       get_int16_be,
-       get_int16_le,
-       get_int32_ne,
-       get_int32_be,
-       get_int32_le,
-       get_int64_ne,
-       get_int64_be,
-       get_int64_le,
-       set_uint8,
-       set_int8,
-       set_uint16_ne,
-       set_uint16_be,
-       set_uint16_le,
-       set_int16_ne,
-       set_int16_be,
-       set_int16_le,
-       set_int32_ne,
-       set_int32_be,
-       set_int32_le,
-       set_int64_ne,
-       set_int64_be,
-       set_int64_le,
-       unsafe_escape];
-   runtime.caml_register_global(1, Stdlib_BytesLabels, "Stdlib__BytesLabels");
-   return;
-   /*<<?>>*/ }
-  (globalThis));
-
-//# unitInfo: Provides: Stdlib__StringLabels
-//# unitInfo: Requires: Stdlib__String
-(function
-  (globalThis){
-   "use strict";
-   var
-    runtime = globalThis.jsoo_runtime,
-    global_data = runtime.caml_get_global_data(),
-    Stdlib_String = global_data.Stdlib__String,
-    make = Stdlib_String[1],
-    init = Stdlib_String[2],
-    empty = Stdlib_String[3],
-    of_bytes = Stdlib_String[4],
-    to_bytes = Stdlib_String[5],
-    concat = Stdlib_String[6],
-    cat = Stdlib_String[7],
-    equal = Stdlib_String[8],
-    compare = Stdlib_String[9],
-    starts_with = Stdlib_String[10],
-    ends_with = Stdlib_String[11],
-    contains_from = Stdlib_String[12],
-    rcontains_from = Stdlib_String[13],
-    contains = Stdlib_String[14],
-    sub = Stdlib_String[15],
-    split_on_char = Stdlib_String[16],
-    map = Stdlib_String[17],
-    mapi = Stdlib_String[18],
-    fold_left = Stdlib_String[19],
-    fold_right = Stdlib_String[20],
-    for_all = Stdlib_String[21],
-    exists = Stdlib_String[22],
-    trim = Stdlib_String[23],
-    escaped = Stdlib_String[24],
-    uppercase_ascii = Stdlib_String[25],
-    lowercase_ascii = Stdlib_String[26],
-    capitalize_ascii = Stdlib_String[27],
-    uncapitalize_ascii = Stdlib_String[28],
-    iter = Stdlib_String[29],
-    iteri = Stdlib_String[30],
-    index_from = Stdlib_String[31],
-    index_from_opt = Stdlib_String[32],
-    rindex_from = Stdlib_String[33],
-    rindex_from_opt = Stdlib_String[34],
-    index = Stdlib_String[35],
-    index_opt = Stdlib_String[36],
-    rindex = Stdlib_String[37],
-    rindex_opt = Stdlib_String[38],
-    to_seq = Stdlib_String[39],
-    to_seqi = Stdlib_String[40],
-    of_seq = Stdlib_String[41],
-    get_utf_8_uchar = Stdlib_String[42],
-    is_valid_utf_8 = Stdlib_String[43],
-    get_utf_16be_uchar = Stdlib_String[44],
-    is_valid_utf_16be = Stdlib_String[45],
-    get_utf_16le_uchar = Stdlib_String[46],
-    is_valid_utf_16le = Stdlib_String[47],
-    blit = Stdlib_String[48],
-    get_uint8 = Stdlib_String[49],
-    get_int8 = Stdlib_String[50],
-    get_uint16_ne = Stdlib_String[51],
-    get_uint16_be = Stdlib_String[52],
-    get_uint16_le = Stdlib_String[53],
-    get_int16_ne = Stdlib_String[54],
-    get_int16_be = Stdlib_String[55],
-    get_int16_le = Stdlib_String[56],
-    get_int32_ne = Stdlib_String[57],
-    hash = Stdlib_String[58],
-    seeded_hash = Stdlib_String[59],
-    get_int32_be = Stdlib_String[60],
-    get_int32_le = Stdlib_String[61],
-    get_int64_ne = Stdlib_String[62],
-    get_int64_be = Stdlib_String[63],
-    get_int64_le = Stdlib_String[64],
-    Stdlib_StringLabels =
-      [0,
-       make,
-       init,
-       empty,
-       of_bytes,
-       to_bytes,
-       concat,
-       cat,
-       equal,
-       compare,
-       starts_with,
-       ends_with,
-       contains_from,
-       rcontains_from,
-       contains,
-       sub,
-       split_on_char,
-       map,
-       mapi,
-       fold_left,
-       fold_right,
-       for_all,
-       exists,
-       trim,
-       escaped,
-       uppercase_ascii,
-       lowercase_ascii,
-       capitalize_ascii,
-       uncapitalize_ascii,
-       iter,
-       iteri,
-       index_from,
-       index_from_opt,
-       rindex_from,
-       rindex_from_opt,
-       index,
-       index_opt,
-       rindex,
-       rindex_opt,
-       to_seq,
-       to_seqi,
-       of_seq,
-       get_utf_8_uchar,
-       is_valid_utf_8,
-       get_utf_16be_uchar,
-       is_valid_utf_16be,
-       get_utf_16le_uchar,
-       is_valid_utf_16le,
-       blit,
-       get_uint8,
-       get_int8,
-       get_uint16_ne,
-       get_uint16_be,
-       get_uint16_le,
-       get_int16_ne,
-       get_int16_be,
-       get_int16_le,
-       get_int32_ne,
-       hash,
-       seeded_hash,
-       get_int32_be,
-       get_int32_le,
-       get_int64_ne,
-       get_int64_be,
-       get_int64_le];
-   runtime.caml_register_global
-    (1, Stdlib_StringLabels, "Stdlib__StringLabels");
-   return;
-   /*<<?>>*/ }
-  (globalThis));
-
-//# unitInfo: Provides: Stdlib__MoreLabels
-//# unitInfo: Requires: Stdlib__Hashtbl, Stdlib__Map, Stdlib__Set
-(function
-  (globalThis){
-   "use strict";
-   var
-    runtime = globalThis.jsoo_runtime,
-    global_data = runtime.caml_get_global_data(),
-    Stdlib_Set = global_data.Stdlib__Set,
-    Stdlib_Map = global_data.Stdlib__Map,
-    Stdlib_Hashtbl = global_data.Stdlib__Hashtbl,
-    Stdlib_MoreLabels = [0, Stdlib_Hashtbl, Stdlib_Map, Stdlib_Set];
-   runtime.caml_register_global(3, Stdlib_MoreLabels, "Stdlib__MoreLabels");
-   return;
-   /*<<?>>*/ }
-  (globalThis));
-
-//# unitInfo: Provides: Stdlib__StdLabels
-(function(globalThis){
-   "use strict";
-   var runtime = globalThis.jsoo_runtime, Stdlib_StdLabels = [0];
-   runtime.caml_register_global(0, Stdlib_StdLabels, "Stdlib__StdLabels");
-   return;
-   /*<<?>>*/ }
-  (globalThis));
-
-//# unitInfo: Provides: Stdlib__In_channel
-//# unitInfo: Requires: Stdlib, Stdlib__Bytes, Stdlib__Fun, Stdlib__Sys
-(function
-  (globalThis){
-   "use strict";
-   var
-    runtime = globalThis.jsoo_runtime,
-    caml_create_bytes = runtime.caml_create_bytes,
-    caml_maybe_attach_backtrace = runtime.caml_maybe_attach_backtrace,
-    caml_ml_bytes_length = runtime.caml_ml_bytes_length,
-    caml_wrap_exception = runtime.caml_wrap_exception;
-    /*<<?>>*/ function caml_call1(f, a0){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 1
-            ? f(a0)
-            : runtime.caml_call_gen(f, [a0]);
-   }
-    /*<<?>>*/ function caml_call2(f, a0, a1){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 2
-            ? f(a0, a1)
-            : runtime.caml_call_gen(f, [a0, a1]);
-   }
-    /*<<?>>*/ function caml_call3(f, a0, a1, a2){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 3
-            ? f(a0, a1, a2)
-            : runtime.caml_call_gen(f, [a0, a1, a2]);
-   }
-    /*<<?>>*/ function caml_call4(f, a0, a1, a2, a3){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 4
-            ? f(a0, a1, a2, a3)
-            : runtime.caml_call_gen(f, [a0, a1, a2, a3]);
-   }
-    /*<<?>>*/ function caml_call5(f, a0, a1, a2, a3, a4){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 5
-            ? f(a0, a1, a2, a3, a4)
-            : runtime.caml_call_gen(f, [a0, a1, a2, a3, a4]);
-   }
-   var
-    global_data = runtime.caml_get_global_data(),
-    Stdlib_Bytes = global_data.Stdlib__Bytes,
-    Stdlib = global_data.Stdlib,
-    Stdlib_Sys = global_data.Stdlib__Sys,
-    Stdlib_Fun = global_data.Stdlib__Fun,
-    stdin = Stdlib[38],
-    open_bin = Stdlib[80],
-    open_text = Stdlib[79],
-    open_gen = Stdlib[81],
-    cst_In_channel_input_all_chann =
-      "In_channel.input_all: channel content is larger than maximum string length",
-    _a_ = [0, 0];
-   function with_open(openfun, s, f){
-     /*<<in_channel.ml:35:2>>*/  /*<<in_channel.ml:35:11>>*/ var
-     ic =  /*<<in_channel.ml:35:11>>*/ caml_call1(openfun, s);
-    function _r_(param){
-      /*<<in_channel.ml:37:15>>*/ return  /*<<in_channel.ml:36:2>>*/ caml_call1
-             (f, ic);
-     /*<<in_channel.ml:37:19>>*/ }
-    function _s_(param){
-      /*<<in_channel.ml:36:34>>*/ return  /*<<in_channel.ml:37:4>>*/ caml_call1
-             (Stdlib[94], ic);
-     /*<<in_channel.ml:36:58>>*/ }
-     /*<<in_channel.ml:37:4>>*/ return  /*<<in_channel.ml:37:4>>*/ caml_call2
-            (Stdlib_Fun[4], _s_, _r_);
-    /*<<in_channel.ml:37:20>>*/ }
-   function with_open_bin(s, f){
-     /*<<in_channel.ml:40:2>>*/ return with_open(Stdlib[80], s, f);
-    /*<<in_channel.ml:40:34>>*/ }
-   function with_open_text(s, f){
-     /*<<in_channel.ml:43:2>>*/ return with_open(Stdlib[79], s, f);
-    /*<<in_channel.ml:43:30>>*/ }
-   function with_open_gen(flags, perm, s, f){
-     /*<<in_channel.ml:46:2>>*/ return with_open
-            ( /*<<in_channel.ml:46:12>>*/ caml_call2(Stdlib[81], flags, perm),
-             s,
-             f);
-    /*<<in_channel.ml:46:47>>*/ }
-   var
-    seek = Stdlib[96][4],
-    pos = Stdlib[96][5],
-    length = Stdlib[96][6],
-    close = Stdlib[93],
-    close_noerr = Stdlib[94];
-   function input_char(ic){
-     /*<<in_channel.ml:55:2>>*/ try{
-      /*<<in_channel.ml:55:8>>*/  /*<<in_channel.ml:55:8>>*/ var
-      c =  /*<<in_channel.ml:55:8>>*/ caml_call1(Stdlib[82], ic);
-    }
-    catch(_q_){
-     var _p_ = caml_wrap_exception(_q_);
-     if(_p_ === Stdlib[12])  /*<<in_channel.ml:57:29>>*/ return 0;
-     throw caml_maybe_attach_backtrace(_p_, 0);
-    }
-     /*<<in_channel.ml:56:9>>*/ return [0, c];
-    /*<<in_channel.ml:57:33>>*/ }
-   function input_byte(ic){
-     /*<<in_channel.ml:60:2>>*/ try{
-      /*<<in_channel.ml:60:8>>*/  /*<<in_channel.ml:60:8>>*/ var
-      n =  /*<<in_channel.ml:60:8>>*/ caml_call1(Stdlib[87], ic);
-    }
-    catch(_o_){
-     var _n_ = caml_wrap_exception(_o_);
-     if(_n_ === Stdlib[12])  /*<<in_channel.ml:62:29>>*/ return 0;
-     throw caml_maybe_attach_backtrace(_n_, 0);
-    }
-     /*<<in_channel.ml:61:9>>*/ return [0, n];
-    /*<<in_channel.ml:62:33>>*/ }
-   function input_line(ic){
-     /*<<in_channel.ml:65:2>>*/ try{
-      /*<<in_channel.ml:65:8>>*/  /*<<in_channel.ml:65:8>>*/ var
-      s =  /*<<in_channel.ml:65:8>>*/ caml_call1(Stdlib[83], ic);
-    }
-    catch(_m_){
-     var _l_ = caml_wrap_exception(_m_);
-     if(_l_ === Stdlib[12])  /*<<in_channel.ml:67:29>>*/ return 0;
-     throw caml_maybe_attach_backtrace(_l_, 0);
-    }
-     /*<<in_channel.ml:66:9>>*/ return [0, s];
-    /*<<in_channel.ml:67:33>>*/ }
-   var input = Stdlib[84];
-   function really_input(ic, buf, pos, len){
-     /*<<in_channel.ml:72:2>>*/ try{
-      /*<<in_channel.ml:72:8>>*/  /*<<in_channel.ml:72:8>>*/ caml_call4
-      (Stdlib[85], ic, buf, pos, len);
-      /*<<in_channel.ml:73:10>>*/ return _a_;
-    }
-    catch(_k_){
-     var _j_ = caml_wrap_exception(_k_);
-     if(_j_ === Stdlib[12])  /*<<in_channel.ml:74:29>>*/ return 0;
-     throw caml_maybe_attach_backtrace(_j_, 0);
-    }
-    /*<<in_channel.ml:74:33>>*/ }
-   function really_input_string(ic, len){
-     /*<<in_channel.ml:77:2>>*/ try{
-      /*<<in_channel.ml:77:8>>*/  /*<<in_channel.ml:77:8>>*/ var
-      s =  /*<<in_channel.ml:77:8>>*/ caml_call2(Stdlib[86], ic, len);
-    }
-    catch(_i_){
-     var _h_ = caml_wrap_exception(_i_);
-     if(_h_ === Stdlib[12])  /*<<in_channel.ml:79:29>>*/ return 0;
-     throw caml_maybe_attach_backtrace(_h_, 0);
-    }
-     /*<<in_channel.ml:78:9>>*/ return [0, s];
-    /*<<in_channel.ml:79:33>>*/ }
-   function read_upto(ic, buf, ofs, len){
-     /*<<in_channel.ml:84:2>>*/ var ofs$0 = ofs, len$0 = len;
-     /*<<in_channel.ml:85:4>>*/ for(;;){
-     if(0 !== len$0){
-       /*<<in_channel.ml:87:14>>*/  /*<<in_channel.ml:87:14>>*/ var
-       r =
-          /*<<in_channel.ml:87:14>>*/ caml_call4
-          (Stdlib[84], ic, buf, ofs$0, len$0);
-       /*<<in_channel.ml:88:6>>*/ if(0 !== r){
-       var
-        len$1 = len$0 - r | 0,
-        ofs$1 = ofs$0 + r | 0,
-        ofs$0 = ofs$1,
-        len$0 = len$1;
-       continue;
-      }
-     }
-      /*<<in_channel.ml:94:2>>*/ return ofs$0 - ofs | 0;
-    }
-    /*<<in_channel.ml:94:20>>*/ }
-   function ensure(buf, ofs, n){
-     /*<<in_channel.ml:109:2>>*/ var len = caml_ml_bytes_length(buf);
-    if((ofs + n | 0) <= len)  /*<<in_channel.ml:110:25>>*/ return buf;
-     /*<<in_channel.ml:112:18>>*/  /*<<in_channel.ml:112:18>>*/ var
-     new_len = [0, len];
-    for(;;){
-     if(new_len[1] >= (ofs + n | 0)){
-       /*<<in_channel.ml:126:18>>*/ var
-       new_len$0 = new_len[1],
-       new_len$1 =
-         new_len$0 <= Stdlib_Sys[12]
-          ? new_len$0
-          : ofs
-            < Stdlib_Sys[12]
-            ? Stdlib_Sys[12]
-            :  /*<<in_channel.ml:123:8>>*/ caml_call1
-              (Stdlib[2], cst_In_channel_input_all_chann),
-        /*<<in_channel.ml:126:18>>*/ new_buf =
-          /*<<in_channel.ml:126:18>>*/ caml_create_bytes(new_len$1);
-       /*<<in_channel.ml:127:4>>*/  /*<<in_channel.ml:127:4>>*/ caml_call5
-       (Stdlib_Bytes[11], buf, 0, new_buf, 0, ofs);
-       /*<<in_channel.ml:127:4>>*/ return new_buf;
-     }
-     new_len[1] = (2 * new_len[1] | 0) + 1 | 0;
-    }
-    /*<<in_channel.ml:129:5>>*/ }
-   function input_all(ic){
-     /*<<in_channel.ml:132:2>>*/  /*<<in_channel.ml:132:2>>*/ var
-     chunk_size = 65536;
-     /*<<in_channel.ml:133:2>>*/ try{
-      /*<<in_channel.ml:135:36>>*/ var
-       /*<<in_channel.ml:135:36>>*/ _d_ =
-         /*<<in_channel.ml:135:36>>*/ caml_call1(Stdlib[91], ic),
-       /*<<in_channel.ml:135:6>>*/ _e_ =
-         /*<<in_channel.ml:135:6>>*/ caml_call1(Stdlib[92], ic) - _d_ | 0,
-      initial_size = _e_;
-    }
-    catch(_g_){
-     var _b_ = caml_wrap_exception(_g_);
-     if(_b_[1] !== Stdlib[11]) throw caml_maybe_attach_backtrace(_b_, 0);
-     var initial_size = -1;
-    }
-     /*<<in_channel.ml:139:2>>*/ var
-      /*<<in_channel.ml:139:2>>*/ initial_size$0 =
-       0 <= initial_size ? initial_size : chunk_size,
-     initial_size$1 =
-       initial_size$0 <= Stdlib_Sys[12] ? initial_size$0 : Stdlib_Sys[12],
-      /*<<in_channel.ml:146:12>>*/ buf =
-        /*<<in_channel.ml:146:12>>*/ caml_create_bytes(initial_size$1),
-      /*<<in_channel.ml:147:14>>*/ nread =
-       read_upto(ic, buf, 0, initial_size$1);
-    if(nread < initial_size$1)
-      /*<<in_channel.ml:149:4>>*/ return  /*<<in_channel.ml:149:4>>*/ caml_call3
-             (Stdlib_Bytes[8], buf, 0, nread);
-     /*<<in_channel.ml:150:7>>*/ try{
-      /*<<in_channel.ml:151:10>>*/  /*<<in_channel.ml:151:10>>*/ var
-      c =  /*<<in_channel.ml:151:10>>*/ caml_call1(Stdlib[82], ic);
-    }
-    catch(_f_){
-     var _c_ = caml_wrap_exception(_f_);
-     if(_c_ === Stdlib[12])
-       /*<<in_channel.ml:154:8>>*/ return  /*<<in_channel.ml:154:8>>*/ caml_call1
-              (Stdlib_Bytes[44], buf);
-     throw caml_maybe_attach_backtrace(_c_, 0);
-    }
-     /*<<in_channel.ml:168:18>>*/  /*<<in_channel.ml:168:18>>*/ var
-     buf$2 = ensure(buf, nread, 65537);
-     /*<<in_channel.ml:169:8>>*/  /*<<in_channel.ml:169:8>>*/ runtime.caml_bytes_set
-     (buf$2, nread, c);
-     /*<<in_channel.ml:169:8>>*/ var
-      /*<<in_channel.ml:169:8>>*/ ofs$1 = nread + 1 | 0,
-     buf$0 = buf$2,
-     ofs = ofs$1;
-     /*<<in_channel.ml:158:10>>*/ for(;;){
-      /*<<in_channel.ml:158:20>>*/ var
-       /*<<in_channel.ml:158:20>>*/ buf$1 = ensure(buf$0, ofs, chunk_size),
-      rem = caml_ml_bytes_length(buf$1) - ofs | 0,
-       /*<<in_channel.ml:162:18>>*/ r = read_upto(ic, buf$1, ofs, rem);
-     if(r < rem)
-       /*<<in_channel.ml:158:20>>*/ return  /*<<in_channel.ml:158:20>>*/ caml_call3
-              (Stdlib_Bytes[8], buf$1, 0, ofs + r | 0);
-     var ofs$0 = ofs + rem | 0, buf$0 = buf$1, ofs = ofs$0;
-    }
-    /*<<in_channel.ml:171:5>>*/ }
-   var
-    set_binary_mode = Stdlib[95],
-    Stdlib_In_channel =
-      [0,
-       stdin,
-       open_bin,
-       open_text,
-       open_gen,
-       with_open_bin,
-       with_open_text,
-       with_open_gen,
-       seek,
-       pos,
-       length,
-       close,
-       close_noerr,
-       input_char,
-       input_byte,
-       input_line,
-       input,
-       really_input,
-       really_input_string,
-       input_all,
-       set_binary_mode];
-   runtime.caml_register_global(6, Stdlib_In_channel, "Stdlib__In_channel");
-   return;
-   /*<<?>>*/ }
-  (globalThis));
-
-//# unitInfo: Provides: Stdlib__Out_channel
-//# unitInfo: Requires: Stdlib, Stdlib__Fun
-(function
-  (globalThis){
-   "use strict";
-   var runtime = globalThis.jsoo_runtime;
-    /*<<?>>*/ function caml_call1(f, a0){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 1
-            ? f(a0)
-            : runtime.caml_call_gen(f, [a0]);
-   }
-    /*<<?>>*/ function caml_call2(f, a0, a1){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 2
-            ? f(a0, a1)
-            : runtime.caml_call_gen(f, [a0, a1]);
-   }
-   var
-    global_data = runtime.caml_get_global_data(),
-    Stdlib = global_data.Stdlib,
-    Stdlib_Fun = global_data.Stdlib__Fun,
-    stdout = Stdlib[39],
-    stderr = Stdlib[40],
-    open_bin = Stdlib[61],
-    open_text = Stdlib[60],
-    open_gen = Stdlib[62];
-   function with_open(openfun, s, f){
-     /*<<out_channel.ml:36:2>>*/  /*<<out_channel.ml:36:11>>*/ var
-     oc =  /*<<out_channel.ml:36:11>>*/ caml_call1(openfun, s);
-    function _a_(param){
-      /*<<out_channel.ml:38:15>>*/ return  /*<<out_channel.ml:37:2>>*/ caml_call1
-             (f, oc);
-     /*<<out_channel.ml:38:19>>*/ }
-    function _b_(param){
-      /*<<out_channel.ml:37:34>>*/ return  /*<<out_channel.ml:38:4>>*/ caml_call1
-             (Stdlib[77], oc);
-     /*<<out_channel.ml:37:59>>*/ }
-     /*<<out_channel.ml:38:4>>*/ return  /*<<out_channel.ml:38:4>>*/ caml_call2
-            (Stdlib_Fun[4], _b_, _a_);
-    /*<<out_channel.ml:38:20>>*/ }
-   function with_open_bin(s, f){
-     /*<<out_channel.ml:41:2>>*/ return with_open(Stdlib[61], s, f);
-    /*<<out_channel.ml:41:35>>*/ }
-   function with_open_text(s, f){
-     /*<<out_channel.ml:44:2>>*/ return with_open(Stdlib[60], s, f);
-    /*<<out_channel.ml:44:31>>*/ }
-   function with_open_gen(flags, perm, s, f){
-     /*<<out_channel.ml:47:2>>*/ return with_open
-            ( /*<<out_channel.ml:47:12>>*/ caml_call2(Stdlib[62], flags, perm),
-             s,
-             f);
-    /*<<out_channel.ml:47:48>>*/ }
-   var
-    seek = Stdlib[96][1],
-    pos = Stdlib[96][2],
-    length = Stdlib[96][3],
-    close = Stdlib[76],
-    close_noerr = Stdlib[77],
-    flush = Stdlib[63],
-    flush_all = Stdlib[64],
-    output_char = Stdlib[65],
-    output_byte = Stdlib[70],
-    output_string = Stdlib[66],
-    output_bytes = Stdlib[67],
-    output = Stdlib[68],
-    output_substring = Stdlib[69],
-    set_binary_mode = Stdlib[78],
-    Stdlib_Out_channel =
-      [0,
-       stdout,
-       stderr,
-       open_bin,
-       open_text,
-       open_gen,
-       with_open_bin,
-       with_open_text,
-       with_open_gen,
-       seek,
-       pos,
-       length,
-       close,
-       close_noerr,
-       flush,
-       flush_all,
-       output_char,
-       output_byte,
-       output_string,
-       output_bytes,
-       output,
-       output_substring,
-       set_binary_mode,
-       runtime.caml_ml_set_buffered,
-       runtime.caml_ml_is_buffered];
-   runtime.caml_register_global(2, Stdlib_Out_channel, "Stdlib__Out_channel");
-   return;
-   /*<<?>>*/ }
-  (globalThis));
-
-//# unitInfo: Provides: Stdlib__Effect
-//# unitInfo: Requires: Stdlib, Stdlib__Callback, Stdlib__Printexc, Stdlib__Printf
-//# unitInfo: Effects_without_cps: true
-(function
-  (globalThis){
-   "use strict";
-   var
-    runtime = globalThis.jsoo_runtime,
-    caml_alloc_stack = runtime.caml_alloc_stack,
-    caml_continuation_use_noexc = runtime.caml_continuation_use_noexc,
-    caml_fresh_oo_id = runtime.caml_fresh_oo_id,
-    caml_maybe_attach_backtrace = runtime.caml_maybe_attach_backtrace,
-    caml_restore_raw_backtrace = runtime.caml_restore_raw_backtrace,
-    caml_wrap_exception = runtime.caml_wrap_exception,
-    jsoo_effect_not_supported = runtime.jsoo_effect_not_supported;
-    /*<<?>>*/ function caml_call1(f, a0){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 1
-            ? f(a0)
-            : runtime.caml_call_gen(f, [a0]);
-   }
-    /*<<?>>*/ function caml_call2(f, a0, a1){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 2
-            ? f(a0, a1)
-            : runtime.caml_call_gen(f, [a0, a1]);
-   }
-    /*<<effect.ml:18:12>>*/ var
-    global_data = runtime.caml_get_global_data(),
-    Stdlib = global_data.Stdlib,
-    Stdlib_Printexc = global_data.Stdlib__Printexc,
-    Stdlib_Printf = global_data.Stdlib__Printf,
-    Stdlib_Callback = global_data.Stdlib__Callback,
-     /*<<effect.ml:18:12>>*/ Unhandled =
-      [248, "Stdlib.Effect.Unhandled", caml_fresh_oo_id(0)],
-     /*<<effect.ml:19:0>>*/ Continuation_already_resumed =
-      [248, "Stdlib.Effect.Continuation_already_resumed", caml_fresh_oo_id(0)],
-    cst_impossible = "impossible",
-    cst_Initial_setup = "Initial_setup__",
-    cst_E = "E",
-    _a_ =
-      [0,
-       [11, "Stdlib.Effect.Unhandled(", [2, 0, [12, 41, 0]]],
-       "Stdlib.Effect.Unhandled(%s)"],
-    cst_Stdlib_Effect_Should_not_s = "Stdlib.Effect.Should_not_see_this__",
-    cst_Effect_Unhandled = "Effect.Unhandled",
-    cst_Effect_Continuation_alread = "Effect.Continuation_already_resumed";
-   function printer(param){
-     /*<<effect.ml:22:16>>*/ if(param[1] !== Unhandled)
-      /*<<effect.ml:28:11>>*/ return 0;
-     /*<<effect.ml:25:12>>*/ var
-     x = param[2],
-      /*<<effect.ml:25:12>>*/ _j_ =
-        /*<<effect.ml:25:12>>*/ caml_call1(Stdlib_Printexc[26], x),
-      /*<<effect.ml:24:18>>*/ msg =
-        /*<<effect.ml:24:18>>*/ caml_call2(Stdlib_Printf[4], _a_, _j_);
-     /*<<effect.ml:27:8>>*/ return [0, msg];
-    /*<<effect.ml:28:15>>*/ }
-    /*<<effect.ml:30:2>>*/  /*<<effect.ml:30:2>>*/ caml_call1
-    (Stdlib_Printexc[9], printer);
-    /*<<effect.ml:33:12>>*/  /*<<effect.ml:33:12>>*/ var
-    Should_not_see_this =
-      [248, cst_Stdlib_Effect_Should_not_s, caml_fresh_oo_id(0)];
-    /*<<effect.ml:34:8>>*/  /*<<effect.ml:34:8>>*/ caml_call2
-    (Stdlib_Callback[2],
-     cst_Effect_Unhandled,
-     [0, Unhandled, Should_not_see_this]);
-    /*<<effect.ml:36:8>>*/  /*<<effect.ml:36:8>>*/ caml_call2
-    (Stdlib_Callback[2],
-     cst_Effect_Continuation_alread,
-     Continuation_already_resumed);
-    /*<<effect.ml:36:8>>*/ function continue$0(k, v){
-    function _h_(x){
-      /*<<effect.ml:57:58>>*/ return x;
-     /*<<effect.ml:57:59>>*/ }
-     /*<<effect.ml:57:28>>*/  /*<<effect.ml:57:28>>*/ var
-     _i_ =  /*<<effect.ml:57:28>>*/ caml_continuation_use_noexc(k);
-     /*<<effect.ml:57:28>>*/ return  /*<<effect.ml:57:28>>*/ jsoo_effect_not_supported
-            ();
-    /*<<effect.ml:57:62>>*/ }
-   function discontinue(k, e){
-    function _f_(e){
-      /*<<effect.ml:59:61>>*/ throw  /*<<effect.ml:59:61>>*/ caml_maybe_attach_backtrace
-            (e, 1);
-     /*<<effect.ml:59:68>>*/ }
-     /*<<effect.ml:59:31>>*/  /*<<effect.ml:59:31>>*/ var
-     _g_ =  /*<<effect.ml:59:31>>*/ caml_continuation_use_noexc(k);
-     /*<<effect.ml:59:31>>*/ return  /*<<effect.ml:59:31>>*/ jsoo_effect_not_supported
-            ();
-    /*<<effect.ml:59:71>>*/ }
-   function discontinue_with_backtrace(k, e, bt){
-    function _d_(e){
-      /*<<effect.ml:62:4>>*/ caml_restore_raw_backtrace(e, bt);
-      /*<<effect.ml:62:4>>*/ throw  /*<<effect.ml:62:4>>*/ caml_maybe_attach_backtrace
-            (e, 0);
-     /*<<effect.ml:62:38>>*/ }
-     /*<<effect.ml:61:49>>*/  /*<<effect.ml:61:49>>*/ var
-     _e_ =  /*<<effect.ml:61:49>>*/ caml_continuation_use_noexc(k);
-     /*<<effect.ml:61:49>>*/ return  /*<<effect.ml:61:49>>*/ jsoo_effect_not_supported
-            ();
-    /*<<effect.ml:62:41>>*/ }
-   function match_with(comp, arg, handler){
-    function effc(eff, k, last_fiber){
-      /*<<effect.ml:74:6>>*/  /*<<effect.ml:74:12>>*/ var
-      match =  /*<<effect.ml:74:12>>*/ caml_call1(handler[3], eff);
-     if(! match)
-       /*<<effect.ml:76:16>>*/ return  /*<<effect.ml:76:16>>*/ jsoo_effect_not_supported
-              ();
-     var f = match[1];
-      /*<<effect.ml:75:18>>*/ return  /*<<effect.ml:75:18>>*/ caml_call1(f, k);
-     /*<<effect.ml:76:42>>*/ }
-     /*<<effect.ml:78:12>>*/  /*<<effect.ml:78:12>>*/ var
-     s =
-        /*<<effect.ml:78:12>>*/ caml_alloc_stack(handler[1], handler[2], effc);
-     /*<<effect.ml:79:4>>*/ return  /*<<effect.ml:79:4>>*/ jsoo_effect_not_supported
-            ();
-    /*<<effect.ml:79:23>>*/ }
-   function try_with(comp, arg, handler){
-    function effc(eff, k, last_fiber){
-      /*<<effect.ml:86:6>>*/  /*<<effect.ml:86:12>>*/ var
-      match =  /*<<effect.ml:86:12>>*/ caml_call1(handler[1], eff);
-     if(! match)
-       /*<<effect.ml:88:16>>*/ return  /*<<effect.ml:88:16>>*/ jsoo_effect_not_supported
-              ();
-     var f = match[1];
-      /*<<effect.ml:87:18>>*/ return  /*<<effect.ml:87:18>>*/ caml_call1(f, k);
-     /*<<effect.ml:88:42>>*/ }
-    function _c_(e){
-      /*<<effect.ml:90:47>>*/ throw  /*<<effect.ml:90:47>>*/ caml_maybe_attach_backtrace
-            (e, 1);
-     /*<<effect.ml:90:54>>*/ }
-     /*<<effect.ml:90:12>>*/  /*<<effect.ml:90:12>>*/ var
-     s =
-        /*<<effect.ml:90:12>>*/ caml_alloc_stack
-        (function(x){
-           /*<<effect.ml:90:34>>*/ return x;
-          /*<<effect.ml:90:35>>*/ },
-         _c_,
-         effc);
-     /*<<effect.ml:91:4>>*/ return  /*<<effect.ml:91:4>>*/ jsoo_effect_not_supported
-            ();
-    /*<<effect.ml:91:23>>*/ }
-    /*<<effect.ml:44:14>>*/  /*<<effect.ml:44:14>>*/ var
-    Deep =
-      [0,
-       continue$0,
-       discontinue,
-       discontinue_with_backtrace,
-       match_with,
-       try_with];
-   function fiber(f){
-     /*<<effect.ml:111:4>>*/ var
-      /*<<effect.ml:111:38>>*/ Initial_setup =
-       [248, cst_Initial_setup, caml_fresh_oo_id(0)],
-      /*<<effect.ml:112:18>>*/ E = [248, cst_E, caml_fresh_oo_id(0)];
-    function f$0(param){
-      /*<<effect.ml:113:16>>*/ return  /*<<effect.ml:113:18>>*/ caml_call1
-             (f,  /*<<effect.ml:113:18>>*/ jsoo_effect_not_supported());
-     /*<<effect.ml:113:45>>*/ }
-     /*<<effect.ml:114:4>>*/ function error(param){
-      /*<<effect.ml:114:18>>*/ return  /*<<effect.ml:114:18>>*/ caml_call1
-             (Stdlib[2], cst_impossible);
-     /*<<effect.ml:114:39>>*/ }
-    function effc(eff, k, last_fiber){
-      /*<<effect.ml:116:6>>*/ if(eff === Initial_setup)
-       /*<<effect.ml:117:29>>*/ throw [0, E, k];
-      /*<<effect.ml:118:13>>*/ return error(0);
-     /*<<effect.ml:118:21>>*/ }
-     /*<<effect.ml:120:12>>*/  /*<<effect.ml:120:12>>*/ var
-     s =  /*<<effect.ml:120:12>>*/ caml_alloc_stack(error, error, effc);
-     /*<<effect.ml:121:4>>*/ try{
-      /*<<effect.ml:121:10>>*/  /*<<effect.ml:121:10>>*/ jsoo_effect_not_supported
-      ();
-     var _b_ = 0;
-    }
-    catch(exn$0){
-     var exn = caml_wrap_exception(exn$0);
-     if(exn[1] !== E) throw caml_maybe_attach_backtrace(exn, 0);
-     var k = exn[2];
-      /*<<effect.ml:122:23>>*/ return k;
-    }
-     /*<<effect.ml:123:11>>*/ return error(0);
-    /*<<effect.ml:123:19>>*/ }
-   function continue_gen(k, resume_fun, v, handler){
-    function effc(eff, k, last_fiber){
-      /*<<effect.ml:142:6>>*/  /*<<effect.ml:142:12>>*/ var
-      match =  /*<<effect.ml:142:12>>*/ caml_call1(handler[3], eff);
-     if(! match)
-       /*<<effect.ml:144:16>>*/ return  /*<<effect.ml:144:16>>*/ jsoo_effect_not_supported
-              ();
-     var f = match[1];
-      /*<<effect.ml:143:18>>*/ return  /*<<effect.ml:143:18>>*/ caml_call1
-             (f, k);
-     /*<<effect.ml:144:42>>*/ }
-     /*<<effect.ml:146:16>>*/  /*<<effect.ml:146:16>>*/ var
-     stack =
-        /*<<effect.ml:146:16>>*/ runtime.caml_continuation_use_and_update_handler_noexc
-        (k, handler[1], handler[2], effc);
-     /*<<effect.ml:147:4>>*/ return  /*<<effect.ml:147:4>>*/ jsoo_effect_not_supported
-            ();
-    /*<<effect.ml:147:29>>*/ }
-   function continue_with(k, v, handler){
-     /*<<effect.ml:150:4>>*/ return continue_gen
-            (k,
-             function(x){
-               /*<<effect.ml:150:29>>*/ return x;
-              /*<<effect.ml:150:30>>*/ },
-             v,
-             handler);
-    /*<<effect.ml:150:41>>*/ }
-   function discontinue_with(k, v, handler){
-     /*<<effect.ml:153:4>>*/ return continue_gen
-            (k,
-             function(e){
-               /*<<effect.ml:153:29>>*/ throw  /*<<effect.ml:153:29>>*/ caml_maybe_attach_backtrace
-                     (e, 1);
-              /*<<effect.ml:153:36>>*/ },
-             v,
-             handler);
-    /*<<effect.ml:153:47>>*/ }
-   function discontinue_with_backtrace$0(k, v, bt, handler){
-     /*<<effect.ml:156:4>>*/ return continue_gen
-            (k,
-             function(e){
-               /*<<effect.ml:156:29>>*/ caml_restore_raw_backtrace(e, bt);
-               /*<<effect.ml:156:29>>*/ throw  /*<<effect.ml:156:29>>*/ caml_maybe_attach_backtrace
-                     (e, 0);
-              /*<<effect.ml:156:63>>*/ },
-             v,
-             handler);
-    /*<<effect.ml:156:74>>*/ }
-   var
-    Stdlib_Effect =
-      [0,
-       Unhandled,
-       Continuation_already_resumed,
-       Deep,
-       [0,
-        fiber,
-        continue_with,
-        discontinue_with,
-        discontinue_with_backtrace$0]];
-   runtime.caml_register_global(13, Stdlib_Effect, "Stdlib__Effect");
-   return;
-   /*<<?>>*/ }
-  (globalThis));
diff --git a/testing/dead_field.js b/testing/dead_field.js
deleted file mode 100644
index c9c740a5b2..0000000000
--- a/testing/dead_field.js
+++ /dev/null
@@ -1,29 +0,0 @@
-// Generated by js_of_ocaml
-//# buildInfo:effects=false, kind=cmo, use-js-string=true, version=5.4.0+git-5.2.0-99-g50bcd077-dirty
-
-//# unitInfo: Provides: Dead_field
-//# unitInfo: Requires: Stdlib
-(function
-  (globalThis){
-   "use strict";
-   var runtime = globalThis.jsoo_runtime;
-   function caml_call1(f, a0){
-    return (f.l >= 0 ? f.l : f.l = f.length) == 1
-            ? f(a0)
-            : runtime.caml_call_gen(f, [a0]);
-   }
-   var
-    _d_ = undefined,
-    global_data = runtime.caml_get_global_data(),
-    Stdlib = global_data.Stdlib;
-   function _a_(_f_, _e_){
-    var _g_ = _f_ ? [0, 1, _d_, _e_] : [0, 3, _d_, 4];
-    return [0, _g_[1], _g_[3]];
-   }
-   var _b_ = _a_(0, 2)[2], _c_ = _a_(1, 1)[1] + _b_ | 0;
-   caml_call1(Stdlib[44], _c_);
-   var Dead_field = [0];
-   runtime.caml_register_global(1, Dead_field, "Dead_field");
-   return;
-  }
-  (globalThis));

From 658dcb0dcadbfc6ec7db1d4824b797e8c4ff06bc Mon Sep 17 00:00:00 2001
From: Micah Cantor <micahcantor01@gmail.com>
Date: Wed, 4 Oct 2023 11:41:22 -0500
Subject: [PATCH 084/112] Move documentation

---
 compiler/lib/global_deadcode.ml  | 10 ----------
 compiler/lib/global_deadcode.mli | 13 +++++++++++++
 2 files changed, 13 insertions(+), 10 deletions(-)

diff --git a/compiler/lib/global_deadcode.ml b/compiler/lib/global_deadcode.ml
index 2022864a8d..525c31a26a 100644
--- a/compiler/lib/global_deadcode.ml
+++ b/compiler/lib/global_deadcode.ml
@@ -14,16 +14,6 @@
  * You should have received a copy of the GNU Lesser General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
-
- This module provides a global liveness analysis more powerful than that found in [deadcode.ml]. In particular,
- this analysis annotates blocks with the specific fields that are live. It also uses [global_flow.ml] to determine
- the liveness of function return values. It first computes an initial liveness of each variable by traversing the program IR.
- Then it propagates this information to the dependencies of each variable using a flow analysis solver. Lastly it replaces
- dead variables with a sentinal zero variable.
-
- Although this module does not perform any dead-code elimination itself, it is designed to be used to identify and substitute 
- dead variables that are then removed by [deadcode.ml]. In particular it can allow the elimination of unused functions defined 
- in functors, which the original deadcode elimination cannot. 
  *)
 
 open Code
diff --git a/compiler/lib/global_deadcode.mli b/compiler/lib/global_deadcode.mli
index ccb1b6c0b6..b5b94e7cbe 100644
--- a/compiler/lib/global_deadcode.mli
+++ b/compiler/lib/global_deadcode.mli
@@ -16,6 +16,19 @@
  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  *)
 
+(** Global deadcode elimination pass.
+
+This module provides a global liveness analysis more powerful than that found in [deadcode.ml]. In particular,
+this analysis annotates blocks with the specific fields that are live. It also uses [global_flow.ml] to determine
+the liveness of function return values. It first computes an initial liveness of each variable by traversing the program IR.
+Then it propagates this information to the dependencies of each variable using a flow analysis solver. Lastly it replaces
+dead variables with a sentinal zero variable (the JS value `undefined`).
+
+Although this module does not perform any dead-code elimination itself, it is designed to be used to identify and substitute 
+dead variables that are then removed by [deadcode.ml]. In particular it allows for the elimination of unused functions defined 
+in functors, which the original deadcode elimination cannot. 
+*)
+
 val add_sentinal : Code.program -> Code.program * Code.Var.t
 
 val f : Code.program -> Code.Var.t -> Global_flow.info -> Code.program
\ No newline at end of file

From 68673240462c4d700ed3d0613bfec51d8e043f95 Mon Sep 17 00:00:00 2001
From: Micah Cantor <micahcantor01@gmail.com>
Date: Mon, 9 Oct 2023 20:50:11 -0500
Subject: [PATCH 085/112] remove option from deadcode_sentinal

---
 compiler/lib/driver.ml    |  8 ++++----
 compiler/lib/generate.ml  | 16 +++++++---------
 compiler/lib/generate.mli |  2 +-
 3 files changed, 12 insertions(+), 14 deletions(-)

diff --git a/compiler/lib/driver.ml b/compiler/lib/driver.ml
index 1b0bad697d..5d96c644b2 100644
--- a/compiler/lib/driver.ml
+++ b/compiler/lib/driver.ml
@@ -110,14 +110,14 @@ let exact_calls profile p =
         let p, deadcode_sentinal = Global_deadcode.add_sentinal p in
         let info = Global_flow.f ~fast p in
         let p = Global_deadcode.f p deadcode_sentinal info in
-        p, info, Some deadcode_sentinal
+        p, info, deadcode_sentinal
       else
         let info = Global_flow.f ~fast p in
-        p, info, None
+        p, info, Code.Var.fresh () (* If deadcode is not run, this field is set to a dummy fresh variable *)
     in
     let p = Specialize.f ~function_arity:(fun f -> Global_flow.function_arity info f) p in
     p, deadcode_sentinal
-  else p, None
+  else p, Code.Var.fresh ()
 
 let print p =
   if debug () then Code.Print.program (fun _ _ -> "") p;
@@ -186,7 +186,7 @@ let generate
     ~exported_runtime
     ~wrap_with_fun
     ~warn_on_unhandled_effect
-    (((p, live_vars), cps_calls), deadcode_sentinal)  =
+    (((p, live_vars), cps_calls), deadcode_sentinal) =
   if times () then Format.eprintf "Start Generation...@.";
   let should_export = should_export wrap_with_fun in
   Generate.f
diff --git a/compiler/lib/generate.ml b/compiler/lib/generate.ml
index 290ff920d3..1d9280d95e 100644
--- a/compiler/lib/generate.ml
+++ b/compiler/lib/generate.ml
@@ -285,7 +285,7 @@ module Ctx = struct
     ; should_export : bool
     ; effect_warning : bool ref
     ; cps_calls : Effects.cps_calls
-    ; deadcode_sentinal : Var.t option
+    ; deadcode_sentinal : Var.t
     }
 
   let initial
@@ -1042,10 +1042,10 @@ let rec translate_expr ctx queue loc x e level : _ * J.statement_list =
             let (prop', cx), queue = access_queue queue x in
             let cx =
               match cx with
-              | J.EVar (J.V v) -> (
-                  match ctx.deadcode_sentinal with
-                  | Some s -> if Var.equal v s then J.ElementHole else J.Element cx
-                  | None -> J.Element cx)
+              | J.EVar (J.V v) ->
+                  if Var.equal v ctx.deadcode_sentinal
+                  then J.ElementHole
+                  else J.Element cx
               | _ -> J.Element cx
             in
             cx :: args, or_p prop prop', queue)
@@ -1596,10 +1596,8 @@ and compile_conditional st queue ~fall_through last scope_stack : _ * _ =
     match last with
     | Return x ->
         let (_px, cx), queue = access_queue queue x in
-        let return_expr = 
-          match st.ctx.deadcode_sentinal with
-            | Some sentinal when Var.equal sentinal x -> None
-            | _ -> Some cx
+        let return_expr =
+          if Var.equal st.ctx.deadcode_sentinal x then None else Some cx
         in
         true, flush_all queue [ J.Return_statement return_expr, loc ]
     | Raise (x, k) ->
diff --git a/compiler/lib/generate.mli b/compiler/lib/generate.mli
index 6a0df32259..eaf1ab8f5e 100644
--- a/compiler/lib/generate.mli
+++ b/compiler/lib/generate.mli
@@ -25,7 +25,7 @@ val f :
   -> cps_calls:Effects.cps_calls
   -> should_export:bool
   -> warn_on_unhandled_effect:bool
-  -> deadcode_sentinal:Code.Var.t option
+  -> deadcode_sentinal:Code.Var.t
   -> Parse_bytecode.Debug.t
   -> Javascript.program
 

From bd81aee711e6aaf44aaea8464f035e494f28cb65 Mon Sep 17 00:00:00 2001
From: Hugo Heuzard <hugo.heuzard@gmail.com>
Date: Tue, 10 Oct 2023 10:25:37 +0200
Subject: [PATCH 086/112] improve test

---
 compiler/lib/driver.ml                     |   6 +-
 compiler/lib/global_deadcode.mli           |   2 +-
 compiler/tests-compiler/global_deadcode.ml | 111 +++++++++++++--------
 compiler/tests-compiler/util/util.ml       |   8 ++
 compiler/tests-compiler/util/util.mli      |   2 +
 5 files changed, 88 insertions(+), 41 deletions(-)

diff --git a/compiler/lib/driver.ml b/compiler/lib/driver.ml
index 5d96c644b2..172bdcb324 100644
--- a/compiler/lib/driver.ml
+++ b/compiler/lib/driver.ml
@@ -113,7 +113,11 @@ let exact_calls profile p =
         p, info, deadcode_sentinal
       else
         let info = Global_flow.f ~fast p in
-        p, info, Code.Var.fresh () (* If deadcode is not run, this field is set to a dummy fresh variable *)
+        let deadcode_sentinal =
+          (* If deadcode is not enabled, this field is set to a dummy fresh variable *)
+          Code.Var.fresh ()
+        in
+        p, info, deadcode_sentinal
     in
     let p = Specialize.f ~function_arity:(fun f -> Global_flow.function_arity info f) p in
     p, deadcode_sentinal
diff --git a/compiler/lib/global_deadcode.mli b/compiler/lib/global_deadcode.mli
index b5b94e7cbe..250a0edddd 100644
--- a/compiler/lib/global_deadcode.mli
+++ b/compiler/lib/global_deadcode.mli
@@ -31,4 +31,4 @@ in functors, which the original deadcode elimination cannot.
 
 val add_sentinal : Code.program -> Code.program * Code.Var.t
 
-val f : Code.program -> Code.Var.t -> Global_flow.info -> Code.program
\ No newline at end of file
+val f : Code.program -> Code.Var.t -> Global_flow.info -> Code.program
diff --git a/compiler/tests-compiler/global_deadcode.ml b/compiler/tests-compiler/global_deadcode.ml
index 211f9bea2f..de7a3632f9 100644
--- a/compiler/tests-compiler/global_deadcode.ml
+++ b/compiler/tests-compiler/global_deadcode.ml
@@ -4,7 +4,7 @@ let%expect_test "Eliminates unused functions from functor" =
   let program =
     (* Create two instances of Set functor so compiler can't inline one implementation. *)
     compile_and_parse_whole_program
-    ~flags: ["--enable"; "globaldeadcode"]
+      ~flags:[ "--enable"; "globaldeadcode" ]
       {|
       module Int_set = Set.Make (Int);;
       module String_set = Set.Make (String);;
@@ -15,45 +15,75 @@ let%expect_test "Eliminates unused functions from functor" =
       print_endline (string_of_int (Int_set.find 1 int_set) ^ (String_set.find "hello" string_set))
       |}
   in
-  (* Expect: compiles functor members used in the program *)
-  print_fun_decl program (Some "find");
+  let app = find_variable program "String_set" in
+  (let open Js_of_ocaml_compiler in
+   match app with
+   | Javascript.ECall (EVar (S { name = Utf8 name; _ }), _, _, _) ->
+       print_fun_decl program (Some name)
+   | _ -> ());
   [%expect
     {|
-    function find(x, param){
-     var param$0 = param;
-     for(;;){
-      if(! param$0) throw caml_maybe_attach_backtrace(Not_found, 1);
-      var
-       r = param$0[3],
-       v = param$0[2],
-       l = param$0[1],
-       c = caml_call2(Ord[1], x, v);
-      if(0 === c) return v;
-      var r$0 = 0 <= c ? r : l, param$0 = r$0;
+    function _e_(Ord){
+     function height(param){if(! param) return 0; var h = param[4]; return h;}
+     function create(l, v, r){
+      if(l) var h = l[4], hl = h; else var hl = 0;
+      if(r) var h$0 = r[4], hr = h$0; else var hr = 0;
+      var _m_ = hr <= hl ? hl + 1 | 0 : hr + 1 | 0;
+      return [0, l, v, r, _m_];
      }
+     function bal(l, v, r){
+      if(l) var h = l[4], hl = h; else var hl = 0;
+      if(r) var h$0 = r[4], hr = h$0; else var hr = 0;
+      if((hr + 2 | 0) < hl){
+       if(! l) return invalid_arg(_b_);
+       var lr = l[3], lv = l[2], ll = l[1], _h_ = height(lr);
+       if(_h_ <= height(ll)) return create(ll, lv, create(lr, v, r));
+       if(! lr) return invalid_arg(_a_);
+       var lrr = lr[3], lrv = lr[2], lrl = lr[1], _i_ = create(lrr, v, r);
+       return create(create(ll, lv, lrl), lrv, _i_);
+      }
+      if((hl + 2 | 0) >= hr){
+       var _l_ = hr <= hl ? hl + 1 | 0 : hr + 1 | 0;
+       return [0, l, v, r, _l_];
+      }
+      if(! r) return invalid_arg(_d_);
+      var rr = r[3], rv = r[2], rl = r[1], _j_ = height(rl);
+      if(_j_ <= height(rr)) return create(create(l, v, rl), rv, rr);
+      if(! rl) return invalid_arg(_c_);
+      var rlr = rl[3], rlv = rl[2], rll = rl[1], _k_ = create(rlr, rv, rr);
+      return create(create(l, v, rll), rlv, _k_);
+     }
+     function add(x, t){
+      if(! t) return [0, 0, x, 0, 1];
+      var r = t[3], v = t[2], l = t[1], c = caml_call2(Ord[1], x, v);
+      if(0 === c) return t;
+      if(0 <= c){var rr = add(x, r); return r === rr ? t : bal(l, v, rr);}
+      var ll = add(x, l);
+      return l === ll ? t : bal(ll, v, r);
+     }
+     function singleton(x){return [0, 0, x, 0, 1];}
+     var empty = 0;
+     function find(x, param){
+      var param$0 = param;
+      for(;;){
+       if(! param$0) throw caml_maybe_attach_backtrace(Not_found, 1);
+       var
+        r = param$0[3],
+        v = param$0[2],
+        l = param$0[1],
+        c = caml_call2(Ord[1], x, v);
+       if(0 === c) return v;
+       var r$0 = 0 <= c ? r : l, param$0 = r$0;
+      }
+     }
+     return [0, empty, add, singleton, , , , , , , , , , , , , , find];
     }
-    //end |}];
-  print_fun_decl program (Some "add");
-  [%expect {|
-    function add(x, t){
-     if(! t) return [0, 0, x, 0, 1];
-     var r = t[3], v = t[2], l = t[1], c = caml_call2(Ord[1], x, v);
-     if(0 === c) return t;
-     if(0 <= c){var rr = add(x, r); return r === rr ? t : bal(l, v, rr);}
-     var ll = add(x, l);
-     return l === ll ? t : bal(ll, v, r);
-    }
-    //end |}];
-  (* Expect: does not compile unused functor member *)
-  print_fun_decl program (Some "union");
-  [%expect {| not found |}];
-  print_fun_decl program (Some "inter");
-  [%expect {| not found |}]
+    //end |}]
 
 let%expect_test "Omit unused fields" =
   let program =
     compile_and_parse
-    ~flags:["--enable"; "globaldeadcode"]
+      ~flags:[ "--enable"; "globaldeadcode" ]
       {|
       let f b x =
         let t = if b then (1, 2, x) else (3, x, 4) in
@@ -61,10 +91,11 @@ let%expect_test "Omit unused fields" =
         (u, v)
       in print_int (fst (f true 1) + snd (f false 2))
       |}
-  in 
+  in
   (* Expect second field in each triple to be omitted. *)
   print_fun_decl program (Some "f");
-  [%expect {|
+  [%expect
+    {|
     function f(b, x){
      var t = b ? [0, 1, , x] : [0, 3, , 4], v = t[3], u = t[1];
      return [0, u, v];
@@ -74,7 +105,7 @@ let%expect_test "Omit unused fields" =
 let%expect_test "Omit unused return expressions" =
   let program =
     compile_and_parse
-    ~flags:["--enable"; "globaldeadcode"]
+      ~flags:[ "--enable"; "globaldeadcode" ]
       {|
       let f x =
         print_int x; 
@@ -82,9 +113,11 @@ let%expect_test "Omit unused return expressions" =
       in 
       ignore (f 5 + f 6)
       |}
-  in 
+  in
   (* Expect return value of f to be omitted. *)
   print_fun_decl program (Some "f");
-  [%expect "
-    function f(x){caml_call1(Stdlib[44], x); return;}
-    //end"];
\ No newline at end of file
+  [%expect
+    {|
+       function f(x){caml_call1(Stdlib[44], x); return;}
+       //end
+     |}]
diff --git a/compiler/tests-compiler/util/util.ml b/compiler/tests-compiler/util/util.ml
index 6ee6908049..9e81901d5e 100644
--- a/compiler/tests-compiler/util/util.ml
+++ b/compiler/tests-compiler/util/util.ml
@@ -444,6 +444,14 @@ class find_variable_declaration r n =
       super#variable_declaration k v
   end
 
+let find_variable program n =
+  let r = ref [] in
+  let o = new find_variable_declaration r n in
+  ignore (o#program program);
+  match !r with
+  | [ DeclIdent (_, Some (expression, _)) ] -> expression
+  | _ -> raise Not_found
+
 let print_var_decl program n =
   let r = ref [] in
   let o = new find_variable_declaration r n in
diff --git a/compiler/tests-compiler/util/util.mli b/compiler/tests-compiler/util/util.mli
index 5cdf488398..cfca291b85 100644
--- a/compiler/tests-compiler/util/util.mli
+++ b/compiler/tests-compiler/util/util.mli
@@ -71,6 +71,8 @@ val print_var_decl : Javascript.program -> string -> unit
 
 val print_fun_decl : Javascript.program -> string option -> unit
 
+val find_variable : Javascript.program -> string -> Javascript.expression
+
 val compile_and_run :
      ?debug:bool
   -> ?skip_modern:bool

From 596dcb55f1aef0649afbfdbec1f3c672c8645d44 Mon Sep 17 00:00:00 2001
From: Hugo Heuzard <hugo.heuzard@gmail.com>
Date: Tue, 10 Oct 2023 13:35:48 +0200
Subject: [PATCH 087/112] fix test

---
 compiler/tests-compiler/global_deadcode.ml | 124 +++++++++++----------
 compiler/tests-compiler/util/util.ml       |   8 ++
 compiler/tests-compiler/util/util.mli      |   2 +
 3 files changed, 78 insertions(+), 56 deletions(-)

diff --git a/compiler/tests-compiler/global_deadcode.ml b/compiler/tests-compiler/global_deadcode.ml
index de7a3632f9..ab290f7313 100644
--- a/compiler/tests-compiler/global_deadcode.ml
+++ b/compiler/tests-compiler/global_deadcode.ml
@@ -13,71 +13,83 @@ let%expect_test "Eliminates unused functions from functor" =
       let string_set = String_set.empty in
       let string_set = String_set.add "hello" string_set in
       print_endline (string_of_int (Int_set.find 1 int_set) ^ (String_set.find "hello" string_set))
-      |}
+       |}
   in
   let app = find_variable program "String_set" in
   (let open Js_of_ocaml_compiler in
+   let open Stdlib in
    match app with
-   | Javascript.ECall (EVar (S { name = Utf8 name; _ }), _, _, _) ->
-       print_fun_decl program (Some name)
+   | Javascript.ECall (EVar (S { name = Utf8 name; _ }), _, _, _) -> (
+       let _, _, body, _ = find_function program name in
+       match List.rev body with
+       | (Return_statement (Some (EArr return)), loc) :: rest ->
+           let return =
+             ( Javascript.Return_statement
+                 (Some
+                    (EArr
+                       (List.filter return ~f:(function
+                           | Javascript.ElementHole -> false
+                           | _ -> true))))
+             , loc )
+           in
+           print_program (List.rev (return :: rest))
+       | _ -> ())
    | _ -> ());
   [%expect
     {|
-    function _e_(Ord){
-     function height(param){if(! param) return 0; var h = param[4]; return h;}
-     function create(l, v, r){
-      if(l) var h = l[4], hl = h; else var hl = 0;
-      if(r) var h$0 = r[4], hr = h$0; else var hr = 0;
-      var _m_ = hr <= hl ? hl + 1 | 0 : hr + 1 | 0;
-      return [0, l, v, r, _m_];
-     }
-     function bal(l, v, r){
-      if(l) var h = l[4], hl = h; else var hl = 0;
-      if(r) var h$0 = r[4], hr = h$0; else var hr = 0;
-      if((hr + 2 | 0) < hl){
-       if(! l) return invalid_arg(_b_);
-       var lr = l[3], lv = l[2], ll = l[1], _h_ = height(lr);
-       if(_h_ <= height(ll)) return create(ll, lv, create(lr, v, r));
-       if(! lr) return invalid_arg(_a_);
-       var lrr = lr[3], lrv = lr[2], lrl = lr[1], _i_ = create(lrr, v, r);
-       return create(create(ll, lv, lrl), lrv, _i_);
-      }
-      if((hl + 2 | 0) >= hr){
-       var _l_ = hr <= hl ? hl + 1 | 0 : hr + 1 | 0;
-       return [0, l, v, r, _l_];
-      }
-      if(! r) return invalid_arg(_d_);
-      var rr = r[3], rv = r[2], rl = r[1], _j_ = height(rl);
-      if(_j_ <= height(rr)) return create(create(l, v, rl), rv, rr);
-      if(! rl) return invalid_arg(_c_);
-      var rlr = rl[3], rlv = rl[2], rll = rl[1], _k_ = create(rlr, rv, rr);
-      return create(create(l, v, rll), rlv, _k_);
+    function height(param){if(! param) return 0; var h = param[4]; return h;}
+    function create(l, v, r){
+     if(l) var h = l[4], hl = h; else var hl = 0;
+     if(r) var h$0 = r[4], hr = h$0; else var hr = 0;
+     var _m_ = hr <= hl ? hl + 1 | 0 : hr + 1 | 0;
+     return [0, l, v, r, _m_];
+    }
+    function bal(l, v, r){
+     if(l) var h = l[4], hl = h; else var hl = 0;
+     if(r) var h$0 = r[4], hr = h$0; else var hr = 0;
+     if((hr + 2 | 0) < hl){
+      if(! l) return invalid_arg(_b_);
+      var lr = l[3], lv = l[2], ll = l[1], _h_ = height(lr);
+      if(_h_ <= height(ll)) return create(ll, lv, create(lr, v, r));
+      if(! lr) return invalid_arg(_a_);
+      var lrr = lr[3], lrv = lr[2], lrl = lr[1], _i_ = create(lrr, v, r);
+      return create(create(ll, lv, lrl), lrv, _i_);
      }
-     function add(x, t){
-      if(! t) return [0, 0, x, 0, 1];
-      var r = t[3], v = t[2], l = t[1], c = caml_call2(Ord[1], x, v);
-      if(0 === c) return t;
-      if(0 <= c){var rr = add(x, r); return r === rr ? t : bal(l, v, rr);}
-      var ll = add(x, l);
-      return l === ll ? t : bal(ll, v, r);
+     if((hl + 2 | 0) >= hr){
+      var _l_ = hr <= hl ? hl + 1 | 0 : hr + 1 | 0;
+      return [0, l, v, r, _l_];
      }
-     function singleton(x){return [0, 0, x, 0, 1];}
-     var empty = 0;
-     function find(x, param){
-      var param$0 = param;
-      for(;;){
-       if(! param$0) throw caml_maybe_attach_backtrace(Not_found, 1);
-       var
-        r = param$0[3],
-        v = param$0[2],
-        l = param$0[1],
-        c = caml_call2(Ord[1], x, v);
-       if(0 === c) return v;
-       var r$0 = 0 <= c ? r : l, param$0 = r$0;
-      }
+     if(! r) return invalid_arg(_d_);
+     var rr = r[3], rv = r[2], rl = r[1], _j_ = height(rl);
+     if(_j_ <= height(rr)) return create(create(l, v, rl), rv, rr);
+     if(! rl) return invalid_arg(_c_);
+     var rlr = rl[3], rlv = rl[2], rll = rl[1], _k_ = create(rlr, rv, rr);
+     return create(create(l, v, rll), rlv, _k_);
+    }
+    function add(x, t){
+     if(! t) return [0, 0, x, 0, 1];
+     var r = t[3], v = t[2], l = t[1], c = caml_call2(Ord[1], x, v);
+     if(0 === c) return t;
+     if(0 <= c){var rr = add(x, r); return r === rr ? t : bal(l, v, rr);}
+     var ll = add(x, l);
+     return l === ll ? t : bal(ll, v, r);
+    }
+    function singleton(x){return [0, 0, x, 0, 1];}
+    var empty = 0;
+    function find(x, param){
+     var param$0 = param;
+     for(;;){
+      if(! param$0) throw caml_maybe_attach_backtrace(Not_found, 1);
+      var
+       r = param$0[3],
+       v = param$0[2],
+       l = param$0[1],
+       c = caml_call2(Ord[1], x, v);
+      if(0 === c) return v;
+      var r$0 = 0 <= c ? r : l, param$0 = r$0;
      }
-     return [0, empty, add, singleton, , , , , , , , , , , , , , find];
     }
+    return [0, empty, add, singleton, find];
     //end |}]
 
 let%expect_test "Omit unused fields" =
@@ -108,9 +120,9 @@ let%expect_test "Omit unused return expressions" =
       ~flags:[ "--enable"; "globaldeadcode" ]
       {|
       let f x =
-        print_int x; 
+        print_int x;
         x + 1
-      in 
+      in
       ignore (f 5 + f 6)
       |}
   in
diff --git a/compiler/tests-compiler/util/util.ml b/compiler/tests-compiler/util/util.ml
index 9e81901d5e..428245646f 100644
--- a/compiler/tests-compiler/util/util.ml
+++ b/compiler/tests-compiler/util/util.ml
@@ -491,6 +491,14 @@ class find_function_declaration r n =
 
 let print_program p = print_string (program_to_string p)
 
+let find_function program n =
+  let r = ref [] in
+  let o = new find_function_declaration r (Some n) in
+  ignore (o#program program);
+  match !r with
+  | [ (_, fd) ] -> fd
+  | _ -> raise Not_found
+
 let print_fun_decl program n =
   let r = ref [] in
   let o = new find_function_declaration r n in
diff --git a/compiler/tests-compiler/util/util.mli b/compiler/tests-compiler/util/util.mli
index cfca291b85..a8718910d2 100644
--- a/compiler/tests-compiler/util/util.mli
+++ b/compiler/tests-compiler/util/util.mli
@@ -73,6 +73,8 @@ val print_fun_decl : Javascript.program -> string option -> unit
 
 val find_variable : Javascript.program -> string -> Javascript.expression
 
+val find_function : Javascript.program -> string -> Javascript.function_declaration
+
 val compile_and_run :
      ?debug:bool
   -> ?skip_modern:bool

From 34edd4540048866a4c530a8bb8febdc30cf9ed27 Mon Sep 17 00:00:00 2001
From: Micah Cantor <micahcantor01@gmail.com>
Date: Tue, 17 Oct 2023 10:42:15 -0500
Subject: [PATCH 088/112] remove deadcode flag from pure_expr

---
 compiler/lib/global_deadcode.ml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/compiler/lib/global_deadcode.ml b/compiler/lib/global_deadcode.ml
index 525c31a26a..d45dee0cc9 100644
--- a/compiler/lib/global_deadcode.ml
+++ b/compiler/lib/global_deadcode.ml
@@ -58,7 +58,7 @@ end
 
 module Solver = G.Solver (Domain)
 
-let pure_expr pure_funs e = Pure_fun.pure_expr pure_funs e && Config.Flag.deadcode ()
+let pure_expr pure_funs e = Pure_fun.pure_expr pure_funs e
 
 let definitions nv prog =
   let defs = Array.make nv Param in

From cd3eb5a365d949951696482a424e29531db92e68 Mon Sep 17 00:00:00 2001
From: Micah Cantor <micahcantor01@gmail.com>
Date: Tue, 17 Oct 2023 10:45:04 -0500
Subject: [PATCH 089/112] equal exhaustive case

---
 compiler/lib/global_deadcode.ml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/compiler/lib/global_deadcode.ml b/compiler/lib/global_deadcode.ml
index d45dee0cc9..29f9d3b3e5 100644
--- a/compiler/lib/global_deadcode.ml
+++ b/compiler/lib/global_deadcode.ml
@@ -43,7 +43,7 @@ module Domain = struct
     match l1, l2 with
     | Top, Top | Dead, Dead -> true
     | Live f1, Live f2 -> IntSet.equal f1 f2
-    | _ -> false
+    | Top, (Dead | Live _) | Live _, (Dead | Top) | Dead, (Live _ | Top) -> false
 
   let bot = Dead
 

From 04a7e875b68019793ce1c90ccd578d5f493ec652 Mon Sep 17 00:00:00 2001
From: Micah Cantor <micahcantor01@gmail.com>
Date: Tue, 17 Oct 2023 10:46:03 -0500
Subject: [PATCH 090/112] definitions exhaustive case

---
 compiler/lib/global_deadcode.ml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/compiler/lib/global_deadcode.ml b/compiler/lib/global_deadcode.ml
index 29f9d3b3e5..b2414f1d08 100644
--- a/compiler/lib/global_deadcode.ml
+++ b/compiler/lib/global_deadcode.ml
@@ -71,7 +71,7 @@ let definitions nv prog =
           match i with
           | Let (x, e) -> set_def x (Expr e)
           | Assign (x, _) -> set_def x Param
-          | _ -> ())
+          | Set_field (_, _, _) | Offset_ref (_, _) | Array_set (_, _, _) -> ())
         block.body)
     prog.blocks;
   defs

From 646b216fade85c7567e0b559fedd661b1c972503 Mon Sep 17 00:00:00 2001
From: Micah Cantor <micahcantor01@gmail.com>
Date: Tue, 17 Oct 2023 11:27:48 -0500
Subject: [PATCH 091/112] Use Var.Tbl instead of var array

---
 compiler/lib/global_deadcode.ml | 74 +++++++++++++++++----------------
 1 file changed, 38 insertions(+), 36 deletions(-)

diff --git a/compiler/lib/global_deadcode.ml b/compiler/lib/global_deadcode.ml
index b2414f1d08..c300ea9e39 100644
--- a/compiler/lib/global_deadcode.ml
+++ b/compiler/lib/global_deadcode.ml
@@ -60,9 +60,9 @@ module Solver = G.Solver (Domain)
 
 let pure_expr pure_funs e = Pure_fun.pure_expr pure_funs e
 
-let definitions nv prog =
-  let defs = Array.make nv Param in
-  let set_def x d = defs.(Var.idx x) <- d in
+let definitions prog =
+  let defs = Var.Tbl.make () Param in
+  let set_def x d = Var.Tbl.set defs x d in
   Addr.Map.iter
     (fun _ block ->
       (* Add defs from block body *)
@@ -92,9 +92,9 @@ type usage_kind =
     
     We use information from global flow to try to add edges between function calls and their return values
     at known call sites. *)
-let usages nv prog (global_info : Global_flow.info) : usage_kind Var.Map.t array =
-  let uses = Array.make nv Var.Map.empty in
-  let add_use kind x y = uses.(Var.idx y) <- Var.Map.add x kind uses.(Var.idx y) in
+let usages prog (global_info : Global_flow.info) : usage_kind Var.Map.t Var.Tbl.t =
+  let uses = Var.Tbl.make () Var.Map.empty in
+  let add_use kind x y = Var.Tbl.set uses y (Var.Map.add x kind (Var.Tbl.get uses y)) in
   let add_arg_dep params args =
     try List.iter2 ~f:(fun x y -> add_use Propagate x y) params args
     with Invalid_argument _ -> ()
@@ -196,17 +196,16 @@ let expr_vars e =
     + Or, it is returned or applied to a function and the global flow analysis marked it as escaping.
     
     A variable [x[i]] is marked as [Live {i}] if it is used in an instruction where field [i] is referenced or set. *)
-let liveness nv prog pure_funs (global_info : Global_flow.info) =
-  let live_vars = Array.make nv Dead in
-  let add_top v =
-    let idx = Var.idx v in
-    live_vars.(idx) <- Top
-  in
-  let add_live v i =
-    let idx = Var.idx v in
-    match live_vars.(idx) with
-    | Live fields -> live_vars.(idx) <- Live (IntSet.add i fields)
-    | _ -> live_vars.(idx) <- Live (IntSet.singleton i)
+let liveness prog pure_funs (global_info : Global_flow.info) =
+  let live_vars = Var.Tbl.make () Dead in
+  let add_top v = Var.Tbl.set live_vars v Top in
+  let add_live_field v i =
+    let live_fields =
+      match Var.Tbl.get live_vars v with
+      | Live fields -> Live (IntSet.add i fields)
+      | Top | Dead -> Live (IntSet.singleton i)
+    in
+    Var.Tbl.set live_vars v live_fields
   in
   let live_instruction i =
     match i with
@@ -224,13 +223,13 @@ let liveness nv prog pure_funs (global_info : Global_flow.info) =
               Var.Set.iter add_top vars)
     | Assign (_, _) -> ()
     | Set_field (x, i, y) ->
-        add_live x i;
+        add_live_field x i;
         add_top y
     | Array_set (x, y, z) ->
         add_top x;
         add_top y;
         add_top z
-    | Offset_ref (x, i) -> add_live x i
+    | Offset_ref (x, i) -> add_live_field x i
   in
   let live_block block =
     List.iter ~f:(fun (i, _) -> live_instruction i) block.body;
@@ -245,17 +244,21 @@ let liveness nv prog pure_funs (global_info : Global_flow.info) =
   Addr.Map.iter (fun _ block -> live_block block) prog.blocks;
   live_vars
 
-(* Returns the set of variables given the adjacency list of variable dependencies. *)
+(* Returns the set of variables given a table of variables. *)
 let variables deps =
   let vars = Var.ISet.empty () in
-  Array.iteri ~f:(fun i _ -> Var.ISet.add vars (Var.of_idx i)) deps;
+  Var.Tbl.iter (fun v _ -> Var.ISet.add vars v) deps;
   vars
 
 (** Propagate liveness of the usages of a variable [x] to [x]. The liveness of [x] is
     defined by joining its current liveness and the contribution of each vairable [y]
     that uses [x]. *)
-let propagate uses defs live_vars live_table x =
-  let idx = Var.idx x in
+let propagate
+    (uses : usage_kind Var.Map.t Var.Tbl.t)
+    (defs : def Var.Tbl.t)
+    (live_vars : live Var.Tbl.t)
+    live_table
+    x =
   (* Variable [y] uses [x] either in its definition ([Compute]) or as a closure/block parameter
       ([Propagate]). In the latter case, the contribution is simply the liveness of [y]. In the former,
        the contribution depends on the liveness of [y] and its definition. *)
@@ -268,7 +271,7 @@ let propagate uses defs live_vars live_table x =
         | Dead -> Dead
         (* If y is a live block, then x is the join of liveness fields that are x *)
         | Live fields -> (
-            match defs.(Var.idx y) with
+            match Var.Tbl.get defs y with
             | Expr (Block (_, vars, _)) ->
                 let found = ref false in
                 Array.iteri
@@ -280,7 +283,7 @@ let propagate uses defs live_vars live_table x =
             | _ -> Top)
         (* If y is top and y is a field access, x depends only on that field *)
         | Top -> (
-            match defs.(Var.idx y) with
+            match Var.Tbl.get defs y with
             | Expr (Field (_, i)) -> Live (IntSet.singleton i)
             | _ -> Top))
     (* If x is used as an argument for parameter y, then contribution is liveness of y *)
@@ -288,13 +291,13 @@ let propagate uses defs live_vars live_table x =
   in
   Var.Map.fold
     (fun y usage_kind live -> Domain.join (contribution y usage_kind) live)
-    uses.(idx)
-    (Domain.join live_vars.(idx) (Var.Tbl.get live_table x))
+    (Var.Tbl.get uses x)
+    (Domain.join (Var.Tbl.get live_vars x) (Var.Tbl.get live_table x))
 
 let solver vars uses defs live_vars =
   let g =
     { G.domain = vars
-    ; G.iter_children = (fun f x -> Var.Map.iter (fun y _ -> f y) uses.(Var.idx x))
+    ; G.iter_children = (fun f x -> Var.Map.iter (fun y _ -> f y) (Var.Tbl.get uses x))
     }
   in
   Solver.f () (G.invert () g) (propagate uses defs live_vars)
@@ -369,9 +372,9 @@ module Print = struct
 
   let print_uses uses =
     Format.eprintf "Usages:\n";
-    Array.iteri
-      ~f:(fun i ds ->
-        Format.eprintf "v%d: { " i;
+    Var.Tbl.iter
+      (fun v ds ->
+        Format.eprintf "%a: { " Var.print v;
         Var.Map.iter
           (fun d k ->
             Format.eprintf
@@ -387,7 +390,7 @@ module Print = struct
 
   let print_liveness live_vars =
     Format.eprintf "Liveness:\n";
-    Array.iteri ~f:(fun i l -> Format.eprintf "v%d: %s\n" i (live_to_string l)) live_vars
+    Var.Tbl.iter (fun v l -> Format.eprintf "%a: %s\n" Var.print v (live_to_string l)) live_vars
 
   let print_live_tbl live_table =
     Format.eprintf "Liveness with dependencies:\n";
@@ -406,14 +409,13 @@ let add_sentinal p =
 (** Run the liveness analysis and replace dead variables with the given sentinal. *)
 let f p sentinal global_info =
   let t = Timer.make () in
-  let nv = Var.count () in
   (* Compute definitions *)
-  let defs = definitions nv p in
+  let defs = definitions p in
   (* Compute usages *)
-  let uses = usages nv p global_info in
+  let uses = usages p global_info in
   (* Compute initial liveness *)
   let pure_funs = Pure_fun.f p in
-  let live_vars = liveness nv p pure_funs global_info in
+  let live_vars = liveness p pure_funs global_info in
   (* Propagate liveness to dependencies *)
   let vars = variables uses in
   let live_table = solver vars uses defs live_vars in

From fc846de5ff436100be11ec8f869f90cdc62f444a Mon Sep 17 00:00:00 2001
From: Micah Cantor <micahcantor01@gmail.com>
Date: Tue, 17 Oct 2023 13:35:32 -0500
Subject: [PATCH 092/112] small fixes

---
 compiler/lib/global_deadcode.ml | 11 +++++------
 1 file changed, 5 insertions(+), 6 deletions(-)

diff --git a/compiler/lib/global_deadcode.ml b/compiler/lib/global_deadcode.ml
index c300ea9e39..68b39523cd 100644
--- a/compiler/lib/global_deadcode.ml
+++ b/compiler/lib/global_deadcode.ml
@@ -96,8 +96,7 @@ let usages prog (global_info : Global_flow.info) : usage_kind Var.Map.t Var.Tbl.
   let uses = Var.Tbl.make () Var.Map.empty in
   let add_use kind x y = Var.Tbl.set uses y (Var.Map.add x kind (Var.Tbl.get uses y)) in
   let add_arg_dep params args =
-    try List.iter2 ~f:(fun x y -> add_use Propagate x y) params args
-    with Invalid_argument _ -> ()
+    List.iter2 ~f:(fun x y -> add_use Propagate x y) params args
   in
   let add_cont_deps (pc, args) =
     match try Some (Addr.Map.find pc prog.blocks) with Not_found -> None with
@@ -118,7 +117,7 @@ let usages prog (global_info : Global_flow.info) : usage_kind Var.Map.t Var.Tbl.
                 | Expr (Closure (params, _)) ->
                     (* If the function is under/over-applied then global flow will mark arguments and return value as escaping.
                        So we only need to consider the case when there is an exact application. *)
-                    if List.length params = List.length args
+                    if List.compare_lengths params args = 0
                     then (
                       let return_values = Var.Map.find k global_info.info_return_vals in
                       Var.Set.iter (add_use Propagate x) return_values;
@@ -143,15 +142,15 @@ let usages prog (global_info : Global_flow.info) : usage_kind Var.Map.t Var.Tbl.
   in
   Addr.Map.iter
     (fun _ block ->
-      (* Add deps from block body *)
+      (* Add uses from block body *)
       List.iter
         ~f:(fun (i, _) ->
           match i with
           | Let (x, e) -> add_expr_uses x e
-          | Assign (x, y) -> add_use Compute x y
+          | Assign (x, y) -> add_use Propagate x y
           | Set_field (_, _, _) | Offset_ref (_, _) | Array_set (_, _, _) -> ())
         block.body;
-      (* Add deps from block branch *)
+      (* Add uses from block branch *)
       match fst block.branch with
       | Return _ | Raise _ | Stop -> ()
       | Branch cont -> add_cont_deps cont

From 5dfd1caed57d2d0c85606063347b77238cffdb77 Mon Sep 17 00:00:00 2001
From: Micah Cantor <micahcantor01@gmail.com>
Date: Tue, 17 Oct 2023 13:49:26 -0500
Subject: [PATCH 093/112] make exhaustive

---
 compiler/lib/global_deadcode.ml | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

diff --git a/compiler/lib/global_deadcode.ml b/compiler/lib/global_deadcode.ml
index 68b39523cd..3b7b5111f4 100644
--- a/compiler/lib/global_deadcode.ml
+++ b/compiler/lib/global_deadcode.ml
@@ -208,7 +208,9 @@ let liveness prog pure_funs (global_info : Global_flow.info) =
   in
   let live_instruction i =
     match i with
-    | Let (_x, e) -> (
+    | Let (_, e) -> (
+        (* If e is an impure application, we only need to set escaping arguments
+           as top. Otherwise, set all variables in e as top.  *)
         if not (pure_expr pure_funs e)
         then
           match e with
@@ -217,7 +219,7 @@ let liveness prog pure_funs (global_info : Global_flow.info) =
               List.iter
                 ~f:(fun x -> if variable_may_escape x global_info then add_top x)
                 args
-          | _ ->
+          | Block (_, _, _) | Field (_, _) | Closure (_, _) | Constant _ | Prim (_, _) ->
               let vars = expr_vars e in
               Var.Set.iter add_top vars)
     | Assign (_, _) -> ()
@@ -319,7 +321,7 @@ let zero prog sentinal live_table =
   let is_live v =
     match Var.Tbl.get live_table v with
     | Dead -> false
-    | _ -> true
+    | Top | Live _ -> true
   in
   let zero_var x = if is_live x then x else sentinal in
   let zero_instr instr =
@@ -389,7 +391,9 @@ module Print = struct
 
   let print_liveness live_vars =
     Format.eprintf "Liveness:\n";
-    Var.Tbl.iter (fun v l -> Format.eprintf "%a: %s\n" Var.print v (live_to_string l)) live_vars
+    Var.Tbl.iter
+      (fun v l -> Format.eprintf "%a: %s\n" Var.print v (live_to_string l))
+      live_vars
 
   let print_live_tbl live_table =
     Format.eprintf "Liveness with dependencies:\n";

From dfb0c22e92cd9faf8f2a91d4a281b1d92c5f53ae Mon Sep 17 00:00:00 2001
From: Micah Cantor <micahcantor01@gmail.com>
Date: Tue, 17 Oct 2023 13:58:02 -0500
Subject: [PATCH 094/112] add comment about closure variables

---
 compiler/lib/global_deadcode.ml | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/compiler/lib/global_deadcode.ml b/compiler/lib/global_deadcode.ml
index 3b7b5111f4..151cf017c5 100644
--- a/compiler/lib/global_deadcode.ml
+++ b/compiler/lib/global_deadcode.ml
@@ -183,6 +183,9 @@ let expr_vars e =
           | Pc _ -> acc)
         ~init:vars
         args
+  (* We can ignore closures. We want the set of previously defined variables used
+    in the expression, so not parameters. The continuation may use some variables 
+    but we will add these when we visit the body  *)
   | Constant _ | Closure (_, _) -> vars
 
 (** Compute the initial liveness of each variable in the program. 

From be14b110213814c4d81b0fb7dca439c561f0b5c2 Mon Sep 17 00:00:00 2001
From: Micah Cantor <micahcantor01@gmail.com>
Date: Tue, 17 Oct 2023 14:20:12 -0500
Subject: [PATCH 095/112] clarifying comments

---
 compiler/lib/global_deadcode.ml | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/compiler/lib/global_deadcode.ml b/compiler/lib/global_deadcode.ml
index 151cf017c5..e630bbabc0 100644
--- a/compiler/lib/global_deadcode.ml
+++ b/compiler/lib/global_deadcode.ml
@@ -147,6 +147,7 @@ let usages prog (global_info : Global_flow.info) : usage_kind Var.Map.t Var.Tbl.
         ~f:(fun (i, _) ->
           match i with
           | Let (x, e) -> add_expr_uses x e
+          (* For assignment, propagate liveness from new to old variable like a block parameter *)
           | Assign (x, y) -> add_use Propagate x y
           | Set_field (_, _, _) | Offset_ref (_, _) | Array_set (_, _, _) -> ())
         block.body;
@@ -212,8 +213,9 @@ let liveness prog pure_funs (global_info : Global_flow.info) =
   let live_instruction i =
     match i with
     | Let (_, e) -> (
-        (* If e is an impure application, we only need to set escaping arguments
-           as top. Otherwise, set all variables in e as top.  *)
+        (* If e is impure, set all variables in e as Top. The only exception is for function applications, 
+           where we may be able to do better. Global flow gives us information about which arguments in
+           a function application esacpe, so set only these as top.  *)
         if not (pure_expr pure_funs e)
         then
           match e with
@@ -225,7 +227,6 @@ let liveness prog pure_funs (global_info : Global_flow.info) =
           | Block (_, _, _) | Field (_, _) | Closure (_, _) | Constant _ | Prim (_, _) ->
               let vars = expr_vars e in
               Var.Set.iter add_top vars)
-    | Assign (_, _) -> ()
     | Set_field (x, i, y) ->
         add_live_field x i;
         add_top y
@@ -234,6 +235,8 @@ let liveness prog pure_funs (global_info : Global_flow.info) =
         add_top y;
         add_top z
     | Offset_ref (x, i) -> add_live_field x i
+    (* Assignment can be ignored. Liveness of old variable is just propagated to new variable. See [usages]. *)
+    | Assign (_, _) -> ()
   in
   let live_block block =
     List.iter ~f:(fun (i, _) -> live_instruction i) block.body;

From 02148767e80b11152e311c0f437f8d5ba59f386f Mon Sep 17 00:00:00 2001
From: Micah Cantor <micahcantor01@gmail.com>
Date: Tue, 17 Oct 2023 14:45:49 -0500
Subject: [PATCH 096/112] small fixes

---
 compiler/lib/global_deadcode.ml | 34 ++++++++++++++++++---------------
 1 file changed, 19 insertions(+), 15 deletions(-)

diff --git a/compiler/lib/global_deadcode.ml b/compiler/lib/global_deadcode.ml
index e630bbabc0..38dfe0082a 100644
--- a/compiler/lib/global_deadcode.ml
+++ b/compiler/lib/global_deadcode.ml
@@ -185,8 +185,8 @@ let expr_vars e =
         ~init:vars
         args
   (* We can ignore closures. We want the set of previously defined variables used
-    in the expression, so not parameters. The continuation may use some variables 
-    but we will add these when we visit the body  *)
+     in the expression, so not parameters. The continuation may use some variables
+     but we will add these when we visit the body *)
   | Constant _ | Closure (_, _) -> vars
 
 (** Compute the initial liveness of each variable in the program. 
@@ -212,10 +212,10 @@ let liveness prog pure_funs (global_info : Global_flow.info) =
   in
   let live_instruction i =
     match i with
+    (* If e is impure, set all variables in e as Top. The only exception is for function applications,
+       where we may be able to do better. Global flow gives us information about which arguments in
+       a function application esacpe, so set only these as top. *)
     | Let (_, e) -> (
-        (* If e is impure, set all variables in e as Top. The only exception is for function applications, 
-           where we may be able to do better. Global flow gives us information about which arguments in
-           a function application esacpe, so set only these as top.  *)
         if not (pure_expr pure_funs e)
         then
           match e with
@@ -322,7 +322,7 @@ let zero prog sentinal live_table =
     while !i >= 0 && Var.equal vars.(!i) sentinal do
       i := !i - 1
     done;
-    Array.sub vars ~pos:0 ~len:(!i + 1)
+    if !i < Array.length vars - 1 then Array.sub vars ~pos:0 ~len:(!i + 1) else vars
   in
   let is_live v =
     match Var.Tbl.get live_table v with
@@ -349,21 +349,25 @@ let zero prog sentinal live_table =
         | Apply ap ->
             let args = List.map ~f:zero_var ap.args in
             Let (x, Apply { ap with args })
-        | _ -> instr)
-    | _ -> instr
+        | Field (_, _) | Closure (_, _) | Constant _ | Prim (_, _) -> instr)
+    | Assign (_, _) | Set_field (_, _, _) | Offset_ref (_, _) | Array_set (_, _, _) ->
+        instr
   in
   let zero_block block =
     (* Analyze block instructions *)
     let body = List.map ~f:(fun (instr, loc) -> zero_instr instr, loc) block.body in
     (* Analyze branch *)
     let branch =
-      let last, loc = block.branch in
-      let last =
-        match last with
-        | Return x -> Return (zero_var x)
-        | _ -> last
-      in
-      last, loc
+      (* Zero out return values in last instruction, otherwise do nothing. *)
+      match block.branch with
+      | Return x, loc -> Return (zero_var x), loc
+      | Raise (_, _), _
+      | Stop, _
+      | Branch _, _
+      | Cond (_, _, _), _
+      | Switch (_, _), _
+      | Pushtrap (_, _, _, _), _
+      | Poptrap _, _ -> block.branch
     in
     { block with body; branch }
   in

From 07c37bdcb8dfa0229c30b42e5ca28aea47b7bee3 Mon Sep 17 00:00:00 2001
From: Micah Cantor <micahcantor01@gmail.com>
Date: Tue, 17 Oct 2023 15:01:51 -0500
Subject: [PATCH 097/112] Don't expose add_sentinal

---
 compiler/lib/driver.ml           | 3 +--
 compiler/lib/global_deadcode.ml  | 6 ++++--
 compiler/lib/global_deadcode.mli | 4 +---
 3 files changed, 6 insertions(+), 7 deletions(-)

diff --git a/compiler/lib/driver.ml b/compiler/lib/driver.ml
index 172bdcb324..dbef4af4bb 100644
--- a/compiler/lib/driver.ml
+++ b/compiler/lib/driver.ml
@@ -107,9 +107,8 @@ let exact_calls profile p =
     let p, info, deadcode_sentinal =
       if Config.Flag.globaldeadcode ()
       then
-        let p, deadcode_sentinal = Global_deadcode.add_sentinal p in
         let info = Global_flow.f ~fast p in
-        let p = Global_deadcode.f p deadcode_sentinal info in
+        let p, deadcode_sentinal = Global_deadcode.f p info in
         p, info, deadcode_sentinal
       else
         let info = Global_flow.f ~fast p in
diff --git a/compiler/lib/global_deadcode.ml b/compiler/lib/global_deadcode.ml
index 38dfe0082a..8436052ae9 100644
--- a/compiler/lib/global_deadcode.ml
+++ b/compiler/lib/global_deadcode.ml
@@ -420,8 +420,10 @@ let add_sentinal p =
   Code.prepend p [ instr, loc ], sentinal
 
 (** Run the liveness analysis and replace dead variables with the given sentinal. *)
-let f p sentinal global_info =
+let f p global_info =
   let t = Timer.make () in
+  (* Add sentinal variable *)
+  let p, sentinal = add_sentinal p in
   (* Compute definitions *)
   let defs = definitions p in
   (* Compute usages *)
@@ -447,4 +449,4 @@ let f p sentinal global_info =
     Format.printf "After Zeroing:\n";
     Code.Print.program (fun _ _ -> "") p);
   if times () then Format.eprintf "  deadcode dgraph.: %a@." Timer.print t;
-  p
+  p, sentinal
diff --git a/compiler/lib/global_deadcode.mli b/compiler/lib/global_deadcode.mli
index 250a0edddd..80eb0ac95b 100644
--- a/compiler/lib/global_deadcode.mli
+++ b/compiler/lib/global_deadcode.mli
@@ -29,6 +29,4 @@ dead variables that are then removed by [deadcode.ml]. In particular it allows f
 in functors, which the original deadcode elimination cannot. 
 *)
 
-val add_sentinal : Code.program -> Code.program * Code.Var.t
-
-val f : Code.program -> Code.Var.t -> Global_flow.info -> Code.program
+val f : Code.program -> Global_flow.info -> (Code.program * Code.Var.t)

From 4026c20df511493ff5e095798e0328d83263e7f6 Mon Sep 17 00:00:00 2001
From: Micah Cantor <micahcantor01@gmail.com>
Date: Wed, 18 Oct 2023 09:25:48 -0500
Subject: [PATCH 098/112] typos

---
 compiler/lib/global_deadcode.ml | 9 ++-------
 1 file changed, 2 insertions(+), 7 deletions(-)

diff --git a/compiler/lib/global_deadcode.ml b/compiler/lib/global_deadcode.ml
index 8436052ae9..73c73e1fdd 100644
--- a/compiler/lib/global_deadcode.ml
+++ b/compiler/lib/global_deadcode.ml
@@ -214,7 +214,7 @@ let liveness prog pure_funs (global_info : Global_flow.info) =
     match i with
     (* If e is impure, set all variables in e as Top. The only exception is for function applications,
        where we may be able to do better. Global flow gives us information about which arguments in
-       a function application esacpe, so set only these as top. *)
+       a function application escape, so set only these as top. *)
     | Let (_, e) -> (
         if not (pure_expr pure_funs e)
         then
@@ -260,12 +260,7 @@ let variables deps =
 (** Propagate liveness of the usages of a variable [x] to [x]. The liveness of [x] is
     defined by joining its current liveness and the contribution of each vairable [y]
     that uses [x]. *)
-let propagate
-    (uses : usage_kind Var.Map.t Var.Tbl.t)
-    (defs : def Var.Tbl.t)
-    (live_vars : live Var.Tbl.t)
-    live_table
-    x =
+let propagate uses defs live_vars live_table x =
   (* Variable [y] uses [x] either in its definition ([Compute]) or as a closure/block parameter
       ([Propagate]). In the latter case, the contribution is simply the liveness of [y]. In the former,
        the contribution depends on the liveness of [y] and its definition. *)

From 18fd434292507ab96dfc76739f72c8d2f9a7ee70 Mon Sep 17 00:00:00 2001
From: Hugo Heuzard <hugo.heuzard@gmail.com>
Date: Wed, 18 Oct 2023 17:51:09 +0200
Subject: [PATCH 099/112] small cleanup

---
 compiler/lib/driver.ml           | 22 +++++++++-------------
 compiler/lib/global_deadcode.ml  | 15 +++++++--------
 compiler/lib/global_deadcode.mli | 25 +++++++++++++++----------
 3 files changed, 31 insertions(+), 31 deletions(-)

diff --git a/compiler/lib/driver.ml b/compiler/lib/driver.ml
index dbef4af4bb..1b2f38dfc0 100644
--- a/compiler/lib/driver.ml
+++ b/compiler/lib/driver.ml
@@ -97,6 +97,10 @@ let effects p =
   else p, (Code.Var.Set.empty : Effects.cps_calls)
 
 let exact_calls profile p =
+  let deadcode_sentinal =
+    (* If deadcode is disabled, this field is just fresh variable *)
+    Code.Var.fresh ()
+  in
   if not (Config.Flag.effects ())
   then
     let fast =
@@ -104,23 +108,15 @@ let exact_calls profile p =
       | O3 -> false
       | O1 | O2 -> true
     in
-    let p, info, deadcode_sentinal =
+    let info = Global_flow.f ~fast p in
+    let p =
       if Config.Flag.globaldeadcode ()
-      then
-        let info = Global_flow.f ~fast p in
-        let p, deadcode_sentinal = Global_deadcode.f p info in
-        p, info, deadcode_sentinal
-      else
-        let info = Global_flow.f ~fast p in
-        let deadcode_sentinal =
-          (* If deadcode is not enabled, this field is set to a dummy fresh variable *)
-          Code.Var.fresh ()
-        in
-        p, info, deadcode_sentinal
+      then Global_deadcode.f p ~deadcode_sentinal info
+      else p
     in
     let p = Specialize.f ~function_arity:(fun f -> Global_flow.function_arity info f) p in
     p, deadcode_sentinal
-  else p, Code.Var.fresh ()
+  else p, deadcode_sentinal
 
 let print p =
   if debug () then Code.Print.program (fun _ _ -> "") p;
diff --git a/compiler/lib/global_deadcode.ml b/compiler/lib/global_deadcode.ml
index 73c73e1fdd..c18f5c50f4 100644
--- a/compiler/lib/global_deadcode.ml
+++ b/compiler/lib/global_deadcode.ml
@@ -408,17 +408,16 @@ module Print = struct
 end
 
 (** Add a sentinal variable declaration to the IR. The fresh variable is assigned to `undefined`. *)
-let add_sentinal p =
-  let sentinal = Var.fresh_n "sentinal" in
+let add_sentinal p sentinal =
   let undefined = Prim (Extern "%undefined", []) in
-  let instr, loc = Let (sentinal, undefined), Before 0 in
-  Code.prepend p [ instr, loc ], sentinal
+  let instr, loc = Let (sentinal, undefined), noloc in
+  Code.prepend p [ instr, loc ]
 
 (** Run the liveness analysis and replace dead variables with the given sentinal. *)
-let f p global_info =
+let f p ~deadcode_sentinal global_info =
   let t = Timer.make () in
   (* Add sentinal variable *)
-  let p, sentinal = add_sentinal p in
+  let p = add_sentinal p deadcode_sentinal in
   (* Compute definitions *)
   let defs = definitions p in
   (* Compute usages *)
@@ -438,10 +437,10 @@ let f p global_info =
     Print.print_uses uses;
     Print.print_live_tbl live_table);
   (* Zero out dead fields *)
-  let p = zero p sentinal live_table in
+  let p = zero p deadcode_sentinal live_table in
   if debug ()
   then (
     Format.printf "After Zeroing:\n";
     Code.Print.program (fun _ _ -> "") p);
   if times () then Format.eprintf "  deadcode dgraph.: %a@." Timer.print t;
-  p, sentinal
+  p
diff --git a/compiler/lib/global_deadcode.mli b/compiler/lib/global_deadcode.mli
index 80eb0ac95b..0c44ef8d93 100644
--- a/compiler/lib/global_deadcode.mli
+++ b/compiler/lib/global_deadcode.mli
@@ -18,15 +18,20 @@
 
 (** Global deadcode elimination pass.
 
-This module provides a global liveness analysis more powerful than that found in [deadcode.ml]. In particular,
-this analysis annotates blocks with the specific fields that are live. It also uses [global_flow.ml] to determine
-the liveness of function return values. It first computes an initial liveness of each variable by traversing the program IR.
-Then it propagates this information to the dependencies of each variable using a flow analysis solver. Lastly it replaces
-dead variables with a sentinal zero variable (the JS value `undefined`).
+This module provides a global liveness analysis more powerful than
+that found in [deadcode.ml]. In particular, this analysis annotates
+blocks with the specific fields that are live. It also uses
+[global_flow.ml] to determine the liveness of function return
+values. It first computes an initial liveness of each variable by
+traversing the program IR.  Then it propagates this information to
+the dependencies of each variable using a flow analysis
+solver. Lastly it replaces dead variables with a sentinal zero
+variable (the JS value `undefined`).
 
-Although this module does not perform any dead-code elimination itself, it is designed to be used to identify and substitute 
-dead variables that are then removed by [deadcode.ml]. In particular it allows for the elimination of unused functions defined 
-in functors, which the original deadcode elimination cannot. 
-*)
+Although this module does not perform any dead-code elimination
+itself, it is designed to be used to identify and substitute dead
+variables that are then removed by [deadcode.ml]. In particular it
+allows for the elimination of unused functions defined in functors,
+which the original deadcode elimination cannot.  *)
 
-val f : Code.program -> Global_flow.info -> (Code.program * Code.Var.t)
+val f : Code.program -> deadcode_sentinal:Code.Var.t -> Global_flow.info -> Code.program

From 527998ce32874914f8edf2b3a2447ce6fb51a41d Mon Sep 17 00:00:00 2001
From: Hugo Heuzard <hugo.heuzard@gmail.com>
Date: Wed, 18 Oct 2023 17:52:57 +0200
Subject: [PATCH 100/112] CR

---
 compiler/lib/global_deadcode.ml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/compiler/lib/global_deadcode.ml b/compiler/lib/global_deadcode.ml
index c18f5c50f4..f955e6421a 100644
--- a/compiler/lib/global_deadcode.ml
+++ b/compiler/lib/global_deadcode.ml
@@ -317,7 +317,7 @@ let zero prog sentinal live_table =
     while !i >= 0 && Var.equal vars.(!i) sentinal do
       i := !i - 1
     done;
-    if !i < Array.length vars - 1 then Array.sub vars ~pos:0 ~len:(!i + 1) else vars
+    if !i + 1 < Array.length vars then Array.sub vars ~pos:0 ~len:(!i + 1) else vars
   in
   let is_live v =
     match Var.Tbl.get live_table v with

From a817445e3157c7289d85bd3184ef132cb8357c43 Mon Sep 17 00:00:00 2001
From: Micah Cantor <micahcantor01@gmail.com>
Date: Wed, 18 Oct 2023 14:29:01 -0500
Subject: [PATCH 101/112] cleanup

---
 compiler/lib/global_deadcode.ml | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/compiler/lib/global_deadcode.ml b/compiler/lib/global_deadcode.ml
index 73c73e1fdd..83490a5988 100644
--- a/compiler/lib/global_deadcode.ml
+++ b/compiler/lib/global_deadcode.ml
@@ -241,12 +241,11 @@ let liveness prog pure_funs (global_info : Global_flow.info) =
   let live_block block =
     List.iter ~f:(fun (i, _) -> live_instruction i) block.body;
     match fst block.branch with
-    | Stop -> ()
     | Return x -> if variable_may_escape x global_info then add_top x
     | Raise (x, _) -> add_top x
     | Cond (x, _, _) -> add_top x
     | Switch (x, _) -> add_top x
-    | Branch _ | Poptrap _ | Pushtrap _ -> ()
+    | Stop | Branch _ | Poptrap _ | Pushtrap _ -> ()
   in
   Addr.Map.iter (fun _ block -> live_block block) prog.blocks;
   live_vars

From 48fccd4502c0114a26b0c3595dc37773a74a6c42 Mon Sep 17 00:00:00 2001
From: Micah Cantor <micahcantor01@gmail.com>
Date: Thu, 19 Oct 2023 10:53:01 -0500
Subject: [PATCH 102/112] remove pure_expr alias

---
 compiler/lib/global_deadcode.ml | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/compiler/lib/global_deadcode.ml b/compiler/lib/global_deadcode.ml
index 9df9a3ef24..8417af0b57 100644
--- a/compiler/lib/global_deadcode.ml
+++ b/compiler/lib/global_deadcode.ml
@@ -58,8 +58,6 @@ end
 
 module Solver = G.Solver (Domain)
 
-let pure_expr pure_funs e = Pure_fun.pure_expr pure_funs e
-
 let definitions prog =
   let defs = Var.Tbl.make () Param in
   let set_def x d = Var.Tbl.set defs x d in
@@ -192,7 +190,7 @@ let expr_vars e =
 (** Compute the initial liveness of each variable in the program. 
 
     A variable [x] is marked as [Top] if 
-    + It is used in an impure expression (as defined by [pure_expr]);
+    + It is used in an impure expression (as defined by [Pure_fun.pure_expr]);
     + It is used in a conditonal/switch;
     + It is raised by an exception;
     + It is used in another stateful instruction (like setting a block or array field);
@@ -216,7 +214,7 @@ let liveness prog pure_funs (global_info : Global_flow.info) =
        where we may be able to do better. Global flow gives us information about which arguments in
        a function application escape, so set only these as top. *)
     | Let (_, e) -> (
-        if not (pure_expr pure_funs e)
+        if not (Pure_fun.pure_expr pure_funs e)
         then
           match e with
           | Apply { f; args; _ } ->

From 99caa929ee6f66437260688c9fc057bbc98a75a1 Mon Sep 17 00:00:00 2001
From: Hugo Heuzard <hugo.heuzard@gmail.com>
Date: Thu, 26 Oct 2023 11:43:34 +0200
Subject: [PATCH 103/112] Compiler: add purity for jsoo-special primitives

---
 compiler/lib/primitive.ml                  | 10 ++++++++-
 compiler/tests-compiler/global_deadcode.ml | 24 +++++++++++-----------
 2 files changed, 21 insertions(+), 13 deletions(-)

diff --git a/compiler/lib/primitive.ml b/compiler/lib/primitive.ml
index 55f9e8d27a..ee7f3ba72c 100644
--- a/compiler/lib/primitive.ml
+++ b/compiler/lib/primitive.ml
@@ -73,7 +73,15 @@ let arity nm = Hashtbl.find arities (resolve nm)
 
 let has_arity nm a = try Hashtbl.find arities (resolve nm) = a with Not_found -> false
 
-let is_pure nm = Poly.(kind nm <> `Mutator)
+let is_pure nm = match nm with
+  | "%undefined"
+  | "%closure"
+  | "%identity"
+  | "%direct_int_div"
+  | "%direct_int_mod"
+  | "%direct_int_mul"
+    -> true
+  | _ -> Poly.(kind nm <> `Mutator)
 
 let exists p = Hashtbl.mem kinds p
 
diff --git a/compiler/tests-compiler/global_deadcode.ml b/compiler/tests-compiler/global_deadcode.ml
index ab290f7313..49d1583dfc 100644
--- a/compiler/tests-compiler/global_deadcode.ml
+++ b/compiler/tests-compiler/global_deadcode.ml
@@ -41,30 +41,30 @@ let%expect_test "Eliminates unused functions from functor" =
     function create(l, v, r){
      if(l) var h = l[4], hl = h; else var hl = 0;
      if(r) var h$0 = r[4], hr = h$0; else var hr = 0;
-     var _m_ = hr <= hl ? hl + 1 | 0 : hr + 1 | 0;
-     return [0, l, v, r, _m_];
+     var _n_ = hr <= hl ? hl + 1 | 0 : hr + 1 | 0;
+     return [0, l, v, r, _n_];
     }
     function bal(l, v, r){
      if(l) var h = l[4], hl = h; else var hl = 0;
      if(r) var h$0 = r[4], hr = h$0; else var hr = 0;
      if((hr + 2 | 0) < hl){
       if(! l) return invalid_arg(_b_);
-      var lr = l[3], lv = l[2], ll = l[1], _h_ = height(lr);
-      if(_h_ <= height(ll)) return create(ll, lv, create(lr, v, r));
+      var lr = l[3], lv = l[2], ll = l[1], _i_ = height(lr);
+      if(_i_ <= height(ll)) return create(ll, lv, create(lr, v, r));
       if(! lr) return invalid_arg(_a_);
-      var lrr = lr[3], lrv = lr[2], lrl = lr[1], _i_ = create(lrr, v, r);
-      return create(create(ll, lv, lrl), lrv, _i_);
+      var lrr = lr[3], lrv = lr[2], lrl = lr[1], _j_ = create(lrr, v, r);
+      return create(create(ll, lv, lrl), lrv, _j_);
      }
      if((hl + 2 | 0) >= hr){
-      var _l_ = hr <= hl ? hl + 1 | 0 : hr + 1 | 0;
-      return [0, l, v, r, _l_];
+      var _m_ = hr <= hl ? hl + 1 | 0 : hr + 1 | 0;
+      return [0, l, v, r, _m_];
      }
      if(! r) return invalid_arg(_d_);
-     var rr = r[3], rv = r[2], rl = r[1], _j_ = height(rl);
-     if(_j_ <= height(rr)) return create(create(l, v, rl), rv, rr);
+     var rr = r[3], rv = r[2], rl = r[1], _k_ = height(rl);
+     if(_k_ <= height(rr)) return create(create(l, v, rl), rv, rr);
      if(! rl) return invalid_arg(_c_);
-     var rlr = rl[3], rlv = rl[2], rll = rl[1], _k_ = create(rlr, rv, rr);
-     return create(create(l, v, rll), rlv, _k_);
+     var rlr = rl[3], rlv = rl[2], rll = rl[1], _l_ = create(rlr, rv, rr);
+     return create(create(l, v, rll), rlv, _l_);
     }
     function add(x, t){
      if(! t) return [0, 0, x, 0, 1];

From ddc39573ef2d1dd1092bf9b1f08dca2f344c273d Mon Sep 17 00:00:00 2001
From: Micah Cantor <micahcantor01@gmail.com>
Date: Mon, 30 Oct 2023 10:14:02 -0500
Subject: [PATCH 104/112] make globaldeadcode default on

---
 compiler/lib/config.ml                     | 2 +-
 compiler/tests-compiler/global_deadcode.ml | 3 ---
 2 files changed, 1 insertion(+), 4 deletions(-)

diff --git a/compiler/lib/config.ml b/compiler/lib/config.ml
index 4d6ab7cc25..9385a063ba 100644
--- a/compiler/lib/config.ml
+++ b/compiler/lib/config.ml
@@ -58,7 +58,7 @@ module Flag = struct
 
   let deadcode = o ~name:"deadcode" ~default:true
 
-  let globaldeadcode = o ~name:"globaldeadcode" ~default:false
+  let globaldeadcode = o ~name:"globaldeadcode" ~default:true
 
   let shortvar = o ~name:"shortvar" ~default:true
 
diff --git a/compiler/tests-compiler/global_deadcode.ml b/compiler/tests-compiler/global_deadcode.ml
index 49d1583dfc..d5ccec6b8a 100644
--- a/compiler/tests-compiler/global_deadcode.ml
+++ b/compiler/tests-compiler/global_deadcode.ml
@@ -4,7 +4,6 @@ let%expect_test "Eliminates unused functions from functor" =
   let program =
     (* Create two instances of Set functor so compiler can't inline one implementation. *)
     compile_and_parse_whole_program
-      ~flags:[ "--enable"; "globaldeadcode" ]
       {|
       module Int_set = Set.Make (Int);;
       module String_set = Set.Make (String);;
@@ -95,7 +94,6 @@ let%expect_test "Eliminates unused functions from functor" =
 let%expect_test "Omit unused fields" =
   let program =
     compile_and_parse
-      ~flags:[ "--enable"; "globaldeadcode" ]
       {|
       let f b x =
         let t = if b then (1, 2, x) else (3, x, 4) in
@@ -117,7 +115,6 @@ let%expect_test "Omit unused fields" =
 let%expect_test "Omit unused return expressions" =
   let program =
     compile_and_parse
-      ~flags:[ "--enable"; "globaldeadcode" ]
       {|
       let f x =
         print_int x;

From 1c492f09dd150a815d059b85d8c76d41d467cf85 Mon Sep 17 00:00:00 2001
From: Micah Cantor <micahcantor01@gmail.com>
Date: Mon, 30 Oct 2023 14:16:25 -0500
Subject: [PATCH 105/112] Fix offset_ref liveness

---
 compiler/lib/global_deadcode.ml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/compiler/lib/global_deadcode.ml b/compiler/lib/global_deadcode.ml
index 8417af0b57..2d1e6a0946 100644
--- a/compiler/lib/global_deadcode.ml
+++ b/compiler/lib/global_deadcode.ml
@@ -232,7 +232,7 @@ let liveness prog pure_funs (global_info : Global_flow.info) =
         add_top x;
         add_top y;
         add_top z
-    | Offset_ref (x, i) -> add_live_field x i
+    | Offset_ref (x, _) -> add_live_field x 0
     (* Assignment can be ignored. Liveness of old variable is just propagated to new variable. See [usages]. *)
     | Assign (_, _) -> ()
   in

From 70664e97a3697dc59d845558b6db91bed7a31147 Mon Sep 17 00:00:00 2001
From: Micah Cantor <micahcantor01@gmail.com>
Date: Mon, 30 Oct 2023 14:31:58 -0500
Subject: [PATCH 106/112] promote output changes from default on

---
 compiler/tests-compiler/direct_calls.ml |  20 ++---
 compiler/tests-compiler/gh1007.ml       | 100 +++++++++++++-----------
 compiler/tests-compiler/gh1494.ml       |   2 +-
 3 files changed, 65 insertions(+), 57 deletions(-)

diff --git a/compiler/tests-compiler/direct_calls.ml b/compiler/tests-compiler/direct_calls.ml
index 30fdcc82fd..a6148b9780 100644
--- a/compiler/tests-compiler/direct_calls.ml
+++ b/compiler/tests-compiler/direct_calls.ml
@@ -57,26 +57,26 @@ let%expect_test "direct calls without --enable effects" =
   [%expect
     {|
     function test1(param){
-     function f(g, x){return caml_call1(g, x);}
-     var _d_ = 7;
-     f(function(x){return x + 1 | 0;}, _d_);
-     var _e_ = 4.;
-     f(function(x){return x * 2.;}, _e_);
+     function f(g, x){caml_call1(g, x); return;}
+     var _e_ = 7;
+     f(function(x){return x + 1 | 0;}, _e_);
+     var _f_ = 4.;
+     f(function(x){return x * 2.;}, _f_);
      return 0;
     }
     //end
     function test2(param){
-     function f(g, x){return caml_call1(g, x);}
-     var _c_ = 7;
-     f(function(x){return x + 1 | 0;}, _c_);
+     function f(g, x){caml_call1(g, x); return;}
+     var _d_ = 7;
+     f(function(x){return x + 1 | 0;}, _d_);
      f(function(x){return caml_call2(Stdlib[28], x, cst_a$0);}, cst_a);
      return 0;
     }
     //end
     function test3(x){
      function F(symbol){function f(x){return x + 1 | 0;} return [0, f];}
-     var M1 = F([0]), M2 = F([0]), _b_ = M2[1].call(null, 2);
-     return [0, M1[1].call(null, 1), _b_];
+     var M1 = F([0]), M2 = F([0]), _c_ = M2[1].call(null, 2);
+     return [0, M1[1].call(null, 1), _c_];
     }
     //end
     function test4(x){
diff --git a/compiler/tests-compiler/gh1007.ml b/compiler/tests-compiler/gh1007.ml
index 46eb031059..322e329ed5 100644
--- a/compiler/tests-compiler/gh1007.ml
+++ b/compiler/tests-compiler/gh1007.ml
@@ -366,30 +366,34 @@ let ()  = M.run ()
       var
        even =
          function(n){
-          if(2 < n >>> 0) return 1 - (1 - odd(n - 1 | 0));
-          switch(n){
-            case 0:
-             return 1;
-            case 1:
-             return 1 - (1 - odd(0));
-            default: return 1 - (1 - odd(1));
-          }
+          if(2 >= n >>> 0)
+           switch(n){
+             case 0:
+              return;
+             case 1:
+              odd(0); return;
+             default: odd(1); return;
+           }
+          odd(n - 1 | 0);
+          return;
          },
        odd =
          function(n){
-          if(2 < n >>> 0) return 1 - (1 - even(n - 1 | 0));
-          switch(n){
-            case 0:
-             return 0;
-            case 1:
-             return 1 - (1 - even(0));
-            default: return 1 - (1 - even(1));
-          }
+          if(2 >= n >>> 0)
+           switch(n){
+             case 0:
+              return;
+             case 1:
+              even(0); return;
+             default: even(1); return;
+           }
+          even(n - 1 | 0);
+          return;
          };
       even(i);
-      var _a_ = i + 1 | 0;
+      var _b_ = i + 1 | 0;
       if(4 === i) return 0;
-      var i = _a_;
+      var i = _b_;
      }
     }
     //end |}]
@@ -463,32 +467,36 @@ let ()  = M.run ()
        closures =
          function(i){
           function even(n){
-           if(2 < n >>> 0) return 1 - (1 - odd(n - 1 | 0));
-           switch(n){
-             case 0:
-              var
-               f = function(param){return caml_call2(Stdlib_Printf[2], _c_, i);};
-              delayed[1] = [0, f, delayed[1]];
-              f(0);
-              return 1;
-             case 1:
-              return 1 - (1 - odd(0));
-             default: return 1 - (1 - odd(1));
-           }
+           if(2 >= n >>> 0)
+            switch(n){
+              case 0:
+               var
+                f = function(param){return caml_call2(Stdlib_Printf[2], _c_, i);};
+               delayed[1] = [0, f, delayed[1]];
+               f(0);
+               return;
+              case 1:
+               odd(0); return;
+              default: odd(1); return;
+            }
+           odd(n - 1 | 0);
+           return;
           }
           function odd(n){
-           if(2 < n >>> 0) return 1 - (1 - even(n - 1 | 0));
-           switch(n){
-             case 0:
-              var
-               f = function(param){return caml_call2(Stdlib_Printf[2], _b_, i);};
-              delayed[1] = [0, f, delayed[1]];
-              f(0);
-              return 0;
-             case 1:
-              return 1 - (1 - even(0));
-             default: return 1 - (1 - even(1));
-           }
+           if(2 >= n >>> 0)
+            switch(n){
+              case 0:
+               var
+                f = function(param){return caml_call2(Stdlib_Printf[2], _b_, i);};
+               delayed[1] = [0, f, delayed[1]];
+               f(0);
+               return;
+              case 1:
+               even(0); return;
+              default: even(1); return;
+            }
+           even(n - 1 | 0);
+           return;
           }
           var block = [0, even, odd];
           return block;
@@ -496,12 +504,12 @@ let ()  = M.run ()
        closures$0 = closures(i),
        even = closures$0[1];
       even(i);
-      var _e_ = i + 1 | 0;
+      var _f_ = i + 1 | 0;
       if(4 === i){
-       var _d_ = caml_call1(list_rev, delayed[1]);
-       return caml_call2(list_iter, function(f){return caml_call1(f, 0);}, _d_);
+       var _e_ = caml_call1(list_rev, delayed[1]);
+       return caml_call2(list_iter, function(f){return caml_call1(f, 0);}, _e_);
       }
-      var i = _e_;
+      var i = _f_;
      }
     }
     //end |}]
diff --git a/compiler/tests-compiler/gh1494.ml b/compiler/tests-compiler/gh1494.ml
index fd646b38f2..17cab23faf 100644
--- a/compiler/tests-compiler/gh1494.ml
+++ b/compiler/tests-compiler/gh1494.ml
@@ -39,7 +39,7 @@ let () =
   [%expect
     {|
     function bug(param){
-     var g = [0, function(x){return function(_c_){return _c_;};}];
+     var g = [0, function(x){return function(_d_){return _d_;};}];
      return [0, function(param){return caml_call1(g[1], 1);}, g];
     }
     //end |}]

From 8d1841f748ab5ef4a4eb37d4b1e13dddc934b132 Mon Sep 17 00:00:00 2001
From: Hugo Heuzard <hugo.heuzard@gmail.com>
Date: Tue, 31 Oct 2023 10:21:31 +0100
Subject: [PATCH 107/112] tune

---
 compiler/lib/primitive.ml         |   6 +-
 compiler/tests-compiler/gh1007.ml | 108 ++++++++++++++----------------
 2 files changed, 53 insertions(+), 61 deletions(-)

diff --git a/compiler/lib/primitive.ml b/compiler/lib/primitive.ml
index ee7f3ba72c..b1a4a6adf5 100644
--- a/compiler/lib/primitive.ml
+++ b/compiler/lib/primitive.ml
@@ -73,14 +73,14 @@ let arity nm = Hashtbl.find arities (resolve nm)
 
 let has_arity nm a = try Hashtbl.find arities (resolve nm) = a with Not_found -> false
 
-let is_pure nm = match nm with
+let is_pure nm =
+  match nm with
   | "%undefined"
   | "%closure"
   | "%identity"
   | "%direct_int_div"
   | "%direct_int_mod"
-  | "%direct_int_mul"
-    -> true
+  | "%direct_int_mul" -> true
   | _ -> Poly.(kind nm <> `Mutator)
 
 let exists p = Hashtbl.mem kinds p
diff --git a/compiler/tests-compiler/gh1007.ml b/compiler/tests-compiler/gh1007.ml
index 322e329ed5..084225d871 100644
--- a/compiler/tests-compiler/gh1007.ml
+++ b/compiler/tests-compiler/gh1007.ml
@@ -347,7 +347,7 @@ end = struct
 
  let run () =
    for i = 0 to 4 do
-     ignore (even (i) : bool)
+     if even (i) then print_string ""
    done
 end
 
@@ -366,34 +366,30 @@ let ()  = M.run ()
       var
        even =
          function(n){
-          if(2 >= n >>> 0)
-           switch(n){
-             case 0:
-              return;
-             case 1:
-              odd(0); return;
-             default: odd(1); return;
-           }
-          odd(n - 1 | 0);
-          return;
+          if(2 < n >>> 0) return 1 - (1 - odd(n - 1 | 0));
+          switch(n){
+            case 0:
+             return 1;
+            case 1:
+             return 1 - (1 - odd(0));
+            default: return 1 - (1 - odd(1));
+          }
          },
        odd =
          function(n){
-          if(2 >= n >>> 0)
-           switch(n){
-             case 0:
-              return;
-             case 1:
-              even(0); return;
-             default: even(1); return;
-           }
-          even(n - 1 | 0);
-          return;
+          if(2 < n >>> 0) return 1 - (1 - even(n - 1 | 0));
+          switch(n){
+            case 0:
+             return 0;
+            case 1:
+             return 1 - (1 - even(0));
+            default: return 1 - (1 - even(1));
+          }
          };
-      even(i);
-      var _b_ = i + 1 | 0;
+      if(even(i)) caml_call1(Stdlib[42], cst);
+      var _a_ = i + 1 | 0;
       if(4 === i) return 0;
-      var i = _b_;
+      var i = _a_;
      }
     }
     //end |}]
@@ -435,7 +431,7 @@ end = struct
 
  let run () =
    for i = 0 to 4 do
-     ignore (even (i) : bool)
+     if even (i) then print_string ""
    done;
    list_iter (fun f -> f ()) (list_rev !delayed)
 end
@@ -467,49 +463,45 @@ let ()  = M.run ()
        closures =
          function(i){
           function even(n){
-           if(2 >= n >>> 0)
-            switch(n){
-              case 0:
-               var
-                f = function(param){return caml_call2(Stdlib_Printf[2], _c_, i);};
-               delayed[1] = [0, f, delayed[1]];
-               f(0);
-               return;
-              case 1:
-               odd(0); return;
-              default: odd(1); return;
-            }
-           odd(n - 1 | 0);
-           return;
+           if(2 < n >>> 0) return 1 - (1 - odd(n - 1 | 0));
+           switch(n){
+             case 0:
+              var
+               f = function(param){return caml_call2(Stdlib_Printf[2], _c_, i);};
+              delayed[1] = [0, f, delayed[1]];
+              f(0);
+              return 1;
+             case 1:
+              return 1 - (1 - odd(0));
+             default: return 1 - (1 - odd(1));
+           }
           }
           function odd(n){
-           if(2 >= n >>> 0)
-            switch(n){
-              case 0:
-               var
-                f = function(param){return caml_call2(Stdlib_Printf[2], _b_, i);};
-               delayed[1] = [0, f, delayed[1]];
-               f(0);
-               return;
-              case 1:
-               even(0); return;
-              default: even(1); return;
-            }
-           even(n - 1 | 0);
-           return;
+           if(2 < n >>> 0) return 1 - (1 - even(n - 1 | 0));
+           switch(n){
+             case 0:
+              var
+               f = function(param){return caml_call2(Stdlib_Printf[2], _b_, i);};
+              delayed[1] = [0, f, delayed[1]];
+              f(0);
+              return 0;
+             case 1:
+              return 1 - (1 - even(0));
+             default: return 1 - (1 - even(1));
+           }
           }
           var block = [0, even, odd];
           return block;
          },
        closures$0 = closures(i),
        even = closures$0[1];
-      even(i);
-      var _f_ = i + 1 | 0;
+      if(even(i)) caml_call1(Stdlib[42], cst);
+      var _e_ = i + 1 | 0;
       if(4 === i){
-       var _e_ = caml_call1(list_rev, delayed[1]);
-       return caml_call2(list_iter, function(f){return caml_call1(f, 0);}, _e_);
+       var _d_ = caml_call1(list_rev, delayed[1]);
+       return caml_call2(list_iter, function(f){return caml_call1(f, 0);}, _d_);
       }
-      var i = _f_;
+      var i = _e_;
      }
     }
     //end |}]

From 47a69f9f51a8f15ec045fce7327ac1a6cce9c6ea Mon Sep 17 00:00:00 2001
From: Micah Cantor <micahcantor01@gmail.com>
Date: Thu, 9 Nov 2023 19:53:41 -0600
Subject: [PATCH 108/112] change log

---
 CHANGES.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/CHANGES.md b/CHANGES.md
index 2ba018e26e..e7f5362330 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -1,6 +1,7 @@
 # Dev (2023-??-??) - ??
 
 ## Features/Changes
+* Compiler: global dead code elimination (#1503)
 * Compiler: change control-flow compilation strategy (#1496)
 * Compiler: Dead code elimination of unused references (#2076)
 * Compiler: reduce memory consumption (#1516)

From d4c57b94262240744452722508b88698352fa2ed Mon Sep 17 00:00:00 2001
From: Hugo Heuzard <hugo.heuzard@gmail.com>
Date: Fri, 10 Nov 2023 08:46:05 +0100
Subject: [PATCH 109/112] no global deadcode if no deadcode

---
 compiler/lib/driver.ml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/compiler/lib/driver.ml b/compiler/lib/driver.ml
index 1b2f38dfc0..a291924c9d 100644
--- a/compiler/lib/driver.ml
+++ b/compiler/lib/driver.ml
@@ -110,7 +110,7 @@ let exact_calls profile p =
     in
     let info = Global_flow.f ~fast p in
     let p =
-      if Config.Flag.globaldeadcode ()
+      if Config.Flag.globaldeadcode () && Config.Flag.deadcode ()
       then Global_deadcode.f p ~deadcode_sentinal info
       else p
     in

From dffa09a8e1549ee4e0fb05c518b8919ba8538d04 Mon Sep 17 00:00:00 2001
From: Hugo Heuzard <hugo.heuzard@gmail.com>
Date: Sat, 11 Nov 2023 08:22:43 +0100
Subject: [PATCH 110/112] rm trailing space

---
 compiler/lib/global_deadcode.ml | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/compiler/lib/global_deadcode.ml b/compiler/lib/global_deadcode.ml
index 2d1e6a0946..f6ad5b7743 100644
--- a/compiler/lib/global_deadcode.ml
+++ b/compiler/lib/global_deadcode.ml
@@ -86,8 +86,8 @@ type usage_kind =
 
 (** Compute the adjacency list for the dependency graph of given program. An edge between
     variables [x] and [y] is marked [Compute] if [x] is used in the definition of [y]. It is marked
-    as [Propagate] if [x] is applied as a closure or block argument the parameter [y]. 
-    
+    as [Propagate] if [x] is applied as a closure or block argument the parameter [y].
+
     We use information from global flow to try to add edges between function calls and their return values
     at known call sites. *)
 let usages prog (global_info : Global_flow.info) : usage_kind Var.Map.t Var.Tbl.t =
@@ -187,15 +187,15 @@ let expr_vars e =
      but we will add these when we visit the body *)
   | Constant _ | Closure (_, _) -> vars
 
-(** Compute the initial liveness of each variable in the program. 
+(** Compute the initial liveness of each variable in the program.
 
-    A variable [x] is marked as [Top] if 
+    A variable [x] is marked as [Top] if
     + It is used in an impure expression (as defined by [Pure_fun.pure_expr]);
     + It is used in a conditonal/switch;
     + It is raised by an exception;
     + It is used in another stateful instruction (like setting a block or array field);
     + Or, it is returned or applied to a function and the global flow analysis marked it as escaping.
-    
+
     A variable [x[i]] is marked as [Live {i}] if it is used in an instruction where field [i] is referenced or set. *)
 let liveness prog pure_funs (global_info : Global_flow.info) =
   let live_vars = Var.Tbl.make () Dead in
@@ -301,12 +301,12 @@ let solver vars uses defs live_vars =
   in
   Solver.f () (G.invert () g) (propagate uses defs live_vars)
 
-(** Replace each instance of a dead variable with a sentinal value. 
-  Blocks that end in dead variables are compacted to the first live entry. 
+(** Replace each instance of a dead variable with a sentinal value.
+  Blocks that end in dead variables are compacted to the first live entry.
   Dead variables are replaced when
     + They appear in a dead field of a block; or
     + They are returned; or
-    + They are applied to a function. 
+    + They are applied to a function.
  *)
 let zero prog sentinal live_table =
   let compact_vars vars =

From 1a135ea935f2cdde74d074a22c2dfd224c08f6ca Mon Sep 17 00:00:00 2001
From: Hugo Heuzard <hugo.heuzard@gmail.com>
Date: Sat, 11 Nov 2023 08:25:28 +0100
Subject: [PATCH 111/112] accept

---
 compiler/tests-full/stdlib.cma.expected.js | 4906 ++++++++++----------
 1 file changed, 2490 insertions(+), 2416 deletions(-)

diff --git a/compiler/tests-full/stdlib.cma.expected.js b/compiler/tests-full/stdlib.cma.expected.js
index e95d98a6a6..859f00feef 100644
--- a/compiler/tests-full/stdlib.cma.expected.js
+++ b/compiler/tests-full/stdlib.cma.expected.js
@@ -1284,6 +1284,7 @@
     Stdlib = global_data.Stdlib,
     Assert_failure = global_data.Assert_failure,
     Stdlib_Sys = global_data.Stdlib__Sys,
+    _b_ = undefined,
     cst_Obj_Ephemeron_blit_key = "Obj.Ephemeron.blit_key",
     cst_Obj_Ephemeron_check_key = "Obj.Ephemeron.check_key",
     cst_Obj_Ephemeron_unset_key = "Obj.Ephemeron.unset_key",
@@ -1361,9 +1362,9 @@
     max_ephe_length = Stdlib_Sys[13] - 2 | 0;
    function create(l){
      /*<<obj.ml:132:4>>*/ var
-     _g_ = 0 <= l ? 1 : 0,
-     _h_ = _g_ ? l <= max_ephe_length ? 1 : 0 : _g_;
-    if(1 - _h_)
+     _h_ = 0 <= l ? 1 : 0,
+     _i_ = _h_ ? l <= max_ephe_length ? 1 : 0 : _h_;
+    if(1 - _i_)
       /*<<obj.ml:133:6>>*/  /*<<obj.ml:133:6>>*/ caml_call1
       (Stdlib[1], cst_Obj_Ephemeron_create);
      /*<<obj.ml:134:4>>*/ return  /*<<obj.ml:134:4>>*/ runtime.caml_ephe_create
@@ -1374,10 +1375,12 @@
     /*<<obj.ml:136:49>>*/ }
    function raise_if_invalid_offset(e, o, msg){
      /*<<obj.ml:139:4>>*/ var
-     _d_ = 0 <= o ? 1 : 0,
-     _e_ = _d_ ? o < length(e) ? 1 : 0 : _d_,
-     _f_ = 1 - _e_;
-    return _f_ ?  /*<<obj.ml:140:6>>*/ caml_call1(Stdlib[1], msg) : _f_;
+     _e_ = 0 <= o ? 1 : 0,
+     _f_ = _e_ ? o < length(e) ? 1 : 0 : _e_,
+     _g_ = 1 - _f_;
+    if(! _g_) return _g_;
+     /*<<obj.ml:140:6>>*/  /*<<obj.ml:140:6>>*/ caml_call1(Stdlib[1], msg);
+     /*<<obj.ml:140:6>>*/ return;
     /*<<obj.ml:140:21>>*/ }
    function get_key(e, o){
      /*<<obj.ml:144:4>>*/ raise_if_invalid_offset
@@ -1416,13 +1419,13 @@
        0 <= o1
        && (length(e1) - l | 0) >= o1 && 0 <= o2 && (length(e2) - l | 0) >= o2){
      var
-      _b_ = 0 !== l ? 1 : 0,
-      _c_ =
-        _b_
+      _c_ = 0 !== l ? 1 : 0,
+      _d_ =
+        _c_
          ?  /*<<obj.ml:174:24>>*/ runtime.caml_ephe_blit_key
            (e1, o1, e2, o2, l)
-         : _b_;
-      /*<<obj.ml:174:24>>*/ return _c_;
+         : _c_;
+      /*<<obj.ml:174:24>>*/ return _d_;
     }
      /*<<obj.ml:173:9>>*/ return  /*<<obj.ml:173:9>>*/ caml_call1
             (Stdlib[1], cst_Obj_Ephemeron_blit_key);
@@ -4970,6 +4973,7 @@
             : runtime.caml_call_gen(f, [a0, a1]);
    }
    var
+    _g_ = undefined,
     global_data = runtime.caml_get_global_data(),
     Stdlib = global_data.Stdlib,
     Stdlib_Uchar = global_data.Stdlib__Uchar,
@@ -5014,15 +5018,15 @@
    function init(n, f){
      /*<<bytes.ml:47:2>>*/ var
       /*<<bytes.ml:47:10>>*/ s =  /*<<bytes.ml:47:10>>*/ caml_create_bytes(n),
-      /*<<bytes.ml:48:2>>*/ _aq_ = n - 1 | 0,
-      /*<<bytes.ml:47:10>>*/ _ap_ = 0;
-    if(_aq_ >= 0){
-     var i = _ap_;
+      /*<<bytes.ml:48:2>>*/ _ar_ = n - 1 | 0,
+      /*<<bytes.ml:47:10>>*/ _aq_ = 0;
+    if(_ar_ >= 0){
+     var i = _aq_;
      for(;;){
       caml_bytes_unsafe_set(s, i,  /*<<bytes.ml:49:19>>*/ caml_call1(f, i));
-       /*<<bytes.ml:48:2>>*/  /*<<bytes.ml:48:2>>*/ var _ar_ = i + 1 | 0;
-      if(_aq_ === i) break;
-      var i = _ar_;
+       /*<<bytes.ml:48:2>>*/  /*<<bytes.ml:48:2>>*/ var _as_ = i + 1 | 0;
+      if(_ar_ === i) break;
+      var i = _as_;
      }
     }
      /*<<bytes.ml:51:2>>*/ return s;
@@ -5064,11 +5068,11 @@
    function symbol(a, b){
      /*<<bytes.ml:77:2>>*/ var
      c = a + b | 0,
-     _ao_ = b < 0 ? 1 : 0,
+     _ap_ = b < 0 ? 1 : 0,
      match = c < 0 ? 1 : 0;
     a:
     {
-     if(a < 0){if(_ao_ && ! match) break a;} else if(! _ao_ && match) break a;
+     if(a < 0){if(_ap_ && ! match) break a;} else if(! _ap_ && match) break a;
       /*<<bytes.ml:81:9>>*/ return c;
     }
      /*<<bytes.ml:80:27>>*/ return  /*<<bytes.ml:80:27>>*/ caml_call1
@@ -5131,32 +5135,32 @@
     /*<<bytes.ml:106:45>>*/ }
    function iter(f, a){
      /*<<bytes.ml:110:2>>*/ var
-     _am_ = caml_ml_bytes_length(a) - 1 | 0,
-      /*<<bytes.ml:110:2>>*/ _al_ = 0;
-    if(_am_ >= 0){
-     var i = _al_;
+     _an_ = caml_ml_bytes_length(a) - 1 | 0,
+      /*<<bytes.ml:110:2>>*/ _am_ = 0;
+    if(_an_ >= 0){
+     var i = _am_;
      for(;;){
        /*<<bytes.ml:110:31>>*/  /*<<bytes.ml:110:31>>*/ caml_call1
        (f, caml_bytes_unsafe_get(a, i));
-       /*<<bytes.ml:110:31>>*/  /*<<bytes.ml:110:31>>*/ var _an_ = i + 1 | 0;
-      if(_am_ === i) break;
-      var i = _an_;
+       /*<<bytes.ml:110:31>>*/  /*<<bytes.ml:110:31>>*/ var _ao_ = i + 1 | 0;
+      if(_an_ === i) break;
+      var i = _ao_;
      }
     }
     return 0;
     /*<<bytes.ml:110:53>>*/ }
    function iteri(f, a){
      /*<<bytes.ml:114:2>>*/ var
-     _aj_ = caml_ml_bytes_length(a) - 1 | 0,
-      /*<<bytes.ml:114:2>>*/ _ai_ = 0;
-    if(_aj_ >= 0){
-     var i = _ai_;
+     _ak_ = caml_ml_bytes_length(a) - 1 | 0,
+      /*<<bytes.ml:114:2>>*/ _aj_ = 0;
+    if(_ak_ >= 0){
+     var i = _aj_;
      for(;;){
        /*<<bytes.ml:114:31>>*/  /*<<bytes.ml:114:31>>*/ caml_call2
        (f, i, caml_bytes_unsafe_get(a, i));
-       /*<<bytes.ml:114:31>>*/  /*<<bytes.ml:114:31>>*/ var _ak_ = i + 1 | 0;
-      if(_aj_ === i) break;
-      var i = _ak_;
+       /*<<bytes.ml:114:31>>*/  /*<<bytes.ml:114:31>>*/ var _al_ = i + 1 | 0;
+      if(_ak_ === i) break;
+      var i = _al_;
      }
     }
     return 0;
@@ -5179,13 +5183,13 @@
         param = tl;
        continue;
       }
-      var _ah_ = caml_ml_bytes_length(hd) + acc | 0;
+      var _ai_ = caml_ml_bytes_length(hd) + acc | 0;
      }
      else
-      var _ah_ = acc;
+      var _ai_ = acc;
       /*<<bytes.ml:136:12>>*/ var
        /*<<bytes.ml:136:12>>*/ dst =
-         /*<<bytes.ml:136:12>>*/ caml_create_bytes(_ah_),
+         /*<<bytes.ml:136:12>>*/ caml_create_bytes(_ai_),
       pos = pos$1,
       param$0 = l;
      for(;;){
@@ -5223,10 +5227,10 @@
     /*<<bytes.ml:145:3>>*/ }
    function is_space(param){
      /*<<bytes.ml:151:15>>*/  /*<<bytes.ml:151:15>>*/ var
-     _ag_ = param - 9 | 0;
+     _ah_ = param - 9 | 0;
     a:
     {
-     if(4 < _ag_ >>> 0){if(23 !== _ag_) break a;} else if(2 === _ag_) break a;
+     if(4 < _ah_ >>> 0){if(23 !== _ah_) break a;} else if(2 === _ah_) break a;
       /*<<bytes.ml:152:41>>*/ return 1;
     }
      /*<<bytes.ml:153:9>>*/ return 0;
@@ -5250,10 +5254,10 @@
    function unsafe_escape(s){
      /*<<bytes.ml:184:2>>*/ var
       /*<<bytes.ml:184:10>>*/ n = [0, 0],
-     _$_ = caml_ml_bytes_length(s) - 1 | 0,
-      /*<<bytes.ml:184:10>>*/ ___ = 0;
-    if(_$_ >= 0){
-     var i$0 = ___;
+     _aa_ = caml_ml_bytes_length(s) - 1 | 0,
+      /*<<bytes.ml:184:10>>*/ _$_ = 0;
+    if(_aa_ >= 0){
+     var i$0 = _$_;
      for(;;){
       var match = caml_bytes_unsafe_get(s, i$0);
       a:
@@ -5263,12 +5267,12 @@
         c:
         {
          if(32 <= match){
-          var _ad_ = match - 34 | 0;
-          if(58 < _ad_ >>> 0){
-           if(93 <= _ad_) break c;
+          var _ae_ = match - 34 | 0;
+          if(58 < _ae_ >>> 0){
+           if(93 <= _ae_) break c;
           }
-          else if(56 < _ad_ - 1 >>> 0) break b;
-          var _ae_ = 1;
+          else if(56 < _ae_ - 1 >>> 0) break b;
+          var _af_ = 1;
           break a;
          }
          if(11 <= match){
@@ -5276,15 +5280,15 @@
          }
          else if(8 <= match) break b;
         }
-        var _ae_ = 4;
+        var _af_ = 4;
         break a;
        }
-       var _ae_ = 2;
+       var _af_ = 2;
       }
-      n[1] = n[1] + _ae_ | 0;
-       /*<<bytes.ml:185:2>>*/  /*<<bytes.ml:185:2>>*/ var _af_ = i$0 + 1 | 0;
-      if(_$_ === i$0) break;
-      var i$0 = _af_;
+      n[1] = n[1] + _af_ | 0;
+       /*<<bytes.ml:185:2>>*/  /*<<bytes.ml:185:2>>*/ var _ag_ = i$0 + 1 | 0;
+      if(_aa_ === i$0) break;
+      var i$0 = _ag_;
      }
     }
     if(n[1] === caml_ml_bytes_length(s))  /*<<bytes.ml:192:24>>*/ return s;
@@ -5292,10 +5296,10 @@
      s$0 =  /*<<bytes.ml:194:13>>*/ caml_create_bytes(n[1]);
     n[1] = 0;
      /*<<bytes.ml:196:4>>*/ var
-     _ab_ = caml_ml_bytes_length(s) - 1 | 0,
-      /*<<bytes.ml:196:4>>*/ _aa_ = 0;
-    if(_ab_ >= 0){
-     var i = _aa_;
+     _ac_ = caml_ml_bytes_length(s) - 1 | 0,
+      /*<<bytes.ml:196:4>>*/ _ab_ = 0;
+    if(_ac_ >= 0){
+     var i = _ab_;
      for(;;){
       var c = caml_bytes_unsafe_get(s, i);
       a:
@@ -5353,9 +5357,9 @@
        caml_bytes_unsafe_set(s$0, n[1], c);
       }
       n[1]++;
-       /*<<bytes.ml:196:4>>*/  /*<<bytes.ml:196:4>>*/ var _ac_ = i + 1 | 0;
-      if(_ab_ === i) break;
-      var i = _ac_;
+       /*<<bytes.ml:196:4>>*/  /*<<bytes.ml:196:4>>*/ var _ad_ = i + 1 | 0;
+      if(_ac_ === i) break;
+      var i = _ad_;
      }
     }
      /*<<bytes.ml:221:4>>*/ return s$0;
@@ -5370,18 +5374,18 @@
      /*<<bytes.ml:233:12>>*/ var
       /*<<bytes.ml:233:12>>*/ r =
         /*<<bytes.ml:233:12>>*/ caml_create_bytes(l),
-      /*<<bytes.ml:234:4>>*/ _Y_ = l - 1 | 0,
-      /*<<bytes.ml:233:12>>*/ _X_ = 0;
-    if(_Y_ >= 0){
-     var i = _X_;
+      /*<<bytes.ml:234:4>>*/ _Z_ = l - 1 | 0,
+      /*<<bytes.ml:233:12>>*/ _Y_ = 0;
+    if(_Z_ >= 0){
+     var i = _Y_;
      for(;;){
       caml_bytes_unsafe_set
        (r,
         i,
          /*<<bytes.ml:234:41>>*/ caml_call1(f, caml_bytes_unsafe_get(s, i)));
-       /*<<bytes.ml:234:4>>*/  /*<<bytes.ml:234:4>>*/ var _Z_ = i + 1 | 0;
-      if(_Y_ === i) break;
-      var i = _Z_;
+       /*<<bytes.ml:234:4>>*/  /*<<bytes.ml:234:4>>*/ var ___ = i + 1 | 0;
+      if(_Z_ === i) break;
+      var i = ___;
      }
     }
      /*<<bytes.ml:235:4>>*/ return r;
@@ -5392,18 +5396,18 @@
      /*<<bytes.ml:241:12>>*/ var
       /*<<bytes.ml:241:12>>*/ r =
         /*<<bytes.ml:241:12>>*/ caml_create_bytes(l),
-      /*<<bytes.ml:242:4>>*/ _V_ = l - 1 | 0,
-      /*<<bytes.ml:241:12>>*/ _U_ = 0;
-    if(_V_ >= 0){
-     var i = _U_;
+      /*<<bytes.ml:242:4>>*/ _W_ = l - 1 | 0,
+      /*<<bytes.ml:241:12>>*/ _V_ = 0;
+    if(_W_ >= 0){
+     var i = _V_;
      for(;;){
       caml_bytes_unsafe_set
        (r,
         i,
          /*<<bytes.ml:242:41>>*/ caml_call2(f, i, caml_bytes_unsafe_get(s, i)));
-       /*<<bytes.ml:242:4>>*/  /*<<bytes.ml:242:4>>*/ var _W_ = i + 1 | 0;
-      if(_V_ === i) break;
-      var i = _W_;
+       /*<<bytes.ml:242:4>>*/  /*<<bytes.ml:242:4>>*/ var _X_ = i + 1 | 0;
+      if(_W_ === i) break;
+      var i = _X_;
      }
     }
      /*<<bytes.ml:243:4>>*/ return r;
@@ -5411,17 +5415,17 @@
    function fold_left(f, x, a){
      /*<<bytes.ml:247:2>>*/ var
       /*<<bytes.ml:247:10>>*/ r = [0, x],
-     _S_ = caml_ml_bytes_length(a) - 1 | 0,
-      /*<<bytes.ml:247:10>>*/ _R_ = 0;
-    if(_S_ >= 0){
-     var i = _R_;
+     _T_ = caml_ml_bytes_length(a) - 1 | 0,
+      /*<<bytes.ml:247:10>>*/ _S_ = 0;
+    if(_T_ >= 0){
+     var i = _S_;
      for(;;){
       r[1] =
         /*<<bytes.ml:249:9>>*/ caml_call2
         (f, r[1], caml_bytes_unsafe_get(a, i));
-       /*<<bytes.ml:248:2>>*/  /*<<bytes.ml:248:2>>*/ var _T_ = i + 1 | 0;
-      if(_S_ === i) break;
-      var i = _T_;
+       /*<<bytes.ml:248:2>>*/  /*<<bytes.ml:248:2>>*/ var _U_ = i + 1 | 0;
+      if(_T_ === i) break;
+      var i = _U_;
      }
     }
     return r[1];
@@ -5429,17 +5433,17 @@
    function fold_right(f, a, x){
      /*<<bytes.ml:254:2>>*/ var
       /*<<bytes.ml:254:10>>*/ r = [0, x],
-      /*<<bytes.ml:255:2>>*/ _P_ =
+      /*<<bytes.ml:255:2>>*/ _Q_ =
         /*<<bytes.ml:255:2>>*/ caml_ml_bytes_length(a) - 1 | 0;
-    if(_P_ >= 0){
-     var i = _P_;
+    if(_Q_ >= 0){
+     var i = _Q_;
      for(;;){
       r[1] =
         /*<<bytes.ml:256:9>>*/ caml_call2
         (f, caml_bytes_unsafe_get(a, i), r[1]);
-       /*<<bytes.ml:255:2>>*/  /*<<bytes.ml:255:2>>*/ var _Q_ = i - 1 | 0;
+       /*<<bytes.ml:255:2>>*/  /*<<bytes.ml:255:2>>*/ var _R_ = i - 1 | 0;
       if(0 === i) break;
-      var i = _Q_;
+      var i = _R_;
      }
     }
     return r[1];
@@ -5494,8 +5498,8 @@
      /*<<bytes.ml:291:2>>*/ var
      len_s = caml_ml_bytes_length(s),
      len_pre = caml_ml_bytes_length(prefix),
-     _O_ = len_pre <= len_s ? 1 : 0;
-    if(! _O_) return _O_;
+     _P_ = len_pre <= len_s ? 1 : 0;
+    if(! _P_) return _P_;
     var i = 0;
      /*<<bytes.ml:294:4>>*/ for(;;){
      if(i === len_pre)  /*<<bytes.ml:294:24>>*/ return 1;
@@ -5511,8 +5515,8 @@
      len_s = caml_ml_bytes_length(s),
      len_suf = caml_ml_bytes_length(suffix),
      diff = len_s - len_suf | 0,
-     _N_ = 0 <= diff ? 1 : 0;
-    if(! _N_) return _N_;
+     _O_ = 0 <= diff ? 1 : 0;
+    if(! _O_) return _O_;
     var i = 0;
      /*<<bytes.ml:305:4>>*/ for(;;){
      if(i === len_suf)  /*<<bytes.ml:305:24>>*/ return 1;
@@ -5611,13 +5615,13 @@
     if(0 <= i && l >= i)
       /*<<bytes.ml:377:4>>*/ try{
        /*<<bytes.ml:377:15>>*/ index_rec(s, l, i, c);
-       /*<<bytes.ml:377:36>>*/  /*<<bytes.ml:377:36>>*/ var _L_ = 1;
-       /*<<bytes.ml:377:36>>*/ return _L_;
+       /*<<bytes.ml:377:36>>*/  /*<<bytes.ml:377:36>>*/ var _M_ = 1;
+       /*<<bytes.ml:377:36>>*/ return _M_;
      }
-     catch(_M_){
-      var _K_ = caml_wrap_exception(_M_);
-      if(_K_ === Stdlib[8])  /*<<bytes.ml:377:59>>*/ return 0;
-      throw caml_maybe_attach_backtrace(_K_, 0);
+     catch(_N_){
+      var _L_ = caml_wrap_exception(_N_);
+      if(_L_ === Stdlib[8])  /*<<bytes.ml:377:59>>*/ return 0;
+      throw caml_maybe_attach_backtrace(_L_, 0);
      }
      /*<<bytes.ml:375:4>>*/ return  /*<<bytes.ml:375:4>>*/ caml_call1
             (Stdlib[1], cst_String_contains_from_Bytes);
@@ -5629,13 +5633,13 @@
      /*<<bytes.ml:385:2>>*/ if(0 <= i && caml_ml_bytes_length(s) > i)
       /*<<bytes.ml:388:4>>*/ try{
        /*<<bytes.ml:388:15>>*/ rindex_rec(s, i, c);
-       /*<<bytes.ml:388:35>>*/  /*<<bytes.ml:388:35>>*/ var _I_ = 1;
-       /*<<bytes.ml:388:35>>*/ return _I_;
+       /*<<bytes.ml:388:35>>*/  /*<<bytes.ml:388:35>>*/ var _J_ = 1;
+       /*<<bytes.ml:388:35>>*/ return _J_;
      }
-     catch(_J_){
-      var _H_ = caml_wrap_exception(_J_);
-      if(_H_ === Stdlib[8])  /*<<bytes.ml:388:58>>*/ return 0;
-      throw caml_maybe_attach_backtrace(_H_, 0);
+     catch(_K_){
+      var _I_ = caml_wrap_exception(_K_);
+      if(_I_ === Stdlib[8])  /*<<bytes.ml:388:58>>*/ return 0;
+      throw caml_maybe_attach_backtrace(_I_, 0);
      }
      /*<<bytes.ml:386:4>>*/ return  /*<<bytes.ml:386:4>>*/ caml_call1
             (Stdlib[1], cst_String_rcontains_from_Byte);
@@ -5646,23 +5650,23 @@
       /*<<bytes.ml:398:10>>*/ r = [0, 0],
       /*<<bytes.ml:399:10>>*/ j =
        [0,  /*<<bytes.ml:399:2>>*/ caml_ml_bytes_length(s)],
-      /*<<bytes.ml:400:2>>*/ _D_ =
+      /*<<bytes.ml:400:2>>*/ _E_ =
         /*<<bytes.ml:400:2>>*/ caml_ml_bytes_length(s) - 1 | 0;
-    if(_D_ >= 0){
-     var i = _D_;
+    if(_E_ >= 0){
+     var i = _E_;
      for(;;){
       if(caml_bytes_unsafe_get(s, i) === sep){
-       var _F_ = r[1];
-       r[1] = [0, sub(s, i + 1 | 0, (j[1] - i | 0) - 1 | 0), _F_];
+       var _G_ = r[1];
+       r[1] = [0, sub(s, i + 1 | 0, (j[1] - i | 0) - 1 | 0), _G_];
        j[1] = i;
       }
-       /*<<bytes.ml:400:2>>*/  /*<<bytes.ml:400:2>>*/ var _G_ = i - 1 | 0;
+       /*<<bytes.ml:400:2>>*/  /*<<bytes.ml:400:2>>*/ var _H_ = i - 1 | 0;
       if(0 === i) break;
-      var i = _G_;
+      var i = _H_;
      }
     }
-    var _E_ = r[1];
-     /*<<bytes.ml:406:2>>*/ return [0, sub(s, 0, j[1]), _E_];
+    var _F_ = r[1];
+     /*<<bytes.ml:406:2>>*/ return [0, sub(s, 0, j[1]), _F_];
     /*<<bytes.ml:406:18>>*/ }
    function to_seq(s){
     function aux(i, param){
@@ -5671,14 +5675,14 @@
       /*<<bytes.ml:414:14>>*/ var
        /*<<bytes.ml:414:14>>*/ x =
          /*<<bytes.ml:414:14>>*/ caml_bytes_get(s, i),
-       /*<<bytes.ml:414:14>>*/ _B_ = i + 1 | 0;
+       /*<<bytes.ml:414:14>>*/ _C_ = i + 1 | 0;
       /*<<bytes.ml:415:6>>*/ return [0,
              x,
-             function(_C_){ /*<<?>>*/ return aux(_B_, _C_);}];
+             function(_D_){ /*<<?>>*/ return aux(_C_, _D_);}];
      /*<<bytes.ml:415:29>>*/ }
-     /*<<bytes.ml:417:2>>*/  /*<<bytes.ml:417:2>>*/ var _z_ = 0;
-     /*<<bytes.ml:417:2>>*/ return function(_A_){
-      /*<<?>>*/ return aux(_z_, _A_);};
+     /*<<bytes.ml:417:2>>*/  /*<<bytes.ml:417:2>>*/ var _A_ = 0;
+     /*<<bytes.ml:417:2>>*/ return function(_B_){
+      /*<<?>>*/ return aux(_A_, _B_);};
     /*<<bytes.ml:417:7>>*/ }
    function to_seqi(s){
     function aux(i, param){
@@ -5687,20 +5691,20 @@
       /*<<bytes.ml:423:14>>*/ var
        /*<<bytes.ml:423:14>>*/ x =
          /*<<bytes.ml:423:14>>*/ caml_bytes_get(s, i),
-       /*<<bytes.ml:423:14>>*/ _x_ = i + 1 | 0;
+       /*<<bytes.ml:423:14>>*/ _y_ = i + 1 | 0;
       /*<<bytes.ml:424:6>>*/ return [0,
              [0, i, x],
-             function(_y_){ /*<<?>>*/ return aux(_x_, _y_);}];
+             function(_z_){ /*<<?>>*/ return aux(_y_, _z_);}];
      /*<<bytes.ml:424:33>>*/ }
-     /*<<bytes.ml:426:2>>*/  /*<<bytes.ml:426:2>>*/ var _v_ = 0;
-     /*<<bytes.ml:426:2>>*/ return function(_w_){
-      /*<<?>>*/ return aux(_v_, _w_);};
+     /*<<bytes.ml:426:2>>*/  /*<<bytes.ml:426:2>>*/ var _w_ = 0;
+     /*<<bytes.ml:426:2>>*/ return function(_x_){
+      /*<<?>>*/ return aux(_w_, _x_);};
     /*<<bytes.ml:426:7>>*/ }
    function of_seq(i){
      /*<<bytes.ml:429:2>>*/ var
       /*<<bytes.ml:429:10>>*/ n = [0, 0],
       /*<<bytes.ml:430:12>>*/ buf = [0, make(256, 0)];
-    function _u_(c){
+    function _v_(c){
       /*<<bytes.ml:441:7>>*/ if(n[1] === caml_ml_bytes_length(buf[1])){
        /*<<bytes.ml:433:18>>*/  /*<<bytes.ml:433:18>>*/ var
        new_len =
@@ -5722,7 +5726,7 @@
      return 0;
      /*<<bytes.ml:443:13>>*/ }
      /*<<bytes.ml:439:2>>*/  /*<<bytes.ml:439:2>>*/ caml_call2
-     (Stdlib_Seq[4], _u_, i);
+     (Stdlib_Seq[4], _v_, i);
     return sub(buf[1], 0, n[1]);
     /*<<bytes.ml:445:15>>*/ }
    function unsafe_get_uint16_le(b, i){
@@ -5739,9 +5743,9 @@
     /*<<bytes.ml:477:40>>*/ }
    function get_int8(b, i){
      /*<<bytes.ml:480:2>>*/ var
-      /*<<bytes.ml:480:2>>*/ _s_ = Stdlib_Sys[10] - 8 | 0,
-     _t_ = Stdlib_Sys[10] - 8 | 0;
-    return  /*<<bytes.ml:480:3>>*/ caml_bytes_get(b, i) << _t_ >> _s_;
+      /*<<bytes.ml:480:2>>*/ _t_ = Stdlib_Sys[10] - 8 | 0,
+     _u_ = Stdlib_Sys[10] - 8 | 0;
+    return  /*<<bytes.ml:480:3>>*/ caml_bytes_get(b, i) << _u_ >> _t_;
     /*<<bytes.ml:480:65>>*/ }
    function get_uint16_le(b, i){
      /*<<bytes.ml:483:2>>*/ return Stdlib_Sys[11]
@@ -5757,21 +5761,21 @@
     /*<<bytes.ml:488:24>>*/ }
    function get_int16_ne(b, i){
      /*<<bytes.ml:491:2>>*/ var
-      /*<<bytes.ml:491:2>>*/ _q_ = Stdlib_Sys[10] - 16 | 0,
-     _r_ = Stdlib_Sys[10] - 16 | 0;
-    return  /*<<bytes.ml:491:3>>*/ caml_bytes_get16(b, i) << _r_ >> _q_;
+      /*<<bytes.ml:491:2>>*/ _r_ = Stdlib_Sys[10] - 16 | 0,
+     _s_ = Stdlib_Sys[10] - 16 | 0;
+    return  /*<<bytes.ml:491:3>>*/ caml_bytes_get16(b, i) << _s_ >> _r_;
     /*<<bytes.ml:491:71>>*/ }
    function get_int16_le(b, i){
      /*<<bytes.ml:494:2>>*/ var
-      /*<<bytes.ml:494:2>>*/ _o_ = Stdlib_Sys[10] - 16 | 0,
-     _p_ = Stdlib_Sys[10] - 16 | 0;
-    return get_uint16_le(b, i) << _p_ >> _o_;
+      /*<<bytes.ml:494:2>>*/ _p_ = Stdlib_Sys[10] - 16 | 0,
+     _q_ = Stdlib_Sys[10] - 16 | 0;
+    return get_uint16_le(b, i) << _q_ >> _p_;
     /*<<bytes.ml:494:71>>*/ }
    function get_int16_be(b, i){
      /*<<bytes.ml:497:2>>*/ var
-      /*<<bytes.ml:497:2>>*/ _m_ = Stdlib_Sys[10] - 16 | 0,
-     _n_ = Stdlib_Sys[10] - 16 | 0;
-    return get_uint16_be(b, i) << _n_ >> _m_;
+      /*<<bytes.ml:497:2>>*/ _n_ = Stdlib_Sys[10] - 16 | 0,
+     _o_ = Stdlib_Sys[10] - 16 | 0;
+    return get_uint16_be(b, i) << _o_ >> _n_;
     /*<<bytes.ml:497:71>>*/ }
    function get_int32_le(b, i){
      /*<<bytes.ml:500:2>>*/ return Stdlib_Sys[11]
@@ -5798,14 +5802,22 @@
               ( /*<<bytes.ml:512:36>>*/ caml_bytes_get64(b, i));
     /*<<bytes.ml:513:23>>*/ }
    function unsafe_set_uint16_le(b, i, x){
-     /*<<bytes.ml:516:2>>*/ return Stdlib_Sys[11]
-            ?  /*<<bytes.ml:517:7>>*/ caml_bytes_set16(b, i, caml_bswap16(x))
-            :  /*<<bytes.ml:518:7>>*/ caml_bytes_set16(b, i, x);
+     /*<<bytes.ml:516:2>>*/ if(Stdlib_Sys[11]){
+      /*<<bytes.ml:517:7>>*/  /*<<bytes.ml:517:7>>*/ caml_bytes_set16
+      (b, i, caml_bswap16(x));
+      /*<<bytes.ml:517:7>>*/ return;
+    }
+     /*<<bytes.ml:518:7>>*/  /*<<bytes.ml:518:7>>*/ caml_bytes_set16(b, i, x);
+     /*<<bytes.ml:518:7>>*/ return;
     /*<<bytes.ml:518:33>>*/ }
    function unsafe_set_uint16_be(b, i, x){
-     /*<<bytes.ml:521:2>>*/ return Stdlib_Sys[11]
-            ?  /*<<bytes.ml:522:7>>*/ caml_bytes_set16(b, i, x)
-            :  /*<<bytes.ml:523:2>>*/ caml_bytes_set16(b, i, caml_bswap16(x));
+     /*<<bytes.ml:521:2>>*/ if(Stdlib_Sys[11]){
+      /*<<bytes.ml:522:7>>*/  /*<<bytes.ml:522:7>>*/ caml_bytes_set16(b, i, x);
+      /*<<bytes.ml:522:7>>*/ return;
+    }
+     /*<<bytes.ml:523:2>>*/  /*<<bytes.ml:523:2>>*/ caml_bytes_set16
+     (b, i, caml_bswap16(x));
+     /*<<bytes.ml:523:2>>*/ return;
     /*<<bytes.ml:523:37>>*/ }
    function set_int16_le(b, i, x){
      /*<<bytes.ml:526:2>>*/ return Stdlib_Sys[11]
@@ -5847,9 +5859,9 @@
     dec_invalid = Stdlib_Uchar[22];
    function dec_ret(n, u){
      /*<<bytes.ml:557:27>>*/  /*<<bytes.ml:557:46>>*/ var
-     _l_ =  /*<<bytes.ml:557:46>>*/ caml_call1(Stdlib_Uchar[9], u);
+     _m_ =  /*<<bytes.ml:557:46>>*/ caml_call1(Stdlib_Uchar[9], u);
      /*<<bytes.ml:557:46>>*/ return  /*<<bytes.ml:557:46>>*/ caml_call2
-            (Stdlib_Uchar[21], n, _l_);
+            (Stdlib_Uchar[21], n, _m_);
     /*<<bytes.ml:557:69>>*/ }
    function not_in_x80_to_xBF(b){
      /*<<bytes.ml:575:35>>*/ return 2 !== (b >>> 6 | 0) ? 1 : 0;
@@ -5862,9 +5874,9 @@
     /*<<bytes.ml:577:51>>*/ }
    function not_in_x90_to_xBF(b){
      /*<<bytes.ml:578:35>>*/ var
-     _j_ = b < 144 ? 1 : 0,
-     _k_ = _j_ || (191 < b ? 1 : 0);
-    return _k_;
+     _k_ = b < 144 ? 1 : 0,
+     _l_ = _k_ || (191 < b ? 1 : 0);
+    return _l_;
     /*<<bytes.ml:578:55>>*/ }
    function not_in_x80_to_x8F(b){
      /*<<bytes.ml:579:35>>*/ return 8 !== (b >>> 4 | 0) ? 1 : 0;
@@ -6061,9 +6073,9 @@
             (dec_invalid, 1);
     /*<<bytes.ml:648:22>>*/ }
    function set_utf_8_uchar(b, i, u){
-     /*<<bytes.ml:651:2>>*/ function set(_i_, _h_, _g_){
-      /*<<?>>*/ caml_bytes_unsafe_set(_i_, _h_, _g_);
-     return 0;
+     /*<<bytes.ml:651:2>>*/ function set(_j_, _i_, _h_){
+      /*<<?>>*/ caml_bytes_unsafe_set(_j_, _i_, _h_);
+     return;
     }
      /*<<bytes.ml:652:2>>*/ var
       /*<<bytes.ml:652:2>>*/ max =
@@ -7293,6 +7305,7 @@
             : runtime.caml_call_gen(f, [a0, a1, a2]);
    }
     /*<<array.ml:37:20>>*/ var
+    _b_ = undefined,
     global_data = runtime.caml_get_global_data(),
     Stdlib_Seq = global_data.Stdlib__Seq,
     Assert_failure = global_data.Assert_failure,
@@ -7320,16 +7333,16 @@
       /*<<array.ml:53:13>>*/ res =
         /*<<array.ml:53:13>>*/ caml_make_vect
         (l,  /*<<array.ml:53:22>>*/ caml_call1(f, 0)),
-      /*<<array.ml:54:3>>*/ _ay_ = l - 1 | 0,
-      /*<<array.ml:53:13>>*/ _ax_ = 1;
-    if(_ay_ >= 1){
-     var i = _ax_;
+      /*<<array.ml:54:3>>*/ _az_ = l - 1 | 0,
+      /*<<array.ml:53:13>>*/ _ay_ = 1;
+    if(_az_ >= 1){
+     var i = _ay_;
      for(;;){
        /*<<array.ml:55:5>>*/ res[1 + i] =
         /*<<array.ml:55:22>>*/ caml_call1(f, i);
-       /*<<array.ml:55:5>>*/  /*<<array.ml:55:5>>*/ var _az_ = i + 1 | 0;
-      if(_ay_ === i) break;
-      var i = _az_;
+       /*<<array.ml:55:5>>*/  /*<<array.ml:55:5>>*/ var _aA_ = i + 1 | 0;
+      if(_az_ === i) break;
+      var i = _aA_;
      }
     }
      /*<<array.ml:57:3>>*/ return res;
@@ -7338,15 +7351,15 @@
      /*<<array.ml:60:2>>*/ var
       /*<<array.ml:60:12>>*/ res =
         /*<<array.ml:60:12>>*/ caml_make_vect(sx, [0]),
-      /*<<array.ml:61:2>>*/ _av_ = sx - 1 | 0,
-      /*<<array.ml:60:12>>*/ _au_ = 0;
-    if(_av_ >= 0){
-     var x = _au_;
+      /*<<array.ml:61:2>>*/ _aw_ = sx - 1 | 0,
+      /*<<array.ml:60:12>>*/ _av_ = 0;
+    if(_aw_ >= 0){
+     var x = _av_;
      for(;;){
       res[1 + x] =  /*<<array.ml:62:21>>*/ caml_make_vect(sy, init);
-       /*<<array.ml:61:2>>*/  /*<<array.ml:61:2>>*/ var _aw_ = x + 1 | 0;
-      if(_av_ === x) break;
-      var x = _aw_;
+       /*<<array.ml:61:2>>*/  /*<<array.ml:61:2>>*/ var _ax_ = x + 1 | 0;
+      if(_aw_ === x) break;
+      var x = _ax_;
      }
     }
      /*<<array.ml:64:2>>*/ return res;
@@ -7397,15 +7410,15 @@
     /*<<array.ml:89:38>>*/ }
    function iter(f, a){
      /*<<array.ml:92:2>>*/ var
-     _as_ = a.length - 1 - 1 | 0,
-      /*<<array.ml:92:2>>*/ _ar_ = 0;
-    if(_as_ >= 0){
-     var i = _ar_;
+     _at_ = a.length - 1 - 1 | 0,
+      /*<<array.ml:92:2>>*/ _as_ = 0;
+    if(_at_ >= 0){
+     var i = _as_;
      for(;;){
        /*<<array.ml:92:31>>*/  /*<<array.ml:92:31>>*/ caml_call1(f, a[1 + i]);
-       /*<<array.ml:92:31>>*/  /*<<array.ml:92:31>>*/ var _at_ = i + 1 | 0;
-      if(_as_ === i) break;
-      var i = _at_;
+       /*<<array.ml:92:31>>*/  /*<<array.ml:92:31>>*/ var _au_ = i + 1 | 0;
+      if(_at_ === i) break;
+      var i = _au_;
      }
     }
     return 0;
@@ -7415,16 +7428,16 @@
       /*<<array.ml:96:4>>*/ return  /*<<array.ml:96:4>>*/ caml_call1
              (Stdlib[1], cst_Array_iter2_arrays_must_ha);
      /*<<array.ml:98:4>>*/ var
-     _ap_ = a.length - 1 - 1 | 0,
-      /*<<array.ml:98:4>>*/ _ao_ = 0;
-    if(_ap_ >= 0){
-     var i = _ao_;
+     _aq_ = a.length - 1 - 1 | 0,
+      /*<<array.ml:98:4>>*/ _ap_ = 0;
+    if(_aq_ >= 0){
+     var i = _ap_;
      for(;;){
        /*<<array.ml:98:33>>*/  /*<<array.ml:98:33>>*/ caml_call2
        (f, a[1 + i], b[1 + i]);
-       /*<<array.ml:98:33>>*/  /*<<array.ml:98:33>>*/ var _aq_ = i + 1 | 0;
-      if(_ap_ === i) break;
-      var i = _aq_;
+       /*<<array.ml:98:33>>*/  /*<<array.ml:98:33>>*/ var _ar_ = i + 1 | 0;
+      if(_aq_ === i) break;
+      var i = _ar_;
      }
     }
     return 0;
@@ -7436,48 +7449,48 @@
       /*<<array.ml:103:12>>*/ r =
         /*<<array.ml:103:12>>*/ caml_make_vect
         (l,  /*<<array.ml:103:21>>*/ caml_call1(f, a[1])),
-      /*<<array.ml:104:4>>*/ _am_ = l - 1 | 0,
-      /*<<array.ml:103:12>>*/ _al_ = 1;
-    if(_am_ >= 1){
-     var i = _al_;
+      /*<<array.ml:104:4>>*/ _an_ = l - 1 | 0,
+      /*<<array.ml:103:12>>*/ _am_ = 1;
+    if(_an_ >= 1){
+     var i = _am_;
      for(;;){
        /*<<array.ml:105:6>>*/ r[1 + i] =
         /*<<array.ml:105:21>>*/ caml_call1(f, a[1 + i]);
-       /*<<array.ml:105:6>>*/  /*<<array.ml:105:6>>*/ var _an_ = i + 1 | 0;
-      if(_am_ === i) break;
-      var i = _an_;
+       /*<<array.ml:105:6>>*/  /*<<array.ml:105:6>>*/ var _ao_ = i + 1 | 0;
+      if(_an_ === i) break;
+      var i = _ao_;
      }
     }
      /*<<array.ml:107:4>>*/ return r;
     /*<<array.ml:108:5>>*/ }
    function map_inplace(f, a){
      /*<<array.ml:111:2>>*/ var
-     _aj_ = a.length - 1 - 1 | 0,
-      /*<<array.ml:111:2>>*/ _ai_ = 0;
-    if(_aj_ >= 0){
-     var i = _ai_;
+     _ak_ = a.length - 1 - 1 | 0,
+      /*<<array.ml:111:2>>*/ _aj_ = 0;
+    if(_ak_ >= 0){
+     var i = _aj_;
      for(;;){
        /*<<array.ml:112:4>>*/ a[1 + i] =
         /*<<array.ml:112:19>>*/ caml_call1(f, a[1 + i]);
-       /*<<array.ml:112:4>>*/  /*<<array.ml:112:4>>*/ var _ak_ = i + 1 | 0;
-      if(_aj_ === i) break;
-      var i = _ak_;
+       /*<<array.ml:112:4>>*/  /*<<array.ml:112:4>>*/ var _al_ = i + 1 | 0;
+      if(_ak_ === i) break;
+      var i = _al_;
      }
     }
     return 0;
     /*<<array.ml:113:6>>*/ }
    function mapi_inplace(f, a){
      /*<<array.ml:116:2>>*/ var
-     _ag_ = a.length - 1 - 1 | 0,
-      /*<<array.ml:116:2>>*/ _af_ = 0;
-    if(_ag_ >= 0){
-     var i = _af_;
+     _ah_ = a.length - 1 - 1 | 0,
+      /*<<array.ml:116:2>>*/ _ag_ = 0;
+    if(_ah_ >= 0){
+     var i = _ag_;
      for(;;){
        /*<<array.ml:117:4>>*/ a[1 + i] =
         /*<<array.ml:117:19>>*/ caml_call2(f, i, a[1 + i]);
-       /*<<array.ml:117:4>>*/  /*<<array.ml:117:4>>*/ var _ah_ = i + 1 | 0;
-      if(_ag_ === i) break;
-      var i = _ah_;
+       /*<<array.ml:117:4>>*/  /*<<array.ml:117:4>>*/ var _ai_ = i + 1 | 0;
+      if(_ah_ === i) break;
+      var i = _ai_;
      }
     }
     return 0;
@@ -7494,32 +7507,32 @@
       /*<<array.ml:127:14>>*/ r =
         /*<<array.ml:127:14>>*/ caml_make_vect
         (la,  /*<<array.ml:127:24>>*/ caml_call2(f, a[1], b[1])),
-      /*<<array.ml:128:6>>*/ _ad_ = la - 1 | 0,
-      /*<<array.ml:127:14>>*/ _ac_ = 1;
-    if(_ad_ >= 1){
-     var i = _ac_;
+      /*<<array.ml:128:6>>*/ _ae_ = la - 1 | 0,
+      /*<<array.ml:127:14>>*/ _ad_ = 1;
+    if(_ae_ >= 1){
+     var i = _ad_;
      for(;;){
        /*<<array.ml:129:8>>*/ r[1 + i] =
         /*<<array.ml:129:23>>*/ caml_call2(f, a[1 + i], b[1 + i]);
-       /*<<array.ml:129:8>>*/  /*<<array.ml:129:8>>*/ var _ae_ = i + 1 | 0;
-      if(_ad_ === i) break;
-      var i = _ae_;
+       /*<<array.ml:129:8>>*/  /*<<array.ml:129:8>>*/ var _af_ = i + 1 | 0;
+      if(_ae_ === i) break;
+      var i = _af_;
      }
     }
      /*<<array.ml:131:6>>*/ return r;
     /*<<array.ml:133:5>>*/ }
    function iteri(f, a){
      /*<<array.ml:136:2>>*/ var
-     _aa_ = a.length - 1 - 1 | 0,
-      /*<<array.ml:136:2>>*/ _$_ = 0;
-    if(_aa_ >= 0){
-     var i = _$_;
+     _ab_ = a.length - 1 - 1 | 0,
+      /*<<array.ml:136:2>>*/ _aa_ = 0;
+    if(_ab_ >= 0){
+     var i = _aa_;
      for(;;){
        /*<<array.ml:136:31>>*/  /*<<array.ml:136:31>>*/ caml_call2
        (f, i, a[1 + i]);
-       /*<<array.ml:136:31>>*/  /*<<array.ml:136:31>>*/ var _ab_ = i + 1 | 0;
-      if(_aa_ === i) break;
-      var i = _ab_;
+       /*<<array.ml:136:31>>*/  /*<<array.ml:136:31>>*/ var _ac_ = i + 1 | 0;
+      if(_ab_ === i) break;
+      var i = _ac_;
      }
     }
     return 0;
@@ -7531,16 +7544,16 @@
       /*<<array.ml:141:12>>*/ r =
         /*<<array.ml:141:12>>*/ caml_make_vect
         (l,  /*<<array.ml:141:21>>*/ caml_call2(f, 0, a[1])),
-      /*<<array.ml:142:4>>*/ _Z_ = l - 1 | 0,
-      /*<<array.ml:141:12>>*/ _Y_ = 1;
-    if(_Z_ >= 1){
-     var i = _Y_;
+      /*<<array.ml:142:4>>*/ ___ = l - 1 | 0,
+      /*<<array.ml:141:12>>*/ _Z_ = 1;
+    if(___ >= 1){
+     var i = _Z_;
      for(;;){
        /*<<array.ml:143:6>>*/ r[1 + i] =
         /*<<array.ml:143:21>>*/ caml_call2(f, i, a[1 + i]);
-       /*<<array.ml:143:6>>*/  /*<<array.ml:143:6>>*/ var ___ = i + 1 | 0;
-      if(_Z_ === i) break;
-      var i = ___;
+       /*<<array.ml:143:6>>*/  /*<<array.ml:143:6>>*/ var _$_ = i + 1 | 0;
+      if(___ === i) break;
+      var i = _$_;
      }
     }
      /*<<array.ml:145:4>>*/ return r;
@@ -7589,15 +7602,15 @@
    function fold_left(f, x, a){
      /*<<array.ml:168:2>>*/ var
       /*<<array.ml:168:10>>*/ r = [0, x],
-     _W_ = a.length - 1 - 1 | 0,
-      /*<<array.ml:168:10>>*/ _V_ = 0;
-    if(_W_ >= 0){
-     var i = _V_;
+     _X_ = a.length - 1 - 1 | 0,
+      /*<<array.ml:168:10>>*/ _W_ = 0;
+    if(_X_ >= 0){
+     var i = _W_;
      for(;;){
       r[1] =  /*<<array.ml:170:9>>*/ caml_call2(f, r[1], a[1 + i]);
-       /*<<array.ml:169:2>>*/  /*<<array.ml:169:2>>*/ var _X_ = i + 1 | 0;
-      if(_W_ === i) break;
-      var i = _X_;
+       /*<<array.ml:169:2>>*/  /*<<array.ml:169:2>>*/ var _Y_ = i + 1 | 0;
+      if(_X_ === i) break;
+      var i = _Y_;
      }
     }
     return r[1];
@@ -7614,10 +7627,10 @@
       /*<<array.ml:178:23>>*/ output_array =
         /*<<array.ml:178:23>>*/ caml_make_vect(len, elt),
       /*<<array.ml:179:14>>*/ acc$1 = [0, acc$0],
-      /*<<array.ml:180:4>>*/ _T_ = len - 1 | 0,
-      /*<<array.ml:179:14>>*/ _S_ = 1;
-    if(_T_ >= 1){
-     var i = _S_;
+      /*<<array.ml:180:4>>*/ _U_ = len - 1 | 0,
+      /*<<array.ml:179:14>>*/ _T_ = 1;
+    if(_U_ >= 1){
+     var i = _T_;
      for(;;){
        /*<<array.ml:181:22>>*/ var
         /*<<array.ml:181:22>>*/ match$0 =
@@ -7626,9 +7639,9 @@
        acc$2 = match$0[1];
       acc$1[1] = acc$2;
        /*<<array.ml:183:6>>*/ output_array[1 + i] = elt$0;
-       /*<<array.ml:180:4>>*/  /*<<array.ml:180:4>>*/ var _U_ = i + 1 | 0;
-      if(_T_ === i) break;
-      var i = _U_;
+       /*<<array.ml:180:4>>*/  /*<<array.ml:180:4>>*/ var _V_ = i + 1 | 0;
+      if(_U_ === i) break;
+      var i = _V_;
      }
     }
      /*<<array.ml:185:4>>*/ return [0, acc$1[1], output_array];
@@ -7636,14 +7649,14 @@
    function fold_right(f, a, x){
      /*<<array.ml:189:2>>*/ var
       /*<<array.ml:189:10>>*/ r = [0, x],
-      /*<<array.ml:190:2>>*/ _Q_ = a.length - 1 - 1 | 0;
-    if(_Q_ >= 0){
-     var i = _Q_;
+      /*<<array.ml:190:2>>*/ _R_ = a.length - 1 - 1 | 0;
+    if(_R_ >= 0){
+     var i = _R_;
      for(;;){
       r[1] =  /*<<array.ml:191:9>>*/ caml_call2(f, a[1 + i], r[1]);
-       /*<<array.ml:190:2>>*/  /*<<array.ml:190:2>>*/ var _R_ = i - 1 | 0;
+       /*<<array.ml:190:2>>*/  /*<<array.ml:190:2>>*/ var _S_ = i - 1 | 0;
       if(0 === i) break;
-      var i = _R_;
+      var i = _S_;
      }
     }
     return r[1];
@@ -7787,17 +7800,17 @@
         /*<<array.ml:293:12>>*/ caml_make_vect(n, a0),
       /*<<array.ml:294:12>>*/ b =
         /*<<array.ml:294:12>>*/ caml_make_vect(n, b0),
-      /*<<array.ml:295:4>>*/ _O_ = n - 1 | 0,
-      /*<<array.ml:294:12>>*/ _N_ = 1;
-    if(_O_ >= 1){
-     var i = _N_;
+      /*<<array.ml:295:4>>*/ _P_ = n - 1 | 0,
+      /*<<array.ml:294:12>>*/ _O_ = 1;
+    if(_P_ >= 1){
+     var i = _O_;
      for(;;){
       var match$0 = x[1 + i], bi = match$0[2], ai = match$0[1];
        /*<<array.ml:297:6>>*/ a[1 + i] = ai;
        /*<<array.ml:298:6>>*/ b[1 + i] = bi;
-       /*<<array.ml:295:4>>*/  /*<<array.ml:295:4>>*/ var _P_ = i + 1 | 0;
-      if(_O_ === i) break;
-      var i = _P_;
+       /*<<array.ml:295:4>>*/  /*<<array.ml:295:4>>*/ var _Q_ = i + 1 | 0;
+      if(_P_ === i) break;
+      var i = _Q_;
      }
     }
      /*<<array.ml:300:4>>*/ return [0, a, b];
@@ -7813,15 +7826,15 @@
      /*<<array.ml:309:12>>*/ var
       /*<<array.ml:309:12>>*/ x =
         /*<<array.ml:309:12>>*/ caml_make_vect(na, [0, a[1], b[1]]),
-      /*<<array.ml:310:4>>*/ _L_ = na - 1 | 0,
-      /*<<array.ml:309:12>>*/ _K_ = 1;
-    if(_L_ >= 1){
-     var i = _K_;
+      /*<<array.ml:310:4>>*/ _M_ = na - 1 | 0,
+      /*<<array.ml:309:12>>*/ _L_ = 1;
+    if(_M_ >= 1){
+     var i = _L_;
      for(;;){
       x[1 + i] = [0, a[1 + i], b[1 + i]];
-       /*<<array.ml:310:4>>*/  /*<<array.ml:310:4>>*/ var _M_ = i + 1 | 0;
-      if(_L_ === i) break;
-      var i = _M_;
+       /*<<array.ml:310:4>>*/  /*<<array.ml:310:4>>*/ var _N_ = i + 1 | 0;
+      if(_M_ === i) break;
+      var i = _N_;
      }
     }
      /*<<array.ml:313:4>>*/ return x;
@@ -7835,42 +7848,42 @@
        /*<<array.ml:320:12>>*/ x = [0, i31];
      if((i31 + 2 | 0) < l){
        /*<<array.ml:321:22>>*/ var
-        /*<<array.ml:321:22>>*/ _D_ = i31 + 1 | 0,
-        /*<<array.ml:322:25>>*/ _E_ = caml_check_bound(a, _D_)[1 + _D_];
+        /*<<array.ml:321:22>>*/ _E_ = i31 + 1 | 0,
+        /*<<array.ml:322:25>>*/ _F_ = caml_check_bound(a, _E_)[1 + _E_];
       if
        ( /*<<array.ml:322:9>>*/ caml_call2
-         (cmp, caml_check_bound(a, i31)[1 + i31], _E_)
+         (cmp, caml_check_bound(a, i31)[1 + i31], _F_)
         < 0)
        x[1] = i31 + 1 | 0;
        /*<<array.ml:323:6>>*/ var
-        /*<<array.ml:323:6>>*/ _F_ = i31 + 2 | 0,
-        /*<<array.ml:323:24>>*/ _G_ = caml_check_bound(a, _F_)[1 + _F_],
-       _H_ = x[1];
+        /*<<array.ml:323:6>>*/ _G_ = i31 + 2 | 0,
+        /*<<array.ml:323:24>>*/ _H_ = caml_check_bound(a, _G_)[1 + _G_],
+       _I_ = x[1];
       if
        ( /*<<array.ml:323:9>>*/ caml_call2
-         (cmp, caml_check_bound(a, _H_)[1 + _H_], _G_)
+         (cmp, caml_check_bound(a, _I_)[1 + _I_], _H_)
         < 0)
        x[1] = i31 + 2 | 0;
       return x[1];
      }
      if((i31 + 1 | 0) < l){
        /*<<array.ml:326:38>>*/ var
-       _I_ = i31 + 1 | 0,
-        /*<<array.ml:326:38>>*/ _J_ = caml_check_bound(a, _I_)[1 + _I_];
+       _J_ = i31 + 1 | 0,
+        /*<<array.ml:326:38>>*/ _K_ = caml_check_bound(a, _J_)[1 + _J_];
        /*<<array.ml:326:22>>*/ if
        (0
         >
           /*<<array.ml:326:22>>*/ caml_call2
-          (cmp, caml_check_bound(a, i31)[1 + i31], _J_))
+          (cmp, caml_check_bound(a, i31)[1 + i31], _K_))
         /*<<array.ml:327:11>>*/ return i31 + 1 | 0;
      }
      if(i31 < l)  /*<<array.ml:328:27>>*/ return i31;
       /*<<array.ml:328:36>>*/ throw  /*<<array.ml:328:36>>*/ caml_maybe_attach_backtrace
             ([0, Bottom, i], 1);
      /*<<array.ml:328:52>>*/ }
-    var l = a.length - 1, _x_ = ((l + 1 | 0) / 3 | 0) - 1 | 0;
-    if(_x_ >= 0){
-     var i$6 = _x_;
+    var l = a.length - 1, _y_ = ((l + 1 | 0) / 3 | 0) - 1 | 0;
+    if(_y_ >= 0){
+     var i$6 = _y_;
      for(;;){
        /*<<array.ml:357:50>>*/  /*<<array.ml:357:50>>*/ var
        e$1 = caml_check_bound(a, i$6)[1 + i$6];
@@ -7888,8 +7901,8 @@
          break;
         }
          /*<<array.ml:333:14>>*/  /*<<array.ml:333:14>>*/ var
-         _u_ = caml_check_bound(a, j)[1 + j];
-         /*<<array.ml:333:6>>*/ caml_check_bound(a, i)[1 + i] = _u_;
+         _v_ = caml_check_bound(a, j)[1 + j];
+         /*<<array.ml:333:6>>*/ caml_check_bound(a, i)[1 + i] = _v_;
         var i = j;
        }
       }
@@ -7899,14 +7912,14 @@
        var i$0 = exn[2];
         /*<<array.ml:339:61>>*/ caml_check_bound(a, i$0)[1 + i$0] = e$1;
       }
-       /*<<array.ml:357:38>>*/  /*<<array.ml:357:38>>*/ var _C_ = i$6 - 1 | 0;
+       /*<<array.ml:357:38>>*/  /*<<array.ml:357:38>>*/ var _D_ = i$6 - 1 | 0;
       if(0 === i$6) break;
-      var i$6 = _C_;
+      var i$6 = _D_;
      }
     }
-     /*<<array.ml:358:2>>*/  /*<<array.ml:358:2>>*/ var _y_ = l - 1 | 0;
-    if(_y_ >= 2){
-     var i$4 = _y_;
+     /*<<array.ml:358:2>>*/  /*<<array.ml:358:2>>*/ var _z_ = l - 1 | 0;
+    if(_z_ >= 2){
+     var i$4 = _z_;
      a:
      for(;;){
        /*<<array.ml:359:12>>*/  /*<<array.ml:359:12>>*/ var
@@ -7918,8 +7931,8 @@
         /*<<array.ml:341:4>>*/ for(;;){
          /*<<array.ml:341:12>>*/ var
           /*<<array.ml:341:12>>*/ j$0 = maxson(i$4, i$1),
-          /*<<array.ml:342:12>>*/ _v_ = caml_check_bound(a, j$0)[1 + j$0];
-         /*<<array.ml:342:4>>*/ caml_check_bound(a, i$1)[1 + i$1] = _v_;
+          /*<<array.ml:342:12>>*/ _w_ = caml_check_bound(a, j$0)[1 + j$0];
+         /*<<array.ml:342:4>>*/ caml_check_bound(a, i$1)[1 + i$1] = _w_;
         var i$1 = j$0;
        }
       }
@@ -7940,30 +7953,30 @@
           /*<<array.ml:352:13>>*/ caml_check_bound(a, i$3)[1 + i$3] = e$0;
         else{
           /*<<array.ml:350:14>>*/  /*<<array.ml:350:14>>*/ var
-          _w_ = caml_check_bound(a, father)[1 + father];
-          /*<<array.ml:350:6>>*/ caml_check_bound(a, i$3)[1 + i$3] = _w_;
+          _x_ = caml_check_bound(a, father)[1 + father];
+          /*<<array.ml:350:6>>*/ caml_check_bound(a, i$3)[1 + i$3] = _x_;
          if(0 < father){var i$3 = father; continue;}
           /*<<array.ml:351:49>>*/ caml_check_bound(a, 0)[1] = e$0;
         }
-         /*<<array.ml:358:2>>*/  /*<<array.ml:358:2>>*/ var _B_ = i$4 - 1 | 0;
+         /*<<array.ml:358:2>>*/  /*<<array.ml:358:2>>*/ var _C_ = i$4 - 1 | 0;
         if(2 === i$4) break a;
-        var i$4 = _B_;
+        var i$4 = _C_;
         break;
        }
       }
      }
     }
-    var _z_ = 1 < l ? 1 : 0;
-    if(_z_){
+    var _A_ = 1 < l ? 1 : 0;
+    if(_A_){
       /*<<array.ml:363:25>>*/  /*<<array.ml:363:25>>*/ var
       e = caml_check_bound(a, 1)[2];
       /*<<array.ml:363:38>>*/ a[2] = caml_check_bound(a, 0)[1];
       /*<<array.ml:363:57>>*/ a[1] = e;
-     var _A_ = 0;
+     var _B_ = 0;
     }
     else
-     var _A_ = _z_;
-     /*<<array.ml:363:57>>*/ return _A_;
+     var _B_ = _A_;
+     /*<<array.ml:363:57>>*/ return _B_;
     /*<<array.ml:363:67>>*/ }
    function stable_sort(cmp, a){
     function merge(src1ofs, src1len, src2, src2ofs, src2len, dst, dstofs){
@@ -8007,38 +8020,38 @@
      /*<<array.ml:386:70>>*/ }
     function isortto(srcofs, dst, dstofs, len){
       /*<<array.ml:389:4>>*/ var
-      _m_ = len - 1 | 0,
-       /*<<array.ml:389:4>>*/ _l_ = 0;
-     if(_m_ >= 0){
-      var i = _l_;
+      _n_ = len - 1 | 0,
+       /*<<array.ml:389:4>>*/ _m_ = 0;
+     if(_n_ >= 0){
+      var i = _m_;
       a:
       for(;;){
         /*<<array.ml:390:14>>*/ var
-        _n_ = srcofs + i | 0,
-         /*<<array.ml:390:14>>*/ e = caml_check_bound(a, _n_)[1 + _n_],
+        _o_ = srcofs + i | 0,
+         /*<<array.ml:390:14>>*/ e = caml_check_bound(a, _o_)[1 + _o_],
          /*<<array.ml:391:14>>*/ j = [0, (dstofs + i | 0) - 1 | 0];
        for(;;){
         if(dstofs <= j[1]){
-         var _o_ = j[1];
+         var _p_ = j[1];
           /*<<array.ml:392:29>>*/ if
           (0
            <
              /*<<array.ml:392:29>>*/ caml_call2
-             (cmp, caml_check_bound(dst, _o_)[1 + _o_], e)){
+             (cmp, caml_check_bound(dst, _p_)[1 + _p_], e)){
            /*<<array.ml:393:25>>*/ var
-           _p_ = j[1],
-            /*<<array.ml:393:25>>*/ _q_ = caml_check_bound(dst, _p_)[1 + _p_],
-           _r_ = j[1] + 1 | 0;
-           /*<<array.ml:393:8>>*/ caml_check_bound(dst, _r_)[1 + _r_] = _q_;
+           _q_ = j[1],
+            /*<<array.ml:393:25>>*/ _r_ = caml_check_bound(dst, _q_)[1 + _q_],
+           _s_ = j[1] + 1 | 0;
+           /*<<array.ml:393:8>>*/ caml_check_bound(dst, _s_)[1 + _s_] = _r_;
           j[1] += -1;
           continue;
          }
         }
-        var _s_ = j[1] + 1 | 0;
-         /*<<array.ml:396:6>>*/ caml_check_bound(dst, _s_)[1 + _s_] = e;
-         /*<<array.ml:389:4>>*/  /*<<array.ml:389:4>>*/ var _t_ = i + 1 | 0;
-        if(_m_ === i) break a;
-        var i = _t_;
+        var _t_ = j[1] + 1 | 0;
+         /*<<array.ml:396:6>>*/ caml_check_bound(dst, _t_)[1 + _t_] = e;
+         /*<<array.ml:389:4>>*/  /*<<array.ml:389:4>>*/ var _u_ = i + 1 | 0;
+        if(_n_ === i) break a;
+        var i = _u_;
         break;
        }
       }
@@ -8046,13 +8059,16 @@
      return 0;
      /*<<array.ml:397:8>>*/ }
     function sortto(srcofs, dst, dstofs, len){
-      /*<<array.ml:400:4>>*/ if(len <= 5)
-       /*<<array.ml:400:26>>*/ return isortto(srcofs, dst, dstofs, len);
+      /*<<array.ml:400:4>>*/ if(len <= 5){
+       /*<<array.ml:400:26>>*/ isortto(srcofs, dst, dstofs, len);
+       /*<<array.ml:400:26>>*/ return;
+     }
      var l1 = len / 2 | 0, l2 = len - l1 | 0;
       /*<<array.ml:403:6>>*/ sortto(srcofs + l1 | 0, dst, dstofs + l1 | 0, l2);
       /*<<array.ml:404:6>>*/ sortto(srcofs, a, srcofs + l2 | 0, l1);
-      /*<<array.ml:404:6>>*/ return merge
-             (srcofs + l2 | 0, l1, dst, dstofs + l1 | 0, l2, dst, dstofs);
+      /*<<array.ml:404:6>>*/ merge
+      (srcofs + l2 | 0, l1, dst, dstofs + l1 | 0, l2, dst, dstofs);
+      /*<<array.ml:404:6>>*/ return;
      /*<<array.ml:406:7>>*/ }
     var l = a.length - 1;
     if(l <= 5)  /*<<array.ml:409:22>>*/ return isortto(0, a, 0, l);
@@ -8071,14 +8087,14 @@
        /*<<array.ml:429:9>>*/ return 0;
       /*<<array.ml:427:14>>*/ var
        /*<<array.ml:427:14>>*/ x = a[1 + i],
-       /*<<array.ml:427:14>>*/ _j_ = i + 1 | 0;
+       /*<<array.ml:427:14>>*/ _k_ = i + 1 | 0;
       /*<<array.ml:428:6>>*/ return [0,
              x,
-             function(_k_){ /*<<?>>*/ return aux(_j_, _k_);}];
+             function(_l_){ /*<<?>>*/ return aux(_k_, _l_);}];
      /*<<array.ml:429:16>>*/ }
-     /*<<array.ml:431:2>>*/  /*<<array.ml:431:2>>*/ var _h_ = 0;
-     /*<<array.ml:431:2>>*/ return function(_i_){
-      /*<<?>>*/ return aux(_h_, _i_);};
+     /*<<array.ml:431:2>>*/  /*<<array.ml:431:2>>*/ var _i_ = 0;
+     /*<<array.ml:431:2>>*/ return function(_j_){
+      /*<<?>>*/ return aux(_i_, _j_);};
     /*<<array.ml:431:7>>*/ }
    function to_seqi(a){
     function aux(i, param){
@@ -8086,22 +8102,22 @@
        /*<<array.ml:439:9>>*/ return 0;
       /*<<array.ml:437:14>>*/ var
        /*<<array.ml:437:14>>*/ x = a[1 + i],
-       /*<<array.ml:437:14>>*/ _f_ = i + 1 | 0;
+       /*<<array.ml:437:14>>*/ _g_ = i + 1 | 0;
       /*<<array.ml:438:6>>*/ return [0,
              [0, i, x],
-             function(_g_){ /*<<?>>*/ return aux(_f_, _g_);}];
+             function(_h_){ /*<<?>>*/ return aux(_g_, _h_);}];
      /*<<array.ml:439:16>>*/ }
-     /*<<array.ml:441:2>>*/  /*<<array.ml:441:2>>*/ var _d_ = 0;
-     /*<<array.ml:441:2>>*/ return function(_e_){
-      /*<<?>>*/ return aux(_d_, _e_);};
+     /*<<array.ml:441:2>>*/  /*<<array.ml:441:2>>*/ var _e_ = 0;
+     /*<<array.ml:441:2>>*/ return function(_f_){
+      /*<<?>>*/ return aux(_e_, _f_);};
     /*<<array.ml:441:7>>*/ }
    function of_seq(i$2){
-     /*<<array.ml:455:2>>*/ var _b_ = 0;
-    function _c_(acc, x){
+     /*<<array.ml:455:2>>*/ var _c_ = 0;
+    function _d_(acc, x){
       /*<<array.ml:455:38>>*/ return [0, x, acc];
      /*<<array.ml:455:44>>*/ }
      /*<<array.ml:455:10>>*/  /*<<array.ml:455:10>>*/ var
-     l =  /*<<array.ml:455:10>>*/ caml_call3(Stdlib_Seq[5], _c_, _b_, i$2);
+     l =  /*<<array.ml:455:10>>*/ caml_call3(Stdlib_Seq[5], _d_, _c_, i$2);
     if(! l)  /*<<array.ml:444:10>>*/ return [0];
      /*<<array.ml:446:16>>*/ var
      tl = l[2],
@@ -8205,6 +8221,7 @@
             : runtime.caml_call_gen(f, [a0, a1, a2]);
    }
     /*<<float.ml:38:20>>*/ var
+    _j_ = undefined,
     global_data = runtime.caml_get_global_data(),
     Stdlib_Seq = global_data.Stdlib__Seq,
     Stdlib_List = global_data.Stdlib__List,
@@ -8250,8 +8267,8 @@
     pi = 3.141592653589793;
    function is_integer(x){
      /*<<float.ml:116:19>>*/ var
-     _aw_ = x ==  /*<<float.ml:116:23>>*/ runtime.caml_trunc_float(x) ? 1 : 0;
-    return _aw_ ? is_finite(x) : _aw_;
+     _ax_ = x ==  /*<<float.ml:116:23>>*/ runtime.caml_trunc_float(x) ? 1 : 0;
+    return _ax_ ? is_finite(x) : _ax_;
     /*<<float.ml:116:45>>*/ }
    function succ(x){
      /*<<float.ml:121:13>>*/ return  /*<<float.ml:121:13>>*/ caml_nextafter_float
@@ -8352,32 +8369,34 @@
             (10, 100, 0, x);
     /*<<float.ml:170:41>>*/ }
    function unsafe_fill(a, ofs, len, v){
-     /*<<float.ml:184:4>>*/ var _au_ = (ofs + len | 0) - 1 | 0;
-    if(_au_ >= ofs){
+     /*<<float.ml:184:4>>*/ var _av_ = (ofs + len | 0) - 1 | 0;
+    if(_av_ >= ofs){
      var i = ofs;
      for(;;){
        /*<<float.ml:184:36>>*/ a[1 + i] = v;
-       /*<<float.ml:184:36>>*/  /*<<float.ml:184:36>>*/ var _av_ = i + 1 | 0;
-      if(_au_ === i) break;
-      var i = _av_;
+       /*<<float.ml:184:36>>*/  /*<<float.ml:184:36>>*/ var _aw_ = i + 1 | 0;
+      if(_av_ === i) break;
+      var i = _aw_;
      }
     }
     return 0;
     /*<<float.ml:184:57>>*/ }
    function check(a, ofs, len, msg){
-     /*<<float.ml:190:4>>*/ var _aq_ = ofs < 0 ? 1 : 0;
-    if(_aq_)
-     var _ar_ = _aq_;
+     /*<<float.ml:190:4>>*/ var _ar_ = ofs < 0 ? 1 : 0;
+    if(_ar_)
+     var _as_ = _ar_;
     else{
-     var _as_ = len < 0 ? 1 : 0;
-     if(_as_)
-      var _ar_ = _as_;
+     var _at_ = len < 0 ? 1 : 0;
+     if(_at_)
+      var _as_ = _at_;
      else
       var
-       _at_ = (ofs + len | 0) < 0 ? 1 : 0,
-       _ar_ = _at_ || (a.length - 1 < (ofs + len | 0) ? 1 : 0);
+       _au_ = (ofs + len | 0) < 0 ? 1 : 0,
+       _as_ = _au_ || (a.length - 1 < (ofs + len | 0) ? 1 : 0);
     }
-    return _ar_ ?  /*<<float.ml:191:6>>*/ caml_call1(Stdlib[1], msg) : _ar_;
+    if(! _as_) return _as_;
+     /*<<float.ml:191:6>>*/  /*<<float.ml:191:6>>*/ caml_call1(Stdlib[1], msg);
+     /*<<float.ml:191:6>>*/ return;
     /*<<float.ml:191:21>>*/ }
    function make(n, v){
      /*<<float.ml:194:4>>*/  /*<<float.ml:194:17>>*/ var
@@ -8392,16 +8411,16 @@
      /*<<float.ml:201:16>>*/ var
       /*<<float.ml:201:16>>*/ res =
         /*<<float.ml:201:16>>*/ caml_floatarray_create(l),
-      /*<<float.ml:202:6>>*/ _ao_ = l - 1 | 0,
-      /*<<float.ml:201:16>>*/ _an_ = 0;
-    if(_ao_ >= 0){
-     var i = _an_;
+      /*<<float.ml:202:6>>*/ _ap_ = l - 1 | 0,
+      /*<<float.ml:201:16>>*/ _ao_ = 0;
+    if(_ap_ >= 0){
+     var i = _ao_;
      for(;;){
        /*<<float.ml:203:8>>*/ res[1 + i] =
         /*<<float.ml:203:25>>*/ caml_call1(f, i);
-       /*<<float.ml:203:8>>*/  /*<<float.ml:203:8>>*/ var _ap_ = i + 1 | 0;
-      if(_ao_ === i) break;
-      var i = _ap_;
+       /*<<float.ml:203:8>>*/  /*<<float.ml:203:8>>*/ var _aq_ = i + 1 | 0;
+      if(_ap_ === i) break;
+      var i = _aq_;
      }
     }
      /*<<float.ml:205:6>>*/ return res;
@@ -8483,11 +8502,11 @@
             (src, sofs, dst, dofs, len);
     /*<<float.ml:256:37>>*/ }
    function to_list(a){
-     /*<<float.ml:259:25>>*/ function _al_(_am_){
-      /*<<?>>*/ return a[1 + _am_];
+     /*<<float.ml:259:25>>*/ function _am_(_an_){
+      /*<<?>>*/ return a[1 + _an_];
     }
      /*<<float.ml:259:25>>*/ return  /*<<float.ml:259:25>>*/ caml_call2
-            (Stdlib_List[11], a.length - 1, _al_);
+            (Stdlib_List[11], a.length - 1, _am_);
     /*<<float.ml:259:39>>*/ }
    function of_list(l){
      /*<<float.ml:262:4>>*/ var
@@ -8508,16 +8527,16 @@
     /*<<float.ml:268:12>>*/ }
    function iter(f, a){
      /*<<float.ml:272:4>>*/ var
-     _aj_ = a.length - 1 - 1 | 0,
-      /*<<float.ml:272:4>>*/ _ai_ = 0;
-    if(_aj_ >= 0){
-     var i = _ai_;
+     _ak_ = a.length - 1 - 1 | 0,
+      /*<<float.ml:272:4>>*/ _aj_ = 0;
+    if(_ak_ >= 0){
+     var i = _aj_;
      for(;;){
        /*<<float.ml:272:33>>*/  /*<<float.ml:272:33>>*/ caml_call1
        (f, a[1 + i]);
-       /*<<float.ml:272:33>>*/  /*<<float.ml:272:33>>*/ var _ak_ = i + 1 | 0;
-      if(_aj_ === i) break;
-      var i = _ak_;
+       /*<<float.ml:272:33>>*/  /*<<float.ml:272:33>>*/ var _al_ = i + 1 | 0;
+      if(_ak_ === i) break;
+      var i = _al_;
      }
     }
     return 0;
@@ -8527,16 +8546,16 @@
       /*<<float.ml:277:6>>*/ return  /*<<float.ml:277:6>>*/ caml_call1
              (Stdlib[1], cst_Float_Array_iter2_arrays_m);
      /*<<float.ml:279:6>>*/ var
-     _ag_ = a.length - 1 - 1 | 0,
-      /*<<float.ml:279:6>>*/ _af_ = 0;
-    if(_ag_ >= 0){
-     var i = _af_;
+     _ah_ = a.length - 1 - 1 | 0,
+      /*<<float.ml:279:6>>*/ _ag_ = 0;
+    if(_ah_ >= 0){
+     var i = _ag_;
      for(;;){
        /*<<float.ml:279:35>>*/  /*<<float.ml:279:35>>*/ caml_call2
        (f, a[1 + i], b[1 + i]);
-       /*<<float.ml:279:35>>*/  /*<<float.ml:279:35>>*/ var _ah_ = i + 1 | 0;
-      if(_ag_ === i) break;
-      var i = _ah_;
+       /*<<float.ml:279:35>>*/  /*<<float.ml:279:35>>*/ var _ai_ = i + 1 | 0;
+      if(_ah_ === i) break;
+      var i = _ai_;
      }
     }
     return 0;
@@ -8546,32 +8565,32 @@
      l = a.length - 1,
       /*<<float.ml:283:12>>*/ r =
         /*<<float.ml:283:12>>*/ caml_floatarray_create(l),
-      /*<<float.ml:284:4>>*/ _ad_ = l - 1 | 0,
-      /*<<float.ml:283:12>>*/ _ac_ = 0;
-    if(_ad_ >= 0){
-     var i = _ac_;
+      /*<<float.ml:284:4>>*/ _ae_ = l - 1 | 0,
+      /*<<float.ml:283:12>>*/ _ad_ = 0;
+    if(_ae_ >= 0){
+     var i = _ad_;
      for(;;){
        /*<<float.ml:285:6>>*/ r[1 + i] =
         /*<<float.ml:285:21>>*/ caml_call1(f, a[1 + i]);
-       /*<<float.ml:285:6>>*/  /*<<float.ml:285:6>>*/ var _ae_ = i + 1 | 0;
-      if(_ad_ === i) break;
-      var i = _ae_;
+       /*<<float.ml:285:6>>*/  /*<<float.ml:285:6>>*/ var _af_ = i + 1 | 0;
+      if(_ae_ === i) break;
+      var i = _af_;
      }
     }
      /*<<float.ml:287:4>>*/ return r;
     /*<<float.ml:287:5>>*/ }
    function map_inplace(f, a){
      /*<<float.ml:291:4>>*/ var
-     _aa_ = a.length - 1 - 1 | 0,
-      /*<<float.ml:291:4>>*/ _$_ = 0;
-    if(_aa_ >= 0){
-     var i = _$_;
+     _ab_ = a.length - 1 - 1 | 0,
+      /*<<float.ml:291:4>>*/ _aa_ = 0;
+    if(_ab_ >= 0){
+     var i = _aa_;
      for(;;){
        /*<<float.ml:292:6>>*/ a[1 + i] =
         /*<<float.ml:292:21>>*/ caml_call1(f, a[1 + i]);
-       /*<<float.ml:292:6>>*/  /*<<float.ml:292:6>>*/ var _ab_ = i + 1 | 0;
-      if(_aa_ === i) break;
-      var i = _ab_;
+       /*<<float.ml:292:6>>*/  /*<<float.ml:292:6>>*/ var _ac_ = i + 1 | 0;
+      if(_ab_ === i) break;
+      var i = _ac_;
      }
     }
     return 0;
@@ -8586,32 +8605,32 @@
      /*<<float.ml:301:14>>*/ var
       /*<<float.ml:301:14>>*/ r =
         /*<<float.ml:301:14>>*/ caml_floatarray_create(la),
-      /*<<float.ml:302:6>>*/ _Z_ = la - 1 | 0,
-      /*<<float.ml:301:14>>*/ _Y_ = 0;
-    if(_Z_ >= 0){
-     var i = _Y_;
+      /*<<float.ml:302:6>>*/ ___ = la - 1 | 0,
+      /*<<float.ml:301:14>>*/ _Z_ = 0;
+    if(___ >= 0){
+     var i = _Z_;
      for(;;){
        /*<<float.ml:303:8>>*/ r[1 + i] =
         /*<<float.ml:303:23>>*/ caml_call2(f, a[1 + i], b[1 + i]);
-       /*<<float.ml:303:8>>*/  /*<<float.ml:303:8>>*/ var ___ = i + 1 | 0;
-      if(_Z_ === i) break;
-      var i = ___;
+       /*<<float.ml:303:8>>*/  /*<<float.ml:303:8>>*/ var _$_ = i + 1 | 0;
+      if(___ === i) break;
+      var i = _$_;
      }
     }
      /*<<float.ml:305:6>>*/ return r;
     /*<<float.ml:306:7>>*/ }
    function iteri(f, a){
      /*<<float.ml:310:4>>*/ var
-     _W_ = a.length - 1 - 1 | 0,
-      /*<<float.ml:310:4>>*/ _V_ = 0;
-    if(_W_ >= 0){
-     var i = _V_;
+     _X_ = a.length - 1 - 1 | 0,
+      /*<<float.ml:310:4>>*/ _W_ = 0;
+    if(_X_ >= 0){
+     var i = _W_;
      for(;;){
        /*<<float.ml:310:33>>*/  /*<<float.ml:310:33>>*/ caml_call2
        (f, i, a[1 + i]);
-       /*<<float.ml:310:33>>*/  /*<<float.ml:310:33>>*/ var _X_ = i + 1 | 0;
-      if(_W_ === i) break;
-      var i = _X_;
+       /*<<float.ml:310:33>>*/  /*<<float.ml:310:33>>*/ var _Y_ = i + 1 | 0;
+      if(_X_ === i) break;
+      var i = _Y_;
      }
     }
     return 0;
@@ -8621,32 +8640,32 @@
      l = a.length - 1,
       /*<<float.ml:314:12>>*/ r =
         /*<<float.ml:314:12>>*/ caml_floatarray_create(l),
-      /*<<float.ml:315:4>>*/ _T_ = l - 1 | 0,
-      /*<<float.ml:314:12>>*/ _S_ = 0;
-    if(_T_ >= 0){
-     var i = _S_;
+      /*<<float.ml:315:4>>*/ _U_ = l - 1 | 0,
+      /*<<float.ml:314:12>>*/ _T_ = 0;
+    if(_U_ >= 0){
+     var i = _T_;
      for(;;){
        /*<<float.ml:316:6>>*/ r[1 + i] =
         /*<<float.ml:316:21>>*/ caml_call2(f, i, a[1 + i]);
-       /*<<float.ml:316:6>>*/  /*<<float.ml:316:6>>*/ var _U_ = i + 1 | 0;
-      if(_T_ === i) break;
-      var i = _U_;
+       /*<<float.ml:316:6>>*/  /*<<float.ml:316:6>>*/ var _V_ = i + 1 | 0;
+      if(_U_ === i) break;
+      var i = _V_;
      }
     }
      /*<<float.ml:318:4>>*/ return r;
     /*<<float.ml:318:5>>*/ }
    function mapi_inplace(f, a){
      /*<<float.ml:322:4>>*/ var
-     _Q_ = a.length - 1 - 1 | 0,
-      /*<<float.ml:322:4>>*/ _P_ = 0;
-    if(_Q_ >= 0){
-     var i = _P_;
+     _R_ = a.length - 1 - 1 | 0,
+      /*<<float.ml:322:4>>*/ _Q_ = 0;
+    if(_R_ >= 0){
+     var i = _Q_;
      for(;;){
        /*<<float.ml:323:6>>*/ a[1 + i] =
         /*<<float.ml:323:21>>*/ caml_call2(f, i, a[1 + i]);
-       /*<<float.ml:323:6>>*/  /*<<float.ml:323:6>>*/ var _R_ = i + 1 | 0;
-      if(_Q_ === i) break;
-      var i = _R_;
+       /*<<float.ml:323:6>>*/  /*<<float.ml:323:6>>*/ var _S_ = i + 1 | 0;
+      if(_R_ === i) break;
+      var i = _S_;
      }
     }
     return 0;
@@ -8654,15 +8673,15 @@
    function fold_left(f, x, a){
      /*<<float.ml:328:4>>*/ var
       /*<<float.ml:328:12>>*/ r = [0, x],
-     _N_ = a.length - 1 - 1 | 0,
-      /*<<float.ml:328:12>>*/ _M_ = 0;
-    if(_N_ >= 0){
-     var i = _M_;
+     _O_ = a.length - 1 - 1 | 0,
+      /*<<float.ml:328:12>>*/ _N_ = 0;
+    if(_O_ >= 0){
+     var i = _N_;
      for(;;){
       r[1] =  /*<<float.ml:330:11>>*/ caml_call2(f, r[1], a[1 + i]);
-       /*<<float.ml:329:4>>*/  /*<<float.ml:329:4>>*/ var _O_ = i + 1 | 0;
-      if(_N_ === i) break;
-      var i = _O_;
+       /*<<float.ml:329:4>>*/  /*<<float.ml:329:4>>*/ var _P_ = i + 1 | 0;
+      if(_O_ === i) break;
+      var i = _P_;
      }
     }
     return r[1];
@@ -8670,14 +8689,14 @@
    function fold_right(f, a, x){
      /*<<float.ml:336:4>>*/ var
       /*<<float.ml:336:12>>*/ r = [0, x],
-      /*<<float.ml:337:4>>*/ _K_ = a.length - 1 - 1 | 0;
-    if(_K_ >= 0){
-     var i = _K_;
+      /*<<float.ml:337:4>>*/ _L_ = a.length - 1 - 1 | 0;
+    if(_L_ >= 0){
+     var i = _L_;
      for(;;){
       r[1] =  /*<<float.ml:338:11>>*/ caml_call2(f, a[1 + i], r[1]);
-       /*<<float.ml:337:4>>*/  /*<<float.ml:337:4>>*/ var _L_ = i - 1 | 0;
+       /*<<float.ml:337:4>>*/  /*<<float.ml:337:4>>*/ var _M_ = i - 1 | 0;
       if(0 === i) break;
-      var i = _L_;
+      var i = _M_;
      }
     }
     return r[1];
@@ -8813,9 +8832,9 @@
       /*<<float.ml:438:38>>*/ throw  /*<<float.ml:438:38>>*/ caml_maybe_attach_backtrace
             ([0, Bottom, i], 1);
      /*<<float.ml:438:54>>*/ }
-    var l = a.length - 1, _E_ = ((l + 1 | 0) / 3 | 0) - 1 | 0;
-    if(_E_ >= 0){
-     var i$6 = _E_;
+    var l = a.length - 1, _F_ = ((l + 1 | 0) / 3 | 0) - 1 | 0;
+    if(_F_ >= 0){
+     var i$6 = _F_;
      for(;;){
        /*<<float.ml:467:52>>*/  /*<<float.ml:467:52>>*/ var
        e$1 =  /*<<float.ml:467:52>>*/ caml_array_get(a, i$6);
@@ -8845,14 +8864,14 @@
         /*<<float.ml:449:63>>*/  /*<<float.ml:449:63>>*/ caml_array_set
         (a, i$0, e$1);
       }
-       /*<<float.ml:467:40>>*/  /*<<float.ml:467:40>>*/ var _J_ = i$6 - 1 | 0;
+       /*<<float.ml:467:40>>*/  /*<<float.ml:467:40>>*/ var _K_ = i$6 - 1 | 0;
       if(0 === i$6) break;
-      var i$6 = _J_;
+      var i$6 = _K_;
      }
     }
-     /*<<float.ml:468:4>>*/  /*<<float.ml:468:4>>*/ var _F_ = l - 1 | 0;
-    if(_F_ >= 2){
-     var i$4 = _F_;
+     /*<<float.ml:468:4>>*/  /*<<float.ml:468:4>>*/ var _G_ = l - 1 | 0;
+    if(_G_ >= 2){
+     var i$4 = _G_;
      a:
      for(;;){
        /*<<float.ml:469:14>>*/  /*<<float.ml:469:14>>*/ var
@@ -8893,25 +8912,25 @@
           /*<<float.ml:461:51>>*/  /*<<float.ml:461:51>>*/ caml_array_set
           (a, 0, e$0);
         }
-         /*<<float.ml:468:4>>*/  /*<<float.ml:468:4>>*/ var _I_ = i$4 - 1 | 0;
+         /*<<float.ml:468:4>>*/  /*<<float.ml:468:4>>*/ var _J_ = i$4 - 1 | 0;
         if(2 === i$4) break a;
-        var i$4 = _I_;
+        var i$4 = _J_;
         break;
        }
       }
      }
     }
-    var _G_ = 1 < l ? 1 : 0;
-    if(_G_){
+    var _H_ = 1 < l ? 1 : 0;
+    if(_H_){
       /*<<float.ml:473:27>>*/  /*<<float.ml:473:27>>*/ var
       e =  /*<<float.ml:473:27>>*/ caml_array_get(a, 1);
       /*<<float.ml:473:40>>*/  /*<<float.ml:473:40>>*/ caml_array_set
       (a, 1,  /*<<float.ml:473:48>>*/ caml_array_get(a, 0));
-     var _H_ =  /*<<float.ml:473:59>>*/ caml_array_set(a, 0, e);
+     var _I_ =  /*<<float.ml:473:59>>*/ caml_array_set(a, 0, e);
     }
     else
-     var _H_ = _G_;
-     /*<<float.ml:473:59>>*/ return _H_;
+     var _I_ = _H_;
+     /*<<float.ml:473:59>>*/ return _I_;
     /*<<float.ml:473:69>>*/ }
    function stable_sort(cmp, a){
     function merge(src1ofs, src1len, src2, src2ofs, src2len, dst, dstofs){
@@ -8961,10 +8980,10 @@
      /*<<float.ml:496:72>>*/ }
     function isortto(srcofs, dst, dstofs, len){
       /*<<float.ml:499:6>>*/ var
-      _C_ = len - 1 | 0,
-       /*<<float.ml:499:6>>*/ _B_ = 0;
-     if(_C_ >= 0){
-      var i = _B_;
+      _D_ = len - 1 | 0,
+       /*<<float.ml:499:6>>*/ _C_ = 0;
+     if(_D_ >= 0){
+      var i = _C_;
       a:
       for(;;){
         /*<<float.ml:500:16>>*/ var
@@ -8988,9 +9007,9 @@
         }
          /*<<float.ml:506:8>>*/  /*<<float.ml:506:8>>*/ caml_array_set
          (dst, j[1] + 1 | 0, e);
-         /*<<float.ml:499:6>>*/  /*<<float.ml:499:6>>*/ var _D_ = i + 1 | 0;
-        if(_C_ === i) break a;
-        var i = _D_;
+         /*<<float.ml:499:6>>*/  /*<<float.ml:499:6>>*/ var _E_ = i + 1 | 0;
+        if(_D_ === i) break a;
+        var i = _E_;
         break;
        }
       }
@@ -8998,13 +9017,16 @@
      return 0;
      /*<<float.ml:507:10>>*/ }
     function sortto(srcofs, dst, dstofs, len){
-      /*<<float.ml:510:6>>*/ if(len <= 5)
-       /*<<float.ml:510:28>>*/ return isortto(srcofs, dst, dstofs, len);
+      /*<<float.ml:510:6>>*/ if(len <= 5){
+       /*<<float.ml:510:28>>*/ isortto(srcofs, dst, dstofs, len);
+       /*<<float.ml:510:28>>*/ return;
+     }
      var l1 = len / 2 | 0, l2 = len - l1 | 0;
       /*<<float.ml:513:8>>*/ sortto(srcofs + l1 | 0, dst, dstofs + l1 | 0, l2);
       /*<<float.ml:514:8>>*/ sortto(srcofs, a, srcofs + l2 | 0, l1);
-      /*<<float.ml:514:8>>*/ return merge
-             (srcofs + l2 | 0, l1, dst, dstofs + l1 | 0, l2, dst, dstofs);
+      /*<<float.ml:514:8>>*/ merge
+      (srcofs + l2 | 0, l1, dst, dstofs + l1 | 0, l2, dst, dstofs);
+      /*<<float.ml:514:8>>*/ return;
      /*<<float.ml:516:9>>*/ }
     var l = a.length - 1;
     if(l <= 5)  /*<<float.ml:519:24>>*/ return isortto(0, a, 0, l);
@@ -9023,14 +9045,14 @@
        /*<<float.ml:537:11>>*/ return 0;
       /*<<float.ml:535:16>>*/ var
        /*<<float.ml:535:16>>*/ x = a[1 + i],
-       /*<<float.ml:535:16>>*/ _z_ = i + 1 | 0;
+       /*<<float.ml:535:16>>*/ _A_ = i + 1 | 0;
       /*<<float.ml:536:8>>*/ return [0,
              x,
-             function(_A_){ /*<<?>>*/ return aux(_z_, _A_);}];
+             function(_B_){ /*<<?>>*/ return aux(_A_, _B_);}];
      /*<<float.ml:537:18>>*/ }
-     /*<<float.ml:539:4>>*/  /*<<float.ml:539:4>>*/ var _x_ = 0;
-     /*<<float.ml:539:4>>*/ return function(_y_){
-      /*<<?>>*/ return aux(_x_, _y_);};
+     /*<<float.ml:539:4>>*/  /*<<float.ml:539:4>>*/ var _y_ = 0;
+     /*<<float.ml:539:4>>*/ return function(_z_){
+      /*<<?>>*/ return aux(_y_, _z_);};
     /*<<float.ml:539:9>>*/ }
    function to_seqi(a){
     function aux(i, param){
@@ -9038,23 +9060,23 @@
        /*<<float.ml:548:11>>*/ return 0;
       /*<<float.ml:546:16>>*/ var
        /*<<float.ml:546:16>>*/ x = a[1 + i],
-       /*<<float.ml:546:16>>*/ _v_ = i + 1 | 0;
+       /*<<float.ml:546:16>>*/ _w_ = i + 1 | 0;
       /*<<float.ml:547:8>>*/ return [0,
              [0, i, x],
-             function(_w_){ /*<<?>>*/ return aux(_v_, _w_);}];
+             function(_x_){ /*<<?>>*/ return aux(_w_, _x_);}];
      /*<<float.ml:548:18>>*/ }
-     /*<<float.ml:550:4>>*/  /*<<float.ml:550:4>>*/ var _t_ = 0;
-     /*<<float.ml:550:4>>*/ return function(_u_){
-      /*<<?>>*/ return aux(_t_, _u_);};
+     /*<<float.ml:550:4>>*/  /*<<float.ml:550:4>>*/ var _u_ = 0;
+     /*<<float.ml:550:4>>*/ return function(_v_){
+      /*<<?>>*/ return aux(_u_, _v_);};
     /*<<float.ml:550:9>>*/ }
    function of_seq(i$2){
-     /*<<float.ml:564:4>>*/ var _r_ = 0;
-    function _s_(acc, x){
+     /*<<float.ml:564:4>>*/ var _s_ = 0;
+    function _t_(acc, x){
       /*<<float.ml:564:40>>*/ return [0, x, acc];
      /*<<float.ml:564:46>>*/ }
      /*<<float.ml:564:12>>*/ var
       /*<<float.ml:564:12>>*/ l =
-        /*<<float.ml:564:12>>*/ caml_call3(Stdlib_Seq[5], _s_, _r_, i$2),
+        /*<<float.ml:564:12>>*/ caml_call3(Stdlib_Seq[5], _t_, _s_, i$2),
       /*<<float.ml:554:14>>*/ len =
         /*<<float.ml:554:14>>*/ caml_call1(Stdlib_List[1], l),
       /*<<float.ml:555:12>>*/ a =
@@ -9079,16 +9101,16 @@
       /*<<float.ml:571:14>>*/ r =
         /*<<float.ml:571:14>>*/ runtime.caml_make_vect
         (l,  /*<<float.ml:571:27>>*/ caml_call1(f, a[1])),
-      /*<<float.ml:572:6>>*/ _p_ = l - 1 | 0,
-      /*<<float.ml:571:14>>*/ _o_ = 1;
-    if(_p_ >= 1){
-     var i = _o_;
+      /*<<float.ml:572:6>>*/ _q_ = l - 1 | 0,
+      /*<<float.ml:571:14>>*/ _p_ = 1;
+    if(_q_ >= 1){
+     var i = _p_;
      for(;;){
        /*<<float.ml:573:8>>*/ r[1 + i] =
         /*<<float.ml:573:29>>*/ caml_call1(f, a[1 + i]);
-       /*<<float.ml:573:8>>*/  /*<<float.ml:573:8>>*/ var _q_ = i + 1 | 0;
-      if(_p_ === i) break;
-      var i = _q_;
+       /*<<float.ml:573:8>>*/  /*<<float.ml:573:8>>*/ var _r_ = i + 1 | 0;
+      if(_q_ === i) break;
+      var i = _r_;
      }
     }
      /*<<float.ml:575:6>>*/ return r;
@@ -9098,16 +9120,16 @@
      l = a.length - 1,
       /*<<float.ml:580:12>>*/ r =
         /*<<float.ml:580:12>>*/ caml_floatarray_create(l),
-      /*<<float.ml:581:4>>*/ _m_ = l - 1 | 0,
-      /*<<float.ml:580:12>>*/ _l_ = 0;
-    if(_m_ >= 0){
-     var i = _l_;
+      /*<<float.ml:581:4>>*/ _n_ = l - 1 | 0,
+      /*<<float.ml:580:12>>*/ _m_ = 0;
+    if(_n_ >= 0){
+     var i = _m_;
      for(;;){
        /*<<float.ml:582:6>>*/ r[1 + i] =
         /*<<float.ml:582:21>>*/ caml_call1(f, a[1 + i]);
-       /*<<float.ml:582:6>>*/  /*<<float.ml:582:6>>*/ var _n_ = i + 1 | 0;
-      if(_m_ === i) break;
-      var i = _n_;
+       /*<<float.ml:582:6>>*/  /*<<float.ml:582:6>>*/ var _o_ = i + 1 | 0;
+      if(_n_ === i) break;
+      var i = _o_;
      }
     }
      /*<<float.ml:584:4>>*/ return r;
@@ -9118,7 +9140,7 @@
     _e_ = caml_array_get,
     _f_ =
       [0,
-       function(_k_){ /*<<?>>*/ return _k_.length - 1;},
+       function(_l_){ /*<<?>>*/ return _l_.length - 1;},
        _e_,
        _d_,
        make,
@@ -9194,7 +9216,7 @@
        seeded_hash,
        hash,
        [0,
-        function(_j_){ /*<<?>>*/ return _j_.length - 1;},
+        function(_k_){ /*<<?>>*/ return _k_.length - 1;},
         _i_,
         _h_,
         make,
@@ -10058,6 +10080,7 @@
        0,
        0,
        0],
+    _a_ = undefined,
     cst_syntax_error = "syntax error";
    function grow_stacks(param){
      /*<<parsing.ml:108:2>>*/ var
@@ -10084,7 +10107,7 @@
      (Stdlib_Array[8], env[4], 0, new_end, 0, oldsize);
     env[4] = new_end;
     env[5] = newsize;
-    return 0;
+    return;
     /*<<parsing.ml:122:28>>*/ }
    function clear_parser(param){
      /*<<parsing.ml:125:2>>*/  /*<<parsing.ml:125:2>>*/ caml_call4
@@ -10137,17 +10160,17 @@
         case 4:
          try{
            /*<<parsing.ml:143:39>>*/ var
-           _i_ = env[13],
-            /*<<parsing.ml:143:39>>*/ _j_ =
+           _j_ = env[13],
+            /*<<parsing.ml:143:39>>*/ _k_ =
               /*<<parsing.ml:143:39>>*/ caml_call1
-              (caml_check_bound(tables[1], _i_)[1 + _i_], env),
-            /*<<parsing.ml:143:39>>*/ _k_ = 4,
-           value = _j_,
-           action = _k_;
+              (caml_check_bound(tables[1], _j_)[1 + _j_], env),
+            /*<<parsing.ml:143:39>>*/ _l_ = 4,
+           value = _k_,
+           action = _l_;
          }
-         catch(_m_){
-          var _h_ = caml_wrap_exception(_m_);
-          if(_h_ !== Parse_error) throw caml_maybe_attach_backtrace(_h_, 0);
+         catch(_n_){
+          var _i_ = caml_wrap_exception(_n_);
+          if(_i_ !== Parse_error) throw caml_maybe_attach_backtrace(_i_, 0);
           var value = 0, action = 5;
          }
          var cmd = action, arg = value;
@@ -10183,9 +10206,9 @@
                 ? 1
                 : 0;
         /*<<parsing.ml:182:38>>*/  /*<<parsing.ml:182:38>>*/ var
-        _l_ =  /*<<parsing.ml:182:38>>*/ runtime.caml_obj_tag(tok);
-        /*<<parsing.ml:182:17>>*/ return caml_check_bound(tables[3], _l_)
-                [1 + _l_]
+        _m_ =  /*<<parsing.ml:182:38>>*/ runtime.caml_obj_tag(tok);
+        /*<<parsing.ml:182:17>>*/ return caml_check_bound(tables[3], _m_)
+                [1 + _m_]
                === curr_char
                ? 1
                : 0;
@@ -10195,21 +10218,21 @@
     }
     /*<<parsing.ml:184:17>>*/ }
    function peek_val(env, n){
-     /*<<parsing.ml:187:2>>*/ var _g_ = env[11] - n | 0;
-     /*<<parsing.ml:187:12>>*/ return caml_check_bound(env[2], _g_)[1 + _g_];
+     /*<<parsing.ml:187:2>>*/ var _h_ = env[11] - n | 0;
+     /*<<parsing.ml:187:12>>*/ return caml_check_bound(env[2], _h_)[1 + _h_];
     /*<<parsing.ml:187:37>>*/ }
    function symbol_start_pos(param){
      /*<<parsing.ml:190:2>>*/ var i$1 = env[12], i = i$1;
      /*<<parsing.ml:191:4>>*/ for(;;){
      if(0 >= i){
-      var _f_ = env[11];
-       /*<<parsing.ml:191:19>>*/ return caml_check_bound(env[4], _f_)[1 + _f_];
+      var _g_ = env[11];
+       /*<<parsing.ml:191:19>>*/ return caml_check_bound(env[4], _g_)[1 + _g_];
      }
       /*<<parsing.ml:193:15>>*/ var
-      _d_ = (env[11] - i | 0) + 1 | 0,
-       /*<<parsing.ml:193:15>>*/ st = caml_check_bound(env[3], _d_)[1 + _d_],
       _e_ = (env[11] - i | 0) + 1 | 0,
-       /*<<parsing.ml:194:15>>*/ en = caml_check_bound(env[4], _e_)[1 + _e_];
+       /*<<parsing.ml:193:15>>*/ st = caml_check_bound(env[3], _e_)[1 + _e_],
+      _f_ = (env[11] - i | 0) + 1 | 0,
+       /*<<parsing.ml:194:15>>*/ en = caml_check_bound(env[4], _f_)[1 + _f_];
       /*<<parsing.ml:195:9>>*/ if
       ( /*<<parsing.ml:195:9>>*/ runtime.caml_notequal(st, en))
        /*<<parsing.ml:195:23>>*/ return st;
@@ -10219,16 +10242,16 @@
     }
     /*<<parsing.ml:198:19>>*/ }
    function symbol_end_pos(param){
-     /*<<parsing.ml:200:24>>*/ var _c_ = env[11];
-     /*<<parsing.ml:200:24>>*/ return caml_check_bound(env[4], _c_)[1 + _c_];
+     /*<<parsing.ml:200:24>>*/ var _d_ = env[11];
+     /*<<parsing.ml:200:24>>*/ return caml_check_bound(env[4], _d_)[1 + _d_];
     /*<<parsing.ml:200:52>>*/ }
    function rhs_start_pos(n){
-     /*<<parsing.ml:201:22>>*/ var _b_ = env[11] - (env[12] - n | 0) | 0;
-     /*<<parsing.ml:201:22>>*/ return caml_check_bound(env[3], _b_)[1 + _b_];
+     /*<<parsing.ml:201:22>>*/ var _c_ = env[11] - (env[12] - n | 0) | 0;
+     /*<<parsing.ml:201:22>>*/ return caml_check_bound(env[3], _c_)[1 + _c_];
     /*<<parsing.ml:201:73>>*/ }
    function rhs_end_pos(n){
-     /*<<parsing.ml:202:20>>*/ var _a_ = env[11] - (env[12] - n | 0) | 0;
-     /*<<parsing.ml:202:20>>*/ return caml_check_bound(env[4], _a_)[1 + _a_];
+     /*<<parsing.ml:202:20>>*/ var _b_ = env[11] - (env[12] - n | 0) | 0;
+     /*<<parsing.ml:202:20>>*/ return caml_check_bound(env[4], _b_)[1 + _b_];
     /*<<parsing.ml:202:69>>*/ }
    function symbol_start(param){
      /*<<parsing.ml:204:22>>*/ return symbol_start_pos(0)[4];
@@ -12663,6 +12686,7 @@
     Stdlib = global_data.Stdlib,
     Stdlib_String = global_data.Stdlib__String,
     Assert_failure = global_data.Assert_failure,
+    _b_ = undefined,
     cst_Buffer_truncate = "Buffer.truncate",
     _a_ = [0, "buffer.ml", 220, 9],
     cst_Buffer_add_channel = "Buffer.add_channel",
@@ -12751,7 +12775,7 @@
        /*<<buffer.ml:99:2>>*/  /*<<buffer.ml:99:2>>*/ caml_call5
        (Stdlib_Bytes[11], b[1][1], 0, new_buffer, 0, b[2]);
       b[1] = [0, new_buffer, new_len[1]];
-      return 0;
+      return;
      }
      new_len[1] = 2 * new_len[1] | 0;
     }
@@ -12813,14 +12837,14 @@
     }
     /*<<buffer.ml:147:30>>*/ }
    function add_substring(b, s, offset, len){
-     /*<<buffer.ml:150:2>>*/ var _r_ = offset < 0 ? 1 : 0;
-    if(_r_)
-     var _s_ = _r_;
+     /*<<buffer.ml:150:2>>*/ var _s_ = offset < 0 ? 1 : 0;
+    if(_s_)
+     var _t_ = _s_;
     else
      var
-      _t_ = len < 0 ? 1 : 0,
-      _s_ = _t_ || ((caml_ml_string_length(s) - len | 0) < offset ? 1 : 0);
-    if(_s_)
+      _u_ = len < 0 ? 1 : 0,
+      _t_ = _u_ || ((caml_ml_string_length(s) - len | 0) < offset ? 1 : 0);
+    if(_t_)
       /*<<buffer.ml:151:7>>*/  /*<<buffer.ml:151:7>>*/ caml_call1
       (Stdlib[1], cst_Buffer_add_substring_add_s);
      /*<<buffer.ml:153:2>>*/ var
@@ -12875,9 +12899,9 @@
     /*<<buffer.ml:180:46>>*/ }
    function add_channel(b, ic, to_read$1){
      /*<<buffer.ml:206:2>>*/ var
-     _p_ = to_read$1 < 0 ? 1 : 0,
-     _q_ = _p_ || (Stdlib_Sys[12] < to_read$1 ? 1 : 0);
-    if(_q_)
+     _q_ = to_read$1 < 0 ? 1 : 0,
+     _r_ = _q_ || (Stdlib_Sys[12] < to_read$1 ? 1 : 0);
+    if(_r_)
       /*<<buffer.ml:207:4>>*/  /*<<buffer.ml:207:4>>*/ caml_call1
       (Stdlib[1], cst_Buffer_add_channel);
     if(b[1][2] < (b[2] + to_read$1 | 0))
@@ -12923,8 +12947,8 @@
      i$4 = 0;
      /*<<buffer.ml:262:4>>*/ for(;;){
      if(i$4 >= lim$1){
-      var _o_ = 92 === previous ? 1 : 0;
-      return _o_ ? add_char(b, previous) : _o_;
+      var _p_ = 92 === previous ? 1 : 0;
+      return _p_ ? add_char(b, previous) : _p_;
      }
       /*<<buffer.ml:263:12>>*/  /*<<buffer.ml:263:12>>*/ var
       previous$0 =  /*<<buffer.ml:263:12>>*/ caml_string_get(s, i$4);
@@ -13064,14 +13088,14 @@
       /*<<buffer.ml:298:14>>*/ var
        /*<<buffer.ml:298:14>>*/ x =
          /*<<buffer.ml:298:14>>*/ caml_bytes_get(b[1][1], i),
-       /*<<buffer.ml:298:14>>*/ _m_ = i + 1 | 0;
+       /*<<buffer.ml:298:14>>*/ _n_ = i + 1 | 0;
       /*<<buffer.ml:299:6>>*/ return [0,
              x,
-             function(_n_){ /*<<?>>*/ return aux(_m_, _n_);}];
+             function(_o_){ /*<<?>>*/ return aux(_n_, _o_);}];
      /*<<buffer.ml:299:29>>*/ }
-     /*<<buffer.ml:301:2>>*/  /*<<buffer.ml:301:2>>*/ var _k_ = 0;
-     /*<<buffer.ml:301:2>>*/ return function(_l_){
-      /*<<?>>*/ return aux(_k_, _l_);};
+     /*<<buffer.ml:301:2>>*/  /*<<buffer.ml:301:2>>*/ var _l_ = 0;
+     /*<<buffer.ml:301:2>>*/ return function(_m_){
+      /*<<?>>*/ return aux(_l_, _m_);};
     /*<<buffer.ml:301:7>>*/ }
    function to_seqi(b){
     function aux(i, param){
@@ -13080,21 +13104,21 @@
       /*<<buffer.ml:308:14>>*/ var
        /*<<buffer.ml:308:14>>*/ x =
          /*<<buffer.ml:308:14>>*/ caml_bytes_get(b[1][1], i),
-       /*<<buffer.ml:308:14>>*/ _i_ = i + 1 | 0;
+       /*<<buffer.ml:308:14>>*/ _j_ = i + 1 | 0;
       /*<<buffer.ml:309:6>>*/ return [0,
              [0, i, x],
-             function(_j_){ /*<<?>>*/ return aux(_i_, _j_);}];
+             function(_k_){ /*<<?>>*/ return aux(_j_, _k_);}];
      /*<<buffer.ml:309:33>>*/ }
-     /*<<buffer.ml:311:2>>*/  /*<<buffer.ml:311:2>>*/ var _g_ = 0;
-     /*<<buffer.ml:311:2>>*/ return function(_h_){
-      /*<<?>>*/ return aux(_g_, _h_);};
+     /*<<buffer.ml:311:2>>*/  /*<<buffer.ml:311:2>>*/ var _h_ = 0;
+     /*<<buffer.ml:311:2>>*/ return function(_i_){
+      /*<<?>>*/ return aux(_h_, _i_);};
     /*<<buffer.ml:311:7>>*/ }
    function add_seq(b, seq){
-     /*<<buffer.ml:313:29>>*/ function _e_(_f_){
-      /*<<?>>*/ return add_char(b, _f_);
+     /*<<buffer.ml:313:29>>*/ function _f_(_g_){
+      /*<<?>>*/ return add_char(b, _g_);
     }
      /*<<buffer.ml:313:20>>*/ return  /*<<buffer.ml:313:20>>*/ caml_call2
-            (Stdlib_Seq[4], _e_, seq);
+            (Stdlib_Seq[4], _f_, seq);
     /*<<buffer.ml:313:45>>*/ }
    function of_seq(i){
      /*<<buffer.ml:316:2>>*/  /*<<buffer.ml:316:10>>*/ var b = create(32);
@@ -13173,8 +13197,8 @@
     return 0;
     /*<<buffer.ml:378:28>>*/ }
    function add_int16_le(b, x){
-     /*<<buffer.ml:381:2>>*/ var _d_ = Stdlib_Sys[11] ? caml_bswap16(x) : x;
-    return add_int16_ne(b, _d_);
+     /*<<buffer.ml:381:2>>*/ var _e_ = Stdlib_Sys[11] ? caml_bswap16(x) : x;
+    return add_int16_ne(b, _e_);
     /*<<buffer.ml:381:57>>*/ }
    function add_int16_be(b, x){
      /*<<buffer.ml:384:2>>*/ var x$0 = Stdlib_Sys[11] ? x : caml_bswap16(x);
@@ -13182,8 +13206,8 @@
     /*<<buffer.ml:384:57>>*/ }
    function add_int32_le(b, x){
      /*<<buffer.ml:387:2>>*/ var
-     _c_ = Stdlib_Sys[11] ?  /*<<buffer.ml:387:41>>*/ caml_int32_bswap(x) : x;
-     /*<<buffer.ml:387:41>>*/ return add_int32_ne(b, _c_);
+     _d_ = Stdlib_Sys[11] ?  /*<<buffer.ml:387:41>>*/ caml_int32_bswap(x) : x;
+     /*<<buffer.ml:387:41>>*/ return add_int32_ne(b, _d_);
     /*<<buffer.ml:387:57>>*/ }
    function add_int32_be(b, x){
      /*<<buffer.ml:390:2>>*/ var
@@ -13192,8 +13216,8 @@
     /*<<buffer.ml:390:57>>*/ }
    function add_int64_le(b, x){
      /*<<buffer.ml:393:2>>*/ var
-     _b_ = Stdlib_Sys[11] ?  /*<<buffer.ml:393:41>>*/ caml_int64_bswap(x) : x;
-     /*<<buffer.ml:393:41>>*/ return add_int64_ne(b, _b_);
+     _c_ = Stdlib_Sys[11] ?  /*<<buffer.ml:393:41>>*/ caml_int64_bswap(x) : x;
+     /*<<buffer.ml:393:41>>*/ return add_int64_ne(b, _c_);
     /*<<buffer.ml:393:57>>*/ }
    function add_int64_be(b, x){
      /*<<buffer.ml:396:2>>*/ var
@@ -13460,6 +13484,7 @@
             : runtime.caml_call_gen(f, [a0, a1, a2, a3, a4]);
    }
    var
+    _a_ = undefined,
     global_data = runtime.caml_get_global_data(),
     Stdlib_Mutex = global_data.Stdlib__Mutex,
     Stdlib_Condition = global_data.Stdlib__Condition,
@@ -13478,8 +13503,8 @@
    function create_dls(param){
      /*<<domain.ml:59:4>>*/  /*<<domain.ml:59:13>>*/ var
      st =  /*<<domain.ml:59:13>>*/ caml_make_vect(8, unique_value);
-     /*<<domain.ml:60:4>>*/ return  /*<<domain.ml:60:4>>*/ caml_domain_dls_set
-            (st);
+     /*<<domain.ml:60:4>>*/  /*<<domain.ml:60:4>>*/ caml_domain_dls_set(st);
+     /*<<domain.ml:60:4>>*/ return;
     /*<<domain.ml:60:20>>*/ }
     /*<<domain.ml:62:10>>*/ create_dls(0);
     /*<<domain.ml:66:20>>*/ var
@@ -13568,7 +13593,7 @@
      /*<<domain.ml:147:27>>*/ first_spawn_function =
       [0,
        function(param){
-         /*<<domain.ml:147:42>>*/ return 0;
+         /*<<domain.ml:147:42>>*/ return;
         /*<<domain.ml:147:44>>*/ }];
    function before_first_spawn(f){
      /*<<domain.ml:150:2>>*/ if
@@ -13589,7 +13614,7 @@
     at_exit_key =
       new_key
        (0,
-        function(param, _e_){
+        function(param, _f_){
           /*<<domain.ml:166:52>>*/ return 0;
          /*<<domain.ml:166:54>>*/ });
    function at_exit(f){
@@ -13624,8 +13649,8 @@
        /*<<domain.ml:163:41>>*/ };
     }
      /*<<domain.ml:124:6>>*/  /*<<domain.ml:124:6>>*/ var
-     _a_ =  /*<<domain.ml:124:6>>*/ caml_call1(Stdlib_Atomic[2], parent_keys);
-    function _b_(param){
+     _b_ =  /*<<domain.ml:124:6>>*/ caml_call1(Stdlib_Atomic[2], parent_keys);
+    function _c_(param){
       /*<<domain.ml:122:6>>*/ var split = param[2], k = param[1], idx = k[1];
       /*<<domain.ml:123:11>>*/ return [0,
              idx,
@@ -13633,7 +13658,7 @@
      /*<<domain.ml:123:43>>*/ }
      /*<<domain.ml:124:6>>*/ var
       /*<<domain.ml:124:6>>*/ pk =
-        /*<<domain.ml:124:6>>*/ caml_call2(Stdlib_List[20], _b_, _a_),
+        /*<<domain.ml:124:6>>*/ caml_call2(Stdlib_List[20], _c_, _b_),
       /*<<domain.ml:193:19>>*/ term_mutex =
         /*<<domain.ml:193:19>>*/ caml_call1(Stdlib_Mutex[1], 0),
       /*<<domain.ml:194:23>>*/ term_condition =
@@ -13645,7 +13670,7 @@
        /*<<domain.ml:198:4>>*/ try{
         /*<<domain.ml:200:8>>*/ create_dls(0);
        var
-        _c_ =
+        _d_ =
           function(param){
             /*<<domain.ml:128:6>>*/ var
             v = param[2],
@@ -13655,7 +13680,7 @@
             /*<<domain.ml:129:35>>*/ return 0;
            /*<<domain.ml:129:49>>*/ };
         /*<<domain.ml:127:4>>*/  /*<<domain.ml:127:4>>*/ caml_call2
-        (Stdlib_List[18], _c_, pk);
+        (Stdlib_List[18], _d_, pk);
         /*<<domain.ml:202:18>>*/  /*<<domain.ml:202:18>>*/ var
         res =  /*<<domain.ml:202:18>>*/ caml_call1(f, 0);
       }
@@ -13672,8 +13697,8 @@
      catch(ex){
        /*<<domain.ml:215:10>>*/ var
        ex$0 = caml_wrap_exception(ex),
-        /*<<domain.ml:215:10>>*/ _d_ = 0 === result[0] ? [1, ex$0] : result,
-       result$0 = _d_;
+        /*<<domain.ml:215:10>>*/ _e_ = 0 === result[0] ? [1, ex$0] : result,
+       result$0 = _e_;
      }
       /*<<domain.ml:230:4>>*/  /*<<domain.ml:230:4>>*/ caml_call1
       (Stdlib_Mutex[2], term_mutex);
@@ -13804,6 +13829,7 @@
             : runtime.caml_call_gen(f, [a0, a1, a2, a3, a4]);
    }
    var
+    _$_ = undefined,
     global_data = runtime.caml_get_global_data(),
     cst$9 = "%{",
     cst$10 = "%}",
@@ -14130,14 +14156,14 @@
      /*<<camlinternalFormat.ml:28:2>>*/ var
      str_ind = c >>> 3 | 0,
      mask = 1 << (c & 7),
-      /*<<camlinternalFormat.ml:31:30>>*/ _dU_ =
+      /*<<camlinternalFormat.ml:31:30>>*/ _dT_ =
         /*<<camlinternalFormat.ml:31:30>>*/ runtime.caml_bytes_get
         (char_set, str_ind)
        | mask;
      /*<<camlinternalFormat.ml:30:2>>*/ return  /*<<camlinternalFormat.ml:30:2>>*/ caml_bytes_set
             (char_set,
              str_ind,
-              /*<<camlinternalFormat.ml:31:4>>*/ caml_call1(Stdlib[29], _dU_));
+              /*<<camlinternalFormat.ml:31:4>>*/ caml_call1(Stdlib[29], _dT_));
     /*<<camlinternalFormat.ml:31:69>>*/ }
    function freeze_char_set(char_set){
      /*<<camlinternalFormat.ml:34:2>>*/ return  /*<<camlinternalFormat.ml:34:2>>*/ caml_call1
@@ -14149,19 +14175,19 @@
      i = 0;
     for(;;){
       /*<<camlinternalFormat.ml:41:32>>*/  /*<<camlinternalFormat.ml:41:32>>*/ var
-      _dS_ =
+      _dR_ =
          /*<<camlinternalFormat.ml:41:32>>*/ caml_string_get(char_set, i)
         ^ 255;
       /*<<camlinternalFormat.ml:40:4>>*/  /*<<camlinternalFormat.ml:40:4>>*/ caml_bytes_set
       (char_set$0,
        i,
-        /*<<camlinternalFormat.ml:41:6>>*/ caml_call1(Stdlib[29], _dS_));
+        /*<<camlinternalFormat.ml:41:6>>*/ caml_call1(Stdlib[29], _dR_));
       /*<<camlinternalFormat.ml:40:4>>*/  /*<<camlinternalFormat.ml:40:4>>*/ var
-      _dT_ = i + 1 | 0;
+      _dS_ = i + 1 | 0;
      if(31 === i)
        /*<<camlinternalFormat.ml:43:2>>*/ return  /*<<camlinternalFormat.ml:43:2>>*/ caml_call1
               (Stdlib_Bytes[44], char_set$0);
-     var i = _dT_;
+     var i = _dS_;
     }
     /*<<camlinternalFormat.ml:43:34>>*/ }
    function is_in_char_set(char_set, c){
@@ -14221,11 +14247,11 @@
       case 6:
        var prec_opt = ign[2], pad_opt$5 = ign[1];
        if(prec_opt)
-        var ndec = prec_opt[1], _dR_ = [0, ndec];
+        var ndec = prec_opt[1], _dQ_ = [0, ndec];
        else
-        var _dR_ = 0;
+        var _dQ_ = 0;
         /*<<camlinternalFormat.ml:97:4>>*/ return [0,
-               [8, _a_, pad_of_pad_opt(pad_opt$5), _dR_, fmt]];
+               [8, _a_, pad_of_pad_opt(pad_opt$5), _dQ_, fmt]];
       case 7:
        var pad_opt$6 = ign[1];
         /*<<camlinternalFormat.ml:101:4>>*/ return [0,
@@ -14258,9 +14284,8 @@
    function buffer_check_size(buf, overhead){
      /*<<camlinternalFormat.ml:260:2>>*/ var
      len = runtime.caml_ml_bytes_length(buf[2]),
-     min_len = buf[1] + overhead | 0,
-     _dP_ = len < min_len ? 1 : 0;
-    if(_dP_){
+     min_len = buf[1] + overhead | 0;
+    if(len < min_len){
       /*<<camlinternalFormat.ml:263:18>>*/ var
        /*<<camlinternalFormat.ml:263:18>>*/ new_len =
          /*<<camlinternalFormat.ml:263:18>>*/ caml_call2
@@ -14270,18 +14295,15 @@
       /*<<camlinternalFormat.ml:265:4>>*/  /*<<camlinternalFormat.ml:265:4>>*/ caml_call5
       (Stdlib_Bytes[11], buf[2], 0, new_str, 0, len);
      buf[2] = new_str;
-     var _dQ_ = 0;
     }
-    else
-     var _dQ_ = _dP_;
-    return _dQ_;
+    return;
     /*<<camlinternalFormat.ml:267:3>>*/ }
    function buffer_add_char(buf, c){
      /*<<camlinternalFormat.ml:271:2>>*/ buffer_check_size(buf, 1);
      /*<<camlinternalFormat.ml:272:2>>*/  /*<<camlinternalFormat.ml:272:2>>*/ caml_bytes_set
      (buf[2], buf[1], c);
     buf[1] = buf[1] + 1 | 0;
-    return 0;
+    return;
     /*<<camlinternalFormat.ml:273:24>>*/ }
    function buffer_add_string(buf, s){
      /*<<camlinternalFormat.ml:277:2>>*/ var
@@ -14290,7 +14312,7 @@
      /*<<camlinternalFormat.ml:279:2>>*/  /*<<camlinternalFormat.ml:279:2>>*/ caml_call5
      (Stdlib_String[6], s, 0, buf[2], buf[1], str_len);
     buf[1] = buf[1] + str_len | 0;
-    return 0;
+    return;
     /*<<camlinternalFormat.ml:280:30>>*/ }
    function buffer_contents(buf){
      /*<<camlinternalFormat.ml:284:2>>*/ return caml_call3
@@ -14346,68 +14368,78 @@
    function bprint_padty(buf, padty){
      /*<<camlinternalFormat.ml:374:29>>*/ switch(padty){
       case 0:
-        /*<<camlinternalFormat.ml:375:13>>*/ return buffer_add_char(buf, 45);
+        /*<<camlinternalFormat.ml:375:13>>*/ buffer_add_char(buf, 45);
+        /*<<camlinternalFormat.ml:375:13>>*/ return;
       case 1:
-        /*<<camlinternalFormat.ml:376:13>>*/ return 0;
+        /*<<camlinternalFormat.ml:376:13>>*/ return;
       default:
-        /*<<camlinternalFormat.ml:377:13>>*/ return buffer_add_char(buf, 48);
+        /*<<camlinternalFormat.ml:377:13>>*/ buffer_add_char(buf, 48);
+        /*<<camlinternalFormat.ml:377:13>>*/ return;
     }
     /*<<camlinternalFormat.ml:377:36>>*/ }
    function bprint_ignored_flag(buf, ign_flag){
-     /*<<camlinternalFormat.ml:381:2>>*/ return ign_flag
-            ? buffer_add_char(buf, 95)
-            : ign_flag;
+     /*<<camlinternalFormat.ml:381:2>>*/ if(! ign_flag)
+      /*<<camlinternalFormat.ml:381:2>>*/ return ign_flag;
+     /*<<camlinternalFormat.ml:381:19>>*/ buffer_add_char(buf, 95);
+     /*<<camlinternalFormat.ml:381:19>>*/ return;
     /*<<camlinternalFormat.ml:381:42>>*/ }
    function bprint_pad_opt(buf, pad_opt){
      /*<<camlinternalFormat.ml:385:33>>*/ if(! pad_opt)
-      /*<<camlinternalFormat.ml:386:12>>*/ return 0;
+      /*<<camlinternalFormat.ml:386:12>>*/ return;
     var width = pad_opt[1];
-     /*<<camlinternalFormat.ml:387:40>>*/ return buffer_add_string
-            (buf,
-              /*<<camlinternalFormat.ml:387:40>>*/ caml_call1
-              (Stdlib_Int[12], width));
+     /*<<camlinternalFormat.ml:387:40>>*/ buffer_add_string
+     (buf,
+       /*<<camlinternalFormat.ml:387:40>>*/ caml_call1(Stdlib_Int[12], width));
+     /*<<camlinternalFormat.ml:387:40>>*/ return;
     /*<<camlinternalFormat.ml:387:61>>*/ }
    function bprint_padding(buf, pad){
      /*<<camlinternalFormat.ml:393:15>>*/ if(typeof pad === "number")
-      /*<<camlinternalFormat.ml:394:18>>*/ return 0;
+      /*<<camlinternalFormat.ml:394:18>>*/ return;
     if(0 === pad[0]){
      var n = pad[2], padty = pad[1];
       /*<<camlinternalFormat.ml:396:4>>*/ bprint_padty(buf, padty);
-      /*<<camlinternalFormat.ml:397:26>>*/ return buffer_add_string
-             (buf,
-               /*<<camlinternalFormat.ml:397:26>>*/ caml_call1
-               (Stdlib_Int[12], n));
+      /*<<camlinternalFormat.ml:397:26>>*/ buffer_add_string
+      (buf,
+        /*<<camlinternalFormat.ml:397:26>>*/ caml_call1(Stdlib_Int[12], n));
+      /*<<camlinternalFormat.ml:397:26>>*/ return;
     }
     var padty$0 = pad[1];
      /*<<camlinternalFormat.ml:399:4>>*/ bprint_padty(buf, padty$0);
-     /*<<camlinternalFormat.ml:399:4>>*/ return buffer_add_char(buf, 42);
+     /*<<camlinternalFormat.ml:399:4>>*/ buffer_add_char(buf, 42);
+     /*<<camlinternalFormat.ml:399:4>>*/ return;
     /*<<camlinternalFormat.ml:400:27>>*/ }
    function bprint_precision(buf, prec){
-     /*<<camlinternalFormat.ml:404:18>>*/ if(typeof prec === "number")
-     return prec ? buffer_add_string(buf, cst) : 0;
-    var n = prec[1];
-     /*<<camlinternalFormat.ml:407:4>>*/ buffer_add_char(buf, 46);
-     /*<<camlinternalFormat.ml:408:26>>*/ return buffer_add_string
-            (buf,
-              /*<<camlinternalFormat.ml:408:26>>*/ caml_call1
-              (Stdlib_Int[12], n));
+     /*<<camlinternalFormat.ml:404:18>>*/ if(typeof prec !== "number"){
+     var n = prec[1];
+      /*<<camlinternalFormat.ml:407:4>>*/ buffer_add_char(buf, 46);
+      /*<<camlinternalFormat.ml:408:26>>*/ buffer_add_string
+      (buf,
+        /*<<camlinternalFormat.ml:408:26>>*/ caml_call1(Stdlib_Int[12], n));
+      /*<<camlinternalFormat.ml:408:26>>*/ return;
+    }
+    if(! prec)  /*<<camlinternalFormat.ml:405:20>>*/ return;
+     /*<<camlinternalFormat.ml:410:4>>*/ buffer_add_string(buf, cst);
+     /*<<camlinternalFormat.ml:410:4>>*/ return;
     /*<<camlinternalFormat.ml:410:30>>*/ }
    function bprint_iconv_flag(buf, iconv){
      /*<<camlinternalFormat.ml:415:34>>*/ switch(iconv){
       case 1:
       case 4:
-        /*<<camlinternalFormat.ml:416:23>>*/ return buffer_add_char(buf, 43);
+        /*<<camlinternalFormat.ml:416:23>>*/ buffer_add_char(buf, 43);
+        /*<<camlinternalFormat.ml:416:23>>*/ return;
       case 2:
       case 5:
-        /*<<camlinternalFormat.ml:417:23>>*/ return buffer_add_char(buf, 32);
+        /*<<camlinternalFormat.ml:417:23>>*/ buffer_add_char(buf, 32);
+        /*<<camlinternalFormat.ml:417:23>>*/ return;
       case 7:
       case 9:
       case 11:
       case 13:
       case 14:
       case 15:
-        /*<<camlinternalFormat.ml:419:6>>*/ return buffer_add_char(buf, 35);
-      default:  /*<<camlinternalFormat.ml:420:53>>*/ return 0;
+        /*<<camlinternalFormat.ml:419:6>>*/ buffer_add_char(buf, 35);
+        /*<<camlinternalFormat.ml:419:6>>*/ return;
+      default:  /*<<camlinternalFormat.ml:420:53>>*/ return;
     }
     /*<<camlinternalFormat.ml:420:55>>*/ }
    function bprint_altint_fmt(buf, ign_flag, iconv, pad, prec, c){
@@ -14417,8 +14449,9 @@
      /*<<camlinternalFormat.ml:436:2>>*/ bprint_padding(buf, pad);
      /*<<camlinternalFormat.ml:437:2>>*/ bprint_precision(buf, prec);
      /*<<camlinternalFormat.ml:438:2>>*/ buffer_add_char(buf, c);
-     /*<<camlinternalFormat.ml:439:22>>*/ return buffer_add_char
-            (buf, char_of_iconv(iconv));
+     /*<<camlinternalFormat.ml:439:22>>*/ buffer_add_char
+     (buf, char_of_iconv(iconv));
+     /*<<camlinternalFormat.ml:439:22>>*/ return;
     /*<<camlinternalFormat.ml:439:43>>*/ }
    function bprint_fconv_flag(buf, fconv){
      /*<<camlinternalFormat.ml:445:2>>*/ switch(fconv[1]){
@@ -14427,7 +14460,9 @@
         /*<<camlinternalFormat.ml:446:20>>*/ buffer_add_char(buf, 43); break;
       default:  /*<<camlinternalFormat.ml:447:20>>*/ buffer_add_char(buf, 32);
     }
-    return 8 <= fconv[2] ? buffer_add_char(buf, 35) : 0;
+    if(8 > fconv[2])  /*<<camlinternalFormat.ml:452:35>>*/ return;
+     /*<<camlinternalFormat.ml:450:16>>*/ buffer_add_char(buf, 35);
+     /*<<camlinternalFormat.ml:450:16>>*/ return;
     /*<<camlinternalFormat.ml:452:37>>*/ }
    function string_of_formatting_lit(formatting_lit){
      /*<<camlinternalFormat.ml:465:46>>*/ if
@@ -14457,40 +14492,43 @@
       default:
         /*<<camlinternalFormat.ml:475:26>>*/ var
         c = formatting_lit[1],
-         /*<<camlinternalFormat.ml:475:26>>*/ _dO_ =
+         /*<<camlinternalFormat.ml:475:26>>*/ _dP_ =
            /*<<camlinternalFormat.ml:475:26>>*/ caml_call2
            (Stdlib_String[1], 1, c);
         /*<<camlinternalFormat.ml:475:26>>*/ return  /*<<camlinternalFormat.ml:475:26>>*/ caml_call2
-               (Stdlib[28], cst$7, _dO_);
+               (Stdlib[28], cst$7, _dP_);
     }
     /*<<camlinternalFormat.ml:475:43>>*/ }
    function bprint_char_literal(buf, chr){
-     /*<<camlinternalFormat.ml:480:34>>*/ return 37 === chr
-            ? buffer_add_string(buf, cst$8)
-            : buffer_add_char(buf, chr);
+     /*<<camlinternalFormat.ml:480:34>>*/ if(37 === chr){
+      /*<<camlinternalFormat.ml:481:11>>*/ buffer_add_string(buf, cst$8);
+      /*<<camlinternalFormat.ml:481:11>>*/ return;
+    }
+     /*<<camlinternalFormat.ml:482:9>>*/ buffer_add_char(buf, chr);
+     /*<<camlinternalFormat.ml:482:9>>*/ return;
     /*<<camlinternalFormat.ml:482:32>>*/ }
    function bprint_string_literal(buf, str){
      /*<<camlinternalFormat.ml:486:2>>*/ var
-     _dM_ = caml_ml_string_length(str) - 1 | 0,
-      /*<<camlinternalFormat.ml:486:2>>*/ _dL_ = 0;
-    if(_dM_ >= 0){
-     var i = _dL_;
+     _dN_ = caml_ml_string_length(str) - 1 | 0,
+      /*<<camlinternalFormat.ml:486:2>>*/ _dM_ = 0;
+    if(_dN_ >= 0){
+     var i = _dM_;
      for(;;){
        /*<<camlinternalFormat.ml:487:4>>*/ bprint_char_literal
        (buf,  /*<<camlinternalFormat.ml:487:28>>*/ caml_string_get(str, i));
        /*<<camlinternalFormat.ml:487:4>>*/  /*<<camlinternalFormat.ml:487:4>>*/ var
-       _dN_ = i + 1 | 0;
-      if(_dM_ === i) break;
-      var i = _dN_;
+       _dO_ = i + 1 | 0;
+      if(_dN_ === i) break;
+      var i = _dO_;
      }
     }
-    return 0;
+    return;
     /*<<camlinternalFormat.ml:488:6>>*/ }
    function bprint_fmtty(buf, fmtty){
      /*<<camlinternalFormat.ml:496:17>>*/ var fmtty$0 = fmtty;
      /*<<camlinternalFormat.ml:496:17>>*/ for(;;){
      if(typeof fmtty$0 === "number")
-       /*<<camlinternalFormat.ml:521:20>>*/ return 0;
+       /*<<camlinternalFormat.ml:521:20>>*/ return;
      switch(fmtty$0[0]){
        case 0:
         var fmtty$1 = fmtty$0[1];
@@ -14587,7 +14625,7 @@
       ign_flag$0 = ign_flag;
       /*<<camlinternalFormat.ml:535:22>>*/ for(;;){
       if(typeof fmt$0 === "number")
-        /*<<camlinternalFormat.ml:636:23>>*/ return 0;
+        /*<<camlinternalFormat.ml:636:23>>*/ return;
       switch(fmt$0[0]){
         case 0:
          var rest = fmt$0[1];
@@ -14790,12 +14828,18 @@
               c =
                  /*<<camlinternalFormat.ml:358:31>>*/ caml_call1
                  (Stdlib[29], i);
-             return 37 === c
-                     ? (buffer_add_char(buf, 37), buffer_add_char(buf, 37))
-                     : 64
-                       === c
-                       ? (buffer_add_char(buf, 37), buffer_add_char(buf, 64))
-                       : buffer_add_char(buf, c);
+             if(37 === c){
+               /*<<camlinternalFormat.ml:359:13>>*/ buffer_add_char(buf, 37);
+               /*<<camlinternalFormat.ml:359:13>>*/ buffer_add_char(buf, 37);
+               /*<<camlinternalFormat.ml:359:13>>*/ return;
+             }
+             if(64 === c){
+               /*<<camlinternalFormat.ml:360:13>>*/ buffer_add_char(buf, 37);
+               /*<<camlinternalFormat.ml:360:13>>*/ buffer_add_char(buf, 64);
+               /*<<camlinternalFormat.ml:360:13>>*/ return;
+             }
+              /*<<camlinternalFormat.ml:361:13>>*/ buffer_add_char(buf, c);
+              /*<<camlinternalFormat.ml:361:13>>*/ return;
              /*<<camlinternalFormat.ml:361:35>>*/ };
           /*<<camlinternalFormat.ml:363:2>>*/ buffer_add_char(buf, 91);
           /*<<camlinternalFormat.ml:365:7>>*/ var
@@ -14813,18 +14857,18 @@
                 /*<<camlinternalFormat.ml:316:32>>*/ before =
                   /*<<camlinternalFormat.ml:316:32>>*/ caml_call1
                   (Stdlib_Char[1], c - 1 | 0),
-                /*<<camlinternalFormat.ml:317:6>>*/ _dH_ =
+                /*<<camlinternalFormat.ml:317:6>>*/ _dI_ =
                  is_in_char_set(set, c);
-               /*<<camlinternalFormat.ml:317:6>>*/ if(_dH_)
+               /*<<camlinternalFormat.ml:317:6>>*/ if(_dI_)
                 /*<<camlinternalFormat.ml:318:14>>*/ var
-                 /*<<camlinternalFormat.ml:318:14>>*/ _dI_ =
-                  is_in_char_set(set, before),
                  /*<<camlinternalFormat.ml:318:14>>*/ _dJ_ =
-                  _dI_ ? is_in_char_set(set, after) : _dI_,
-                _dK_ = 1 - _dJ_;
+                  is_in_char_set(set, before),
+                 /*<<camlinternalFormat.ml:318:14>>*/ _dK_ =
+                  _dJ_ ? is_in_char_set(set, after) : _dJ_,
+                _dL_ = 1 - _dK_;
               else
-               var _dK_ = _dH_;
-               /*<<camlinternalFormat.ml:318:43>>*/ return _dK_;
+               var _dL_ = _dI_;
+               /*<<camlinternalFormat.ml:318:43>>*/ return _dL_;
               /*<<camlinternalFormat.ml:318:68>>*/ }
              return is_alone;
             },
@@ -14958,12 +15002,12 @@
           (buf, ign_flag$0);
          switch(counter){
            case 0:
-            var _dD_ = 108; break;
+            var _dE_ = 108; break;
            case 1:
-            var _dD_ = 110; break;
-           default: var _dD_ = 78;
+            var _dE_ = 110; break;
+           default: var _dE_ = 78;
          }
-          /*<<camlinternalFormat.ml:614:6>>*/ buffer_add_char(buf, _dD_);
+          /*<<camlinternalFormat.ml:614:6>>*/ buffer_add_char(buf, _dE_);
          var fmt$0 = rest$20, ign_flag$0 = 0;
          break;
         case 22:
@@ -14987,20 +15031,20 @@
           /*<<camlinternalFormat.ml:578:20>>*/ var
           rest$23 = fmt$0[3],
           arity = fmt$0[1],
-           /*<<camlinternalFormat.ml:578:20>>*/ _dF_ =
+           /*<<camlinternalFormat.ml:578:20>>*/ _dG_ =
             int_of_custom_arity(arity),
-          _dE_ = 1;
-         if(_dF_ >= 1){
-          var i$8 = _dE_;
+          _dF_ = 1;
+         if(_dG_ >= 1){
+          var i$8 = _dF_;
           for(;;){
             /*<<camlinternalFormat.ml:579:8>>*/ buffer_add_char(buf, 37);
             /*<<camlinternalFormat.ml:579:33>>*/ bprint_ignored_flag
             (buf, ign_flag$0);
             /*<<camlinternalFormat.ml:580:8>>*/ buffer_add_char(buf, 63);
             /*<<camlinternalFormat.ml:580:8>>*/  /*<<camlinternalFormat.ml:580:8>>*/ var
-            _dG_ = i$8 + 1 | 0;
-           if(_dF_ === i$8) break;
-           var i$8 = _dG_;
+            _dH_ = i$8 + 1 | 0;
+           if(_dG_ === i$8) break;
+           var i$8 = _dH_;
           }
          }
          var fmt$0 = rest$23, ign_flag$0 = 0;
@@ -15072,17 +15116,17 @@
          ed = match[3],
          af = match[2],
          fa = match[1],
-         _di_ =
+         _dj_ =
            function(param){
              /*<<camlinternalFormat.ml:698:17>>*/ af(0);
-             /*<<camlinternalFormat.ml:698:39>>*/ return 0;
+             /*<<camlinternalFormat.ml:698:39>>*/ return;
             /*<<camlinternalFormat.ml:698:43>>*/ };
          /*<<camlinternalFormat.ml:697:4>>*/ return [0,
                 function(param){
                   /*<<camlinternalFormat.ml:697:17>>*/ fa(0);
-                  /*<<camlinternalFormat.ml:697:39>>*/ return 0;
+                  /*<<camlinternalFormat.ml:697:39>>*/ return;
                  /*<<camlinternalFormat.ml:697:43>>*/ },
-                _di_,
+                _dj_,
                 ed,
                 de];
        case 1:
@@ -15093,17 +15137,17 @@
          ed$0 = match$0[3],
          af$0 = match$0[2],
          fa$0 = match$0[1],
-         _dj_ =
+         _dk_ =
            function(param){
              /*<<camlinternalFormat.ml:703:17>>*/ af$0(0);
-             /*<<camlinternalFormat.ml:703:39>>*/ return 0;
+             /*<<camlinternalFormat.ml:703:39>>*/ return;
             /*<<camlinternalFormat.ml:703:43>>*/ };
          /*<<camlinternalFormat.ml:702:4>>*/ return [0,
                 function(param){
                   /*<<camlinternalFormat.ml:702:17>>*/ fa$0(0);
-                  /*<<camlinternalFormat.ml:702:39>>*/ return 0;
+                  /*<<camlinternalFormat.ml:702:39>>*/ return;
                  /*<<camlinternalFormat.ml:702:43>>*/ },
-                _dj_,
+                _dk_,
                 ed$0,
                 de$0];
        case 2:
@@ -15114,17 +15158,17 @@
          ed$1 = match$1[3],
          af$1 = match$1[2],
          fa$1 = match$1[1],
-         _dk_ =
+         _dl_ =
            function(param){
              /*<<camlinternalFormat.ml:708:17>>*/ af$1(0);
-             /*<<camlinternalFormat.ml:708:39>>*/ return 0;
+             /*<<camlinternalFormat.ml:708:39>>*/ return;
             /*<<camlinternalFormat.ml:708:43>>*/ };
          /*<<camlinternalFormat.ml:707:4>>*/ return [0,
                 function(param){
                   /*<<camlinternalFormat.ml:707:17>>*/ fa$1(0);
-                  /*<<camlinternalFormat.ml:707:39>>*/ return 0;
+                  /*<<camlinternalFormat.ml:707:39>>*/ return;
                  /*<<camlinternalFormat.ml:707:43>>*/ },
-                _dk_,
+                _dl_,
                 ed$1,
                 de$1];
        case 3:
@@ -15135,17 +15179,17 @@
          ed$2 = match$2[3],
          af$2 = match$2[2],
          fa$2 = match$2[1],
-         _dl_ =
+         _dm_ =
            function(param){
              /*<<camlinternalFormat.ml:713:17>>*/ af$2(0);
-             /*<<camlinternalFormat.ml:713:39>>*/ return 0;
+             /*<<camlinternalFormat.ml:713:39>>*/ return;
             /*<<camlinternalFormat.ml:713:43>>*/ };
          /*<<camlinternalFormat.ml:712:4>>*/ return [0,
                 function(param){
                   /*<<camlinternalFormat.ml:712:17>>*/ fa$2(0);
-                  /*<<camlinternalFormat.ml:712:39>>*/ return 0;
+                  /*<<camlinternalFormat.ml:712:39>>*/ return;
                  /*<<camlinternalFormat.ml:712:43>>*/ },
-                _dl_,
+                _dm_,
                 ed$2,
                 de$2];
        case 4:
@@ -15156,17 +15200,17 @@
          ed$3 = match$3[3],
          af$3 = match$3[2],
          fa$3 = match$3[1],
-         _dm_ =
+         _dn_ =
            function(param){
              /*<<camlinternalFormat.ml:723:17>>*/ af$3(0);
-             /*<<camlinternalFormat.ml:723:39>>*/ return 0;
+             /*<<camlinternalFormat.ml:723:39>>*/ return;
             /*<<camlinternalFormat.ml:723:43>>*/ };
          /*<<camlinternalFormat.ml:722:4>>*/ return [0,
                 function(param){
                   /*<<camlinternalFormat.ml:722:17>>*/ fa$3(0);
-                  /*<<camlinternalFormat.ml:722:39>>*/ return 0;
+                  /*<<camlinternalFormat.ml:722:39>>*/ return;
                  /*<<camlinternalFormat.ml:722:43>>*/ },
-                _dm_,
+                _dn_,
                 ed$3,
                 de$3];
        case 5:
@@ -15177,17 +15221,17 @@
          ed$4 = match$4[3],
          af$4 = match$4[2],
          fa$4 = match$4[1],
-         _dn_ =
+         _do_ =
            function(param){
              /*<<camlinternalFormat.ml:718:17>>*/ af$4(0);
-             /*<<camlinternalFormat.ml:718:39>>*/ return 0;
+             /*<<camlinternalFormat.ml:718:39>>*/ return;
             /*<<camlinternalFormat.ml:718:43>>*/ };
          /*<<camlinternalFormat.ml:717:4>>*/ return [0,
                 function(param){
                   /*<<camlinternalFormat.ml:717:17>>*/ fa$4(0);
-                  /*<<camlinternalFormat.ml:717:39>>*/ return 0;
+                  /*<<camlinternalFormat.ml:717:39>>*/ return;
                  /*<<camlinternalFormat.ml:717:43>>*/ },
-                _dn_,
+                _do_,
                 ed$4,
                 de$4];
        case 6:
@@ -15198,17 +15242,17 @@
          ed$5 = match$5[3],
          af$5 = match$5[2],
          fa$5 = match$5[1],
-         _do_ =
+         _dp_ =
            function(param){
              /*<<camlinternalFormat.ml:728:17>>*/ af$5(0);
-             /*<<camlinternalFormat.ml:728:39>>*/ return 0;
+             /*<<camlinternalFormat.ml:728:39>>*/ return;
             /*<<camlinternalFormat.ml:728:43>>*/ };
          /*<<camlinternalFormat.ml:727:4>>*/ return [0,
                 function(param){
                   /*<<camlinternalFormat.ml:727:17>>*/ fa$5(0);
-                  /*<<camlinternalFormat.ml:727:39>>*/ return 0;
+                  /*<<camlinternalFormat.ml:727:39>>*/ return;
                  /*<<camlinternalFormat.ml:727:43>>*/ },
-                _do_,
+                _dp_,
                 ed$5,
                 de$5];
        case 7:
@@ -15219,17 +15263,17 @@
          ed$6 = match$6[3],
          af$6 = match$6[2],
          fa$6 = match$6[1],
-         _dp_ =
+         _dq_ =
            function(param){
              /*<<camlinternalFormat.ml:733:17>>*/ af$6(0);
-             /*<<camlinternalFormat.ml:733:39>>*/ return 0;
+             /*<<camlinternalFormat.ml:733:39>>*/ return;
             /*<<camlinternalFormat.ml:733:43>>*/ };
          /*<<camlinternalFormat.ml:732:4>>*/ return [0,
                 function(param){
                   /*<<camlinternalFormat.ml:732:17>>*/ fa$6(0);
-                  /*<<camlinternalFormat.ml:732:39>>*/ return 0;
+                  /*<<camlinternalFormat.ml:732:39>>*/ return;
                  /*<<camlinternalFormat.ml:732:43>>*/ },
-                _dp_,
+                _dq_,
                 ed$6,
                 de$6];
        case 8:
@@ -15240,17 +15284,17 @@
          ed$7 = match$7[3],
          af$7 = match$7[2],
          fa$7 = match$7[1],
-         _dq_ =
+         _dr_ =
            function(param){
              /*<<camlinternalFormat.ml:766:17>>*/ af$7(0);
-             /*<<camlinternalFormat.ml:766:39>>*/ return 0;
+             /*<<camlinternalFormat.ml:766:39>>*/ return;
             /*<<camlinternalFormat.ml:766:43>>*/ };
          /*<<camlinternalFormat.ml:765:4>>*/ return [0,
                 function(param){
                   /*<<camlinternalFormat.ml:765:17>>*/ fa$7(0);
-                  /*<<camlinternalFormat.ml:765:39>>*/ return 0;
+                  /*<<camlinternalFormat.ml:765:39>>*/ return;
                  /*<<camlinternalFormat.ml:765:43>>*/ },
-                _dq_,
+                _dr_,
                 ed$7,
                 de$7];
        case 9:
@@ -15269,33 +15313,33 @@
          dj = match$9[3],
          ga = match$9[2],
          ag = match$9[1],
-         _dr_ =
+         _ds_ =
            function(param){
              /*<<camlinternalFormat.ml:775:17>>*/ jd(0);
              /*<<camlinternalFormat.ml:775:50>>*/ de$8(0);
-             /*<<camlinternalFormat.ml:775:61>>*/ return 0;
+             /*<<camlinternalFormat.ml:775:61>>*/ return;
             /*<<camlinternalFormat.ml:775:65>>*/ },
-         _ds_ =
+         _dt_ =
            function(param){
              /*<<camlinternalFormat.ml:774:17>>*/ ed$8(0);
              /*<<camlinternalFormat.ml:774:50>>*/ dj(0);
-             /*<<camlinternalFormat.ml:774:61>>*/ return 0;
+             /*<<camlinternalFormat.ml:774:61>>*/ return;
             /*<<camlinternalFormat.ml:774:65>>*/ },
-         _dt_ =
+         _du_ =
            function(param){
              /*<<camlinternalFormat.ml:773:17>>*/ ga(0);
              /*<<camlinternalFormat.ml:773:50>>*/ af$8(0);
-             /*<<camlinternalFormat.ml:773:61>>*/ return 0;
+             /*<<camlinternalFormat.ml:773:61>>*/ return;
             /*<<camlinternalFormat.ml:773:65>>*/ };
          /*<<camlinternalFormat.ml:772:4>>*/ return [0,
                 function(param){
                   /*<<camlinternalFormat.ml:772:17>>*/ fa$8(0);
                   /*<<camlinternalFormat.ml:772:50>>*/ ag(0);
-                  /*<<camlinternalFormat.ml:772:61>>*/ return 0;
+                  /*<<camlinternalFormat.ml:772:61>>*/ return;
                  /*<<camlinternalFormat.ml:772:65>>*/ },
+                _du_,
                 _dt_,
-                _ds_,
-                _dr_];
+                _ds_];
        case 10:
          /*<<camlinternalFormat.ml:742:25>>*/ var
          rest$9 = param[1],
@@ -15305,17 +15349,17 @@
          ed$9 = match$10[3],
          af$9 = match$10[2],
          fa$9 = match$10[1],
-         _du_ =
+         _dv_ =
            function(param){
              /*<<camlinternalFormat.ml:744:17>>*/ af$9(0);
-             /*<<camlinternalFormat.ml:744:39>>*/ return 0;
+             /*<<camlinternalFormat.ml:744:39>>*/ return;
             /*<<camlinternalFormat.ml:744:43>>*/ };
          /*<<camlinternalFormat.ml:743:4>>*/ return [0,
                 function(param){
                   /*<<camlinternalFormat.ml:743:17>>*/ fa$9(0);
-                  /*<<camlinternalFormat.ml:743:39>>*/ return 0;
+                  /*<<camlinternalFormat.ml:743:39>>*/ return;
                  /*<<camlinternalFormat.ml:743:43>>*/ },
-                _du_,
+                _dv_,
                 ed$9,
                 de$9];
        case 11:
@@ -15327,17 +15371,17 @@
          ed$10 = match$11[3],
          af$10 = match$11[2],
          fa$10 = match$11[1],
-         _dv_ =
+         _dw_ =
            function(param){
              /*<<camlinternalFormat.ml:739:17>>*/ af$10(0);
-             /*<<camlinternalFormat.ml:739:39>>*/ return 0;
+             /*<<camlinternalFormat.ml:739:39>>*/ return;
             /*<<camlinternalFormat.ml:739:43>>*/ };
          /*<<camlinternalFormat.ml:738:4>>*/ return [0,
                 function(param){
                   /*<<camlinternalFormat.ml:738:17>>*/ fa$10(0);
-                  /*<<camlinternalFormat.ml:738:39>>*/ return 0;
+                  /*<<camlinternalFormat.ml:738:39>>*/ return;
                  /*<<camlinternalFormat.ml:738:43>>*/ },
-                _dv_,
+                _dw_,
                 ed$10,
                 de$10];
        case 12:
@@ -15349,17 +15393,17 @@
          ed$11 = match$12[3],
          af$11 = match$12[2],
          fa$11 = match$12[1],
-         _dw_ =
+         _dx_ =
            function(param){
              /*<<camlinternalFormat.ml:749:17>>*/ af$11(0);
-             /*<<camlinternalFormat.ml:749:39>>*/ return 0;
+             /*<<camlinternalFormat.ml:749:39>>*/ return;
             /*<<camlinternalFormat.ml:749:43>>*/ };
          /*<<camlinternalFormat.ml:748:4>>*/ return [0,
                 function(param){
                   /*<<camlinternalFormat.ml:748:17>>*/ fa$11(0);
-                  /*<<camlinternalFormat.ml:748:39>>*/ return 0;
+                  /*<<camlinternalFormat.ml:748:39>>*/ return;
                  /*<<camlinternalFormat.ml:748:43>>*/ },
-                _dw_,
+                _dx_,
                 ed$11,
                 de$11];
        case 13:
@@ -15371,29 +15415,29 @@
          ed$12 = match$13[3],
          af$12 = match$13[2],
          fa$12 = match$13[1],
-          /*<<camlinternalFormat.ml:753:4>>*/ _dx_ =
+          /*<<camlinternalFormat.ml:753:4>>*/ _dy_ =
            function(param){
              /*<<camlinternalFormat.ml:756:17>>*/ de$12(0);
-             /*<<camlinternalFormat.ml:756:39>>*/ return 0;
+             /*<<camlinternalFormat.ml:756:39>>*/ return;
             /*<<camlinternalFormat.ml:756:43>>*/ },
-         _dy_ =
+         _dz_ =
            function(param){
              /*<<camlinternalFormat.ml:755:17>>*/ ed$12(0);
-             /*<<camlinternalFormat.ml:755:39>>*/ return 0;
+             /*<<camlinternalFormat.ml:755:39>>*/ return;
             /*<<camlinternalFormat.ml:755:43>>*/ },
-         _dz_ =
+         _dA_ =
            function(param){
              /*<<camlinternalFormat.ml:754:17>>*/ af$12(0);
-             /*<<camlinternalFormat.ml:754:39>>*/ return 0;
+             /*<<camlinternalFormat.ml:754:39>>*/ return;
             /*<<camlinternalFormat.ml:754:43>>*/ };
          /*<<camlinternalFormat.ml:753:4>>*/ return [0,
                 function(param){
                   /*<<camlinternalFormat.ml:753:17>>*/ fa$12(0);
-                  /*<<camlinternalFormat.ml:753:39>>*/ return 0;
+                  /*<<camlinternalFormat.ml:753:39>>*/ return;
                  /*<<camlinternalFormat.ml:753:43>>*/ },
+                _dA_,
                 _dz_,
-                _dy_,
-                _dx_];
+                _dy_];
        default:
          /*<<camlinternalFormat.ml:758:25>>*/ var
          rest$13 = param[1],
@@ -15403,46 +15447,46 @@
          ed$13 = match$14[3],
          af$13 = match$14[2],
          fa$13 = match$14[1],
-          /*<<camlinternalFormat.ml:759:4>>*/ _dA_ =
+          /*<<camlinternalFormat.ml:759:4>>*/ _dB_ =
            function(param){
              /*<<camlinternalFormat.ml:762:17>>*/ de$13(0);
-             /*<<camlinternalFormat.ml:762:39>>*/ return 0;
+             /*<<camlinternalFormat.ml:762:39>>*/ return;
             /*<<camlinternalFormat.ml:762:43>>*/ },
-         _dB_ =
+         _dC_ =
            function(param){
              /*<<camlinternalFormat.ml:761:17>>*/ ed$13(0);
-             /*<<camlinternalFormat.ml:761:39>>*/ return 0;
+             /*<<camlinternalFormat.ml:761:39>>*/ return;
             /*<<camlinternalFormat.ml:761:43>>*/ },
-         _dC_ =
+         _dD_ =
            function(param){
              /*<<camlinternalFormat.ml:760:17>>*/ af$13(0);
-             /*<<camlinternalFormat.ml:760:39>>*/ return 0;
+             /*<<camlinternalFormat.ml:760:39>>*/ return;
             /*<<camlinternalFormat.ml:760:43>>*/ };
          /*<<camlinternalFormat.ml:759:4>>*/ return [0,
                 function(param){
                   /*<<camlinternalFormat.ml:759:17>>*/ fa$13(0);
-                  /*<<camlinternalFormat.ml:759:39>>*/ return 0;
+                  /*<<camlinternalFormat.ml:759:39>>*/ return;
                  /*<<camlinternalFormat.ml:759:43>>*/ },
+                _dD_,
                 _dC_,
-                _dB_,
-                _dA_];
+                _dB_];
      }
-     /*<<camlinternalFormat.ml:691:4>>*/ function _df_(param){
-      /*<<camlinternalFormat.ml:694:17>>*/ return 0;
+     /*<<camlinternalFormat.ml:691:4>>*/ function _dg_(param){
+      /*<<camlinternalFormat.ml:694:17>>*/ return;
      /*<<camlinternalFormat.ml:694:21>>*/ }
-    function _dg_(param){
-      /*<<camlinternalFormat.ml:693:17>>*/ return 0;
-     /*<<camlinternalFormat.ml:693:21>>*/ }
     function _dh_(param){
-      /*<<camlinternalFormat.ml:692:17>>*/ return 0;
+      /*<<camlinternalFormat.ml:693:17>>*/ return;
+     /*<<camlinternalFormat.ml:693:21>>*/ }
+    function _di_(param){
+      /*<<camlinternalFormat.ml:692:17>>*/ return;
      /*<<camlinternalFormat.ml:692:21>>*/ }
      /*<<camlinternalFormat.ml:691:4>>*/ return [0,
             function(param){
-              /*<<camlinternalFormat.ml:691:17>>*/ return 0;
+              /*<<camlinternalFormat.ml:691:17>>*/ return;
              /*<<camlinternalFormat.ml:691:21>>*/ },
+            _di_,
             _dh_,
-            _dg_,
-            _df_];
+            _dg_];
    }
    function trans(ty1, ty2){
      /*<<camlinternalFormat.ml:803:17>>*/ a:
@@ -15661,11 +15705,11 @@
                     /*<<camlinternalFormat.ml:835:34>>*/ var
                     rest2$7 = ty2[2],
                     ty2$0 = ty2[1],
-                     /*<<camlinternalFormat.ml:835:34>>*/ _de_ =
+                     /*<<camlinternalFormat.ml:835:34>>*/ _df_ =
                       trans(rest1$7, rest2$7);
                     /*<<camlinternalFormat.ml:835:4>>*/ return [8,
                            trans(ty1$0, ty2$0),
-                           _de_];
+                           _df_];
                   case 10:
                    break a;
                   case 11:
@@ -15955,13 +15999,13 @@
          /*<<camlinternalFormat.ml:914:54>>*/ var
          rest$13 = fmtty$0[2],
          formatting_gen = fmtty$0[1],
-          /*<<camlinternalFormat.ml:914:54>>*/ _db_ = fmtty_of_fmt(rest$13);
+          /*<<camlinternalFormat.ml:914:54>>*/ _dc_ = fmtty_of_fmt(rest$13);
         if(0 === formatting_gen[0])
-         var fmt = formatting_gen[1][1], _dc_ = fmtty_of_fmt(fmt);
+         var fmt = formatting_gen[1][1], _dd_ = fmtty_of_fmt(fmt);
         else
-         var fmt$0 = formatting_gen[1][1], _dc_ = fmtty_of_fmt(fmt$0);
+         var fmt$0 = formatting_gen[1][1], _dd_ = fmtty_of_fmt(fmt$0);
          /*<<camlinternalFormat.ml:914:54>>*/ return  /*<<camlinternalFormat.ml:914:54>>*/ caml_call2
-                (CamlinternalFormatBasics[1], _dc_, _db_);
+                (CamlinternalFormatBasics[1], _dd_, _dc_);
        case 19:
         var rest$14 = fmtty$0[1];
          /*<<camlinternalFormat.ml:897:34>>*/ return [13,
@@ -16014,10 +16058,10 @@
            case 9:
              /*<<camlinternalFormat.ml:943:58>>*/ var
              fmtty$6 = ign[2],
-              /*<<camlinternalFormat.ml:943:58>>*/ _dd_ =
+              /*<<camlinternalFormat.ml:943:58>>*/ _de_ =
                fmtty_of_fmt(fmtty$5);
              /*<<camlinternalFormat.ml:943:58>>*/ return  /*<<camlinternalFormat.ml:943:58>>*/ caml_call2
-                    (CamlinternalFormatBasics[1], fmtty$6, _dd_);
+                    (CamlinternalFormatBasics[1], fmtty$6, _de_);
            case 10:
             var fmtty$0 = fmtty$5; break;
            default: var fmtty$0 = fmtty$5;
@@ -16073,11 +16117,11 @@
     /*<<camlinternalFormat.ml:996:54>>*/ }
    function type_format(fmt, fmtty){
      /*<<camlinternalFormat.ml:1008:19>>*/  /*<<camlinternalFormat.ml:1008:25>>*/ var
-     _da_ = type_format_gen(fmt, fmtty);
-    if(typeof _da_[2] !== "number")
+     _db_ = type_format_gen(fmt, fmtty);
+    if(typeof _db_[2] !== "number")
       /*<<camlinternalFormat.ml:1010:9>>*/ throw  /*<<camlinternalFormat.ml:1010:9>>*/ caml_maybe_attach_backtrace
             (Type_mismatch, 1);
-    var fmt$0 = _da_[1];
+    var fmt$0 = _db_[1];
      /*<<camlinternalFormat.ml:1009:42>>*/ return fmt$0;
     /*<<camlinternalFormat.ml:1010:28>>*/ }
    function type_ignored_param_one(ign, fmt, fmtty){
@@ -16362,7 +16406,7 @@
          fmt_rest$13 = fmt[3],
          sub_fmtty$1 = fmt[2],
          pad_opt$0 = fmt[1],
-          /*<<camlinternalFormat.ml:1099:42>>*/ _c__ =
+          /*<<camlinternalFormat.ml:1099:42>>*/ _c$_ =
            [0,
              /*<<camlinternalFormat.ml:1099:52>>*/ caml_call1
              (CamlinternalFormatBasics[2], sub_fmtty1)];
@@ -16371,7 +16415,7 @@
            ([0,
               /*<<camlinternalFormat.ml:1099:17>>*/ caml_call1
               (CamlinternalFormatBasics[2], sub_fmtty$1)],
-            _c__))
+            _c$_))
           /*<<camlinternalFormat.ml:1100:6>>*/ throw  /*<<camlinternalFormat.ml:1100:6>>*/ caml_maybe_attach_backtrace
                 (Type_mismatch, 1);
          /*<<camlinternalFormat.ml:1102:6>>*/ var
@@ -16541,12 +16585,12 @@
             /*<<camlinternalFormat.ml:1176:6>>*/ var
             sub_fmtty$3 = ign[2],
             pad_opt$2 = ign[1],
-             /*<<camlinternalFormat.ml:1176:6>>*/ _c$_ =
+             /*<<camlinternalFormat.ml:1176:6>>*/ _da_ =
               type_ignored_format_substituti(sub_fmtty$3, rest, fmtty0),
-            match$43 = _c$_[2],
+            match$43 = _da_[2],
             fmtty$21 = match$43[2],
             fmt$22 = match$43[1],
-            sub_fmtty$4 = _c$_[1];
+            sub_fmtty$4 = _da_[1];
             /*<<camlinternalFormat.ml:1177:4>>*/ return [0,
                    [23, [9, pad_opt$2, sub_fmtty$4], fmt$22],
                    fmtty$21];
@@ -16738,7 +16782,7 @@
          sub_fmtty_rest$17 = sub_fmtty[3],
          sub2_fmtty$2 = sub_fmtty[2],
          sub1_fmtty$0 = sub_fmtty[1],
-          /*<<camlinternalFormat.ml:1261:43>>*/ _c8_ =
+          /*<<camlinternalFormat.ml:1261:43>>*/ _c9_ =
            [0,
              /*<<camlinternalFormat.ml:1261:53>>*/ caml_call1
              (CamlinternalFormatBasics[2], sub1_fmtty)];
@@ -16747,11 +16791,11 @@
            ([0,
               /*<<camlinternalFormat.ml:1261:17>>*/ caml_call1
               (CamlinternalFormatBasics[2], sub1_fmtty$0)],
-            _c8_))
+            _c9_))
           /*<<camlinternalFormat.ml:1262:9>>*/ throw  /*<<camlinternalFormat.ml:1262:9>>*/ caml_maybe_attach_backtrace
                 (Type_mismatch, 1);
          /*<<camlinternalFormat.ml:1263:43>>*/  /*<<camlinternalFormat.ml:1263:43>>*/ var
-         _c9_ =
+         _c__ =
            [0,
              /*<<camlinternalFormat.ml:1263:53>>*/ caml_call1
              (CamlinternalFormatBasics[2], sub2_fmtty$1)];
@@ -16760,7 +16804,7 @@
            ([0,
               /*<<camlinternalFormat.ml:1263:17>>*/ caml_call1
               (CamlinternalFormatBasics[2], sub2_fmtty$2)],
-            _c9_))
+            _c__))
           /*<<camlinternalFormat.ml:1264:9>>*/ throw  /*<<camlinternalFormat.ml:1264:9>>*/ caml_maybe_attach_backtrace
                 (Type_mismatch, 1);
          /*<<camlinternalFormat.ml:1265:21>>*/ var
@@ -16852,11 +16896,11 @@
     /*<<camlinternalFormat.ml:1277:28>>*/ }
    function recast(fmt, fmtty){
      /*<<camlinternalFormat.ml:1312:2>>*/  /*<<camlinternalFormat.ml:1312:29>>*/ var
-     _c7_ = symm(fmtty);
+     _c8_ = symm(fmtty);
      /*<<camlinternalFormat.ml:1312:18>>*/ return type_format
             (fmt,
               /*<<camlinternalFormat.ml:1312:18>>*/ caml_call1
-              (CamlinternalFormatBasics[2], _c7_));
+              (CamlinternalFormatBasics[2], _c8_));
     /*<<camlinternalFormat.ml:1312:42>>*/ }
    function fix_padding(padty, width, str){
      /*<<camlinternalFormat.ml:1319:2>>*/ var
@@ -16866,10 +16910,10 @@
         /*<<camlinternalFormat.ml:1321:4>>*/ caml_call1(Stdlib[18], width);
     if(width$0 <= len)  /*<<camlinternalFormat.ml:1332:23>>*/ return str;
      /*<<camlinternalFormat.ml:1333:14>>*/ var
-     _c6_ = 2 === padty$0 ? 48 : 32,
+     _c7_ = 2 === padty$0 ? 48 : 32,
       /*<<camlinternalFormat.ml:1333:14>>*/ res =
         /*<<camlinternalFormat.ml:1333:14>>*/ caml_call2
-        (Stdlib_Bytes[1], width$0, _c6_);
+        (Stdlib_Bytes[1], width$0, _c7_);
      /*<<camlinternalFormat.ml:1334:4>>*/ switch(padty$0){
       case 0:
         /*<<camlinternalFormat.ml:1335:15>>*/  /*<<camlinternalFormat.ml:1335:15>>*/ caml_call5
@@ -17061,16 +17105,16 @@
       /*<<camlinternalFormat.ml:1447:9>>*/ return s;
      /*<<camlinternalFormat.ml:1428:14>>*/ var
       /*<<camlinternalFormat.ml:1428:14>>*/ n = [0, 0],
-     _c1_ = caml_ml_string_length(s) - 1 | 0,
-      /*<<camlinternalFormat.ml:1428:14>>*/ _c0_ = 0;
-    if(_c1_ >= 0){
-     var i$0 = _c0_;
+     _c2_ = caml_ml_string_length(s) - 1 | 0,
+      /*<<camlinternalFormat.ml:1428:14>>*/ _c1_ = 0;
+    if(_c2_ >= 0){
+     var i$0 = _c1_;
      for(;;){
       if(9 >= caml_string_unsafe_get(s, i$0) - 48 >>> 0) n[1]++;
        /*<<camlinternalFormat.ml:1429:6>>*/  /*<<camlinternalFormat.ml:1429:6>>*/ var
-       _c5_ = i$0 + 1 | 0;
-      if(_c1_ === i$0) break;
-      var i$0 = _c5_;
+       _c6_ = i$0 + 1 | 0;
+      if(_c2_ === i$0) break;
+      var i$0 = _c6_;
      }
     }
      /*<<camlinternalFormat.ml:1436:14>>*/ var
@@ -17083,15 +17127,15 @@
       /*<<camlinternalFormat.ml:1438:16>>*/  /*<<camlinternalFormat.ml:1438:16>>*/ caml_bytes_set
       (buf, pos[1], c);
      pos[1]++;
-     return 0;
+     return;
      /*<<camlinternalFormat.ml:1438:46>>*/ }
      /*<<camlinternalFormat.ml:1439:15>>*/ var
       /*<<camlinternalFormat.ml:1439:15>>*/ left =
        [0, ((digits - 1 | 0) % 3 | 0) + 1 | 0],
-     _c3_ = caml_ml_string_length(s) - 1 | 0,
-      /*<<camlinternalFormat.ml:1439:15>>*/ _c2_ = 0;
-    if(_c3_ >= 0){
-     var i = _c2_;
+     _c4_ = caml_ml_string_length(s) - 1 | 0,
+      /*<<camlinternalFormat.ml:1439:15>>*/ _c3_ = 0;
+    if(_c4_ >= 0){
+     var i = _c3_;
      for(;;){
       var c = caml_string_unsafe_get(s, i);
       if(9 < c - 48 >>> 0)
@@ -17105,9 +17149,9 @@
         /*<<camlinternalFormat.ml:1443:61>>*/ put(c);
       }
        /*<<camlinternalFormat.ml:1440:4>>*/  /*<<camlinternalFormat.ml:1440:4>>*/ var
-       _c4_ = i + 1 | 0;
-      if(_c3_ === i) break;
-      var i = _c4_;
+       _c5_ = i + 1 | 0;
+      if(_c4_ === i) break;
+      var i = _c5_;
      }
     }
      /*<<camlinternalFormat.ml:1446:4>>*/ return  /*<<camlinternalFormat.ml:1446:4>>*/ caml_call1
@@ -17116,139 +17160,139 @@
    function convert_int(iconv, n){
      /*<<camlinternalFormat.ml:1451:2>>*/ switch(iconv){
       case 1:
-       var _cZ_ = cst_d$0; break;
+       var _c0_ = cst_d$0; break;
       case 2:
-       var _cZ_ = cst_d$1; break;
+       var _c0_ = cst_d$1; break;
       case 4:
-       var _cZ_ = cst_i$1; break;
+       var _c0_ = cst_i$1; break;
       case 5:
-       var _cZ_ = cst_i$2; break;
+       var _c0_ = cst_i$2; break;
       case 6:
-       var _cZ_ = cst_x; break;
+       var _c0_ = cst_x; break;
       case 7:
-       var _cZ_ = cst_x$0; break;
+       var _c0_ = cst_x$0; break;
       case 8:
-       var _cZ_ = cst_X; break;
+       var _c0_ = cst_X; break;
       case 9:
-       var _cZ_ = cst_X$0; break;
+       var _c0_ = cst_X$0; break;
       case 10:
-       var _cZ_ = cst_o; break;
+       var _c0_ = cst_o; break;
       case 11:
-       var _cZ_ = cst_o$0; break;
+       var _c0_ = cst_o$0; break;
       case 0:
       case 13:
-       var _cZ_ = cst_d; break;
+       var _c0_ = cst_d; break;
       case 3:
       case 14:
-       var _cZ_ = cst_i$0; break;
-      default: var _cZ_ = cst_u;
+       var _c0_ = cst_i$0; break;
+      default: var _c0_ = cst_u;
     }
      /*<<camlinternalFormat.ml:1451:26>>*/ return transform_int_alt
             (iconv,
-              /*<<camlinternalFormat.ml:1451:26>>*/ caml_format_int(_cZ_, n));
+              /*<<camlinternalFormat.ml:1451:26>>*/ caml_format_int(_c0_, n));
     /*<<camlinternalFormat.ml:1451:64>>*/ }
    function convert_int32(iconv, n){
      /*<<camlinternalFormat.ml:1453:2>>*/ switch(iconv){
       case 1:
-       var _cY_ = cst_ld$0; break;
+       var _cZ_ = cst_ld$0; break;
       case 2:
-       var _cY_ = cst_ld$1; break;
+       var _cZ_ = cst_ld$1; break;
       case 4:
-       var _cY_ = cst_li$1; break;
+       var _cZ_ = cst_li$1; break;
       case 5:
-       var _cY_ = cst_li$2; break;
+       var _cZ_ = cst_li$2; break;
       case 6:
-       var _cY_ = cst_lx; break;
+       var _cZ_ = cst_lx; break;
       case 7:
-       var _cY_ = cst_lx$0; break;
+       var _cZ_ = cst_lx$0; break;
       case 8:
-       var _cY_ = cst_lX; break;
+       var _cZ_ = cst_lX; break;
       case 9:
-       var _cY_ = cst_lX$0; break;
+       var _cZ_ = cst_lX$0; break;
       case 10:
-       var _cY_ = cst_lo; break;
+       var _cZ_ = cst_lo; break;
       case 11:
-       var _cY_ = cst_lo$0; break;
+       var _cZ_ = cst_lo$0; break;
       case 0:
       case 13:
-       var _cY_ = cst_ld; break;
+       var _cZ_ = cst_ld; break;
       case 3:
       case 14:
-       var _cY_ = cst_li$0; break;
-      default: var _cY_ = cst_lu;
+       var _cZ_ = cst_li$0; break;
+      default: var _cZ_ = cst_lu;
     }
      /*<<camlinternalFormat.ml:1453:26>>*/ return transform_int_alt
             (iconv,
-              /*<<camlinternalFormat.ml:1453:26>>*/ caml_format_int(_cY_, n));
+              /*<<camlinternalFormat.ml:1453:26>>*/ caml_format_int(_cZ_, n));
     /*<<camlinternalFormat.ml:1453:67>>*/ }
    function convert_nativeint(iconv, n){
      /*<<camlinternalFormat.ml:1455:2>>*/ switch(iconv){
       case 1:
-       var _cX_ = cst_nd$0; break;
+       var _cY_ = cst_nd$0; break;
       case 2:
-       var _cX_ = cst_nd$1; break;
+       var _cY_ = cst_nd$1; break;
       case 4:
-       var _cX_ = cst_ni$1; break;
+       var _cY_ = cst_ni$1; break;
       case 5:
-       var _cX_ = cst_ni$2; break;
+       var _cY_ = cst_ni$2; break;
       case 6:
-       var _cX_ = cst_nx; break;
+       var _cY_ = cst_nx; break;
       case 7:
-       var _cX_ = cst_nx$0; break;
+       var _cY_ = cst_nx$0; break;
       case 8:
-       var _cX_ = cst_nX; break;
+       var _cY_ = cst_nX; break;
       case 9:
-       var _cX_ = cst_nX$0; break;
+       var _cY_ = cst_nX$0; break;
       case 10:
-       var _cX_ = cst_no; break;
+       var _cY_ = cst_no; break;
       case 11:
-       var _cX_ = cst_no$0; break;
+       var _cY_ = cst_no$0; break;
       case 0:
       case 13:
-       var _cX_ = cst_nd; break;
+       var _cY_ = cst_nd; break;
       case 3:
       case 14:
-       var _cX_ = cst_ni$0; break;
-      default: var _cX_ = cst_nu;
+       var _cY_ = cst_ni$0; break;
+      default: var _cY_ = cst_nu;
     }
      /*<<camlinternalFormat.ml:1455:26>>*/ return transform_int_alt
             (iconv,
-              /*<<camlinternalFormat.ml:1455:26>>*/ caml_format_int(_cX_, n));
+              /*<<camlinternalFormat.ml:1455:26>>*/ caml_format_int(_cY_, n));
     /*<<camlinternalFormat.ml:1455:71>>*/ }
    function convert_int64(iconv, n){
      /*<<camlinternalFormat.ml:1457:2>>*/ switch(iconv){
       case 1:
-       var _cW_ = cst_Ld$0; break;
+       var _cX_ = cst_Ld$0; break;
       case 2:
-       var _cW_ = cst_Ld$1; break;
+       var _cX_ = cst_Ld$1; break;
       case 4:
-       var _cW_ = cst_Li$1; break;
+       var _cX_ = cst_Li$1; break;
       case 5:
-       var _cW_ = cst_Li$2; break;
+       var _cX_ = cst_Li$2; break;
       case 6:
-       var _cW_ = cst_Lx; break;
+       var _cX_ = cst_Lx; break;
       case 7:
-       var _cW_ = cst_Lx$0; break;
+       var _cX_ = cst_Lx$0; break;
       case 8:
-       var _cW_ = cst_LX; break;
+       var _cX_ = cst_LX; break;
       case 9:
-       var _cW_ = cst_LX$0; break;
+       var _cX_ = cst_LX$0; break;
       case 10:
-       var _cW_ = cst_Lo; break;
+       var _cX_ = cst_Lo; break;
       case 11:
-       var _cW_ = cst_Lo$0; break;
+       var _cX_ = cst_Lo$0; break;
       case 0:
       case 13:
-       var _cW_ = cst_Ld; break;
+       var _cX_ = cst_Ld; break;
       case 3:
       case 14:
-       var _cW_ = cst_Li$0; break;
-      default: var _cW_ = cst_Lu;
+       var _cX_ = cst_Li$0; break;
+      default: var _cX_ = cst_Lu;
     }
      /*<<camlinternalFormat.ml:1457:26>>*/ return transform_int_alt
             (iconv,
               /*<<camlinternalFormat.ml:1457:26>>*/ runtime.caml_int64_format
-              (_cW_, n));
+              (_cX_, n));
     /*<<camlinternalFormat.ml:1457:67>>*/ }
    function convert_float(fconv, prec, x){
     function hex(param){
@@ -17280,41 +17324,41 @@
         i = 0;
         /*<<camlinternalFormat.ml:1472:6>>*/ for(;;){
         if(i === len)
-         var _cT_ = 0;
+         var _cU_ = 0;
         else{
           /*<<camlinternalFormat.ml:1473:14>>*/  /*<<camlinternalFormat.ml:1473:14>>*/ var
-          _cS_ =
+          _cT_ =
              /*<<camlinternalFormat.ml:1473:14>>*/ caml_string_get(str, i)
             - 46
             | 0;
          a:
          {
-          if(23 < _cS_ >>> 0){
-           if(55 === _cS_) break a;
+          if(23 < _cT_ >>> 0){
+           if(55 === _cT_) break a;
           }
-          else if(21 < _cS_ - 1 >>> 0) break a;
+          else if(21 < _cT_ - 1 >>> 0) break a;
            /*<<camlinternalFormat.ml:1475:15>>*/ var
             /*<<camlinternalFormat.ml:1475:15>>*/ i$0 = i + 1 | 0,
            i = i$0;
           continue;
          }
-         var _cT_ = 1;
+         var _cU_ = 1;
         }
          /*<<camlinternalFormat.ml:1476:7>>*/  /*<<camlinternalFormat.ml:1476:7>>*/ var
-         _cU_ =
-           _cT_
+         _cV_ =
+           _cU_
             ? str
             :  /*<<camlinternalFormat.ml:1476:32>>*/ caml_call2
               (Stdlib[28], str, cst$17);
-         /*<<camlinternalFormat.ml:1487:21>>*/ return caml_special_val(_cU_);
+         /*<<camlinternalFormat.ml:1487:21>>*/ return caml_special_val(_cV_);
        }
       case 6:
         /*<<camlinternalFormat.ml:1482:15>>*/ return hex(0);
       case 7:
         /*<<camlinternalFormat.ml:1483:38>>*/  /*<<camlinternalFormat.ml:1483:38>>*/ var
-        _cV_ = hex(0);
+        _cW_ = hex(0);
         /*<<camlinternalFormat.ml:1483:38>>*/ return  /*<<camlinternalFormat.ml:1483:38>>*/ caml_call1
-               (Stdlib_String[26], _cV_);
+               (Stdlib_String[26], _cW_);
       case 8:
         /*<<camlinternalFormat.ml:1484:33>>*/ return caml_special_val(hex(0));
       default:
@@ -17699,12 +17743,12 @@
          /*<<camlinternalFormat.ml:1573:4>>*/ return function(param){
           /*<<camlinternalFormat.ml:1573:4>>*/ var
           fmt = param[1],
-           /*<<camlinternalFormat.ml:1574:18>>*/ _cR_ = recast(fmt, fmtty);
+           /*<<camlinternalFormat.ml:1574:18>>*/ _cS_ = recast(fmt, fmtty);
           /*<<camlinternalFormat.ml:1574:6>>*/ return make_printf
                  (k$0,
                   acc$0,
                    /*<<camlinternalFormat.ml:1574:6>>*/ caml_call2
-                   (CamlinternalFormatBasics[3], _cR_, rest$13)); /*<<camlinternalFormat.ml:1574:42>>*/ };
+                   (CamlinternalFormatBasics[3], _cS_, rest$13)); /*<<camlinternalFormat.ml:1574:42>>*/ };
        case 15:
         var rest$14 = fmt$0[1];
          /*<<camlinternalFormat.ml:1544:4>>*/ return function(f, x){
@@ -17731,11 +17775,11 @@
          fmt$0 = rest$16;
         break;
        case 18:
-        var _cP_ = fmt$0[1];
-        if(0 === _cP_[0])
+        var _cQ_ = fmt$0[1];
+        if(0 === _cQ_[0])
          var
           rest$17 = fmt$0[2],
-          fmt$1 = _cP_[1][1],
+          fmt$1 = _cQ_[1][1],
           k$3 =
             function(acc, k, rest){
              function k$0(kacc){
@@ -17751,7 +17795,7 @@
         else
          var
           rest$18 = fmt$0[2],
-          fmt$2 = _cP_[1][1],
+          fmt$2 = _cQ_[1][1],
           k$4 =
             function(acc, k, rest){
              function k$0(kacc){
@@ -17807,14 +17851,14 @@
          rest$23 = fmt$0[3],
          f = fmt$0[2],
          arity = fmt$0[1],
-          /*<<camlinternalFormat.ml:1548:33>>*/ _cQ_ =
+          /*<<camlinternalFormat.ml:1548:33>>*/ _cR_ =
             /*<<camlinternalFormat.ml:1548:33>>*/ caml_call1(f, 0);
          /*<<camlinternalFormat.ml:1548:33>>*/ if(counter >= 50)
           /*<<camlinternalFormat.ml:1548:33>>*/ return  /*<<camlinternalFormat.ml:1548:33>>*/ caml_trampoline_return
-                 (make_custom$0, [0, k$0, acc$0, rest$23, arity, _cQ_]);
+                 (make_custom$0, [0, k$0, acc$0, rest$23, arity, _cR_]);
         var counter$0 = counter + 1 | 0;
          /*<<camlinternalFormat.ml:1548:33>>*/ return make_custom$0
-                (counter$0, k$0, acc$0, rest$23, arity, _cQ_);
+                (counter$0, k$0, acc$0, rest$23, arity, _cR_);
      }
     }
     /*<<camlinternalFormat.ml:1605:9>>*/ }
@@ -17997,7 +18041,7 @@
                   fmt); /*<<camlinternalFormat.ml:1655:61>>*/ };
        case 10:
         var rest$9 = fmtty[1];
-         /*<<camlinternalFormat.ml:1646:31>>*/ return function(param, _cO_){
+         /*<<camlinternalFormat.ml:1646:31>>*/ return function(param, _cP_){
           /*<<camlinternalFormat.ml:1646:42>>*/ return make_from_fmtty
                  (k, acc, rest$9, fmt); /*<<camlinternalFormat.ml:1646:72>>*/ };
        case 11:
@@ -18026,13 +18070,13 @@
     /*<<camlinternalFormat.ml:1655:61>>*/ }
    function make_invalid_arg(counter, k, acc, fmt){
      /*<<camlinternalFormat.ml:1663:2>>*/  /*<<camlinternalFormat.ml:1663:16>>*/ var
-     _cN_ = [8, acc, cst_Printf_bad_conversion$0];
+     _cO_ = [8, acc, cst_Printf_bad_conversion$0];
      /*<<camlinternalFormat.ml:1663:2>>*/ if(counter >= 50)
       /*<<camlinternalFormat.ml:1663:2>>*/ return  /*<<camlinternalFormat.ml:1663:2>>*/ caml_trampoline_return
-             (make_printf$0, [0, k, _cN_, fmt]);
+             (make_printf$0, [0, k, _cO_, fmt]);
     var counter$0 = counter + 1 | 0;
      /*<<camlinternalFormat.ml:1663:2>>*/ return make_printf$0
-            (counter$0, k, _cN_, fmt);
+            (counter$0, k, _cO_, fmt);
     /*<<camlinternalFormat.ml:1663:72>>*/ }
    function make_custom$0(counter, k, acc, rest, arity, f){
      /*<<camlinternalFormat.ml:1778:28>>*/ if(arity){
@@ -18046,13 +18090,13 @@
                 /*<<camlinternalFormat.ml:1782:35>>*/ caml_call1(f, x)); /*<<camlinternalFormat.ml:1782:40>>*/ };
     }
      /*<<camlinternalFormat.ml:1779:33>>*/  /*<<camlinternalFormat.ml:1779:33>>*/ var
-     _cM_ = [4, acc, f];
+     _cN_ = [4, acc, f];
      /*<<camlinternalFormat.ml:1779:19>>*/ if(counter >= 50)
       /*<<camlinternalFormat.ml:1779:19>>*/ return  /*<<camlinternalFormat.ml:1779:19>>*/ caml_trampoline_return
-             (make_printf$0, [0, k, _cM_, rest]);
+             (make_printf$0, [0, k, _cN_, rest]);
     var counter$0 = counter + 1 | 0;
      /*<<camlinternalFormat.ml:1779:19>>*/ return make_printf$0
-            (counter$0, k, _cM_, rest);
+            (counter$0, k, _cN_, rest);
     /*<<camlinternalFormat.ml:1782:40>>*/ }
    function make_printf(k, acc, fmt){
      /*<<?>>*/ return caml_trampoline(make_printf$0(0, k, acc, fmt));
@@ -18073,68 +18117,68 @@
      /*<<camlinternalFormat.ml:1863:26>>*/ if(typeof pad === "number"){
      if(typeof prec !== "number"){
        /*<<camlinternalFormat.ml:1867:14>>*/  /*<<camlinternalFormat.ml:1867:14>>*/ var
-       _cl_ = make_iprintf(k, o, fmt);
-       /*<<camlinternalFormat.ml:1867:14>>*/ return function(_cL_){
-        /*<<?>>*/ return _cl_;};
+       _cm_ = make_iprintf(k, o, fmt);
+       /*<<camlinternalFormat.ml:1867:14>>*/ return function(_cM_){
+        /*<<?>>*/ return _cm_;};
      }
      if(prec){
        /*<<camlinternalFormat.ml:1869:21>>*/ var
-        /*<<camlinternalFormat.ml:1869:21>>*/ _ci_ = make_iprintf(k, o, fmt),
-        /*<<camlinternalFormat.ml:1869:14>>*/ _cj_ =
-         function(_cK_){ /*<<?>>*/ return _ci_;};
-       /*<<camlinternalFormat.ml:1869:14>>*/ return function(_cJ_){
-        /*<<?>>*/ return _cj_;};
+        /*<<camlinternalFormat.ml:1869:21>>*/ _cj_ = make_iprintf(k, o, fmt),
+        /*<<camlinternalFormat.ml:1869:14>>*/ _ck_ =
+         function(_cL_){ /*<<?>>*/ return _cj_;};
+       /*<<camlinternalFormat.ml:1869:14>>*/ return function(_cK_){
+        /*<<?>>*/ return _ck_;};
      }
       /*<<camlinternalFormat.ml:1865:14>>*/  /*<<camlinternalFormat.ml:1865:14>>*/ var
-      _ck_ = make_iprintf(k, o, fmt);
-      /*<<camlinternalFormat.ml:1865:14>>*/ return function(_cI_){
-       /*<<?>>*/ return _ck_;};
+      _cl_ = make_iprintf(k, o, fmt);
+      /*<<camlinternalFormat.ml:1865:14>>*/ return function(_cJ_){
+       /*<<?>>*/ return _cl_;};
     }
     if(0 === pad[0]){
      if(typeof prec !== "number"){
        /*<<camlinternalFormat.ml:1873:14>>*/  /*<<camlinternalFormat.ml:1873:14>>*/ var
-       _cp_ = make_iprintf(k, o, fmt);
-       /*<<camlinternalFormat.ml:1873:14>>*/ return function(_cH_){
-        /*<<?>>*/ return _cp_;};
+       _cq_ = make_iprintf(k, o, fmt);
+       /*<<camlinternalFormat.ml:1873:14>>*/ return function(_cI_){
+        /*<<?>>*/ return _cq_;};
      }
      if(prec){
        /*<<camlinternalFormat.ml:1875:21>>*/ var
-        /*<<camlinternalFormat.ml:1875:21>>*/ _cm_ = make_iprintf(k, o, fmt),
-        /*<<camlinternalFormat.ml:1875:14>>*/ _cn_ =
-         function(_cG_){ /*<<?>>*/ return _cm_;};
-       /*<<camlinternalFormat.ml:1875:14>>*/ return function(_cF_){
-        /*<<?>>*/ return _cn_;};
+        /*<<camlinternalFormat.ml:1875:21>>*/ _cn_ = make_iprintf(k, o, fmt),
+        /*<<camlinternalFormat.ml:1875:14>>*/ _co_ =
+         function(_cH_){ /*<<?>>*/ return _cn_;};
+       /*<<camlinternalFormat.ml:1875:14>>*/ return function(_cG_){
+        /*<<?>>*/ return _co_;};
      }
       /*<<camlinternalFormat.ml:1871:14>>*/  /*<<camlinternalFormat.ml:1871:14>>*/ var
-      _co_ = make_iprintf(k, o, fmt);
-      /*<<camlinternalFormat.ml:1871:14>>*/ return function(_cE_){
-       /*<<?>>*/ return _co_;};
+      _cp_ = make_iprintf(k, o, fmt);
+      /*<<camlinternalFormat.ml:1871:14>>*/ return function(_cF_){
+       /*<<?>>*/ return _cp_;};
     }
     if(typeof prec !== "number"){
       /*<<camlinternalFormat.ml:1879:21>>*/ var
-       /*<<camlinternalFormat.ml:1879:21>>*/ _cv_ = make_iprintf(k, o, fmt),
-       /*<<camlinternalFormat.ml:1879:14>>*/ _cw_ =
-        function(_cD_){ /*<<?>>*/ return _cv_;};
-      /*<<camlinternalFormat.ml:1879:14>>*/ return function(_cC_){
-       /*<<?>>*/ return _cw_;};
+       /*<<camlinternalFormat.ml:1879:21>>*/ _cw_ = make_iprintf(k, o, fmt),
+       /*<<camlinternalFormat.ml:1879:14>>*/ _cx_ =
+        function(_cE_){ /*<<?>>*/ return _cw_;};
+      /*<<camlinternalFormat.ml:1879:14>>*/ return function(_cD_){
+       /*<<?>>*/ return _cx_;};
     }
     if(prec){
       /*<<camlinternalFormat.ml:1881:28>>*/ var
-       /*<<camlinternalFormat.ml:1881:28>>*/ _cq_ = make_iprintf(k, o, fmt),
-       /*<<camlinternalFormat.ml:1881:21>>*/ _cr_ =
-        function(_cB_){ /*<<?>>*/ return _cq_;},
-       /*<<camlinternalFormat.ml:1881:14>>*/ _cs_ =
-        function(_cA_){ /*<<?>>*/ return _cr_;};
-      /*<<camlinternalFormat.ml:1881:14>>*/ return function(_cz_){
-       /*<<?>>*/ return _cs_;};
+       /*<<camlinternalFormat.ml:1881:28>>*/ _cr_ = make_iprintf(k, o, fmt),
+       /*<<camlinternalFormat.ml:1881:21>>*/ _cs_ =
+        function(_cC_){ /*<<?>>*/ return _cr_;},
+       /*<<camlinternalFormat.ml:1881:14>>*/ _ct_ =
+        function(_cB_){ /*<<?>>*/ return _cs_;};
+      /*<<camlinternalFormat.ml:1881:14>>*/ return function(_cA_){
+       /*<<?>>*/ return _ct_;};
     }
      /*<<camlinternalFormat.ml:1877:21>>*/  /*<<camlinternalFormat.ml:1877:21>>*/ var
-     _ct_ = make_iprintf(k, o, fmt);
-     /*<<camlinternalFormat.ml:1877:14>>*/ function _cu_(_cy_){
-      /*<<?>>*/ return _ct_;
+     _cu_ = make_iprintf(k, o, fmt);
+     /*<<camlinternalFormat.ml:1877:14>>*/ function _cv_(_cz_){
+      /*<<?>>*/ return _cu_;
     }
-     /*<<camlinternalFormat.ml:1877:14>>*/ return function(_cx_){
-      /*<<?>>*/ return _cu_;};
+     /*<<camlinternalFormat.ml:1877:14>>*/ return function(_cy_){
+      /*<<?>>*/ return _cv_;};
     /*<<camlinternalFormat.ml:1881:52>>*/ }
    function make_iprintf$0(counter, k, o, fmt){
      /*<<camlinternalFormat.ml:1788:17>>*/ var k$0 = k, fmt$0 = fmt;
@@ -18146,69 +18190,69 @@
        case 0:
          /*<<camlinternalFormat.ml:1790:14>>*/ var
          rest = fmt$0[1],
-          /*<<camlinternalFormat.ml:1790:14>>*/ _by_ =
+          /*<<camlinternalFormat.ml:1790:14>>*/ _bz_ =
            make_iprintf(k$0, o, rest);
-         /*<<camlinternalFormat.ml:1790:14>>*/ return function(_ch_){
-          /*<<?>>*/ return _by_;};
+         /*<<camlinternalFormat.ml:1790:14>>*/ return function(_ci_){
+          /*<<?>>*/ return _bz_;};
        case 1:
          /*<<camlinternalFormat.ml:1792:14>>*/ var
          rest$0 = fmt$0[1],
-          /*<<camlinternalFormat.ml:1792:14>>*/ _bz_ =
+          /*<<camlinternalFormat.ml:1792:14>>*/ _bA_ =
            make_iprintf(k$0, o, rest$0);
-         /*<<camlinternalFormat.ml:1792:14>>*/ return function(_cg_){
-          /*<<?>>*/ return _bz_;};
+         /*<<camlinternalFormat.ml:1792:14>>*/ return function(_ch_){
+          /*<<?>>*/ return _bA_;};
        case 2:
-        var _bA_ = fmt$0[1];
-        if(typeof _bA_ === "number"){
+        var _bB_ = fmt$0[1];
+        if(typeof _bB_ === "number"){
           /*<<camlinternalFormat.ml:1794:14>>*/ var
           rest$1 = fmt$0[2],
-           /*<<camlinternalFormat.ml:1794:14>>*/ _bB_ =
+           /*<<camlinternalFormat.ml:1794:14>>*/ _bC_ =
             make_iprintf(k$0, o, rest$1);
-          /*<<camlinternalFormat.ml:1794:14>>*/ return function(_cf_){
-           /*<<?>>*/ return _bB_;};
+          /*<<camlinternalFormat.ml:1794:14>>*/ return function(_cg_){
+           /*<<?>>*/ return _bC_;};
         }
-        if(0 === _bA_[0]){
+        if(0 === _bB_[0]){
           /*<<camlinternalFormat.ml:1796:14>>*/ var
           rest$2 = fmt$0[2],
-           /*<<camlinternalFormat.ml:1796:14>>*/ _bC_ =
+           /*<<camlinternalFormat.ml:1796:14>>*/ _bD_ =
             make_iprintf(k$0, o, rest$2);
-          /*<<camlinternalFormat.ml:1796:14>>*/ return function(_ce_){
-           /*<<?>>*/ return _bC_;};
+          /*<<camlinternalFormat.ml:1796:14>>*/ return function(_cf_){
+           /*<<?>>*/ return _bD_;};
         }
          /*<<camlinternalFormat.ml:1798:21>>*/ var
          rest$3 = fmt$0[2],
-          /*<<camlinternalFormat.ml:1798:21>>*/ _bD_ =
+          /*<<camlinternalFormat.ml:1798:21>>*/ _bE_ =
            make_iprintf(k$0, o, rest$3),
-          /*<<camlinternalFormat.ml:1798:14>>*/ _bE_ =
-           function(_cd_){ /*<<?>>*/ return _bD_;};
-         /*<<camlinternalFormat.ml:1798:14>>*/ return function(_cc_){
-          /*<<?>>*/ return _bE_;};
+          /*<<camlinternalFormat.ml:1798:14>>*/ _bF_ =
+           function(_ce_){ /*<<?>>*/ return _bE_;};
+         /*<<camlinternalFormat.ml:1798:14>>*/ return function(_cd_){
+          /*<<?>>*/ return _bF_;};
        case 3:
-        var _bF_ = fmt$0[1];
-        if(typeof _bF_ === "number"){
+        var _bG_ = fmt$0[1];
+        if(typeof _bG_ === "number"){
           /*<<camlinternalFormat.ml:1800:14>>*/ var
           rest$4 = fmt$0[2],
-           /*<<camlinternalFormat.ml:1800:14>>*/ _bG_ =
+           /*<<camlinternalFormat.ml:1800:14>>*/ _bH_ =
             make_iprintf(k$0, o, rest$4);
-          /*<<camlinternalFormat.ml:1800:14>>*/ return function(_cb_){
-           /*<<?>>*/ return _bG_;};
+          /*<<camlinternalFormat.ml:1800:14>>*/ return function(_cc_){
+           /*<<?>>*/ return _bH_;};
         }
-        if(0 === _bF_[0]){
+        if(0 === _bG_[0]){
           /*<<camlinternalFormat.ml:1802:14>>*/ var
           rest$5 = fmt$0[2],
-           /*<<camlinternalFormat.ml:1802:14>>*/ _bH_ =
+           /*<<camlinternalFormat.ml:1802:14>>*/ _bI_ =
             make_iprintf(k$0, o, rest$5);
-          /*<<camlinternalFormat.ml:1802:14>>*/ return function(_ca_){
-           /*<<?>>*/ return _bH_;};
+          /*<<camlinternalFormat.ml:1802:14>>*/ return function(_cb_){
+           /*<<?>>*/ return _bI_;};
         }
          /*<<camlinternalFormat.ml:1804:21>>*/ var
          rest$6 = fmt$0[2],
-          /*<<camlinternalFormat.ml:1804:21>>*/ _bI_ =
+          /*<<camlinternalFormat.ml:1804:21>>*/ _bJ_ =
            make_iprintf(k$0, o, rest$6),
-          /*<<camlinternalFormat.ml:1804:14>>*/ _bJ_ =
-           function(_b$_){ /*<<?>>*/ return _bI_;};
-         /*<<camlinternalFormat.ml:1804:14>>*/ return function(_b__){
-          /*<<?>>*/ return _bJ_;};
+          /*<<camlinternalFormat.ml:1804:14>>*/ _bK_ =
+           function(_ca_){ /*<<?>>*/ return _bJ_;};
+         /*<<camlinternalFormat.ml:1804:14>>*/ return function(_b$_){
+          /*<<?>>*/ return _bK_;};
        case 4:
         var rest$7 = fmt$0[4], prec = fmt$0[3], pad = fmt$0[2];
          /*<<camlinternalFormat.ml:1806:8>>*/ return fn_of_padding_precision
@@ -18230,31 +18274,31 @@
          /*<<camlinternalFormat.ml:1814:8>>*/ return fn_of_padding_precision
                 (k$0, o, rest$11, pad$3, prec$3);
        case 9:
-        var _bK_ = fmt$0[1];
-        if(typeof _bK_ === "number"){
+        var _bL_ = fmt$0[1];
+        if(typeof _bL_ === "number"){
           /*<<camlinternalFormat.ml:1816:14>>*/ var
           rest$12 = fmt$0[2],
-           /*<<camlinternalFormat.ml:1816:14>>*/ _bL_ =
+           /*<<camlinternalFormat.ml:1816:14>>*/ _bM_ =
             make_iprintf(k$0, o, rest$12);
-          /*<<camlinternalFormat.ml:1816:14>>*/ return function(_b9_){
-           /*<<?>>*/ return _bL_;};
+          /*<<camlinternalFormat.ml:1816:14>>*/ return function(_b__){
+           /*<<?>>*/ return _bM_;};
         }
-        if(0 === _bK_[0]){
+        if(0 === _bL_[0]){
           /*<<camlinternalFormat.ml:1818:14>>*/ var
           rest$13 = fmt$0[2],
-           /*<<camlinternalFormat.ml:1818:14>>*/ _bM_ =
+           /*<<camlinternalFormat.ml:1818:14>>*/ _bN_ =
             make_iprintf(k$0, o, rest$13);
-          /*<<camlinternalFormat.ml:1818:14>>*/ return function(_b8_){
-           /*<<?>>*/ return _bM_;};
+          /*<<camlinternalFormat.ml:1818:14>>*/ return function(_b9_){
+           /*<<?>>*/ return _bN_;};
         }
          /*<<camlinternalFormat.ml:1820:21>>*/ var
          rest$14 = fmt$0[2],
-          /*<<camlinternalFormat.ml:1820:21>>*/ _bN_ =
+          /*<<camlinternalFormat.ml:1820:21>>*/ _bO_ =
            make_iprintf(k$0, o, rest$14),
-          /*<<camlinternalFormat.ml:1820:14>>*/ _bO_ =
-           function(_b7_){ /*<<?>>*/ return _bN_;};
-         /*<<camlinternalFormat.ml:1820:14>>*/ return function(_b6_){
-          /*<<?>>*/ return _bO_;};
+          /*<<camlinternalFormat.ml:1820:14>>*/ _bP_ =
+           function(_b8_){ /*<<?>>*/ return _bO_;};
+         /*<<camlinternalFormat.ml:1820:14>>*/ return function(_b7_){
+          /*<<?>>*/ return _bP_;};
        case 10:
         var rest$15 = fmt$0[1], fmt$0 = rest$15; break;
        case 11:
@@ -18264,45 +18308,45 @@
        case 13:
          /*<<camlinternalFormat.ml:1838:14>>*/ var
          rest$18 = fmt$0[3],
-          /*<<camlinternalFormat.ml:1838:14>>*/ _bP_ =
+          /*<<camlinternalFormat.ml:1838:14>>*/ _bQ_ =
            make_iprintf(k$0, o, rest$18);
-         /*<<camlinternalFormat.ml:1838:14>>*/ return function(_b5_){
-          /*<<?>>*/ return _bP_;};
+         /*<<camlinternalFormat.ml:1838:14>>*/ return function(_b6_){
+          /*<<?>>*/ return _bQ_;};
        case 14:
         var rest$19 = fmt$0[3], fmtty = fmt$0[2];
          /*<<camlinternalFormat.ml:1840:8>>*/ return function(param){
           /*<<camlinternalFormat.ml:1840:8>>*/ var
           fmt = param[1],
-           /*<<camlinternalFormat.ml:1842:24>>*/ _b4_ = recast(fmt, fmtty);
+           /*<<camlinternalFormat.ml:1842:24>>*/ _b5_ = recast(fmt, fmtty);
           /*<<camlinternalFormat.ml:1842:12>>*/ return make_iprintf
                  (k$0,
                   o,
                    /*<<camlinternalFormat.ml:1842:12>>*/ caml_call2
-                   (CamlinternalFormatBasics[3], _b4_, rest$19)); /*<<camlinternalFormat.ml:1842:48>>*/ };
+                   (CamlinternalFormatBasics[3], _b5_, rest$19)); /*<<camlinternalFormat.ml:1842:48>>*/ };
        case 15:
          /*<<camlinternalFormat.ml:1822:21>>*/ var
          rest$20 = fmt$0[1],
-          /*<<camlinternalFormat.ml:1822:21>>*/ _bQ_ =
+          /*<<camlinternalFormat.ml:1822:21>>*/ _bR_ =
            make_iprintf(k$0, o, rest$20),
-          /*<<camlinternalFormat.ml:1822:14>>*/ _bR_ =
-           function(_b3_){ /*<<?>>*/ return _bQ_;};
-         /*<<camlinternalFormat.ml:1822:14>>*/ return function(_b2_){
-          /*<<?>>*/ return _bR_;};
+          /*<<camlinternalFormat.ml:1822:14>>*/ _bS_ =
+           function(_b4_){ /*<<?>>*/ return _bR_;};
+         /*<<camlinternalFormat.ml:1822:14>>*/ return function(_b3_){
+          /*<<?>>*/ return _bS_;};
        case 16:
          /*<<camlinternalFormat.ml:1824:14>>*/ var
          rest$21 = fmt$0[1],
-          /*<<camlinternalFormat.ml:1824:14>>*/ _bS_ =
+          /*<<camlinternalFormat.ml:1824:14>>*/ _bT_ =
            make_iprintf(k$0, o, rest$21);
-         /*<<camlinternalFormat.ml:1824:14>>*/ return function(_b1_){
-          /*<<?>>*/ return _bS_;};
+         /*<<camlinternalFormat.ml:1824:14>>*/ return function(_b2_){
+          /*<<?>>*/ return _bT_;};
        case 17:
         var rest$22 = fmt$0[2], fmt$0 = rest$22; break;
        case 18:
-        var _bT_ = fmt$0[1];
-        if(0 === _bT_[0])
+        var _bU_ = fmt$0[1];
+        if(0 === _bU_[0])
          var
           rest$23 = fmt$0[2],
-          fmt$1 = _bT_[1][1],
+          fmt$1 = _bU_[1][1],
           k$3 =
             function(k, rest){
              function k$0(koc){
@@ -18317,7 +18361,7 @@
         else
          var
           rest$24 = fmt$0[2],
-          fmt$2 = _bT_[1][1],
+          fmt$2 = _bU_[1][1],
           k$4 =
             function(k, rest){
              function k$0(koc){
@@ -18336,32 +18380,32 @@
        case 20:
          /*<<camlinternalFormat.ml:1844:14>>*/ var
          rest$25 = fmt$0[3],
-          /*<<camlinternalFormat.ml:1844:14>>*/ _bU_ =
+          /*<<camlinternalFormat.ml:1844:14>>*/ _bV_ =
            make_iprintf(k$0, o, rest$25);
-         /*<<camlinternalFormat.ml:1844:14>>*/ return function(_b0_){
-          /*<<?>>*/ return _bU_;};
+         /*<<camlinternalFormat.ml:1844:14>>*/ return function(_b1_){
+          /*<<?>>*/ return _bV_;};
        case 21:
          /*<<camlinternalFormat.ml:1846:14>>*/ var
          rest$26 = fmt$0[2],
-          /*<<camlinternalFormat.ml:1846:14>>*/ _bV_ =
+          /*<<camlinternalFormat.ml:1846:14>>*/ _bW_ =
            make_iprintf(k$0, o, rest$26);
-         /*<<camlinternalFormat.ml:1846:14>>*/ return function(_bZ_){
-          /*<<?>>*/ return _bV_;};
+         /*<<camlinternalFormat.ml:1846:14>>*/ return function(_b0_){
+          /*<<?>>*/ return _bW_;};
        case 22:
          /*<<camlinternalFormat.ml:1848:14>>*/ var
          rest$27 = fmt$0[1],
-          /*<<camlinternalFormat.ml:1848:14>>*/ _bW_ =
+          /*<<camlinternalFormat.ml:1848:14>>*/ _bX_ =
            make_iprintf(k$0, o, rest$27);
-         /*<<camlinternalFormat.ml:1848:14>>*/ return function(_bY_){
-          /*<<?>>*/ return _bW_;};
+         /*<<camlinternalFormat.ml:1848:14>>*/ return function(_bZ_){
+          /*<<?>>*/ return _bX_;};
        case 23:
-        var rest$28 = fmt$0[2], ign = fmt$0[1], _bX_ = 0;
+        var rest$28 = fmt$0[2], ign = fmt$0[1], _bY_ = 0;
          /*<<camlinternalFormat.ml:1850:8>>*/ return make_ignored_param
                 (function(param){
                    /*<<camlinternalFormat.ml:1850:37>>*/ return caml_call1
                           (k$0, o);
                   /*<<camlinternalFormat.ml:1850:40>>*/ },
-                 _bX_,
+                 _bY_,
                  ign,
                  rest$28);
        default:
@@ -18379,10 +18423,10 @@
      /*<<?>>*/ if(param){
       /*<<camlinternalFormat.ml:1889:14>>*/ var
       arity = param[1],
-       /*<<camlinternalFormat.ml:1889:14>>*/ _bw_ =
+       /*<<camlinternalFormat.ml:1889:14>>*/ _bx_ =
         fn_of_custom_arity(k, o, fmt, arity);
-      /*<<camlinternalFormat.ml:1889:14>>*/ return function(_bx_){
-       /*<<?>>*/ return _bw_;};
+      /*<<camlinternalFormat.ml:1889:14>>*/ return function(_by_){
+       /*<<?>>*/ return _bx_;};
     }
      /*<<camlinternalFormat.ml:1887:8>>*/ if(counter >= 50)
       /*<<camlinternalFormat.ml:1887:8>>*/ return  /*<<camlinternalFormat.ml:1887:8>>*/ caml_trampoline_return
@@ -18553,9 +18597,9 @@
         var f = acc$0[2], p$3 = acc$0[1];
          /*<<camlinternalFormat.ml:1950:32>>*/ strput_acc(b, p$3);
          /*<<camlinternalFormat.ml:1950:68>>*/  /*<<camlinternalFormat.ml:1950:68>>*/ var
-         _bv_ =  /*<<camlinternalFormat.ml:1950:68>>*/ caml_call1(f, 0);
+         _bw_ =  /*<<camlinternalFormat.ml:1950:68>>*/ caml_call1(f, 0);
          /*<<camlinternalFormat.ml:1950:68>>*/ return  /*<<camlinternalFormat.ml:1950:68>>*/ caml_call2
-                (Stdlib_Buffer[16], b, _bv_);
+                (Stdlib_Buffer[16], b, _bw_);
        case 7:
         var acc$3 = acc$0[1], acc$0 = acc$3; break;
        case 8:
@@ -18586,11 +18630,11 @@
     function k(acc){
       /*<<camlinternalFormat.ml:1961:14>>*/ strput_acc(buf, acc);
       /*<<camlinternalFormat.ml:1961:43>>*/  /*<<camlinternalFormat.ml:1961:43>>*/ var
-      _bu_ =
+      _bv_ =
          /*<<camlinternalFormat.ml:1961:43>>*/ caml_call1
          (Stdlib_Buffer[2], buf);
       /*<<camlinternalFormat.ml:1961:43>>*/ return  /*<<camlinternalFormat.ml:1961:43>>*/ caml_call1
-             (Stdlib[2], _bu_);
+             (Stdlib[2], _bv_);
      /*<<camlinternalFormat.ml:1961:64>>*/ }
      /*<<camlinternalFormat.ml:1962:2>>*/ return make_printf(k, 0, fmt);
    }
@@ -18665,15 +18709,15 @@
       else
         /*<<camlinternalFormat.ml:1994:8>>*/ try{
          /*<<camlinternalFormat.ml:1994:12>>*/ var
-          /*<<camlinternalFormat.ml:1994:12>>*/ _bs_ =
+          /*<<camlinternalFormat.ml:1994:12>>*/ _bt_ =
             /*<<camlinternalFormat.ml:1994:12>>*/ runtime.caml_int_of_string
             ( /*<<camlinternalFormat.ml:1994:26>>*/ caml_call3
               (Stdlib_String[16], str, nstart, nend - nstart | 0)),
-         indent = _bs_;
+         indent = _bt_;
        }
-       catch(_bt_){
-        var _br_ = caml_wrap_exception(_bt_);
-        if(_br_[1] !== Stdlib[7]) throw caml_maybe_attach_backtrace(_br_, 0);
+       catch(_bu_){
+        var _bs_ = caml_wrap_exception(_bu_);
+        if(_bs_[1] !== Stdlib[7]) throw caml_maybe_attach_backtrace(_bs_, 0);
         var indent = invalid_box(0);
        }
        /*<<camlinternalFormat.ml:1996:18>>*/  /*<<camlinternalFormat.ml:1996:18>>*/ var
@@ -18713,9 +18757,9 @@
     /*<<camlinternalFormat.ml:2018:62>>*/ }
    function make_padprec_fmt_ebb(pad, prec, fmt){
      /*<<camlinternalFormat.ml:2038:2>>*/ if(typeof prec === "number")
-     var match = prec ? [0, 1, fmt] : [0, 0, fmt];
+     var match = prec ? [0, 1] : [0, 0];
     else
-     var p = prec[1], match = [0, [0, p], fmt];
+     var p = prec[1], match = [0, [0, p]];
     var prec$0 = match[1];
      /*<<camlinternalFormat.ml:2039:2>>*/ if(typeof pad === "number")
       /*<<camlinternalFormat.ml:2040:26>>*/ return [0, 0, prec$0, fmt];
@@ -18737,8 +18781,9 @@
      /*<<camlinternalFormat.ml:2086:21>>*/ }
      /*<<camlinternalFormat.ml:2091:2>>*/ function unexpected_end_of_format
     (end_ind){
-      /*<<camlinternalFormat.ml:2092:4>>*/ return invalid_format_message
-             (end_ind, cst_unexpected_end_of_format);
+      /*<<camlinternalFormat.ml:2092:4>>*/ invalid_format_message
+      (end_ind, cst_unexpected_end_of_format);
+      /*<<camlinternalFormat.ml:2092:4>>*/ return;
      /*<<camlinternalFormat.ml:2093:32>>*/ }
     function invalid_format_without(str_ind, c, s){
       /*<<camlinternalFormat.ml:2104:4>>*/ return  /*<<camlinternalFormat.ml:2104:4>>*/ caml_call4
@@ -18876,9 +18921,9 @@
              b:
              try{
               var
-               _bg_ = str_ind$3 === end_ind ? 1 : 0,
-               _bh_ =
-                 _bg_
+               _bh_ = str_ind$3 === end_ind ? 1 : 0,
+               _bi_ =
+                 _bh_
                  ||
                   (60
                     !==
@@ -18886,7 +18931,7 @@
                       (str, str_ind$3)
                     ? 1
                     : 0);
-              if(_bh_)
+              if(_bi_)
                 /*<<camlinternalFormat.ml:2666:58>>*/ throw  /*<<camlinternalFormat.ml:2666:58>>*/ caml_maybe_attach_backtrace
                       (Stdlib[8], 1);
                /*<<camlinternalFormat.ml:2667:24>>*/ var
@@ -18925,12 +18970,12 @@
                      str,
                      str_ind$3 - 2 | 0,
                      (str_ind_3 - str_ind$3 | 0) + 3 | 0),
-                  /*<<camlinternalFormat.ml:2675:31>>*/ _bi_ =
-                   [0, s, width, 0],
                   /*<<camlinternalFormat.ml:2675:31>>*/ _bj_ =
+                   [0, s, width, 0],
+                  /*<<camlinternalFormat.ml:2675:31>>*/ _bk_ =
                    str_ind_3 + 1 | 0,
-                 formatting_lit$0 = _bi_,
-                 next_ind = _bj_;
+                 formatting_lit$0 = _bj_,
+                 next_ind = _bk_;
                 break b;
                }
               }
@@ -18956,21 +19001,21 @@
                     str,
                     str_ind$3 - 2 | 0,
                     (str_ind_5 - str_ind$3 | 0) + 3 | 0),
-                 /*<<camlinternalFormat.ml:2681:31>>*/ _bk_ =
-                  [0, s$0, width, offset],
                  /*<<camlinternalFormat.ml:2681:31>>*/ _bl_ =
+                  [0, s$0, width, offset],
+                 /*<<camlinternalFormat.ml:2681:31>>*/ _bm_ =
                   str_ind_5 + 1 | 0,
-                formatting_lit$0 = _bk_,
-                next_ind = _bl_;
+                formatting_lit$0 = _bl_,
+                next_ind = _bm_;
                break b;
               }
                /*<<camlinternalFormat.ml:2682:21>>*/ throw  /*<<camlinternalFormat.ml:2682:21>>*/ caml_maybe_attach_backtrace
                      (Stdlib[8], 1);
              }
-             catch(_bq_){
-              var _bf_ = caml_wrap_exception(_bq_);
-              if(_bf_ !== Stdlib[8] && _bf_[1] !== Stdlib[7])
-               throw caml_maybe_attach_backtrace(_bf_, 0);
+             catch(_br_){
+              var _bg_ = caml_wrap_exception(_br_);
+              if(_bg_ !== Stdlib[8] && _bg_[1] !== Stdlib[7])
+               throw caml_maybe_attach_backtrace(_bg_, 0);
               var formatting_lit$0 = formatting_lit, next_ind = str_ind$3;
              }
              var
@@ -18994,7 +19039,7 @@
                  if(58 > match$6) break c;
                 }
                 else if(45 === match$6) break c;
-                var _bo_ = 0;
+                var _bp_ = 0;
                 break b;
                }
                 /*<<camlinternalFormat.ml:2699:32>>*/ var
@@ -19018,28 +19063,28 @@
                     str,
                     str_ind$4 - 2 | 0,
                     (str_ind_3$0 - str_ind$4 | 0) + 3 | 0),
-                _bo_ = [0, [0, str_ind_3$0 + 1 | 0, [1, s$1, size]]];
+                _bp_ = [0, [0, str_ind_3$0 + 1 | 0, [1, s$1, size]]];
               }
-              var _bn_ = _bo_;
+              var _bo_ = _bp_;
              }
-             catch(_bp_){
-              var _bm_ = caml_wrap_exception(_bp_);
-              if(_bm_ !== Stdlib[8] && _bm_[1] !== Stdlib[7])
-               throw caml_maybe_attach_backtrace(_bm_, 0);
-              var _bn_ = 0;
+             catch(_bq_){
+              var _bn_ = caml_wrap_exception(_bq_);
+              if(_bn_ !== Stdlib[8] && _bn_[1] !== Stdlib[7])
+               throw caml_maybe_attach_backtrace(_bn_, 0);
+              var _bo_ = 0;
              }
-             if(_bn_)
+             if(_bo_)
               var
-               match$5 = _bn_[1],
+               match$5 = _bo_[1],
                formatting_lit$1 = match$5[2],
                next_ind$0 = match$5[1],
                fmt_rest$13 = parse(next_ind$0, end_ind)[1],
-               _be_ = [0, [17, formatting_lit$1, fmt_rest$13]];
+               _bf_ = [0, [17, formatting_lit$1, fmt_rest$13]];
              else
               var
                fmt_rest$14 = parse(str_ind$4, end_ind)[1],
-               _be_ = [0, [17, _Q_, fmt_rest$14]];
-             var match$0 = _be_;
+               _bf_ = [0, [17, _Q_, fmt_rest$14]];
+             var match$0 = _bf_;
              break a;
             case 31:
              var
@@ -19197,29 +19242,29 @@
             /*<<camlinternalFormat.ml:2536:22>>*/ var
              /*<<camlinternalFormat.ml:2536:22>>*/ ignored$2 =
               [9, get_pad_opt(95), sub_fmtty],
-            _aN_ = [0, [23, ignored$2, fmt_rest$7]];
+            _aO_ = [0, [23, ignored$2, fmt_rest$7]];
           else
-           var _aN_ = [0, [14, get_pad_opt(40), sub_fmtty, fmt_rest$7]];
-          var fmt_result = _aN_;
+           var _aO_ = [0, [14, get_pad_opt(40), sub_fmtty, fmt_rest$7]];
+          var fmt_result = _aO_;
           break a;
          case 44:
           var fmt_result = parse(str_ind, end_ind); break a;
          case 67:
            /*<<camlinternalFormat.ml:2397:9>>*/ var
            fmt_rest$10 = parse(str_ind, end_ind)[1],
-            /*<<camlinternalFormat.ml:2397:9>>*/ _aP_ =
+            /*<<camlinternalFormat.ml:2397:9>>*/ _aQ_ =
              get_ign(0) ? [0, [23, 1, fmt_rest$10]] : [0, [1, fmt_rest$10]],
-           fmt_result = _aP_;
+           fmt_result = _aQ_;
           break a;
          case 78:
           var fmt_rest$14 = parse(str_ind, end_ind)[1], counter$0 = 2;
            /*<<camlinternalFormat.ml:2433:9>>*/ if(get_ign(0))
             /*<<camlinternalFormat.ml:2434:22>>*/ var
              /*<<camlinternalFormat.ml:2434:22>>*/ ignored$6 = [11, counter$0],
-            _aV_ = [0, [23, ignored$6, fmt_rest$14]];
+            _aW_ = [0, [23, ignored$6, fmt_rest$14]];
           else
-           var _aV_ = [0, [21, counter$0, fmt_rest$14]];
-          var fmt_result = _aV_;
+           var _aW_ = [0, [21, counter$0, fmt_rest$14]];
+          var fmt_result = _aW_;
           break a;
          case 83:
            /*<<camlinternalFormat.ml:2410:16>>*/ var
@@ -19230,15 +19275,15 @@
             /*<<camlinternalFormat.ml:2413:22>>*/ var
              /*<<camlinternalFormat.ml:2413:22>>*/ ignored$7 =
               [1, get_padprec_opt(95)],
-            _aW_ = [0, [23, ignored$7, fmt_rest$15]];
+            _aX_ = [0, [23, ignored$7, fmt_rest$15]];
           else
             /*<<camlinternalFormat.ml:2417:10>>*/ var
              /*<<camlinternalFormat.ml:2417:10>>*/ match$5 =
               make_padding_fmt_ebb(pad$6, fmt_rest$15),
             fmt_rest$16 = match$5[2],
             pad$7 = match$5[1],
-            _aW_ = [0, [3, pad$7, fmt_rest$16]];
-          var fmt_result = _aW_;
+            _aX_ = [0, [3, pad$7, fmt_rest$16]];
+          var fmt_result = _aX_;
           break a;
          case 91:
           if(str_ind === end_ind)
@@ -19249,8 +19294,9 @@
              create_char_set(0),
            add_char =
              function(c){
-               /*<<camlinternalFormat.ml:2721:6>>*/ return add_in_char_set
-                      (char_set, c);
+               /*<<camlinternalFormat.ml:2721:6>>*/ add_in_char_set
+               (char_set, c);
+               /*<<camlinternalFormat.ml:2721:6>>*/ return;
               /*<<camlinternalFormat.ml:2721:32>>*/ },
            add_range =
              function(c$0, c){
@@ -19262,12 +19308,12 @@
                    /*<<camlinternalFormat.ml:2725:33>>*/ caml_call1
                    (Stdlib[29], i));
                  /*<<camlinternalFormat.ml:2725:8>>*/  /*<<camlinternalFormat.ml:2725:8>>*/ var
-                 _bd_ = i + 1 | 0;
+                 _be_ = i + 1 | 0;
                 if(c === i) break;
-                var i = _bd_;
+                var i = _be_;
                }
               }
-              return 0;
+              return;
               /*<<camlinternalFormat.ml:2726:10>>*/ },
            fail_single_percent =
              function(str_ind){
@@ -19289,13 +19335,13 @@
                 if(93 === c)
                   /*<<camlinternalFormat.ml:2746:8>>*/ return str_ind$0 + 1
                         | 0;
-                var _bc_ = str_ind$0 + 1 | 0;
+                var _bd_ = str_ind$0 + 1 | 0;
                  /*<<camlinternalFormat.ml:2751:8>>*/ if(counter >= 50)
                   /*<<camlinternalFormat.ml:2751:8>>*/ return  /*<<camlinternalFormat.ml:2751:8>>*/ caml_trampoline_return
-                         (parse_char_set_after_char$0, [0, _bc_, end_ind, c]);
+                         (parse_char_set_after_char$0, [0, _bd_, end_ind, c]);
                 var counter$0 = counter + 1 | 0;
                  /*<<camlinternalFormat.ml:2751:8>>*/ return parse_char_set_after_char$0
-                        (counter$0, _bc_, end_ind, c);
+                        (counter$0, _bd_, end_ind, c);
                }
                 /*<<camlinternalFormat.ml:2748:8>>*/ add_char(45);
                var str_ind$1 = str_ind$0 + 1 | 0, str_ind$0 = str_ind$1;
@@ -19346,13 +19392,13 @@
                     /*<<camlinternalFormat.ml:2787:17>>*/ return fail_single_percent
                            (str_ind$2);
                    /*<<camlinternalFormat.ml:2785:12>>*/ add_range(c$0, c$3);
-                  var _ba_ = str_ind$2 + 2 | 0;
+                  var _bb_ = str_ind$2 + 2 | 0;
                    /*<<camlinternalFormat.ml:2785:12>>*/ if(counter >= 50)
                     /*<<camlinternalFormat.ml:2785:12>>*/ return  /*<<camlinternalFormat.ml:2785:12>>*/ caml_trampoline_return
-                           (parse_char_set_content, [0, _ba_, end_ind]);
+                           (parse_char_set_content, [0, _bb_, end_ind]);
                   var counter$2 = counter + 1 | 0;
                    /*<<camlinternalFormat.ml:2785:12>>*/ return parse_char_set_content
-                          (counter$2, _ba_, end_ind);
+                          (counter$2, _bb_, end_ind);
                  }
                  if(93 === c$2){
                    /*<<camlinternalFormat.ml:2778:8>>*/ add_char(c$0);
@@ -19361,23 +19407,23 @@
                          | 0;
                  }
                   /*<<camlinternalFormat.ml:2790:8>>*/ add_range(c$0, c$2);
-                 var _bb_ = str_ind$2 + 1 | 0;
+                 var _bc_ = str_ind$2 + 1 | 0;
                   /*<<camlinternalFormat.ml:2790:8>>*/ if(counter >= 50)
                    /*<<camlinternalFormat.ml:2790:8>>*/ return  /*<<camlinternalFormat.ml:2790:8>>*/ caml_trampoline_return
-                          (parse_char_set_content, [0, _bb_, end_ind]);
+                          (parse_char_set_content, [0, _bc_, end_ind]);
                  var counter$1 = counter + 1 | 0;
                   /*<<camlinternalFormat.ml:2790:8>>*/ return parse_char_set_content
-                         (counter$1, _bb_, end_ind);
+                         (counter$1, _bc_, end_ind);
                 }
                 if(37 === c$0){
                   /*<<camlinternalFormat.ml:2763:8>>*/ add_char(c$1);
-                 var _a$_ = str_ind$0 + 1 | 0;
+                 var _ba_ = str_ind$0 + 1 | 0;
                   /*<<camlinternalFormat.ml:2763:8>>*/ if(counter >= 50)
                    /*<<camlinternalFormat.ml:2763:8>>*/ return  /*<<camlinternalFormat.ml:2763:8>>*/ caml_trampoline_return
-                          (parse_char_set_content, [0, _a$_, end_ind]);
+                          (parse_char_set_content, [0, _ba_, end_ind]);
                  var counter$0 = counter + 1 | 0;
                   /*<<camlinternalFormat.ml:2763:8>>*/ return parse_char_set_content
-                         (counter$0, _a$_, end_ind);
+                         (counter$0, _ba_, end_ind);
                 }
                }
                if(37 === c$0)
@@ -19427,10 +19473,10 @@
             /*<<camlinternalFormat.ml:2544:22>>*/ var
              /*<<camlinternalFormat.ml:2544:22>>*/ ignored$9 =
               [10, get_pad_opt(95), char_set$1],
-            _a1_ = [0, [23, ignored$9, fmt_rest$19]];
+            _a2_ = [0, [23, ignored$9, fmt_rest$19]];
           else
-           var _a1_ = [0, [20, get_pad_opt(91), char_set$1, fmt_rest$19]];
-          var fmt_result = _a1_;
+           var _a2_ = [0, [20, get_pad_opt(91), char_set$1, fmt_rest$19]];
+          var fmt_result = _a2_;
           break a;
          case 97:
           var
@@ -19450,28 +19496,28 @@
           if(match$7){
            if(0 === match$7[1])
              /*<<camlinternalFormat.ml:2382:11>>*/ var
-              /*<<camlinternalFormat.ml:2382:11>>*/ _a2_ =
+              /*<<camlinternalFormat.ml:2382:11>>*/ _a3_ =
                get_ign(0) ? [0, [23, 3, fmt_rest$21]] : [0, [22, fmt_rest$21]],
-             _a3_ = _a2_;
+             _a4_ = _a3_;
            else
             var
-             _a3_ =
+             _a4_ =
                legacy_behavior$0
                 ? char_format(fmt_rest$21)
                 : invalid_format_message
                   (str_ind, cst_non_zero_widths_are_unsupp);
-           var _a4_ = _a3_;
+           var _a5_ = _a4_;
           }
           else
-           var _a4_ = char_format(fmt_rest$21);
-          var fmt_result = _a4_;
+           var _a5_ = char_format(fmt_rest$21);
+          var fmt_result = _a5_;
           break a;
          case 114:
            /*<<camlinternalFormat.ml:2512:9>>*/ var
            fmt_rest$22 = parse(str_ind, end_ind)[1],
-            /*<<camlinternalFormat.ml:2512:9>>*/ _a5_ =
+            /*<<camlinternalFormat.ml:2512:9>>*/ _a6_ =
              get_ign(0) ? [0, [23, 2, fmt_rest$22]] : [0, [19, fmt_rest$22]],
-           fmt_result = _a5_;
+           fmt_result = _a6_;
           break a;
          case 115:
            /*<<camlinternalFormat.ml:2400:16>>*/ var
@@ -19482,15 +19528,15 @@
             /*<<camlinternalFormat.ml:2403:22>>*/ var
              /*<<camlinternalFormat.ml:2403:22>>*/ ignored$10 =
               [0, get_padprec_opt(95)],
-            _a6_ = [0, [23, ignored$10, fmt_rest$23]];
+            _a7_ = [0, [23, ignored$10, fmt_rest$23]];
           else
             /*<<camlinternalFormat.ml:2407:10>>*/ var
              /*<<camlinternalFormat.ml:2407:10>>*/ match$8 =
               make_padding_fmt_ebb(pad$9, fmt_rest$23),
             fmt_rest$24 = match$8[2],
             pad$10 = match$8[1],
-            _a6_ = [0, [2, pad$10, fmt_rest$24]];
-          var fmt_result = _a6_;
+            _a7_ = [0, [2, pad$10, fmt_rest$24]];
+          var fmt_result = _a7_;
           break a;
          case 116:
           var
@@ -19509,10 +19555,10 @@
             /*<<camlinternalFormat.ml:2526:22>>*/ var
              /*<<camlinternalFormat.ml:2526:22>>*/ ignored$11 =
               [8, get_pad_opt(95), sub_fmtty$0],
-            _a7_ = [0, [23, ignored$11, fmt_rest$26]];
+            _a8_ = [0, [23, ignored$11, fmt_rest$26]];
           else
-           var _a7_ = [0, [13, get_pad_opt(123), sub_fmtty$0, fmt_rest$26]];
-          var fmt_result = _a7_;
+           var _a8_ = [0, [13, get_pad_opt(123), sub_fmtty$0, fmt_rest$26]];
+          var fmt_result = _a8_;
           break a;
          case 66:
          case 98:
@@ -19524,15 +19570,15 @@
             /*<<camlinternalFormat.ml:2498:22>>*/ var
              /*<<camlinternalFormat.ml:2498:22>>*/ ignored$3 =
               [7, get_padprec_opt(95)],
-            _aO_ = [0, [23, ignored$3, fmt_rest$8]];
+            _aP_ = [0, [23, ignored$3, fmt_rest$8]];
           else
             /*<<camlinternalFormat.ml:2502:10>>*/ var
              /*<<camlinternalFormat.ml:2502:10>>*/ match$3 =
               make_padding_fmt_ebb(pad$3, fmt_rest$8),
             fmt_rest$9 = match$3[2],
             pad$4 = match$3[1],
-            _aO_ = [0, [9, pad$4, fmt_rest$9]];
-          var fmt_result = _aO_;
+            _aP_ = [0, [9, pad$4, fmt_rest$9]];
+          var fmt_result = _aP_;
           break a;
          case 37:
          case 64:
@@ -19548,22 +19594,22 @@
              /*<<camlinternalFormat.ml:2438:63>>*/ symb$0 =
                /*<<camlinternalFormat.ml:2438:63>>*/ caml_string_get
                (str, str_ind),
-             /*<<camlinternalFormat.ml:2892:25>>*/ _a8_ = symb$0 - 88 | 0;
+             /*<<camlinternalFormat.ml:2892:25>>*/ _a9_ = symb$0 - 88 | 0;
            b:
            {
-            if(32 >= _a8_ >>> 0)
-             switch(_a8_){
+            if(32 >= _a9_ >>> 0)
+             switch(_a9_){
                case 0:
                case 12:
                case 17:
                case 23:
                case 29:
                case 32:
-                var _aU_ = 1; break b;
+                var _aV_ = 1; break b;
              }
-            var _aU_ = 0;
+            var _aV_ = 0;
            }
-            /*<<camlinternalFormat.ml:2438:50>>*/ if(_aU_) break;
+            /*<<camlinternalFormat.ml:2438:50>>*/ if(_aV_) break;
           }
           var fmt_rest$13 = parse(str_ind, end_ind)[1];
           b:
@@ -19584,10 +19630,10 @@
            /*<<camlinternalFormat.ml:2441:9>>*/ if(get_ign(0))
             /*<<camlinternalFormat.ml:2442:22>>*/ var
              /*<<camlinternalFormat.ml:2442:22>>*/ ignored$5 = [11, counter],
-            _aT_ = [0, [23, ignored$5, fmt_rest$13]];
+            _aU_ = [0, [23, ignored$5, fmt_rest$13]];
           else
-           var _aT_ = [0, [21, counter, fmt_rest$13]];
-          var fmt_result = _aT_;
+           var _aU_ = [0, [21, counter, fmt_rest$13]];
+          var fmt_result = _aU_;
           break a;
          case 32:
          case 35:
@@ -19606,26 +19652,26 @@
          case 117:
          case 120:
            /*<<camlinternalFormat.ml:2421:8>>*/ var
-            /*<<camlinternalFormat.ml:2421:8>>*/ _aX_ = get_space(0),
-            /*<<camlinternalFormat.ml:2420:65>>*/ _aY_ = get_hash(0),
+            /*<<camlinternalFormat.ml:2421:8>>*/ _aY_ = get_space(0),
+            /*<<camlinternalFormat.ml:2420:65>>*/ _aZ_ = get_hash(0),
             /*<<camlinternalFormat.ml:2420:18>>*/ iconv$2 =
-             compute_int_conv(pct_ind, str_ind, get_plus(0), _aY_, _aX_, symb),
+             compute_int_conv(pct_ind, str_ind, get_plus(0), _aZ_, _aY_, symb),
            fmt_rest$17 = parse(str_ind, end_ind)[1];
            /*<<camlinternalFormat.ml:2423:9>>*/ if(get_ign(0))
             /*<<camlinternalFormat.ml:2424:22>>*/ var
              /*<<camlinternalFormat.ml:2424:22>>*/ ignored$8 =
               [2, iconv$2, get_pad_opt(95)],
-            _aZ_ = [0, [23, ignored$8, fmt_rest$17]];
+            _a0_ = [0, [23, ignored$8, fmt_rest$17]];
           else
             /*<<camlinternalFormat.ml:2428:48>>*/ var
-             /*<<camlinternalFormat.ml:2428:48>>*/ _a0_ = get_prec(0),
+             /*<<camlinternalFormat.ml:2428:48>>*/ _a1_ = get_prec(0),
              /*<<camlinternalFormat.ml:2428:10>>*/ match$6 =
-              make_padprec_fmt_ebb(get_int_pad(0), _a0_, fmt_rest$17),
+              make_padprec_fmt_ebb(get_int_pad(0), _a1_, fmt_rest$17),
             fmt_rest$18 = match$6[3],
             prec$4 = match$6[2],
             pad$8 = match$6[1],
-            _aZ_ = [0, [4, iconv$2, pad$8, prec$4, fmt_rest$18]];
-          var fmt_result = _aZ_;
+            _a0_ = [0, [4, iconv$2, pad$8, prec$4, fmt_rest$18]];
+          var fmt_result = _a0_;
           break a;
          case 69:
          case 70:
@@ -19655,28 +19701,28 @@
             if(3 >= switcher >>> 0){
              switch(switcher){
                case 0:
-                var _a9_ = 1; break;
+                var _a__ = 1; break;
                case 1:
-                var _a9_ = 0; break;
+                var _a__ = 0; break;
                case 2:
-                var _a9_ = 3; break;
-               default: var _a9_ = 6;
+                var _a__ = 3; break;
+               default: var _a__ = 6;
              }
-             var kind = _a9_;
+             var kind = _a__;
              break b;
             }
            }
            else if(69 <= symb){
             switch(symb - 69 | 0){
               case 0:
-               var _a__ = 2; break;
+               var _a$_ = 2; break;
               case 1:
                break c;
               case 2:
-               var _a__ = 4; break;
-              default: var _a__ = 7;
+               var _a$_ = 4; break;
+              default: var _a$_ = 7;
             }
-            var kind = _a__;
+            var kind = _a$_;
             break b;
            }
            if(hash$1){
@@ -19694,25 +19740,25 @@
             match = get_prec(0);
            if(typeof match === "number")
             var
-             _aQ_ =
+             _aR_ =
                match ? incompatible_flag(pct_ind, str_ind, 95, cst$26) : 0;
            else
-            var ndec = match[1], _aQ_ = [0, ndec];
+            var ndec = match[1], _aR_ = [0, ndec];
             /*<<camlinternalFormat.ml:2488:22>>*/ var
              /*<<camlinternalFormat.ml:2488:22>>*/ ignored$4 =
-              [6, get_pad_opt(95), _aQ_],
-            _aR_ = [0, [23, ignored$4, fmt_rest$11]];
+              [6, get_pad_opt(95), _aR_],
+            _aS_ = [0, [23, ignored$4, fmt_rest$11]];
           }
           else
             /*<<camlinternalFormat.ml:2492:44>>*/ var
-             /*<<camlinternalFormat.ml:2492:44>>*/ _aS_ = get_prec(0),
+             /*<<camlinternalFormat.ml:2492:44>>*/ _aT_ = get_prec(0),
              /*<<camlinternalFormat.ml:2492:10>>*/ match$4 =
-              make_padprec_fmt_ebb(get_pad(0), _aS_, fmt_rest$11),
+              make_padprec_fmt_ebb(get_pad(0), _aT_, fmt_rest$11),
             fmt_rest$12 = match$4[3],
             prec$3 = match$4[2],
             pad$5 = match$4[1],
-            _aR_ = [0, [8, fconv, pad$5, prec$3, fmt_rest$12]];
-          var fmt_result = _aR_;
+            _aS_ = [0, [8, fconv, pad$5, prec$3, fmt_rest$12]];
+          var fmt_result = _aS_;
           break a;
        }
       b:
@@ -19721,89 +19767,89 @@
         switch(symb - 108 | 0){
           case 0:
             /*<<camlinternalFormat.ml:2449:25>>*/ var
-             /*<<camlinternalFormat.ml:2449:25>>*/ _ax_ =
+             /*<<camlinternalFormat.ml:2449:25>>*/ _ay_ =
                /*<<camlinternalFormat.ml:2449:25>>*/ caml_string_get
                (str, str_ind),
-             /*<<camlinternalFormat.ml:2449:10>>*/ _ay_ = get_space(0),
-             /*<<camlinternalFormat.ml:2448:61>>*/ _az_ = get_hash(0),
+             /*<<camlinternalFormat.ml:2449:10>>*/ _az_ = get_space(0),
+             /*<<camlinternalFormat.ml:2448:61>>*/ _aA_ = get_hash(0),
              /*<<camlinternalFormat.ml:2448:8>>*/ iconv =
               compute_int_conv
-               (pct_ind, str_ind + 1 | 0, get_plus(0), _az_, _ay_, _ax_),
+               (pct_ind, str_ind + 1 | 0, get_plus(0), _aA_, _az_, _ay_),
             fmt_rest = parse(str_ind + 1 | 0, end_ind)[1];
             /*<<camlinternalFormat.ml:2451:9>>*/ if(get_ign(0))
              /*<<camlinternalFormat.ml:2452:22>>*/ var
               /*<<camlinternalFormat.ml:2452:22>>*/ ignored =
                [3, iconv, get_pad_opt(95)],
-             _aA_ = [0, [23, ignored, fmt_rest]];
+             _aB_ = [0, [23, ignored, fmt_rest]];
            else
              /*<<camlinternalFormat.ml:2456:48>>*/ var
-              /*<<camlinternalFormat.ml:2456:48>>*/ _aC_ = get_prec(0),
+              /*<<camlinternalFormat.ml:2456:48>>*/ _aD_ = get_prec(0),
               /*<<camlinternalFormat.ml:2456:10>>*/ match$0 =
-               make_padprec_fmt_ebb(get_int_pad(0), _aC_, fmt_rest),
+               make_padprec_fmt_ebb(get_int_pad(0), _aD_, fmt_rest),
              fmt_rest$0 = match$0[3],
              prec$0 = match$0[2],
              pad$0 = match$0[1],
-             _aA_ = [0, [5, iconv, pad$0, prec$0, fmt_rest$0]];
-           var _aB_ = _aA_;
+             _aB_ = [0, [5, iconv, pad$0, prec$0, fmt_rest$0]];
+           var _aC_ = _aB_;
            break;
           case 1:
            break b;
           default:
             /*<<camlinternalFormat.ml:2461:39>>*/ var
-             /*<<camlinternalFormat.ml:2461:39>>*/ _aD_ =
+             /*<<camlinternalFormat.ml:2461:39>>*/ _aE_ =
                /*<<camlinternalFormat.ml:2461:39>>*/ caml_string_get
                (str, str_ind),
-             /*<<camlinternalFormat.ml:2461:24>>*/ _aE_ = get_space(0),
-             /*<<camlinternalFormat.ml:2461:10>>*/ _aF_ = get_hash(0),
+             /*<<camlinternalFormat.ml:2461:24>>*/ _aF_ = get_space(0),
+             /*<<camlinternalFormat.ml:2461:10>>*/ _aG_ = get_hash(0),
              /*<<camlinternalFormat.ml:2460:8>>*/ iconv$0 =
               compute_int_conv
-               (pct_ind, str_ind + 1 | 0, get_plus(0), _aF_, _aE_, _aD_),
+               (pct_ind, str_ind + 1 | 0, get_plus(0), _aG_, _aF_, _aE_),
             fmt_rest$1 = parse(str_ind + 1 | 0, end_ind)[1];
             /*<<camlinternalFormat.ml:2463:9>>*/ if(get_ign(0))
              /*<<camlinternalFormat.ml:2464:22>>*/ var
               /*<<camlinternalFormat.ml:2464:22>>*/ ignored$0 =
                [4, iconv$0, get_pad_opt(95)],
-             _aG_ = [0, [23, ignored$0, fmt_rest$1]];
+             _aH_ = [0, [23, ignored$0, fmt_rest$1]];
            else
              /*<<camlinternalFormat.ml:2468:48>>*/ var
-              /*<<camlinternalFormat.ml:2468:48>>*/ _aH_ = get_prec(0),
+              /*<<camlinternalFormat.ml:2468:48>>*/ _aI_ = get_prec(0),
               /*<<camlinternalFormat.ml:2468:10>>*/ match$1 =
-               make_padprec_fmt_ebb(get_int_pad(0), _aH_, fmt_rest$1),
+               make_padprec_fmt_ebb(get_int_pad(0), _aI_, fmt_rest$1),
              fmt_rest$2 = match$1[3],
              prec$1 = match$1[2],
              pad$1 = match$1[1],
-             _aG_ = [0, [6, iconv$0, pad$1, prec$1, fmt_rest$2]];
-           var _aB_ = _aG_;
+             _aH_ = [0, [6, iconv$0, pad$1, prec$1, fmt_rest$2]];
+           var _aC_ = _aH_;
         }
-        var fmt_result = _aB_;
+        var fmt_result = _aC_;
         break a;
        }
       }
       else if(76 === symb){
         /*<<camlinternalFormat.ml:2473:25>>*/ var
-         /*<<camlinternalFormat.ml:2473:25>>*/ _aI_ =
+         /*<<camlinternalFormat.ml:2473:25>>*/ _aJ_ =
            /*<<camlinternalFormat.ml:2473:25>>*/ caml_string_get(str, str_ind),
-         /*<<camlinternalFormat.ml:2473:10>>*/ _aJ_ = get_space(0),
-         /*<<camlinternalFormat.ml:2472:61>>*/ _aK_ = get_hash(0),
+         /*<<camlinternalFormat.ml:2473:10>>*/ _aK_ = get_space(0),
+         /*<<camlinternalFormat.ml:2472:61>>*/ _aL_ = get_hash(0),
          /*<<camlinternalFormat.ml:2472:8>>*/ iconv$1 =
           compute_int_conv
-           (pct_ind, str_ind + 1 | 0, get_plus(0), _aK_, _aJ_, _aI_),
+           (pct_ind, str_ind + 1 | 0, get_plus(0), _aL_, _aK_, _aJ_),
         fmt_rest$3 = parse(str_ind + 1 | 0, end_ind)[1];
         /*<<camlinternalFormat.ml:2475:9>>*/ if(get_ign(0))
          /*<<camlinternalFormat.ml:2476:22>>*/ var
           /*<<camlinternalFormat.ml:2476:22>>*/ ignored$1 =
            [5, iconv$1, get_pad_opt(95)],
-         _aL_ = [0, [23, ignored$1, fmt_rest$3]];
+         _aM_ = [0, [23, ignored$1, fmt_rest$3]];
        else
          /*<<camlinternalFormat.ml:2480:48>>*/ var
-          /*<<camlinternalFormat.ml:2480:48>>*/ _aM_ = get_prec(0),
+          /*<<camlinternalFormat.ml:2480:48>>*/ _aN_ = get_prec(0),
           /*<<camlinternalFormat.ml:2480:10>>*/ match$2 =
-           make_padprec_fmt_ebb(get_int_pad(0), _aM_, fmt_rest$3),
+           make_padprec_fmt_ebb(get_int_pad(0), _aN_, fmt_rest$3),
          fmt_rest$4 = match$2[3],
          prec$2 = match$2[2],
          pad$2 = match$2[1],
-         _aL_ = [0, [7, iconv$1, pad$2, prec$2, fmt_rest$4]];
-       var fmt_result = _aL_;
+         _aM_ = [0, [7, iconv$1, pad$2, prec$2, fmt_rest$4]];
+       var fmt_result = _aM_;
        break a;
       }
       var
@@ -19812,46 +19858,46 @@
           (failwith_message(_J_), str, str_ind - 1 | 0, symb);
      }
      if(1 - legacy_behavior$0){
-      var _ao_ = 1 - plus_used[1], plus$0 = _ao_ ? plus : _ao_;
+      var _ap_ = 1 - plus_used[1], plus$0 = _ap_ ? plus : _ap_;
       if(plus$0)
         /*<<camlinternalFormat.ml:2564:6>>*/ incompatible_flag
         (pct_ind, str_ind, symb, cst$27);
-      var _ap_ = 1 - hash_used[1], hash$0 = _ap_ ? hash : _ap_;
+      var _aq_ = 1 - hash_used[1], hash$0 = _aq_ ? hash : _aq_;
       if(hash$0)
         /*<<camlinternalFormat.ml:2566:6>>*/ incompatible_flag
         (pct_ind, str_ind, symb, cst$28);
-      var _aq_ = 1 - space_used[1], space$0 = _aq_ ? space : _aq_;
+      var _ar_ = 1 - space_used[1], space$0 = _ar_ ? space : _ar_;
       if(space$0)
         /*<<camlinternalFormat.ml:2568:6>>*/ incompatible_flag
         (pct_ind, str_ind, symb, cst$29);
       var
-       _ar_ = 1 - pad_used[1],
-       _as_ =
-         _ar_
+       _as_ = 1 - pad_used[1],
+       _at_ =
+         _as_
           ?  /*<<camlinternalFormat.ml:2569:25>>*/ caml_notequal
             ([0, pad], _K_)
-          : _ar_;
-       /*<<camlinternalFormat.ml:2569:25>>*/ if(_as_)
+          : _as_;
+       /*<<camlinternalFormat.ml:2569:25>>*/ if(_at_)
         /*<<camlinternalFormat.ml:2570:6>>*/ incompatible_flag
         (pct_ind, str_ind, symb, cst_padding$0);
       var
-       _at_ = 1 - prec_used[1],
-       _au_ =
-         _at_
+       _au_ = 1 - prec_used[1],
+       _av_ =
+         _au_
           ?  /*<<camlinternalFormat.ml:2571:25>>*/ caml_notequal
             ([0, prec], _L_)
-          : _at_;
-       /*<<camlinternalFormat.ml:2571:25>>*/ if(_au_){
-       var _av_ = ign ? 95 : symb;
+          : _au_;
+       /*<<camlinternalFormat.ml:2571:25>>*/ if(_av_){
+       var _aw_ = ign ? 95 : symb;
         /*<<camlinternalFormat.ml:2572:6>>*/ incompatible_flag
-        (pct_ind, str_ind, _av_, cst_precision$2);
+        (pct_ind, str_ind, _aw_, cst_precision$2);
       }
       var plus$1 = ign ? plus : ign;
       if(plus$1)
         /*<<camlinternalFormat.ml:2574:24>>*/ incompatible_flag
         (pct_ind, str_ind, 95, cst$30);
      }
-     var _aw_ = 1 - ign_used[1], ign$0 = _aw_ ? ign : _aw_;
+     var _ax_ = 1 - ign_used[1], ign$0 = _ax_ ? ign : _ax_;
      a:
      if(ign$0){
       b:
@@ -19968,10 +20014,10 @@
         case 3:
          if(legacy_behavior$0){
            /*<<camlinternalFormat.ml:2249:6>>*/ var
-            /*<<camlinternalFormat.ml:2249:6>>*/ _an_ = str_ind$0 + 1 | 0,
+            /*<<camlinternalFormat.ml:2249:6>>*/ _ao_ = str_ind$0 + 1 | 0,
            minus$0 = minus || (45 === symb$0 ? 1 : 0);
            /*<<camlinternalFormat.ml:2249:6>>*/ return parse_literal
-                  (minus$0, _an_);
+                  (minus$0, _ao_);
          }
          break;
       }
@@ -19998,17 +20044,17 @@
        /*<<camlinternalFormat.ml:2151:15>>*/ hash = [0, 0];
      function set_flag(str_ind, flag){
        /*<<camlinternalFormat.ml:2154:6>>*/ var
-       _ak_ = flag[1],
-       _al_ = _ak_ ? 1 - legacy_behavior$0 : _ak_;
-      if(_al_){
+       _al_ = flag[1],
+       _am_ = _al_ ? 1 - legacy_behavior$0 : _al_;
+      if(_am_){
         /*<<camlinternalFormat.ml:2157:22>>*/  /*<<camlinternalFormat.ml:2157:22>>*/ var
-        _am_ =
+        _an_ =
            /*<<camlinternalFormat.ml:2157:22>>*/ caml_string_get(str, str_ind);
         /*<<camlinternalFormat.ml:2155:8>>*/  /*<<camlinternalFormat.ml:2155:8>>*/ caml_call3
-        (failwith_message(_C_), str, str_ind, _am_);
+        (failwith_message(_C_), str, str_ind, _an_);
       }
       flag[1] = 1;
-      return 0;
+      return;
       /*<<camlinternalFormat.ml:2158:19>>*/ }
      var str_ind$0 = str_ind;
       /*<<camlinternalFormat.ml:2161:6>>*/ for(;;){
@@ -20178,13 +20224,13 @@
          [0, sub_fmt, sub_str],
         /*<<camlinternalFormat.ml:2649:8>>*/ formatting$0 =
          is_open_tag ? [0, sub_format$0] : [1, sub_format$0],
-        /*<<camlinternalFormat.ml:2651:8>>*/ _ai_ =
+        /*<<camlinternalFormat.ml:2651:8>>*/ _aj_ =
          [0, [18, formatting$0, fmt_rest$0]];
-       /*<<camlinternalFormat.ml:2651:8>>*/ return _ai_;
+       /*<<camlinternalFormat.ml:2651:8>>*/ return _aj_;
      }
-     catch(_aj_){
-      var _ah_ = caml_wrap_exception(_aj_);
-      if(_ah_ !== Stdlib[8]) throw caml_maybe_attach_backtrace(_ah_, 0);
+     catch(_ak_){
+      var _ai_ = caml_wrap_exception(_ak_);
+      if(_ai_ !== Stdlib[8]) throw caml_maybe_attach_backtrace(_ai_, 0);
        /*<<camlinternalFormat.ml:2657:6>>*/ var
        fmt_rest = parse(str_ind, end_ind)[1],
         /*<<camlinternalFormat.ml:2657:6>>*/ formatting =
@@ -20224,9 +20270,9 @@
       var new_acc = (acc$0 * 10 | 0) + (c - 48 | 0) | 0;
       if(Stdlib_Sys[12] < new_acc){
         /*<<camlinternalFormat.ml:2815:8>>*/  /*<<camlinternalFormat.ml:2815:8>>*/ var
-        _ag_ = Stdlib_Sys[12];
+        _ah_ = Stdlib_Sys[12];
         /*<<camlinternalFormat.ml:2815:8>>*/ return  /*<<camlinternalFormat.ml:2815:8>>*/ caml_call3
-               (failwith_message(_S_), str, new_acc, _ag_);
+               (failwith_message(_S_), str, new_acc, _ah_);
       }
       var
        str_ind$1 = str_ind$0 + 1 | 0,
@@ -20480,16 +20526,16 @@
      fmt = fmt_ebb_of_string(0, str)[1];
      /*<<camlinternalFormat.ml:2978:2>>*/ try{
       /*<<camlinternalFormat.ml:2978:6>>*/  /*<<camlinternalFormat.ml:2978:6>>*/ var
-      _ae_ = [0, type_format(fmt, fmtty), str];
-      /*<<camlinternalFormat.ml:2978:6>>*/ return _ae_;
+      _af_ = [0, type_format(fmt, fmtty), str];
+      /*<<camlinternalFormat.ml:2978:6>>*/ return _af_;
     }
-    catch(_af_){
-     var _ac_ = caml_wrap_exception(_af_);
-     if(_ac_ !== Type_mismatch) throw caml_maybe_attach_backtrace(_ac_, 0);
+    catch(_ag_){
+     var _ad_ = caml_wrap_exception(_ag_);
+     if(_ad_ !== Type_mismatch) throw caml_maybe_attach_backtrace(_ad_, 0);
       /*<<camlinternalFormat.ml:2982:10>>*/  /*<<camlinternalFormat.ml:2982:10>>*/ var
-      _ad_ = string_of_fmtty(fmtty);
+      _ae_ = string_of_fmtty(fmtty);
       /*<<camlinternalFormat.ml:2982:10>>*/ return  /*<<camlinternalFormat.ml:2982:10>>*/ caml_call2
-             (failwith_message(_Z_), str, _ad_);
+             (failwith_message(_Z_), str, _ae_);
     }
     /*<<camlinternalFormat.ml:2982:33>>*/ }
    function format_of_string_format(str, param){
@@ -20499,15 +20545,15 @@
      fmt$0 = fmt_ebb_of_string(0, str)[1];
      /*<<camlinternalFormat.ml:2988:2>>*/ try{
       /*<<camlinternalFormat.ml:2988:6>>*/  /*<<camlinternalFormat.ml:2988:6>>*/ var
-      _aa_ = [0, type_format(fmt$0, fmtty_of_fmt(fmt)), str];
-      /*<<camlinternalFormat.ml:2988:6>>*/ return _aa_;
+      _ab_ = [0, type_format(fmt$0, fmtty_of_fmt(fmt)), str];
+      /*<<camlinternalFormat.ml:2988:6>>*/ return _ab_;
     }
-    catch(_ab_){
-     var _$_ = caml_wrap_exception(_ab_);
-     if(_$_ === Type_mismatch)
+    catch(_ac_){
+     var _aa_ = caml_wrap_exception(_ac_);
+     if(_aa_ === Type_mismatch)
        /*<<camlinternalFormat.ml:2990:4>>*/ return  /*<<camlinternalFormat.ml:2990:4>>*/ caml_call2
               (failwith_message(___), str, str$0);
-     throw caml_maybe_attach_backtrace(_$_, 0);
+     throw caml_maybe_attach_backtrace(_aa_, 0);
     }
    }
    var
@@ -20715,6 +20761,7 @@
             : runtime.caml_call_gen(f, [a0, a1, a2, a3, a4, a5]);
    }
     /*<<arg.ml:50:0>>*/ var
+    _y_ = undefined,
     global_data = runtime.caml_get_global_data(),
     cst$7 = "\n",
     cst$4 = cst$8,
@@ -20807,18 +20854,18 @@
      /*<<arg.ml:79:53>>*/ var
      t = l[2],
      h = l[1],
-      /*<<arg.ml:79:53>>*/ _aD_ =
+      /*<<arg.ml:79:53>>*/ _aE_ =
         /*<<arg.ml:79:53>>*/ caml_call2(Stdlib[28], prefix, h);
-    function _aE_(x, y){
+    function _aF_(x, y){
       /*<<arg.ml:79:40>>*/  /*<<arg.ml:79:44>>*/ var
-      _aG_ =  /*<<arg.ml:79:44>>*/ caml_call2(Stdlib[28], sep, y);
+      _aH_ =  /*<<arg.ml:79:44>>*/ caml_call2(Stdlib[28], sep, y);
       /*<<arg.ml:79:44>>*/ return  /*<<arg.ml:79:44>>*/ caml_call2
-             (Stdlib[28], x, _aG_);
+             (Stdlib[28], x, _aH_);
      /*<<arg.ml:79:51>>*/ }
      /*<<arg.ml:79:12>>*/  /*<<arg.ml:79:12>>*/ var
-     _aF_ =  /*<<arg.ml:79:12>>*/ caml_call3(Stdlib_List[26], _aE_, _aD_, t);
+     _aG_ =  /*<<arg.ml:79:12>>*/ caml_call3(Stdlib_List[26], _aF_, _aE_, t);
      /*<<arg.ml:79:12>>*/ return  /*<<arg.ml:79:12>>*/ caml_call2
-            (Stdlib[28], _aF_, suffix);
+            (Stdlib[28], _aG_, suffix);
     /*<<arg.ml:79:77>>*/ }
    function help_action(param){
      /*<<arg.ml:91:21>>*/ throw  /*<<arg.ml:91:21>>*/ caml_maybe_attach_backtrace
@@ -20827,11 +20874,11 @@
    function add_help(speclist){
      /*<<arg.ml:94:2>>*/ try{
       /*<<arg.ml:95:15>>*/ assoc3(cst_help$2, speclist);
-      /*<<arg.ml:95:42>>*/ var  /*<<arg.ml:95:42>>*/ _aA_ = 0, add1 = _aA_;
+      /*<<arg.ml:95:42>>*/ var  /*<<arg.ml:95:42>>*/ _aB_ = 0, add1 = _aB_;
     }
-    catch(_aC_){
-     var _aw_ = caml_wrap_exception(_aC_);
-     if(_aw_ !== Stdlib[8]) throw caml_maybe_attach_backtrace(_aw_, 0);
+    catch(_aD_){
+     var _ax_ = caml_wrap_exception(_aD_);
+     if(_ax_ !== Stdlib[8]) throw caml_maybe_attach_backtrace(_ax_, 0);
      var
       add1 =
         [0,
@@ -20840,11 +20887,11 @@
     }
     try{
       /*<<arg.ml:99:15>>*/ assoc3(cst_help$1, speclist);
-      /*<<arg.ml:99:43>>*/ var  /*<<arg.ml:99:43>>*/ _az_ = 0, add2 = _az_;
+      /*<<arg.ml:99:43>>*/ var  /*<<arg.ml:99:43>>*/ _aA_ = 0, add2 = _aA_;
     }
-    catch(_aB_){
-     var _ax_ = caml_wrap_exception(_aB_);
-     if(_ax_ !== Stdlib[8]) throw caml_maybe_attach_backtrace(_ax_, 0);
+    catch(_aC_){
+     var _ay_ = caml_wrap_exception(_aC_);
+     if(_ay_ !== Stdlib[8]) throw caml_maybe_attach_backtrace(_ay_, 0);
      var
       add2 =
         [0,
@@ -20852,33 +20899,34 @@
          0];
     }
      /*<<arg.ml:103:13>>*/  /*<<arg.ml:103:13>>*/ var
-     _ay_ =  /*<<arg.ml:103:13>>*/ caml_call2(Stdlib[37], add1, add2);
+     _az_ =  /*<<arg.ml:103:13>>*/ caml_call2(Stdlib[37], add1, add2);
      /*<<arg.ml:103:13>>*/ return  /*<<arg.ml:103:13>>*/ caml_call2
-            (Stdlib[37], speclist, _ay_);
+            (Stdlib[37], speclist, _az_);
     /*<<arg.ml:103:26>>*/ }
    function usage_b(buf, speclist, errmsg){
      /*<<arg.ml:107:2>>*/  /*<<arg.ml:107:2>>*/ caml_call3
      (Stdlib_Printf[5], buf, _d_, errmsg);
      /*<<arg.ml:108:29>>*/  /*<<arg.ml:108:29>>*/ var
-     _as_ = add_help(speclist);
-     /*<<arg.ml:108:12>>*/ function _at_(param){
+     _at_ = add_help(speclist);
+     /*<<arg.ml:108:12>>*/ function _au_(param){
      var
       doc = param[3],
       spec = param[2],
       key = param[1],
-      _au_ = 0 <  /*<<arg.ml:83:2>>*/ caml_ml_string_length(doc) ? 1 : 0;
-     if(! _au_) return _au_;
+      _av_ = 0 <  /*<<arg.ml:83:2>>*/ caml_ml_string_length(doc) ? 1 : 0;
+     if(! _av_) return _av_;
      if(11 !== spec[0])
        /*<<arg.ml:88:8>>*/ return  /*<<arg.ml:88:8>>*/ caml_call4
               (Stdlib_Printf[5], buf, _a_, key, doc);
       /*<<arg.ml:86:38>>*/ var
       l = spec[1],
-       /*<<arg.ml:86:38>>*/ _av_ = make_symlist(cst$1, cst$0, cst, l);
+       /*<<arg.ml:86:38>>*/ _aw_ = make_symlist(cst$1, cst$0, cst, l);
       /*<<arg.ml:86:8>>*/ return  /*<<arg.ml:86:8>>*/ caml_call5
-             (Stdlib_Printf[5], buf, _b_, key, _av_, doc);
+             (Stdlib_Printf[5], buf, _b_, key, _aw_, doc);
     }
-     /*<<arg.ml:108:29>>*/ return  /*<<arg.ml:108:29>>*/ caml_call2
-            (Stdlib_List[18], _at_, _as_);
+     /*<<arg.ml:108:29>>*/  /*<<arg.ml:108:29>>*/ caml_call2
+     (Stdlib_List[18], _au_, _at_);
+     /*<<arg.ml:108:29>>*/ return;
     /*<<arg.ml:108:48>>*/ }
    function usage_string(speclist, errmsg){
      /*<<arg.ml:112:2>>*/  /*<<arg.ml:112:10>>*/ var
@@ -20889,33 +20937,33 @@
     /*<<arg.ml:114:19>>*/ }
    function usage(speclist, errmsg){
      /*<<arg.ml:118:2>>*/  /*<<arg.ml:118:15>>*/ var
-     _ar_ = usage_string(speclist, errmsg);
+     _as_ = usage_string(speclist, errmsg);
      /*<<arg.ml:118:15>>*/ return  /*<<arg.ml:118:15>>*/ caml_call2
-            (Stdlib_Printf[3], _e_, _ar_);
+            (Stdlib_Printf[3], _e_, _as_);
     /*<<arg.ml:118:45>>*/ }
     /*<<arg.ml:121:14>>*/  /*<<arg.ml:121:14>>*/ var current = [0, 0];
    function int_of_string_opt(x){
      /*<<arg.ml:128:2>>*/ try{
       /*<<arg.ml:128:6>>*/  /*<<arg.ml:128:6>>*/ var
-      _ap_ = [0,  /*<<arg.ml:128:11>>*/ runtime.caml_int_of_string(x)];
-      /*<<arg.ml:128:6>>*/ return _ap_;
+      _aq_ = [0,  /*<<arg.ml:128:11>>*/ runtime.caml_int_of_string(x)];
+      /*<<arg.ml:128:6>>*/ return _aq_;
     }
-    catch(_aq_){
-     var _ao_ = caml_wrap_exception(_aq_);
-     if(_ao_[1] === Stdlib[7])  /*<<arg.ml:129:20>>*/ return 0;
-     throw caml_maybe_attach_backtrace(_ao_, 0);
+    catch(_ar_){
+     var _ap_ = caml_wrap_exception(_ar_);
+     if(_ap_[1] === Stdlib[7])  /*<<arg.ml:129:20>>*/ return 0;
+     throw caml_maybe_attach_backtrace(_ap_, 0);
     }
     /*<<arg.ml:129:24>>*/ }
    function float_of_string_opt(x){
      /*<<arg.ml:132:2>>*/ try{
       /*<<arg.ml:132:6>>*/  /*<<arg.ml:132:6>>*/ var
-      _am_ = [0,  /*<<arg.ml:132:11>>*/ runtime.caml_float_of_string(x)];
-      /*<<arg.ml:132:6>>*/ return _am_;
+      _an_ = [0,  /*<<arg.ml:132:11>>*/ runtime.caml_float_of_string(x)];
+      /*<<arg.ml:132:6>>*/ return _an_;
     }
-    catch(_an_){
-     var _al_ = caml_wrap_exception(_an_);
-     if(_al_[1] === Stdlib[7])  /*<<arg.ml:133:20>>*/ return 0;
-     throw caml_maybe_attach_backtrace(_al_, 0);
+    catch(_ao_){
+     var _am_ = caml_wrap_exception(_ao_);
+     if(_am_[1] === Stdlib[7])  /*<<arg.ml:133:20>>*/ return 0;
+     throw caml_maybe_attach_backtrace(_am_, 0);
     }
     /*<<arg.ml:133:24>>*/ }
    function parse_and_expand_argv_dynamic_
@@ -20970,20 +21018,20 @@
      if(current[1] >= argv[1].length - 1) return 0;
       /*<<arg.ml:166:4>>*/ try{
        /*<<arg.ml:167:14>>*/ var
-       _Y_ = current[1],
-        /*<<arg.ml:167:14>>*/ s = caml_check_bound(argv[1], _Y_)[1 + _Y_];
+       _Z_ = current[1],
+        /*<<arg.ml:167:14>>*/ s = caml_check_bound(argv[1], _Z_)[1 + _Z_];
        /*<<arg.ml:168:9>>*/ if
        ( /*<<arg.ml:168:9>>*/ caml_call2(Stdlib_String[11], cst$3, s)){
        try{
          /*<<arg.ml:170:14>>*/ var
          follow$1 = 0,
-          /*<<arg.ml:170:14>>*/ _aa_ = assoc3(s, speclist[1]),
+          /*<<arg.ml:170:14>>*/ _ab_ = assoc3(s, speclist[1]),
          follow$0 = follow$1,
-         action = _aa_;
+         action = _ab_;
        }
-       catch(_aj_){
-        var _Z_ = caml_wrap_exception(_aj_);
-        if(_Z_ !== Stdlib[8]) throw caml_maybe_attach_backtrace(_Z_, 0);
+       catch(_ak_){
+        var ___ = caml_wrap_exception(_ak_);
+        if(___ !== Stdlib[8]) throw caml_maybe_attach_backtrace(___, 0);
          /*<<arg.ml:172:10>>*/ try{
           /*<<arg.ml:71:10>>*/ var
            /*<<arg.ml:71:10>>*/ i =
@@ -20996,24 +21044,23 @@
            /*<<arg.ml:73:2>>*/ keyword =
              /*<<arg.ml:73:2>>*/ caml_call3(Stdlib_String[16], s, 0, i),
            /*<<arg.ml:174:38>>*/ follow = [0, arg],
-           /*<<arg.ml:174:12>>*/ _$_ = assoc3(keyword, speclist[1]),
+           /*<<arg.ml:174:12>>*/ _aa_ = assoc3(keyword, speclist[1]),
           follow$0 = follow,
-          action = _$_;
+          action = _aa_;
         }
-        catch(_ak_){
-         var ___ = caml_wrap_exception(_ak_);
-         if(___ === Stdlib[8])
+        catch(_al_){
+         var _$_ = caml_wrap_exception(_al_);
+         if(_$_ === Stdlib[8])
            /*<<arg.ml:175:28>>*/ throw  /*<<arg.ml:175:28>>*/ caml_maybe_attach_backtrace
                  ([0, Stop, [0, s]], 1);
-         throw caml_maybe_attach_backtrace(___, 0);
+         throw caml_maybe_attach_backtrace(_$_, 0);
         }
        }
        var
         no_arg$0 =
           function(s, follow){
            function no_arg(param){
-             /*<<arg.ml:178:10>>*/ if(! follow)
-              /*<<arg.ml:179:20>>*/ return 0;
+             /*<<arg.ml:178:10>>*/ if(! follow)  /*<<arg.ml:179:20>>*/ return;
             var arg = follow[1];
              /*<<arg.ml:180:24>>*/ throw  /*<<arg.ml:180:24>>*/ caml_maybe_attach_backtrace
                    ([0, Stop, [1, s, arg, cst_no_argument]], 1);
@@ -21031,9 +21078,9 @@
             if((current[1] + 1 | 0) >= argv[1].length - 1)
               /*<<arg.ml:185:19>>*/ throw  /*<<arg.ml:185:19>>*/ caml_maybe_attach_backtrace
                     ([0, Stop, [2, s]], 1);
-            var _ai_ = current[1] + 1 | 0;
-             /*<<arg.ml:184:58>>*/ return caml_check_bound(argv[1], _ai_)
-                    [1 + _ai_];
+            var _aj_ = current[1] + 1 | 0;
+             /*<<arg.ml:184:58>>*/ return caml_check_bound(argv[1], _aj_)
+                    [1 + _aj_];
             /*<<arg.ml:186:27>>*/ }
            return get_arg;
           },
@@ -21061,14 +21108,14 @@
                  /*<<arg.ml:196:22>>*/ arg = get_arg(0);
                 /*<<arg.ml:124:2>>*/ try{
                  /*<<arg.ml:124:6>>*/ var
-                  /*<<arg.ml:124:6>>*/ _ac_ =
+                  /*<<arg.ml:124:6>>*/ _ad_ =
                    [0,  /*<<arg.ml:124:11>>*/ caml_call1(Stdlib[32], arg)],
-                 match = _ac_;
+                 match = _ad_;
                }
-               catch(_ah_){
-                var _ab_ = caml_wrap_exception(_ah_);
-                if(_ab_[1] !== Stdlib[6])
-                 throw caml_maybe_attach_backtrace(_ab_, 0);
+               catch(_ai_){
+                var _ac_ = caml_wrap_exception(_ai_);
+                if(_ac_[1] !== Stdlib[6])
+                 throw caml_maybe_attach_backtrace(_ac_, 0);
                 var match = 0;
                }
                if(! match)
@@ -21163,7 +21210,7 @@
                  /*<<arg.ml:211:14>>*/ return consume_arg(0);
                }
                 /*<<arg.ml:215:44>>*/  /*<<arg.ml:215:44>>*/ var
-                _ad_ = make_symlist(cst$6, cst$5, cst$4, symb);
+                _ae_ = make_symlist(cst$6, cst$5, cst$4, symb);
                 /*<<arg.ml:213:21>>*/ throw  /*<<arg.ml:213:21>>*/ caml_maybe_attach_backtrace
                       ([0,
                         Stop,
@@ -21171,16 +21218,16 @@
                          s,
                          arg$5,
                           /*<<arg.ml:214:42>>*/ caml_call2
-                          (Stdlib[28], cst_one_of, _ad_)]],
+                          (Stdlib[28], cst_one_of, _ae_)]],
                        1);
               case 12:
                var f$5 = param[1];
                 /*<<arg.ml:252:12>>*/ no_arg(0);
                 /*<<arg.ml:255:14>>*/ for(;;){
                 if(current[1] >= (argv[1].length - 1 - 1 | 0)) return 0;
-                var _ae_ = current[1] + 1 | 0;
+                var _af_ = current[1] + 1 | 0;
                  /*<<arg.ml:254:14>>*/  /*<<arg.ml:254:14>>*/ caml_call1
-                 (f$5, caml_check_bound(argv[1], _ae_)[1 + _ae_]);
+                 (f$5, caml_check_bound(argv[1], _af_)[1 + _af_]);
                  /*<<arg.ml:255:14>>*/ consume_arg(0);
                }
                break;
@@ -21193,8 +21240,8 @@
                   /*<<arg.ml:264:14>>*/ return  /*<<arg.ml:264:14>>*/ caml_call1
                          (f$6,
                            /*<<arg.ml:264:14>>*/ caml_call1(Stdlib_List[10], acc[1]));
-                var _ag_ = current[1] + 1 | 0, _af_ = acc[1];
-                acc[1] = [0, caml_check_bound(argv[1], _ag_)[1 + _ag_], _af_];
+                var _ah_ = current[1] + 1 | 0, _ag_ = acc[1];
+                acc[1] = [0, caml_check_bound(argv[1], _ah_)[1 + _ah_], _ag_];
                  /*<<arg.ml:262:14>>*/ consume_arg(0);
                }
                break;
@@ -21271,8 +21318,8 @@
    function parse(l, f, msg){
      /*<<arg.ml:299:2>>*/ try{
       /*<<arg.ml:300:4>>*/  /*<<arg.ml:300:4>>*/ var
-      _X_ = parse_argv(0, caml_sys_argv(0), l, f, msg);
-      /*<<arg.ml:300:4>>*/ return _X_;
+      _Y_ = parse_argv(0, caml_sys_argv(0), l, f, msg);
+      /*<<arg.ml:300:4>>*/ return _Y_;
     }
     catch(exn$0){
      var exn = caml_wrap_exception(exn$0);
@@ -21294,8 +21341,8 @@
    function parse_dynamic(l, f, msg){
      /*<<arg.ml:307:2>>*/ try{
       /*<<arg.ml:308:4>>*/  /*<<arg.ml:308:4>>*/ var
-      _W_ = parse_argv_dynamic(0, caml_sys_argv(0), l, f, msg);
-      /*<<arg.ml:308:4>>*/ return _W_;
+      _X_ = parse_argv_dynamic(0, caml_sys_argv(0), l, f, msg);
+      /*<<arg.ml:308:4>>*/ return _X_;
     }
     catch(exn$0){
      var exn = caml_wrap_exception(exn$0);
@@ -21320,9 +21367,9 @@
        /*<<arg.ml:315:15>>*/ argv = [0, caml_sys_argv(0)],
        /*<<arg.ml:316:15>>*/ spec = [0, l],
        /*<<arg.ml:317:18>>*/ current$0 = [0, current[1]],
-       /*<<arg.ml:318:4>>*/ _V_ =
+       /*<<arg.ml:318:4>>*/ _W_ =
         parse_and_expand_argv_dynamic(current$0, argv, spec, f, msg);
-      /*<<arg.ml:318:4>>*/ return _V_;
+      /*<<arg.ml:318:4>>*/ return _W_;
     }
     catch(exn$0){
      var exn = caml_wrap_exception(exn$0);
@@ -21359,17 +21406,17 @@
       /*<<arg.ml:331:8>>*/  /*<<arg.ml:331:8>>*/ var
       n$0 =  /*<<arg.ml:331:8>>*/ caml_call2(Stdlib_String[36], s, 9);
     }
-    catch(_T_){
-     var _R_ = caml_wrap_exception(_T_);
-     if(_R_ !== Stdlib[8]) throw caml_maybe_attach_backtrace(_R_, 0);
+    catch(_U_){
+     var _S_ = caml_wrap_exception(_U_);
+     if(_S_ !== Stdlib[8]) throw caml_maybe_attach_backtrace(_S_, 0);
       /*<<arg.ml:334:6>>*/ try{
        /*<<arg.ml:334:18>>*/  /*<<arg.ml:334:18>>*/ var
        n =  /*<<arg.ml:334:18>>*/ caml_call2(Stdlib_String[36], s, 32);
      }
-     catch(_U_){
-      var _S_ = caml_wrap_exception(_U_);
-      if(_S_ === Stdlib[8])  /*<<arg.ml:336:31>>*/ return len;
-      throw caml_maybe_attach_backtrace(_S_, 0);
+     catch(_V_){
+      var _T_ = caml_wrap_exception(_V_);
+      if(_T_ === Stdlib[8])  /*<<arg.ml:336:31>>*/ return len;
+      throw caml_maybe_attach_backtrace(_T_, 0);
      }
       /*<<arg.ml:334:18>>*/ return loop(n + 1 | 0);
     }
@@ -21379,12 +21426,12 @@
     var doc = param[3], spec = param[2], kwd = param[1];
      /*<<arg.ml:341:2>>*/ if(11 === spec[0])
      return caml_call2(Stdlib_Int[11], cur, caml_ml_string_length(kwd));
-    var _Q_ = caml_ml_string_length(kwd) + second_word(doc) | 0;
-    return caml_call2(Stdlib_Int[11], cur, _Q_);
+    var _R_ = caml_ml_string_length(kwd) + second_word(doc) | 0;
+    return caml_call2(Stdlib_Int[11], cur, _R_);
    }
    function replace_leading_tab(s){
      /*<<arg.ml:347:2>>*/  /*<<arg.ml:347:13>>*/ var seen = [0, 0];
-    function _P_(c){
+    function _Q_(c){
       /*<<arg.ml:348:13>>*/ if(9 === c && ! seen[1]){
       seen[1] = 1;
        /*<<arg.ml:348:60>>*/ return 32;
@@ -21392,7 +21439,7 @@
       /*<<arg.ml:348:71>>*/ return c;
      /*<<arg.ml:348:73>>*/ }
      /*<<arg.ml:348:2>>*/ return  /*<<arg.ml:348:2>>*/ caml_call2
-            (Stdlib_String[18], _P_, s);
+            (Stdlib_String[18], _Q_, s);
     /*<<arg.ml:348:75>>*/ }
    function align(opt, speclist){
      /*<<arg.ml:374:2>>*/ if(opt)
@@ -21406,7 +21453,7 @@
         (Stdlib_List[26], max_arg_len, 0, completed),
       /*<<arg.ml:376:12>>*/ len$0 =
         /*<<arg.ml:376:12>>*/ caml_call2(Stdlib_Int[10], len, limit);
-     /*<<arg.ml:377:11>>*/ function _J_(ksd){
+     /*<<arg.ml:377:11>>*/ function _K_(ksd){
      var kwd = ksd[1], spec = ksd[2];
      if(! caml_string_notequal(ksd[3], cst$8))
        /*<<arg.ml:355:6>>*/ return ksd;
@@ -21414,20 +21461,20 @@
        /*<<arg.ml:357:19>>*/ var
        msg$0 = ksd[3],
         /*<<arg.ml:357:19>>*/ cutcol$0 = second_word(msg$0),
-        /*<<arg.ml:358:32>>*/ _M_ =
+        /*<<arg.ml:358:32>>*/ _N_ =
           /*<<arg.ml:358:32>>*/ caml_call2
           (Stdlib_Int[11], 0, len$0 - cutcol$0 | 0)
          + 3
          | 0,
         /*<<arg.ml:358:19>>*/ spaces$0 =
-          /*<<arg.ml:358:19>>*/ caml_call2(Stdlib_String[1], _M_, 32),
-        /*<<arg.ml:359:34>>*/ _N_ = replace_leading_tab(msg$0),
-        /*<<arg.ml:359:25>>*/ _O_ =
-          /*<<arg.ml:359:25>>*/ caml_call2(Stdlib[28], spaces$0, _N_);
+          /*<<arg.ml:358:19>>*/ caml_call2(Stdlib_String[1], _N_, 32),
+        /*<<arg.ml:359:34>>*/ _O_ = replace_leading_tab(msg$0),
+        /*<<arg.ml:359:25>>*/ _P_ =
+          /*<<arg.ml:359:25>>*/ caml_call2(Stdlib[28], spaces$0, _O_);
        /*<<arg.ml:359:6>>*/ return [0,
               kwd,
               spec,
-               /*<<arg.ml:359:18>>*/ caml_call2(Stdlib[28], cst$7, _O_)];
+               /*<<arg.ml:359:18>>*/ caml_call2(Stdlib[28], cst$7, _P_)];
      }
       /*<<arg.ml:361:19>>*/ var
       msg = ksd[3],
@@ -21441,24 +21488,24 @@
       /*<<arg.ml:367:21>>*/ var
        /*<<arg.ml:367:21>>*/ spaces =
          /*<<arg.ml:367:21>>*/ caml_call2(Stdlib_String[1], diff, 32),
-       /*<<arg.ml:368:32>>*/ _K_ = replace_leading_tab(msg),
+       /*<<arg.ml:368:32>>*/ _L_ = replace_leading_tab(msg),
        /*<<arg.ml:368:21>>*/ prefix =
-         /*<<arg.ml:368:21>>*/ caml_call3(Stdlib_String[16], _K_, 0, cutcol),
+         /*<<arg.ml:368:21>>*/ caml_call3(Stdlib_String[16], _L_, 0, cutcol),
        /*<<arg.ml:369:21>>*/ suffix =
          /*<<arg.ml:369:21>>*/ caml_call3
          (Stdlib_String[16],
           msg,
           cutcol,
           caml_ml_string_length(msg) - cutcol | 0),
-       /*<<arg.ml:370:29>>*/ _L_ =
+       /*<<arg.ml:370:29>>*/ _M_ =
          /*<<arg.ml:370:29>>*/ caml_call2(Stdlib[28], spaces, suffix);
       /*<<arg.ml:370:8>>*/ return [0,
              kwd,
              spec$0,
-              /*<<arg.ml:370:20>>*/ caml_call2(Stdlib[28], prefix, _L_)];
+              /*<<arg.ml:370:20>>*/ caml_call2(Stdlib[28], prefix, _M_)];
     }
      /*<<arg.ml:377:2>>*/ return  /*<<arg.ml:377:2>>*/ caml_call2
-            (Stdlib_List[20], _J_, completed);
+            (Stdlib_List[20], _K_, completed);
     /*<<arg.ml:377:38>>*/ }
    function read_aux(trim, sep, file){
      /*<<arg.ml:387:2>>*/ var
@@ -21478,20 +21525,21 @@
         (0 < len
          && 13 ===  /*<<arg.ml:381:16>>*/ caml_string_get(word, len - 1 | 0)){
         var
-         _I_ =
+         _J_ =
             /*<<arg.ml:382:4>>*/ caml_call3
             (Stdlib_String[16], word, 0, len - 1 | 0);
         break a;
        }
-       var _I_ = word;
+       var _J_ = word;
       }
-      var word$0 = _I_;
+      var word$0 = _J_;
      }
      else
       var word$0 = word;
      words[1] = [0, word$0, words[1]];
-      /*<<arg.ml:390:2>>*/ return  /*<<arg.ml:390:2>>*/ caml_call1
-             (Stdlib_Buffer[8], buf);
+      /*<<arg.ml:390:2>>*/  /*<<arg.ml:390:2>>*/ caml_call1
+      (Stdlib_Buffer[8], buf);
+      /*<<arg.ml:390:2>>*/ return;
      /*<<arg.ml:394:20>>*/ }
      /*<<arg.ml:396:2>>*/ try{
      for(;;){
@@ -21504,45 +21552,45 @@
         (Stdlib_Buffer[12], buf, c);
      }
     }
-    catch(_H_){
-     var _F_ = caml_wrap_exception(_H_);
-     if(_F_ !== Stdlib[12]) throw caml_maybe_attach_backtrace(_F_, 0);
+    catch(_I_){
+     var _G_ = caml_wrap_exception(_I_);
+     if(_G_ !== Stdlib[12]) throw caml_maybe_attach_backtrace(_G_, 0);
      if(0 <  /*<<arg.ml:403:5>>*/ caml_call1(Stdlib_Buffer[7], buf))
        /*<<arg.ml:403:32>>*/ stash(0);
       /*<<arg.ml:404:2>>*/  /*<<arg.ml:404:2>>*/ caml_call1(Stdlib[93], ic);
       /*<<arg.ml:405:16>>*/  /*<<arg.ml:405:16>>*/ var
-      _G_ =  /*<<arg.ml:405:16>>*/ caml_call1(Stdlib_List[10], words[1]);
+      _H_ =  /*<<arg.ml:405:16>>*/ caml_call1(Stdlib_List[10], words[1]);
       /*<<arg.ml:405:16>>*/ return  /*<<arg.ml:405:16>>*/ caml_call1
-             (Stdlib_Array[10], _G_);
+             (Stdlib_Array[10], _H_);
     }
     /*<<arg.ml:405:33>>*/ }
    var _r_ = 10, _s_ = 1;
-    /*<<arg.ml:407:15>>*/ function read_arg(_E_){
-     /*<<?>>*/ return read_aux(_s_, _r_, _E_);
+    /*<<arg.ml:407:15>>*/ function read_arg(_F_){
+     /*<<?>>*/ return read_aux(_s_, _r_, _F_);
    }
     /*<<arg.ml:407:15>>*/ var  /*<<arg.ml:407:15>>*/ _t_ = 0, _u_ = 0;
-    /*<<arg.ml:409:16>>*/ function read_arg0(_D_){
-     /*<<?>>*/ return read_aux(_u_, _t_, _D_);
+    /*<<arg.ml:409:16>>*/ function read_arg0(_E_){
+     /*<<?>>*/ return read_aux(_u_, _t_, _E_);
    }
    function write_aux(sep, file, args){
      /*<<arg.ml:412:2>>*/  /*<<arg.ml:412:11>>*/ var
      oc =  /*<<arg.ml:412:11>>*/ caml_call1(Stdlib[61], file);
-    function _C_(s){
+    function _D_(s){
       /*<<arg.ml:413:23>>*/ return caml_call4
              (Stdlib_Printf[1], oc, _v_, s, sep);
      /*<<arg.ml:413:46>>*/ }
      /*<<arg.ml:413:2>>*/  /*<<arg.ml:413:2>>*/ caml_call2
-     (Stdlib_Array[11], _C_, args);
+     (Stdlib_Array[11], _D_, args);
      /*<<arg.ml:413:2>>*/ return  /*<<arg.ml:413:2>>*/ caml_call1
             (Stdlib[76], oc);
     /*<<arg.ml:414:14>>*/ }
    var _w_ = 10;
-    /*<<arg.ml:416:16>>*/ function write_arg(_A_, _B_){
-     /*<<?>>*/ return write_aux(_w_, _A_, _B_);
+    /*<<arg.ml:416:16>>*/ function write_arg(_B_, _C_){
+     /*<<?>>*/ return write_aux(_w_, _B_, _C_);
    }
     /*<<arg.ml:416:16>>*/  /*<<arg.ml:416:16>>*/ var _x_ = 0;
-    /*<<arg.ml:418:17>>*/ function write_arg0(_y_, _z_){
-     /*<<?>>*/ return write_aux(_x_, _y_, _z_);
+    /*<<arg.ml:418:17>>*/ function write_arg0(_z_, _A_){
+     /*<<?>>*/ return write_aux(_x_, _z_, _A_);
    }
    var
     Stdlib_Arg =
@@ -22208,6 +22256,7 @@
     global_data = runtime.caml_get_global_data(),
     Stdlib_Printexc = global_data.Stdlib__Printexc,
     Stdlib = global_data.Stdlib,
+    _b_ = undefined,
     cst_Fun_Finally_raised = "Fun.Finally_raised: ",
     cst_Stdlib_Fun_Finally_raised = "Stdlib.Fun.Finally_raised";
    function const$0(c, param){
@@ -22238,9 +22287,8 @@
    function protect(finally$0, work){
     function finally_no_exn(param){
       /*<<fun.ml:29:4>>*/ try{
-       /*<<fun.ml:29:8>>*/  /*<<fun.ml:29:8>>*/ var
-       _b_ =  /*<<fun.ml:29:8>>*/ caml_call1(finally$0, 0);
-       /*<<fun.ml:29:8>>*/ return _b_;
+       /*<<fun.ml:29:8>>*/  /*<<fun.ml:29:8>>*/ caml_call1(finally$0, 0);
+       /*<<fun.ml:29:8>>*/ return;
      }
      catch(e$0){
        /*<<fun.ml:30:15>>*/ var
@@ -22700,6 +22748,7 @@
             : runtime.caml_call_gen(f, [a0, a1, a2]);
    }
    var
+    _a_ = undefined,
     global_data = runtime.caml_get_global_data(),
     Stdlib = global_data.Stdlib,
     Stdlib_Array = global_data.Stdlib__Array,
@@ -22756,45 +22805,49 @@
    }
    var c_layout = 0, fortran_layout = 1;
    function cloop(arr, idx, f, col, max){
-     /*<<bigarray.ml:104:4>>*/ if(col === idx.length - 1)
-      /*<<bigarray.ml:104:35>>*/ return  /*<<bigarray.ml:104:35>>*/ caml_ba_set_generic
-             (arr, idx,  /*<<bigarray.ml:104:47>>*/ caml_call1(f, idx));
+     /*<<bigarray.ml:104:4>>*/ if(col === idx.length - 1){
+      /*<<bigarray.ml:104:35>>*/  /*<<bigarray.ml:104:35>>*/ caml_ba_set_generic
+      (arr, idx,  /*<<bigarray.ml:104:47>>*/ caml_call1(f, idx));
+      /*<<bigarray.ml:104:35>>*/ return;
+    }
      /*<<bigarray.ml:105:27>>*/ var
-      /*<<bigarray.ml:105:27>>*/ _am_ =
+      /*<<bigarray.ml:105:27>>*/ _an_ =
        caml_check_bound(max, col)[1 + col] - 1 | 0,
-      /*<<bigarray.ml:105:9>>*/ _al_ = 0;
-    if(_am_ >= 0){
-     var j = _al_;
+      /*<<bigarray.ml:105:9>>*/ _am_ = 0;
+    if(_an_ >= 0){
+     var j = _am_;
      for(;;){
        /*<<bigarray.ml:106:11>>*/ caml_check_bound(idx, col)[1 + col] = j;
        /*<<bigarray.ml:107:11>>*/ cloop(arr, idx, f, col + 1 | 0, max);
        /*<<bigarray.ml:107:11>>*/  /*<<bigarray.ml:107:11>>*/ var
-       _an_ = j + 1 | 0;
-      if(_am_ === j) break;
-      var j = _an_;
+       _ao_ = j + 1 | 0;
+      if(_an_ === j) break;
+      var j = _ao_;
      }
     }
-    return 0;
+    return;
     /*<<bigarray.ml:108:13>>*/ }
    function floop(arr, idx, f, col, max){
-     /*<<bigarray.ml:110:4>>*/ if(0 > col)
-      /*<<bigarray.ml:110:20>>*/ return  /*<<bigarray.ml:110:20>>*/ caml_ba_set_generic
-             (arr, idx,  /*<<bigarray.ml:110:32>>*/ caml_call1(f, idx));
+     /*<<bigarray.ml:110:4>>*/ if(0 > col){
+      /*<<bigarray.ml:110:20>>*/  /*<<bigarray.ml:110:20>>*/ caml_ba_set_generic
+      (arr, idx,  /*<<bigarray.ml:110:32>>*/ caml_call1(f, idx));
+      /*<<bigarray.ml:110:20>>*/ return;
+    }
      /*<<bigarray.ml:111:22>>*/ var
-      /*<<bigarray.ml:111:22>>*/ _aj_ = caml_check_bound(max, col)[1 + col],
-      /*<<bigarray.ml:111:9>>*/ _ai_ = 1;
-    if(_aj_ >= 1){
-     var j = _ai_;
+      /*<<bigarray.ml:111:22>>*/ _ak_ = caml_check_bound(max, col)[1 + col],
+      /*<<bigarray.ml:111:9>>*/ _aj_ = 1;
+    if(_ak_ >= 1){
+     var j = _aj_;
      for(;;){
        /*<<bigarray.ml:112:11>>*/ caml_check_bound(idx, col)[1 + col] = j;
        /*<<bigarray.ml:113:11>>*/ floop(arr, idx, f, col - 1 | 0, max);
        /*<<bigarray.ml:113:11>>*/  /*<<bigarray.ml:113:11>>*/ var
-       _ak_ = j + 1 | 0;
-      if(_aj_ === j) break;
-      var j = _ak_;
+       _al_ = j + 1 | 0;
+      if(_ak_ === j) break;
+      var j = _al_;
      }
     }
-    return 0;
+    return;
     /*<<bigarray.ml:114:13>>*/ }
    function init(kind, layout, dims, f){
      /*<<bigarray.ml:116:4>>*/ var
@@ -22823,31 +22876,31 @@
         /*<<bigarray.ml:125:12>>*/ caml_ba_num_dims(a),
       /*<<bigarray.ml:126:12>>*/ d =
         /*<<bigarray.ml:126:12>>*/ caml_make_vect(n, 0),
-      /*<<bigarray.ml:127:4>>*/ _af_ = n - 1 | 0,
-      /*<<bigarray.ml:126:12>>*/ _ae_ = 0;
-    if(_af_ >= 0){
-     var i = _ae_;
+      /*<<bigarray.ml:127:4>>*/ _ag_ = n - 1 | 0,
+      /*<<bigarray.ml:126:12>>*/ _af_ = 0;
+    if(_ag_ >= 0){
+     var i = _af_;
      for(;;){
        /*<<bigarray.ml:127:33>>*/  /*<<bigarray.ml:127:33>>*/ var
-       _ag_ =  /*<<bigarray.ml:127:33>>*/ runtime.caml_ba_dim(a, i);
-       /*<<bigarray.ml:127:24>>*/ caml_check_bound(d, i)[1 + i] = _ag_;
+       _ah_ =  /*<<bigarray.ml:127:33>>*/ runtime.caml_ba_dim(a, i);
+       /*<<bigarray.ml:127:24>>*/ caml_check_bound(d, i)[1 + i] = _ah_;
        /*<<bigarray.ml:127:24>>*/  /*<<bigarray.ml:127:24>>*/ var
-       _ah_ = i + 1 | 0;
-      if(_af_ === i) break;
-      var i = _ah_;
+       _ai_ = i + 1 | 0;
+      if(_ag_ === i) break;
+      var i = _ai_;
      }
     }
      /*<<bigarray.ml:128:4>>*/ return d;
     /*<<bigarray.ml:128:5>>*/ }
    function size_in_bytes(arr){
      /*<<bigarray.ml:136:4>>*/ var
-      /*<<bigarray.ml:136:63>>*/ _ac_ = dims(arr),
-      /*<<bigarray.ml:136:38>>*/ _ad_ =
+      /*<<bigarray.ml:136:63>>*/ _ad_ = dims(arr),
+      /*<<bigarray.ml:136:38>>*/ _ae_ =
         /*<<bigarray.ml:136:38>>*/ caml_call3
-        (Stdlib_Array[17], caml_mul, 1, _ac_);
+        (Stdlib_Array[17], caml_mul, 1, _ad_);
      /*<<bigarray.ml:136:4>>*/ return  /*<<bigarray.ml:136:4>>*/ caml_mul
             (kind_size_in_bytes( /*<<bigarray.ml:136:24>>*/ caml_ba_kind(arr)),
-             _ad_);
+             _ae_);
     /*<<bigarray.ml:136:74>>*/ }
    function create(kind, layout){
      /*<<bigarray.ml:157:4>>*/ return  /*<<bigarray.ml:157:4>>*/ caml_ba_create
@@ -22858,9 +22911,9 @@
             (arr, [0]);
     /*<<bigarray.ml:158:37>>*/ }
    function set(arr){
-     /*<<bigarray.ml:159:16>>*/  /*<<bigarray.ml:159:16>>*/ var _aa_ = [0];
-     /*<<bigarray.ml:159:33>>*/ return function(_ab_){
-      /*<<?>>*/ return caml_ba_set_generic(arr, _aa_, _ab_);};
+     /*<<bigarray.ml:159:16>>*/  /*<<bigarray.ml:159:16>>*/ var _ab_ = [0];
+     /*<<bigarray.ml:159:33>>*/ return function(_ac_){
+      /*<<?>>*/ return caml_ba_set_generic(arr, _ab_, _ac_);};
     /*<<bigarray.ml:159:37>>*/ }
    function size_in_bytes$0(arr){
      /*<<bigarray.ml:166:26>>*/ return kind_size_in_bytes
@@ -22878,10 +22931,10 @@
     /*<<bigarray.ml:181:39>>*/ }
    function size_in_bytes$1(arr){
      /*<<bigarray.ml:195:4>>*/  /*<<bigarray.ml:195:38>>*/ var
-     _$_ =  /*<<bigarray.ml:195:38>>*/ caml_ba_dim_1(arr);
+     _aa_ =  /*<<bigarray.ml:195:38>>*/ caml_ba_dim_1(arr);
      /*<<bigarray.ml:195:4>>*/ return  /*<<bigarray.ml:195:4>>*/ caml_mul
             (kind_size_in_bytes( /*<<bigarray.ml:195:24>>*/ caml_ba_kind(arr)),
-             _$_);
+             _aa_);
     /*<<bigarray.ml:195:47>>*/ }
    function slice(a, n){
      /*<<bigarray.ml:199:4>>*/ return  /*<<bigarray.ml:199:10>>*/ runtime.caml_ba_layout
@@ -22893,32 +22946,32 @@
      /*<<bigarray.ml:209:4>>*/  /*<<bigarray.ml:209:14>>*/ var
      arr = create$0(kind, layout, dim);
      /*<<bigarray.ml:210:4>>*/ if(layout){
-      /*<<bigarray.ml:207:4>>*/  /*<<bigarray.ml:207:4>>*/ var _Z_ = 1;
+      /*<<bigarray.ml:207:4>>*/  /*<<bigarray.ml:207:4>>*/ var ___ = 1;
      if(dim >= 1){
-      var i$0 = _Z_;
+      var i$0 = ___;
       for(;;){
         /*<<bigarray.ml:207:24>>*/  /*<<bigarray.ml:207:24>>*/ caml_ba_set_1
         (arr, i$0,  /*<<bigarray.ml:207:41>>*/ caml_call1(f, i$0));
         /*<<bigarray.ml:207:24>>*/  /*<<bigarray.ml:207:24>>*/ var
-        ___ = i$0 + 1 | 0;
+        _$_ = i$0 + 1 | 0;
        if(dim === i$0) break;
-       var i$0 = ___;
+       var i$0 = _$_;
       }
      }
       /*<<bigarray.ml:212:24>>*/ return arr;
     }
      /*<<bigarray.ml:205:4>>*/ var
-     _X_ = dim - 1 | 0,
-      /*<<bigarray.ml:205:4>>*/ _W_ = 0;
-    if(_X_ >= 0){
-     var i = _W_;
+     _Y_ = dim - 1 | 0,
+      /*<<bigarray.ml:205:4>>*/ _X_ = 0;
+    if(_Y_ >= 0){
+     var i = _X_;
      for(;;){
        /*<<bigarray.ml:205:29>>*/  /*<<bigarray.ml:205:29>>*/ caml_ba_set_1
        (arr, i,  /*<<bigarray.ml:205:46>>*/ caml_call1(f, i));
        /*<<bigarray.ml:205:29>>*/  /*<<bigarray.ml:205:29>>*/ var
-       _Y_ = i + 1 | 0;
-      if(_X_ === i) break;
-      var i = _Y_;
+       _Z_ = i + 1 | 0;
+      if(_Y_ === i) break;
+      var i = _Z_;
      }
     }
      /*<<bigarray.ml:211:18>>*/ return arr;
@@ -22927,17 +22980,17 @@
      /*<<bigarray.ml:214:4>>*/ var
       /*<<bigarray.ml:214:13>>*/ ba = create$0(kind, layout, data.length - 1),
       /*<<bigarray.ml:215:4>>*/ ofs = layout ? 1 : 0,
-     _U_ = data.length - 1 - 1 | 0,
-     _T_ = 0;
-    if(_U_ >= 0){
-     var i = _T_;
+     _V_ = data.length - 1 - 1 | 0,
+     _U_ = 0;
+    if(_V_ >= 0){
+     var i = _U_;
      for(;;){
        /*<<bigarray.ml:220:42>>*/  /*<<bigarray.ml:220:42>>*/ caml_ba_set_1
        (ba, i + ofs | 0, caml_check_bound(data, i)[1 + i]);
        /*<<bigarray.ml:220:42>>*/  /*<<bigarray.ml:220:42>>*/ var
-       _V_ = i + 1 | 0;
-      if(_U_ === i) break;
-      var i = _V_;
+       _W_ = i + 1 | 0;
+      if(_V_ === i) break;
+      var i = _W_;
      }
     }
      /*<<bigarray.ml:221:4>>*/ return ba;
@@ -22948,16 +23001,16 @@
     /*<<bigarray.ml:227:46>>*/ }
    function size_in_bytes$2(arr){
      /*<<bigarray.ml:243:4>>*/ var
-      /*<<bigarray.ml:243:51>>*/ _R_ =
+      /*<<bigarray.ml:243:51>>*/ _S_ =
         /*<<bigarray.ml:243:51>>*/ caml_ba_dim_2(arr),
-      /*<<bigarray.ml:243:38>>*/ _S_ =
+      /*<<bigarray.ml:243:38>>*/ _T_ =
         /*<<bigarray.ml:243:38>>*/ caml_ba_dim_1(arr);
     return caml_mul
             ( /*<<bigarray.ml:243:4>>*/ caml_mul
               (kind_size_in_bytes
                 ( /*<<bigarray.ml:243:24>>*/ caml_ba_kind(arr)),
-               _S_),
-             _R_);
+               _T_),
+             _S_);
     /*<<bigarray.ml:243:61>>*/ }
    function slice_left(a, n){
      /*<<bigarray.ml:250:23>>*/ return  /*<<bigarray.ml:250:23>>*/ caml_ba_slice
@@ -22971,54 +23024,54 @@
      /*<<bigarray.ml:267:4>>*/  /*<<bigarray.ml:267:14>>*/ var
      arr = create$1(kind, layout, dim1, dim2);
      /*<<bigarray.ml:268:4>>*/ if(layout){
-      /*<<bigarray.ml:261:4>>*/  /*<<bigarray.ml:261:4>>*/ var _N_ = 1;
+      /*<<bigarray.ml:261:4>>*/  /*<<bigarray.ml:261:4>>*/ var _O_ = 1;
      if(dim2 >= 1){
-      var j$0 = _N_;
+      var j$0 = _O_;
       for(;;){
-        /*<<bigarray.ml:262:6>>*/  /*<<bigarray.ml:262:6>>*/ var _O_ = 1;
+        /*<<bigarray.ml:262:6>>*/  /*<<bigarray.ml:262:6>>*/ var _P_ = 1;
        if(dim1 >= 1){
-        var i$0 = _O_;
+        var i$0 = _P_;
         for(;;){
           /*<<bigarray.ml:263:8>>*/  /*<<bigarray.ml:263:8>>*/ caml_ba_set_2
           (arr, i$0, j$0,  /*<<bigarray.ml:263:27>>*/ caml_call2(f, i$0, j$0));
           /*<<bigarray.ml:263:8>>*/  /*<<bigarray.ml:263:8>>*/ var
-          _Q_ = i$0 + 1 | 0;
+          _R_ = i$0 + 1 | 0;
          if(dim1 === i$0) break;
-         var i$0 = _Q_;
+         var i$0 = _R_;
         }
        }
         /*<<bigarray.ml:261:4>>*/  /*<<bigarray.ml:261:4>>*/ var
-        _P_ = j$0 + 1 | 0;
+        _Q_ = j$0 + 1 | 0;
        if(dim2 === j$0) break;
-       var j$0 = _P_;
+       var j$0 = _Q_;
       }
      }
       /*<<bigarray.ml:270:24>>*/ return arr;
     }
      /*<<bigarray.ml:255:4>>*/ var
-     _I_ = dim1 - 1 | 0,
-      /*<<bigarray.ml:255:4>>*/ _H_ = 0;
-    if(_I_ >= 0){
-     var i = _H_;
+     _J_ = dim1 - 1 | 0,
+      /*<<bigarray.ml:255:4>>*/ _I_ = 0;
+    if(_J_ >= 0){
+     var i = _I_;
      for(;;){
        /*<<bigarray.ml:256:6>>*/ var
-       _K_ = dim2 - 1 | 0,
-        /*<<bigarray.ml:256:6>>*/ _J_ = 0;
-      if(_K_ >= 0){
-       var j = _J_;
+       _L_ = dim2 - 1 | 0,
+        /*<<bigarray.ml:256:6>>*/ _K_ = 0;
+      if(_L_ >= 0){
+       var j = _K_;
        for(;;){
          /*<<bigarray.ml:257:8>>*/  /*<<bigarray.ml:257:8>>*/ caml_ba_set_2
          (arr, i, j,  /*<<bigarray.ml:257:27>>*/ caml_call2(f, i, j));
          /*<<bigarray.ml:257:8>>*/  /*<<bigarray.ml:257:8>>*/ var
-         _M_ = j + 1 | 0;
-        if(_K_ === j) break;
-        var j = _M_;
+         _N_ = j + 1 | 0;
+        if(_L_ === j) break;
+        var j = _N_;
        }
       }
        /*<<bigarray.ml:255:4>>*/  /*<<bigarray.ml:255:4>>*/ var
-       _L_ = i + 1 | 0;
-      if(_I_ === i) break;
-      var i = _L_;
+       _M_ = i + 1 | 0;
+      if(_J_ === i) break;
+      var i = _M_;
      }
     }
      /*<<bigarray.ml:269:18>>*/ return arr;
@@ -23030,10 +23083,10 @@
        0 === dim1 ? 0 : caml_check_bound(data, 0)[1].length - 1,
       /*<<bigarray.ml:274:13>>*/ ba = create$1(kind, layout, dim1, dim2),
       /*<<bigarray.ml:275:4>>*/ ofs = layout ? 1 : 0,
-      /*<<bigarray.ml:280:4>>*/ _C_ = dim1 - 1 | 0,
-     _B_ = 0;
-    if(_C_ >= 0){
-     var i = _B_;
+      /*<<bigarray.ml:280:4>>*/ _D_ = dim1 - 1 | 0,
+     _C_ = 0;
+    if(_D_ >= 0){
+     var i = _C_;
      for(;;){
        /*<<bigarray.ml:281:16>>*/  /*<<bigarray.ml:281:16>>*/ var
        row = caml_check_bound(data, i)[1 + i];
@@ -23041,23 +23094,23 @@
         /*<<bigarray.ml:283:8>>*/  /*<<bigarray.ml:283:8>>*/ caml_call1
         (Stdlib[1], cst_Bigarray_Array2_of_array_n);
        /*<<bigarray.ml:273:32>>*/ var
-        /*<<bigarray.ml:273:32>>*/ _E_ = dim2 - 1 | 0,
-        /*<<bigarray.ml:283:8>>*/ _D_ = 0;
-      if(_E_ >= 0){
-       var j = _D_;
+        /*<<bigarray.ml:273:32>>*/ _F_ = dim2 - 1 | 0,
+        /*<<bigarray.ml:283:8>>*/ _E_ = 0;
+      if(_F_ >= 0){
+       var j = _E_;
        for(;;){
          /*<<bigarray.ml:285:8>>*/  /*<<bigarray.ml:285:8>>*/ caml_ba_set_2
          (ba, i + ofs | 0, j + ofs | 0, caml_check_bound(row, j)[1 + j]);
          /*<<bigarray.ml:285:8>>*/  /*<<bigarray.ml:285:8>>*/ var
-         _G_ = j + 1 | 0;
-        if(_E_ === j) break;
-        var j = _G_;
+         _H_ = j + 1 | 0;
+        if(_F_ === j) break;
+        var j = _H_;
        }
       }
        /*<<bigarray.ml:280:4>>*/  /*<<bigarray.ml:280:4>>*/ var
-       _F_ = i + 1 | 0;
-      if(_C_ === i) break;
-      var i = _F_;
+       _G_ = i + 1 | 0;
+      if(_D_ === i) break;
+      var i = _G_;
      }
     }
      /*<<bigarray.ml:288:4>>*/ return ba;
@@ -23068,20 +23121,20 @@
     /*<<bigarray.ml:294:52>>*/ }
    function size_in_bytes$3(arr){
      /*<<bigarray.ml:312:4>>*/ var
-      /*<<bigarray.ml:312:64>>*/ _y_ =
+      /*<<bigarray.ml:312:64>>*/ _z_ =
         /*<<bigarray.ml:312:64>>*/ runtime.caml_ba_dim_3(arr),
-      /*<<bigarray.ml:312:51>>*/ _z_ =
+      /*<<bigarray.ml:312:51>>*/ _A_ =
         /*<<bigarray.ml:312:51>>*/ caml_ba_dim_2(arr),
-      /*<<bigarray.ml:312:38>>*/ _A_ =
+      /*<<bigarray.ml:312:38>>*/ _B_ =
         /*<<bigarray.ml:312:38>>*/ caml_ba_dim_1(arr);
     return caml_mul
             (caml_mul
               ( /*<<bigarray.ml:312:4>>*/ caml_mul
                 (kind_size_in_bytes
                   ( /*<<bigarray.ml:312:24>>*/ caml_ba_kind(arr)),
-                 _A_),
-               _z_),
-             _y_);
+                 _B_),
+               _A_),
+             _z_);
     /*<<bigarray.ml:312:74>>*/ }
    function slice_left_1(a, n, m){
      /*<<bigarray.ml:319:27>>*/ return  /*<<bigarray.ml:319:27>>*/ caml_ba_slice
@@ -23103,17 +23156,17 @@
      /*<<bigarray.ml:342:4>>*/  /*<<bigarray.ml:342:14>>*/ var
      arr = create$2(kind, layout, dim1, dim2, dim3);
      /*<<bigarray.ml:343:4>>*/ if(layout){
-      /*<<bigarray.ml:334:4>>*/  /*<<bigarray.ml:334:4>>*/ var _s_ = 1;
+      /*<<bigarray.ml:334:4>>*/  /*<<bigarray.ml:334:4>>*/ var _t_ = 1;
      if(dim3 >= 1){
-      var k$0 = _s_;
+      var k$0 = _t_;
       for(;;){
-        /*<<bigarray.ml:335:6>>*/  /*<<bigarray.ml:335:6>>*/ var _t_ = 1;
+        /*<<bigarray.ml:335:6>>*/  /*<<bigarray.ml:335:6>>*/ var _u_ = 1;
        if(dim2 >= 1){
-        var j$0 = _t_;
+        var j$0 = _u_;
         for(;;){
-          /*<<bigarray.ml:336:8>>*/  /*<<bigarray.ml:336:8>>*/ var _v_ = 1;
+          /*<<bigarray.ml:336:8>>*/  /*<<bigarray.ml:336:8>>*/ var _w_ = 1;
          if(dim1 >= 1){
-          var i$0 = _v_;
+          var i$0 = _w_;
           for(;;){
             /*<<bigarray.ml:337:10>>*/  /*<<bigarray.ml:337:10>>*/ caml_ba_set_3
             (arr,
@@ -23122,61 +23175,61 @@
              k$0,
               /*<<bigarray.ml:337:31>>*/ caml_call3(f, i$0, j$0, k$0));
             /*<<bigarray.ml:337:10>>*/  /*<<bigarray.ml:337:10>>*/ var
-            _x_ = i$0 + 1 | 0;
+            _y_ = i$0 + 1 | 0;
            if(dim1 === i$0) break;
-           var i$0 = _x_;
+           var i$0 = _y_;
           }
          }
           /*<<bigarray.ml:335:6>>*/  /*<<bigarray.ml:335:6>>*/ var
-          _w_ = j$0 + 1 | 0;
+          _x_ = j$0 + 1 | 0;
          if(dim2 === j$0) break;
-         var j$0 = _w_;
+         var j$0 = _x_;
         }
        }
         /*<<bigarray.ml:334:4>>*/  /*<<bigarray.ml:334:4>>*/ var
-        _u_ = k$0 + 1 | 0;
+        _v_ = k$0 + 1 | 0;
        if(dim3 === k$0) break;
-       var k$0 = _u_;
+       var k$0 = _v_;
       }
      }
       /*<<bigarray.ml:345:24>>*/ return arr;
     }
      /*<<bigarray.ml:326:4>>*/ var
-     _k_ = dim1 - 1 | 0,
-      /*<<bigarray.ml:326:4>>*/ _j_ = 0;
-    if(_k_ >= 0){
-     var i = _j_;
+     _l_ = dim1 - 1 | 0,
+      /*<<bigarray.ml:326:4>>*/ _k_ = 0;
+    if(_l_ >= 0){
+     var i = _k_;
      for(;;){
        /*<<bigarray.ml:327:6>>*/ var
-       _m_ = dim2 - 1 | 0,
-        /*<<bigarray.ml:327:6>>*/ _l_ = 0;
-      if(_m_ >= 0){
-       var j = _l_;
+       _n_ = dim2 - 1 | 0,
+        /*<<bigarray.ml:327:6>>*/ _m_ = 0;
+      if(_n_ >= 0){
+       var j = _m_;
        for(;;){
          /*<<bigarray.ml:328:8>>*/ var
-         _p_ = dim3 - 1 | 0,
-          /*<<bigarray.ml:328:8>>*/ _o_ = 0;
-        if(_p_ >= 0){
-         var k = _o_;
+         _q_ = dim3 - 1 | 0,
+          /*<<bigarray.ml:328:8>>*/ _p_ = 0;
+        if(_q_ >= 0){
+         var k = _p_;
          for(;;){
            /*<<bigarray.ml:329:10>>*/  /*<<bigarray.ml:329:10>>*/ caml_ba_set_3
            (arr, i, j, k,  /*<<bigarray.ml:329:31>>*/ caml_call3(f, i, j, k));
            /*<<bigarray.ml:329:10>>*/  /*<<bigarray.ml:329:10>>*/ var
-           _r_ = k + 1 | 0;
-          if(_p_ === k) break;
-          var k = _r_;
+           _s_ = k + 1 | 0;
+          if(_q_ === k) break;
+          var k = _s_;
          }
         }
          /*<<bigarray.ml:327:6>>*/  /*<<bigarray.ml:327:6>>*/ var
-         _q_ = j + 1 | 0;
-        if(_m_ === j) break;
-        var j = _q_;
+         _r_ = j + 1 | 0;
+        if(_n_ === j) break;
+        var j = _r_;
        }
       }
        /*<<bigarray.ml:326:4>>*/  /*<<bigarray.ml:326:4>>*/ var
-       _n_ = i + 1 | 0;
-      if(_k_ === i) break;
-      var i = _n_;
+       _o_ = i + 1 | 0;
+      if(_l_ === i) break;
+      var i = _o_;
      }
     }
      /*<<bigarray.ml:344:18>>*/ return arr;
@@ -23192,10 +23245,10 @@
         : caml_check_bound(caml_check_bound(data, 0)[1], 0)[1].length - 1,
       /*<<bigarray.ml:350:13>>*/ ba = create$2(kind, layout, dim1, dim2, dim3),
       /*<<bigarray.ml:351:4>>*/ ofs = layout ? 1 : 0,
-      /*<<bigarray.ml:356:4>>*/ _b_ = dim1 - 1 | 0,
-     _a_ = 0;
-    if(_b_ >= 0){
-     var i = _a_;
+      /*<<bigarray.ml:356:4>>*/ _c_ = dim1 - 1 | 0,
+     _b_ = 0;
+    if(_c_ >= 0){
+     var i = _b_;
      for(;;){
        /*<<bigarray.ml:357:16>>*/  /*<<bigarray.ml:357:16>>*/ var
        row = caml_check_bound(data, i)[1 + i];
@@ -23203,10 +23256,10 @@
         /*<<bigarray.ml:359:8>>*/  /*<<bigarray.ml:359:8>>*/ caml_call1
         (Stdlib[1], cst_Bigarray_Array3_of_array_n);
        /*<<bigarray.ml:348:32>>*/ var
-        /*<<bigarray.ml:348:32>>*/ _d_ = dim2 - 1 | 0,
-        /*<<bigarray.ml:359:8>>*/ _c_ = 0;
-      if(_d_ >= 0){
-       var j = _c_;
+        /*<<bigarray.ml:348:32>>*/ _e_ = dim2 - 1 | 0,
+        /*<<bigarray.ml:359:8>>*/ _d_ = 0;
+      if(_e_ >= 0){
+       var j = _d_;
        for(;;){
          /*<<bigarray.ml:361:18>>*/  /*<<bigarray.ml:361:18>>*/ var
          col = caml_check_bound(row, j)[1 + j];
@@ -23214,10 +23267,10 @@
           /*<<bigarray.ml:363:10>>*/  /*<<bigarray.ml:363:10>>*/ caml_call1
           (Stdlib[1], cst_Bigarray_Array3_of_array_n$0);
          /*<<bigarray.ml:349:32>>*/ var
-          /*<<bigarray.ml:349:32>>*/ _g_ = dim3 - 1 | 0,
-          /*<<bigarray.ml:363:10>>*/ _f_ = 0;
-        if(_g_ >= 0){
-         var k = _f_;
+          /*<<bigarray.ml:349:32>>*/ _h_ = dim3 - 1 | 0,
+          /*<<bigarray.ml:363:10>>*/ _g_ = 0;
+        if(_h_ >= 0){
+         var k = _g_;
          for(;;){
            /*<<bigarray.ml:365:10>>*/  /*<<bigarray.ml:365:10>>*/ caml_ba_set_3
            (ba,
@@ -23226,21 +23279,21 @@
             k + ofs | 0,
             caml_check_bound(col, k)[1 + k]);
            /*<<bigarray.ml:365:10>>*/  /*<<bigarray.ml:365:10>>*/ var
-           _i_ = k + 1 | 0;
-          if(_g_ === k) break;
-          var k = _i_;
+           _j_ = k + 1 | 0;
+          if(_h_ === k) break;
+          var k = _j_;
          }
         }
          /*<<bigarray.ml:359:8>>*/  /*<<bigarray.ml:359:8>>*/ var
-         _h_ = j + 1 | 0;
-        if(_d_ === j) break;
-        var j = _h_;
+         _i_ = j + 1 | 0;
+        if(_e_ === j) break;
+        var j = _i_;
        }
       }
        /*<<bigarray.ml:356:4>>*/  /*<<bigarray.ml:356:4>>*/ var
-       _e_ = i + 1 | 0;
-      if(_b_ === i) break;
-      var i = _e_;
+       _f_ = i + 1 | 0;
+      if(_c_ === i) break;
+      var i = _f_;
      }
     }
      /*<<bigarray.ml:369:4>>*/ return ba;
@@ -24931,6 +24984,7 @@
     Stdlib_Int = global_data.Stdlib__Int,
     Stdlib_Array = global_data.Stdlib__Array,
     Stdlib_Obj = global_data.Stdlib__Obj,
+    _a_ = undefined,
     cst_Weak_Make_hash_bucket_cann = "Weak.Make: hash bucket cannot grow more",
     cst_Weak_fill = "Weak.fill",
     cst_Weak_blit = "Weak.blit",
@@ -24941,9 +24995,9 @@
     cst_Weak_create = "Weak.create";
    function create(l){
      /*<<weak.ml:28:2>>*/ var
-     _Z_ = 0 <= l ? 1 : 0,
-     ___ = _Z_ ? l <= Stdlib_Obj[24][15] ? 1 : 0 : _Z_;
-    if(1 - ___)
+     ___ = 0 <= l ? 1 : 0,
+     _$_ = ___ ? l <= Stdlib_Obj[24][15] ? 1 : 0 : ___;
+    if(1 - _$_)
       /*<<weak.ml:29:4>>*/  /*<<weak.ml:29:4>>*/ caml_call1
       (Stdlib[1], cst_Weak_create);
      /*<<weak.ml:30:2>>*/ return  /*<<weak.ml:30:2>>*/ runtime.caml_weak_create
@@ -24954,10 +25008,12 @@
     /*<<weak.ml:33:55>>*/ }
    function raise_if_invalid_offset(e, o, msg){
      /*<<weak.ml:36:2>>*/ var
-     _W_ = 0 <= o ? 1 : 0,
-     _X_ = _W_ ? o < length(e) ? 1 : 0 : _W_,
-     _Y_ = 1 - _X_;
-    return _Y_ ?  /*<<weak.ml:37:4>>*/ caml_call1(Stdlib[1], msg) : _Y_;
+     _X_ = 0 <= o ? 1 : 0,
+     _Y_ = _X_ ? o < length(e) ? 1 : 0 : _X_,
+     _Z_ = 1 - _Y_;
+    if(! _Z_) return _Z_;
+     /*<<weak.ml:37:4>>*/  /*<<weak.ml:37:4>>*/ caml_call1(Stdlib[1], msg);
+     /*<<weak.ml:37:4>>*/ return;
     /*<<weak.ml:37:20>>*/ }
    function set(e, o, x){
      /*<<weak.ml:42:2>>*/ raise_if_invalid_offset(e, o, cst_Weak_set);
@@ -24990,13 +25046,13 @@
        0 <= o1
        && (length(e1) - l | 0) >= o1 && 0 <= o2 && (length(e2) - l | 0) >= o2){
      var
-      _U_ = 0 !== l ? 1 : 0,
-      _V_ =
-        _U_
+      _V_ = 0 !== l ? 1 : 0,
+      _W_ =
+        _V_
          ?  /*<<weak.ml:69:22>>*/ runtime.caml_ephe_blit_key
            (e1, o1, e2, o2, l)
-         : _U_;
-      /*<<weak.ml:69:22>>*/ return _V_;
+         : _V_;
+      /*<<weak.ml:69:22>>*/ return _W_;
     }
      /*<<weak.ml:68:7>>*/ return  /*<<weak.ml:68:7>>*/ caml_call1
             (Stdlib[1], cst_Weak_blit);
@@ -25004,14 +25060,14 @@
    function fill(ar, ofs, len, x){
      /*<<weak.ml:72:2>>*/ if
      (0 <= ofs && 0 <= len && (length(ar) - len | 0) >= ofs){
-     var _S_ = (ofs + len | 0) - 1 | 0;
-     if(_S_ >= ofs){
+     var _T_ = (ofs + len | 0) - 1 | 0;
+     if(_T_ >= ofs){
       var i = ofs;
       for(;;){
         /*<<weak.ml:76:6>>*/ set(ar, i, x);
-        /*<<weak.ml:76:6>>*/  /*<<weak.ml:76:6>>*/ var _T_ = i + 1 | 0;
-       if(_S_ === i) break;
-       var i = _T_;
+        /*<<weak.ml:76:6>>*/  /*<<weak.ml:76:6>>*/ var _U_ = i + 1 | 0;
+       if(_T_ === i) break;
+       var i = _U_;
       }
      }
      return 0;
@@ -25039,16 +25095,16 @@
      /*<<weak.ml:131:5>>*/ }
     function clear(t){
       /*<<weak.ml:134:4>>*/ var
-      _Q_ = t[1].length - 1 - 1 | 0,
-       /*<<weak.ml:134:4>>*/ _P_ = 0;
-     if(_Q_ >= 0){
-      var i = _P_;
+      _R_ = t[1].length - 1 - 1 | 0,
+       /*<<weak.ml:134:4>>*/ _Q_ = 0;
+     if(_R_ >= 0){
+      var i = _Q_;
       for(;;){
         /*<<weak.ml:135:6>>*/ caml_check_bound(t[1], i)[1 + i] = emptybucket;
         /*<<weak.ml:136:6>>*/ caml_check_bound(t[2], i)[1 + i] = [0];
-        /*<<weak.ml:136:6>>*/  /*<<weak.ml:136:6>>*/ var _R_ = i + 1 | 0;
-       if(_Q_ === i) break;
-       var i = _R_;
+        /*<<weak.ml:136:6>>*/  /*<<weak.ml:136:6>>*/ var _S_ = i + 1 | 0;
+       if(_R_ === i) break;
+       var i = _S_;
       }
      }
      t[3] = limit;
@@ -25056,8 +25112,8 @@
      return 0;
      /*<<weak.ml:139:19>>*/ }
     function fold(f, t, init){
-      /*<<weak.ml:143:4>>*/ var _N_ = t[1], i = 0;
-      /*<<weak.ml:149:21>>*/ function _O_(b, accu$1){
+      /*<<weak.ml:143:4>>*/ var _O_ = t[1], i = 0;
+      /*<<weak.ml:149:21>>*/ function _P_(b, accu$1){
       var i$0 = i, accu = accu$1;
        /*<<weak.ml:144:6>>*/ for(;;){
        if(length(b) <= i$0)  /*<<weak.ml:144:28>>*/ return accu;
@@ -25076,11 +25132,11 @@
       }
      }
       /*<<weak.ml:149:4>>*/ return  /*<<weak.ml:149:4>>*/ caml_call3
-             (Stdlib_Array[19], _O_, _N_, init);
+             (Stdlib_Array[19], _P_, _O_, init);
      /*<<weak.ml:149:49>>*/ }
     function iter(f, t){
-      /*<<weak.ml:153:4>>*/ var _L_ = t[1], i = 0;
-      /*<<weak.ml:159:15>>*/ function _M_(b){
+      /*<<weak.ml:153:4>>*/ var _M_ = t[1], i = 0;
+      /*<<weak.ml:159:15>>*/ function _N_(b){
       var i$0 = i;
        /*<<weak.ml:154:6>>*/ for(;;){
        if(length(b) <= i$0)  /*<<weak.ml:154:28>>*/ return 0;
@@ -25096,15 +25152,15 @@
       }
      }
       /*<<weak.ml:159:15>>*/ return  /*<<weak.ml:159:15>>*/ caml_call2
-             (Stdlib_Array[11], _M_, _L_);
+             (Stdlib_Array[11], _N_, _M_);
      /*<<weak.ml:159:38>>*/ }
     function count_bucket(i, b, accu){
       /*<<weak.ml:173:4>>*/ var i$0 = i, accu$0 = accu;
       /*<<weak.ml:173:4>>*/ for(;;){
       if(length(b) <= i$0)  /*<<weak.ml:173:26>>*/ return accu$0;
        /*<<weak.ml:174:37>>*/ var
-        /*<<weak.ml:174:37>>*/ _K_ = check(b, i$0) ? 1 : 0,
-       accu$1 = accu$0 + _K_ | 0,
+        /*<<weak.ml:174:37>>*/ _L_ = check(b, i$0) ? 1 : 0,
+       accu$1 = accu$0 + _L_ | 0,
        i$1 = i$0 + 1 | 0,
        i$0 = i$1,
        accu$0 = accu$1;
@@ -25112,14 +25168,14 @@
      /*<<weak.ml:174:62>>*/ }
     function count(t){
       /*<<weak.ml:178:4>>*/ var
-       /*<<weak.ml:178:4>>*/ _E_ = 0,
-      _F_ = t[1],
-      _G_ = 0;
-      /*<<weak.ml:178:21>>*/ function _H_(_I_, _J_){
-       /*<<?>>*/ return count_bucket(_G_, _I_, _J_);
+       /*<<weak.ml:178:4>>*/ _F_ = 0,
+      _G_ = t[1],
+      _H_ = 0;
+      /*<<weak.ml:178:21>>*/ function _I_(_J_, _K_){
+       /*<<?>>*/ return count_bucket(_H_, _J_, _K_);
      }
       /*<<weak.ml:178:4>>*/ return  /*<<weak.ml:178:4>>*/ caml_call3
-             (Stdlib_Array[19], _H_, _F_, _E_);
+             (Stdlib_Array[19], _I_, _G_, _F_);
      /*<<weak.ml:178:47>>*/ }
     function add_aux(t, setter, d, h, index){
       /*<<weak.ml:238:4>>*/ var
@@ -25152,18 +25208,18 @@
         /*<<weak.ml:252:8>>*/ caml_check_bound(newhashes, sz)[1 + sz] = h;
         /*<<weak.ml:253:8>>*/ caml_check_bound(t[1], index)[1 + index] = newbucket$0;
         /*<<weak.ml:254:8>>*/ caml_check_bound(t[2], index)[1 + index] = newhashes;
-       var _A_ = sz <= t[3] ? 1 : 0, _B_ = _A_ ? t[3] < newsz ? 1 : 0 : _A_;
-       if(_B_){
+       var _B_ = sz <= t[3] ? 1 : 0, _C_ = _B_ ? t[3] < newsz ? 1 : 0 : _B_;
+       if(_C_){
         t[4] = t[4] + 1 | 0;
         var i$4 = 0;
         for(;;){
           /*<<weak.ml:185:17>>*/ var
-          _q_ = t[5],
+          _r_ = t[5],
            /*<<weak.ml:185:17>>*/ bucket =
-            caml_check_bound(t[1], _q_)[1 + _q_],
-           /*<<weak.ml:186:4>>*/ _r_ = t[5],
+            caml_check_bound(t[1], _r_)[1 + _r_],
+           /*<<weak.ml:186:4>>*/ _s_ = t[5],
            /*<<weak.ml:186:18>>*/ hbucket =
-            caml_check_bound(t[2], _r_)[1 + _r_],
+            caml_check_bound(t[2], _s_)[1 + _s_],
            /*<<weak.ml:187:14>>*/ len = length(bucket),
           prev_len = (((len - 3 | 0) * 2 | 0) + 2 | 0) / 3 | 0,
            /*<<weak.ml:189:15>>*/ live = count_bucket(0, bucket, 0);
@@ -25175,28 +25231,28 @@
            /*<<weak.ml:192:8>>*/ for(;;){
            if(prev_len > j){
             if(0 === prev_len){
-             var _t_ = t[5];
-              /*<<weak.ml:203:8>>*/ caml_check_bound(t[1], _t_)[1 + _t_] = emptybucket;
              var _u_ = t[5];
-              /*<<weak.ml:204:8>>*/ caml_check_bound(t[2], _u_)[1 + _u_] = [0];
+              /*<<weak.ml:203:8>>*/ caml_check_bound(t[1], _u_)[1 + _u_] = emptybucket;
+             var _v_ = t[5];
+              /*<<weak.ml:204:8>>*/ caml_check_bound(t[2], _v_)[1 + _v_] = [0];
             }
             else{
               /*<<weak.ml:206:24>>*/  /*<<weak.ml:206:24>>*/ var
               newbucket = create(prev_len);
               /*<<weak.ml:207:8>>*/ blit(bucket, 0, newbucket, 0, prev_len);
-             var _x_ = t[5];
-              /*<<weak.ml:208:8>>*/ caml_check_bound(t[1], _x_)[1 + _x_] = newbucket;
+             var _y_ = t[5];
+              /*<<weak.ml:208:8>>*/ caml_check_bound(t[1], _y_)[1 + _y_] = newbucket;
               /*<<weak.ml:209:30>>*/ var
-               /*<<weak.ml:209:30>>*/ _y_ =
+               /*<<weak.ml:209:30>>*/ _z_ =
                  /*<<weak.ml:209:30>>*/ caml_call3
                  (Stdlib_Array[5], hbucket, 0, prev_len),
-              _z_ = t[5];
-              /*<<weak.ml:209:8>>*/ caml_check_bound(t[2], _z_)[1 + _z_] = _y_;
+              _A_ = t[5];
+              /*<<weak.ml:209:8>>*/ caml_check_bound(t[2], _A_)[1 + _A_] = _z_;
             }
             var
-             _v_ = t[3] < len ? 1 : 0,
-             _w_ = _v_ ? prev_len <= t[3] ? 1 : 0 : _v_;
-            if(_w_) t[4] = t[4] - 1 | 0;
+             _w_ = t[3] < len ? 1 : 0,
+             _x_ = _w_ ? prev_len <= t[3] ? 1 : 0 : _w_;
+            if(_x_) t[4] = t[4] - 1 | 0;
             break;
            }
             /*<<weak.ml:193:13>>*/ if(check(bucket, i$0))
@@ -25204,8 +25260,8 @@
            else if(check(bucket, j)){
              /*<<weak.ml:195:12>>*/ blit(bucket, j, bucket, i$0, 1);
              /*<<weak.ml:196:27>>*/  /*<<weak.ml:196:27>>*/ var
-             _s_ = caml_check_bound(hbucket, j)[1 + j];
-             /*<<weak.ml:196:12>>*/ caml_check_bound(hbucket, i$0)[1 + i$0] = _s_;
+             _t_ = caml_check_bound(hbucket, j)[1 + j];
+             /*<<weak.ml:196:12>>*/ caml_check_bound(hbucket, i$0)[1 + i$0] = _t_;
              /*<<weak.ml:196:12>>*/ var
               /*<<weak.ml:196:12>>*/ j$0 = j - 1 | 0,
              i$2 = i$0 + 1 | 0,
@@ -25220,13 +25276,13 @@
          }
          t[5] = caml_mod(t[5] + 1 | 0, t[1].length - 1);
           /*<<weak.ml:257:38>>*/  /*<<weak.ml:257:38>>*/ var
-          _D_ = i$4 + 1 | 0;
+          _E_ = i$4 + 1 | 0;
          if(2 === i$4) break;
-         var i$4 = _D_;
+         var i$4 = _E_;
         }
        }
-       var _C_ = ((t[1].length - 1) / 2 | 0) < t[4] ? 1 : 0;
-       if(! _C_) return _C_;
+       var _D_ = ((t[1].length - 1) / 2 | 0) < t[4] ? 1 : 0;
+       if(! _D_) return _D_;
         /*<<weak.ml:181:18>>*/ var
         oldlen = t[1].length - 1,
          /*<<weak.ml:181:18>>*/ newlen =
@@ -25237,9 +25293,9 @@
        if(oldlen < newlen){
          /*<<weak.ml:220:17>>*/ var
           /*<<weak.ml:220:17>>*/ newt = create$0(newlen),
-         _o_ = t[1],
+         _p_ = t[1],
          i = 0,
-          /*<<weak.ml:169:16>>*/ _p_ =
+          /*<<weak.ml:169:16>>*/ _q_ =
            function(j, ob){
             var oi = i;
              /*<<weak.ml:164:6>>*/ for(;;){
@@ -25265,7 +25321,7 @@
             }
            };
          /*<<weak.ml:169:16>>*/  /*<<weak.ml:169:16>>*/ caml_call2
-         (Stdlib_Array[12], _p_, _o_);
+         (Stdlib_Array[12], _q_, _p_);
         t[1] = newt[1];
         t[2] = newt[2];
         t[3] = newt[3];
@@ -25329,7 +25385,7 @@
      }
      /*<<weak.ml:291:10>>*/ }
     function find_opt(t, d){
-      /*<<weak.ml:293:21>>*/ function _n_(h, i){
+      /*<<weak.ml:293:21>>*/ function _o_(h, i){
        /*<<weak.ml:294:48>>*/ return 0;
       /*<<weak.ml:294:52>>*/ }
       /*<<weak.ml:294:34>>*/ return find_aux
@@ -25338,10 +25394,10 @@
               function(b, i, o, v){
                 /*<<weak.ml:293:54>>*/ return o;
                /*<<weak.ml:293:55>>*/ },
-              _n_);
+              _o_);
      /*<<weak.ml:294:53>>*/ }
     function merge(t, d){
-     function _m_(h, i){
+     function _n_(h, i){
        /*<<weak.ml:298:40>>*/ add_aux(t, set, [0, d], h, i);
        /*<<weak.ml:296:21>>*/ return d;
       /*<<weak.ml:298:69>>*/ }
@@ -25351,10 +25407,10 @@
               function(b, i, o, v){
                 /*<<weak.ml:296:54>>*/ return v;
                /*<<weak.ml:296:55>>*/ },
-              _m_);
+              _n_);
      /*<<weak.ml:298:70>>*/ }
     function find(t, d){
-      /*<<weak.ml:300:21>>*/ function _l_(h, i){
+      /*<<weak.ml:300:21>>*/ function _m_(h, i){
        /*<<weak.ml:301:48>>*/ throw  /*<<weak.ml:301:48>>*/ caml_maybe_attach_backtrace
              (Stdlib[8], 1);
       /*<<weak.ml:301:63>>*/ }
@@ -25364,10 +25420,10 @@
               function(b, i, o, v){
                 /*<<weak.ml:300:54>>*/ return v;
                /*<<weak.ml:300:55>>*/ },
-              _l_);
+              _m_);
      /*<<weak.ml:301:64>>*/ }
     function remove(t, d){
-      /*<<weak.ml:303:21>>*/ function _k_(h, i){
+      /*<<weak.ml:303:21>>*/ function _l_(h, i){
        /*<<weak.ml:304:48>>*/ return 0;
       /*<<weak.ml:304:50>>*/ }
       /*<<weak.ml:304:34>>*/ return find_aux
@@ -25376,10 +25432,10 @@
               function(b, i, o, v){
                 /*<<weak.ml:303:54>>*/ return set(b, i, 0);
                /*<<weak.ml:303:66>>*/ },
-              _k_);
+              _l_);
      /*<<weak.ml:304:51>>*/ }
     function mem(t, d){
-      /*<<weak.ml:306:21>>*/ function _j_(h, i){
+      /*<<weak.ml:306:21>>*/ function _k_(h, i){
        /*<<weak.ml:307:48>>*/ return 0;
       /*<<weak.ml:307:53>>*/ }
       /*<<weak.ml:307:34>>*/ return find_aux
@@ -25388,7 +25444,7 @@
               function(b, i, o, v){
                 /*<<weak.ml:306:54>>*/ return 1;
                /*<<weak.ml:306:58>>*/ },
-              _j_);
+              _k_);
      /*<<weak.ml:307:54>>*/ }
     function find_all(t, d){
       /*<<weak.ml:310:4>>*/ var
@@ -25431,17 +25487,17 @@
          /*<<weak.ml:327:15>>*/ caml_call2(Stdlib_Array[13], length, t[1]);
       /*<<weak.ml:328:4>>*/  /*<<weak.ml:328:4>>*/ caml_call2
       (Stdlib_Array[34], runtime.caml_int_compare, lens);
-     var _a_ = 0;
-     function _b_(_i_, _h_){ /*<<?>>*/ return _i_ + _h_ | 0;}
+     var _b_ = 0;
+     function _c_(_j_, _i_){ /*<<?>>*/ return _j_ + _i_ | 0;}
       /*<<weak.ml:329:17>>*/ var
        /*<<weak.ml:329:17>>*/ totlen =
-         /*<<weak.ml:329:17>>*/ caml_call3(Stdlib_Array[17], _b_, _a_, lens),
-       /*<<weak.ml:329:17>>*/ _c_ = len - 1 | 0,
-      _e_ = len / 2 | 0,
-       /*<<weak.ml:330:51>>*/ _d_ = caml_check_bound(lens, _c_)[1 + _c_],
-       /*<<weak.ml:330:37>>*/ _f_ = caml_check_bound(lens, _e_)[1 + _e_],
-       /*<<weak.ml:330:27>>*/ _g_ = caml_check_bound(lens, 0)[1];
-      /*<<weak.ml:330:4>>*/ return [0, len, count(t), totlen, _g_, _f_, _d_];
+         /*<<weak.ml:329:17>>*/ caml_call3(Stdlib_Array[17], _c_, _b_, lens),
+       /*<<weak.ml:329:17>>*/ _d_ = len - 1 | 0,
+      _f_ = len / 2 | 0,
+       /*<<weak.ml:330:51>>*/ _e_ = caml_check_bound(lens, _d_)[1 + _d_],
+       /*<<weak.ml:330:37>>*/ _g_ = caml_check_bound(lens, _f_)[1 + _f_],
+       /*<<weak.ml:330:27>>*/ _h_ = caml_check_bound(lens, 0)[1];
+      /*<<weak.ml:330:4>>*/ return [0, len, count(t), totlen, _h_, _g_, _e_];
      /*<<weak.ml:330:64>>*/ }
      /*<<weak.ml:101:66>>*/ return [0,
             create$0,
@@ -25498,6 +25554,7 @@
             : runtime.caml_call_gen(f, [a0, a1, a2, a3]);
    }
    var
+    _m_ = undefined,
     global_data = runtime.caml_get_global_data(),
     cst$14 = ".",
     cst$11 = cst$15,
@@ -25547,25 +25604,28 @@
     /*<<format.ml:220:32>>*/ }
    var pp_infinity = 1000000010;
    function pp_output_string(state, s){
-     /*<<format.ml:251:31>>*/ return caml_call3
-            (state[17], s, 0, caml_ml_string_length(s));
+     /*<<format.ml:251:31>>*/ caml_call3
+     (state[17], s, 0, caml_ml_string_length(s));
+    return;
     /*<<format.ml:251:72>>*/ }
    function pp_output_newline(state){
-     /*<<format.ml:252:30>>*/ return  /*<<format.ml:252:30>>*/ caml_call1
-            (state[19], 0);
+     /*<<format.ml:252:30>>*/  /*<<format.ml:252:30>>*/ caml_call1
+     (state[19], 0);
+     /*<<format.ml:252:30>>*/ return;
     /*<<format.ml:252:53>>*/ }
    function format_pp_text(state, size, text){
      /*<<format.ml:258:2>>*/ state[9] = state[9] - size | 0;
      /*<<format.ml:259:2>>*/ pp_output_string(state, text);
     state[11] = 0;
-    return 0;
+    return;
     /*<<format.ml:260:31>>*/ }
    function format_string(state, s){
      /*<<format.ml:264:2>>*/  /*<<format.ml:264:5>>*/ var
-     _bQ_ =  /*<<format.ml:264:5>>*/ runtime.caml_string_notequal(s, cst$16);
-     /*<<format.ml:264:5>>*/ return _bQ_
-            ? format_pp_text(state, caml_ml_string_length(s), s)
-            : _bQ_;
+     _bO_ =  /*<<format.ml:264:5>>*/ runtime.caml_string_notequal(s, cst$16);
+     /*<<format.ml:264:5>>*/ if(! _bO_)  /*<<format.ml:264:5>>*/ return _bO_;
+     /*<<format.ml:264:18>>*/ format_pp_text
+     (state, caml_ml_string_length(s), s);
+     /*<<format.ml:264:18>>*/ return;
     /*<<format.ml:264:58>>*/ }
    function break_new_line(state, param, width){
     var after = param[3], offset = param[2], before = param[1];
@@ -25581,10 +25641,12 @@
     var n = state[10];
      /*<<format.ml:254:31>>*/  /*<<format.ml:254:31>>*/ caml_call1
      (state[21], n);
-     /*<<format.ml:276:2>>*/ return format_string(state, after);
+     /*<<format.ml:276:2>>*/ format_string(state, after);
+     /*<<format.ml:276:2>>*/ return;
    }
    function break_line(state, width){
-     /*<<format.ml:281:29>>*/ return break_new_line(state, _a_, width);
+     /*<<format.ml:281:29>>*/ break_new_line(state, _a_, width);
+     /*<<format.ml:281:29>>*/ return;
     /*<<format.ml:281:67>>*/ }
    function break_same_line(state, param){
     var after = param[3], width = param[2], before = param[1];
@@ -25592,7 +25654,8 @@
     state[9] = state[9] - width | 0;
      /*<<format.ml:253:31>>*/  /*<<format.ml:253:31>>*/ caml_call1
      (state[20], width);
-     /*<<format.ml:287:2>>*/ return format_string(state, after);
+     /*<<format.ml:287:2>>*/ format_string(state, after);
+     /*<<format.ml:287:2>>*/ return;
    }
    function format_pp_token(state, size$0, param){
      /*<<?>>*/ if(typeof param === "number")
@@ -25601,7 +25664,7 @@
          /*<<format.ml:348:16>>*/  /*<<format.ml:348:16>>*/ var
          match$3 =
             /*<<format.ml:348:16>>*/ caml_call1(Stdlib_Stack[8], state[3]);
-        if(! match$3)  /*<<format.ml:349:14>>*/ return 0;
+        if(! match$3)  /*<<format.ml:349:14>>*/ return;
          /*<<format.ml:351:6>>*/ var
          tabs = match$3[1][1],
           /*<<format.ml:351:6>>*/ add_tab =
@@ -25614,49 +25677,54 @@
                     : [0, x, add_tab(n, l)];
            };
         tabs[1] = add_tab(state[6] - state[9] | 0, tabs[1]);
-        return 0;
+        return;
        case 1:
          /*<<format.ml:339:4>>*/  /*<<format.ml:339:4>>*/ caml_call1
          (Stdlib_Stack[5], state[2]);
-         /*<<format.ml:339:4>>*/ return 0;
+         /*<<format.ml:339:4>>*/ return;
        case 2:
          /*<<format.ml:345:4>>*/  /*<<format.ml:345:4>>*/ caml_call1
          (Stdlib_Stack[5], state[3]);
-         /*<<format.ml:345:4>>*/ return 0;
+         /*<<format.ml:345:4>>*/ return;
        case 3:
          /*<<format.ml:378:16>>*/  /*<<format.ml:378:16>>*/ var
          match$4 =
             /*<<format.ml:378:16>>*/ caml_call1(Stdlib_Stack[8], state[2]);
-        if(! match$4)
-          /*<<format.ml:379:14>>*/ return pp_output_newline(state);
-        var width$0 = match$4[1][2];
-         /*<<format.ml:380:26>>*/ return break_line(state, width$0);
+        if(match$4){
+         var width$0 = match$4[1][2];
+          /*<<format.ml:380:26>>*/ break_line(state, width$0);
+          /*<<format.ml:380:26>>*/ return;
+        }
+         /*<<format.ml:379:14>>*/ pp_output_newline(state);
+         /*<<format.ml:379:14>>*/ return;
        case 4:
-        var _bO_ = state[10] !== (state[6] - state[9] | 0) ? 1 : 0;
-        if(! _bO_) return _bO_;
+        var _bM_ = state[10] !== (state[6] - state[9] | 0) ? 1 : 0;
+        if(! _bM_) return _bM_;
          /*<<format.ml:306:8>>*/  /*<<format.ml:306:8>>*/ var
          match$1 =
             /*<<format.ml:306:8>>*/ caml_call1(Stdlib_Queue[6], state[28]);
-        if(! match$1)  /*<<format.ml:307:12>>*/ return 0;
+        if(! match$1)  /*<<format.ml:307:12>>*/ return;
         var match$2 = match$1[1], size = match$2[1], length = match$2[3];
         state[12] = state[12] - length | 0;
         state[9] = state[9] + size | 0;
-        return 0;
+        return;
        default:
          /*<<format.ml:419:17>>*/  /*<<format.ml:419:17>>*/ var
          match$5 =
             /*<<format.ml:419:17>>*/ caml_call1(Stdlib_Stack[5], state[5]);
-        if(! match$5)  /*<<format.ml:420:15>>*/ return 0;
+        if(! match$5)  /*<<format.ml:420:15>>*/ return;
          /*<<format.ml:422:20>>*/ var
          tag_name = match$5[1],
           /*<<format.ml:422:20>>*/ marker =
             /*<<format.ml:422:20>>*/ caml_call1(state[25], tag_name);
-         /*<<format.ml:423:7>>*/ return pp_output_string(state, marker);
+         /*<<format.ml:423:7>>*/ pp_output_string(state, marker);
+         /*<<format.ml:423:7>>*/ return;
      }
     switch(param[0]){
       case 0:
        var s = param[1];
-        /*<<format.ml:323:4>>*/ return format_pp_text(state, size$0, s);
+        /*<<format.ml:323:4>>*/ format_pp_text(state, size$0, s);
+        /*<<format.ml:323:4>>*/ return;
       case 1:
         /*<<format.ml:388:4>>*/ var
         breaks = param[2],
@@ -25665,42 +25733,46 @@
         before = breaks[1],
          /*<<format.ml:389:16>>*/ match$6 =
            /*<<format.ml:389:16>>*/ caml_call1(Stdlib_Stack[8], state[2]);
-       if(! match$6)  /*<<format.ml:390:14>>*/ return 0;
+       if(! match$6)  /*<<format.ml:390:14>>*/ return;
        var
         match$7 = match$6[1],
         width$1 = match$7[2],
         box_type$0 = match$7[1];
         /*<<format.ml:392:6>>*/ switch(box_type$0){
          case 0:
-           /*<<format.ml:409:19>>*/ return break_same_line(state, fits);
+           /*<<format.ml:409:19>>*/ break_same_line(state, fits);
+           /*<<format.ml:409:19>>*/ return;
          case 1:
-           /*<<format.ml:408:19>>*/ return break_new_line
-                  (state, breaks, width$1);
+           /*<<format.ml:408:19>>*/ break_new_line(state, breaks, width$1);
+           /*<<format.ml:408:19>>*/ return;
          case 2:
-           /*<<format.ml:406:20>>*/ return break_new_line
-                  (state, breaks, width$1);
+           /*<<format.ml:406:20>>*/ break_new_line(state, breaks, width$1);
+           /*<<format.ml:406:20>>*/ return;
          case 3:
-          return state[9] < (size$0 + caml_ml_string_length(before) | 0)
-                  ? break_new_line(state, breaks, width$1)
-                  : break_same_line(state, fits);
+          if(state[9] < (size$0 + caml_ml_string_length(before) | 0)){
+            /*<<format.ml:395:13>>*/ break_new_line(state, breaks, width$1);
+            /*<<format.ml:395:13>>*/ return;
+          }
+           /*<<format.ml:396:13>>*/ break_same_line(state, fits);
+           /*<<format.ml:396:13>>*/ return;
          case 4:
-          return state[11]
-                  ? break_same_line(state, fits)
-                  : state
-                     [9]
-                    < (size$0 + caml_ml_string_length(before) | 0)
-                    ? break_new_line(state, breaks, width$1)
-                    : ((state
-                       [6]
-                      - width$1
-                      | 0)
-                      + off
-                      | 0)
-                      < state[10]
-                      ? break_new_line(state, breaks, width$1)
-                      : break_same_line(state, fits);
+          if(state[11]){
+            /*<<format.ml:399:37>>*/ break_same_line(state, fits);
+            /*<<format.ml:399:37>>*/ return;
+          }
+          if(state[9] < (size$0 + caml_ml_string_length(before) | 0)){
+            /*<<format.ml:401:15>>*/ break_new_line(state, breaks, width$1);
+            /*<<format.ml:401:15>>*/ return;
+          }
+          if(((state[6] - width$1 | 0) + off | 0) < state[10]){
+            /*<<format.ml:404:13>>*/ break_new_line(state, breaks, width$1);
+            /*<<format.ml:404:13>>*/ return;
+          }
+           /*<<format.ml:405:13>>*/ break_same_line(state, fits);
+           /*<<format.ml:405:13>>*/ return;
          default:
-           /*<<format.ml:407:19>>*/ return break_same_line(state, fits);
+           /*<<format.ml:407:19>>*/ break_same_line(state, fits);
+           /*<<format.ml:407:19>>*/ return;
        }
       case 2:
         /*<<format.ml:359:16>>*/ var
@@ -25709,7 +25781,7 @@
         insertion_point = state[6] - state[9] | 0,
          /*<<format.ml:359:16>>*/ match$8 =
            /*<<format.ml:359:16>>*/ caml_call1(Stdlib_Stack[8], state[3]);
-       if(! match$8)  /*<<format.ml:360:14>>*/ return 0;
+       if(! match$8)  /*<<format.ml:360:14>>*/ return;
         /*<<format.ml:362:6>>*/ var
         tabs$0 = match$8[1][1],
          /*<<format.ml:362:6>>*/ match$9 = tabs$0[1];
@@ -25719,21 +25791,25 @@
          if(param$0){
           var tail = param$0[2], head = param$0[1];
           if(insertion_point > head){var param$0 = tail; continue;}
-          var _bP_ = head;
+          var _bN_ = head;
          }
          else
-          var _bP_ = first;
-         var tab = _bP_;
+          var _bN_ = first;
+         var tab = _bN_;
          break;
         }
        }
        else
         var tab = insertion_point;
        var offset = tab - insertion_point | 0;
-        /*<<format.ml:372:6>>*/ return 0 <= offset
-               ? break_same_line(state, [0, cst$0, offset + n | 0, cst])
-               : break_new_line
-                 (state, [0, cst$2, tab + off$0 | 0, cst$1], state[6]);
+        /*<<format.ml:372:6>>*/ if(0 <= offset){
+         /*<<format.ml:373:33>>*/ break_same_line
+         (state, [0, cst$0, offset + n | 0, cst]);
+         /*<<format.ml:373:33>>*/ return;
+       }
+        /*<<format.ml:374:32>>*/ break_new_line
+        (state, [0, cst$2, tab + off$0 | 0, cst$1], state[6]);
+        /*<<format.ml:374:32>>*/ return;
       case 3:
        var
         ty = param[2],
@@ -25755,19 +25831,22 @@
         width$2 = state[9] - off$1 | 0,
          /*<<format.ml:331:4>>*/ box_type$1 =
           1 === ty ? 1 : state[9] < size$0 ? ty : 5;
-        /*<<format.ml:336:4>>*/ return  /*<<format.ml:336:4>>*/ caml_call2
-               (Stdlib_Stack[3], [0, box_type$1, width$2], state[2]);
+        /*<<format.ml:336:4>>*/  /*<<format.ml:336:4>>*/ caml_call2
+        (Stdlib_Stack[3], [0, box_type$1, width$2], state[2]);
+        /*<<format.ml:336:4>>*/ return;
       case 4:
        var tbox = param[1];
-        /*<<format.ml:342:4>>*/ return  /*<<format.ml:342:4>>*/ caml_call2
-               (Stdlib_Stack[3], tbox, state[3]);
+        /*<<format.ml:342:4>>*/  /*<<format.ml:342:4>>*/ caml_call2
+        (Stdlib_Stack[3], tbox, state[3]);
+        /*<<format.ml:342:4>>*/ return;
       default:
         /*<<format.ml:414:18>>*/ var
         tag_name$0 = param[1],
          /*<<format.ml:414:18>>*/ marker$0 =
            /*<<format.ml:414:18>>*/ caml_call1(state[24], tag_name$0);
         /*<<format.ml:415:5>>*/ pp_output_string(state, marker$0);
-       return caml_call2(Stdlib_Stack[3], tag_name$0, state[5]);
+       caml_call2(Stdlib_Stack[3], tag_name$0, state[5]);
+       return;
     }
    }
    function advance_left(state){
@@ -25781,10 +25860,10 @@
       length = match$0[3],
       token = match$0[2],
       pending_count = state[13] - state[12] | 0,
-       /*<<format.ml:435:7>>*/ _bM_ = 0 <= size ? 1 : 0,
-       /*<<format.ml:435:7>>*/ _bN_ =
-        _bM_ || (state[9] <= pending_count ? 1 : 0);
-     if(! _bN_)  /*<<format.ml:435:7>>*/ return _bN_;
+       /*<<format.ml:435:7>>*/ _bK_ = 0 <= size ? 1 : 0,
+       /*<<format.ml:435:7>>*/ _bL_ =
+        _bK_ || (state[9] <= pending_count ? 1 : 0);
+     if(! _bL_)  /*<<format.ml:435:7>>*/ return _bL_;
       /*<<format.ml:436:6>>*/  /*<<format.ml:436:6>>*/ caml_call1
       (Stdlib_Queue[5], state[28]);
       /*<<format.ml:437:20>>*/  /*<<format.ml:437:20>>*/ var
@@ -25806,48 +25885,40 @@
      (Stdlib_Stack[9], stack);
      /*<<format.ml:463:19>>*/  /*<<format.ml:463:19>>*/ var
      queue_elem = [0, unknown, _b_, 0];
-     /*<<format.ml:464:2>>*/ return  /*<<format.ml:464:2>>*/ caml_call2
-            (Stdlib_Stack[3], [0, -1, queue_elem], stack);
+     /*<<format.ml:464:2>>*/  /*<<format.ml:464:2>>*/ caml_call2
+     (Stdlib_Stack[3], [0, -1, queue_elem], stack);
+     /*<<format.ml:464:2>>*/ return;
     /*<<format.ml:464:50>>*/ }
    function set_size(state, ty){
      /*<<format.ml:476:2>>*/  /*<<format.ml:476:8>>*/ var
      match =  /*<<format.ml:476:8>>*/ caml_call1(Stdlib_Stack[8], state[1]);
-    if(! match)  /*<<format.ml:477:12>>*/ return 0;
+    if(! match)  /*<<format.ml:477:12>>*/ return;
      /*<<format.ml:479:4>>*/ var
      match$0 = match[1],
      queue_elem = match$0[2],
      left_total = match$0[1],
       /*<<format.ml:479:4>>*/ size = queue_elem[1];
-    if(left_total < state[12]) return initialize_scan_stack(state[1]);
-    var _bI_ = queue_elem[2];
-    if(typeof _bI_ !== "number")
-     switch(_bI_[0]){
+    if(left_total < state[12]){initialize_scan_stack(state[1]); return;}
+    var _bJ_ = queue_elem[2];
+    if(typeof _bJ_ !== "number")
+     switch(_bJ_[0]){
        case 3:
-        var
-         _bK_ = 1 - ty,
-         _bL_ =
-           _bK_
-            ? (queue_elem
-               [1]
-              = state[13] + size | 0,
-               /*<<format.ml:493:10>>*/ caml_call1(Stdlib_Stack[5], state[1]),
-              0)
-            : _bK_;
-         /*<<format.ml:493:10>>*/ return _bL_;
+        if(1 - ty){
+         queue_elem[1] = state[13] + size | 0;
+          /*<<format.ml:493:10>>*/  /*<<format.ml:493:10>>*/ caml_call1
+          (Stdlib_Stack[5], state[1]);
+        }
+         /*<<format.ml:493:10>>*/ return;
        case 1:
        case 2:
-        var
-         _bJ_ =
-           ty
-            ? (queue_elem
-               [1]
-              = state[13] + size | 0,
-               /*<<format.ml:488:10>>*/ caml_call1(Stdlib_Stack[5], state[1]),
-              0)
-            : ty;
-         /*<<format.ml:488:10>>*/ return _bJ_;
+        if(ty){
+         queue_elem[1] = state[13] + size | 0;
+          /*<<format.ml:488:10>>*/  /*<<format.ml:488:10>>*/ caml_call1
+          (Stdlib_Stack[5], state[1]);
+        }
+         /*<<format.ml:488:10>>*/ return;
      }
-     /*<<format.ml:497:8>>*/ return 0;
+     /*<<format.ml:497:8>>*/ return;
     /*<<format.ml:497:10>>*/ }
    function scan_push(state, b, token){
      /*<<format.ml:503:2>>*/ pp_enqueue(state, token);
@@ -25865,26 +25936,26 @@
        /*<<format.ml:516:15>>*/ elem = [0, size, [3, indent, br_ty], 0];
       /*<<format.ml:517:4>>*/ return scan_push(state, 0, elem);
     }
-    var _bH_ = state[14] === state[15] ? 1 : 0;
-    if(! _bH_) return _bH_;
+    var _bI_ = state[14] === state[15] ? 1 : 0;
+    if(! _bI_) return _bI_;
     var s = state[16];
      /*<<format.ml:454:2>>*/ return enqueue_string_as
             (state, caml_ml_string_length(s), s);
     /*<<format.ml:519:45>>*/ }
    function pp_close_box(state, param){
-     /*<<format.ml:527:2>>*/ var _bF_ = 1 < state[14] ? 1 : 0;
-    if(_bF_){
+     /*<<format.ml:527:2>>*/ var _bG_ = 1 < state[14] ? 1 : 0;
+    if(_bG_){
      if(state[14] < state[15]){
        /*<<format.ml:531:6>>*/ pp_enqueue(state, [0, zero, 1, 0]);
        /*<<format.ml:532:6>>*/ set_size(state, 1);
        /*<<format.ml:532:27>>*/ set_size(state, 0);
      }
      state[14] = state[14] - 1 | 0;
-     var _bG_ = 0;
+     var _bH_ = 0;
     }
     else
-     var _bG_ = _bF_;
-    return _bG_;
+     var _bH_ = _bG_;
+    return _bH_;
     /*<<format.ml:535:5>>*/ }
    function pp_open_stag(state, tag_name){
      /*<<format.ml:540:2>>*/ if(state[22]){
@@ -25893,8 +25964,8 @@
       /*<<format.ml:543:4>>*/  /*<<format.ml:543:4>>*/ caml_call1
       (state[26], tag_name);
     }
-    var _bE_ = state[23];
-    if(! _bE_) return _bE_;
+    var _bF_ = state[23];
+    if(! _bF_) return _bF_;
      /*<<format.ml:546:16>>*/  /*<<format.ml:546:16>>*/ var
      token = [5, tag_name];
      /*<<format.ml:547:21>>*/ return pp_enqueue(state, [0, zero, token, 0]);
@@ -25902,8 +25973,8 @@
    function pp_close_stag(state, param){
      /*<<format.ml:552:2>>*/ if(state[23])
       /*<<format.ml:553:4>>*/ pp_enqueue(state, [0, zero, 5, 0]);
-    var _bC_ = state[22];
-    if(_bC_){
+    var _bD_ = state[22];
+    if(_bD_){
       /*<<format.ml:555:10>>*/  /*<<format.ml:555:10>>*/ var
       match =  /*<<format.ml:555:10>>*/ caml_call1(Stdlib_Stack[5], state[4]);
      if(match){
@@ -25911,11 +25982,11 @@
        /*<<format.ml:558:6>>*/ return  /*<<format.ml:558:6>>*/ caml_call1
               (state[27], tag_name);
      }
-     var _bD_ = 0;
+     var _bE_ = 0;
     }
     else
-     var _bD_ = _bC_;
-     /*<<format.ml:556:14>>*/ return _bD_;
+     var _bE_ = _bD_;
+     /*<<format.ml:556:14>>*/ return _bE_;
     /*<<format.ml:558:39>>*/ }
    function pp_set_print_tags(state, b){
      /*<<format.ml:560:32>>*/ state[22] = b;
@@ -25969,25 +26040,26 @@
      /*<<format.ml:523:28>>*/ return pp_open_box_gen(state, 0, 3);
     /*<<format.ml:600:23>>*/ }
    function pp_flush_queue(state, end_with_newline){
-     /*<<format.ml:608:2>>*/ var _bA_ = state[4];
-    function _bB_(param){
+     /*<<format.ml:608:2>>*/ var _bB_ = state[4];
+    function _bC_(param){
       /*<<format.ml:603:23>>*/ return pp_close_stag(state, 0);
      /*<<format.ml:603:45>>*/ }
      /*<<format.ml:603:13>>*/  /*<<format.ml:603:13>>*/ caml_call2
-     (Stdlib_Stack[13], _bB_, _bA_);
+     (Stdlib_Stack[13], _bC_, _bB_);
      /*<<format.ml:610:4>>*/ for(;;){
      if(1 >= state[14]){
       state[13] = pp_infinity;
        /*<<format.ml:613:2>>*/ advance_left(state);
       if(end_with_newline)  /*<<format.ml:614:27>>*/ pp_output_newline(state);
-       /*<<format.ml:614:27>>*/ return pp_rinit(state);
+       /*<<format.ml:614:27>>*/ pp_rinit(state);
+       /*<<format.ml:614:27>>*/ return;
      }
       /*<<format.ml:610:4>>*/ pp_close_box(state, 0);
     }
     /*<<format.ml:615:16>>*/ }
    function pp_print_as_size(state, size, s){
-     /*<<format.ml:625:2>>*/ var _bz_ = state[14] < state[15] ? 1 : 0;
-    return _bz_ ? enqueue_string_as(state, size, s) : _bz_;
+     /*<<format.ml:625:2>>*/ var _bA_ = state[14] < state[15] ? 1 : 0;
+    return _bA_ ? enqueue_string_as(state, size, s) : _bA_;
     /*<<format.ml:626:37>>*/ }
    function pp_print_as(state, isize, s){
      /*<<format.ml:630:2>>*/ return pp_print_as_size(state, isize, s);
@@ -26046,20 +26118,20 @@
             (state[18], 0);
     /*<<format.ml:673:69>>*/ }
    function pp_force_newline(state, param){
-     /*<<format.ml:678:2>>*/ var _by_ = state[14] < state[15] ? 1 : 0;
-    return _by_ ? enqueue_advance(state, [0, zero, 3, 0]) : _by_;
+     /*<<format.ml:678:2>>*/ var _bz_ = state[14] < state[15] ? 1 : 0;
+    return _bz_ ? enqueue_advance(state, [0, zero, 3, 0]) : _bz_;
     /*<<format.ml:679:78>>*/ }
    function pp_print_if_newline(state, param){
-     /*<<format.ml:684:2>>*/ var _bx_ = state[14] < state[15] ? 1 : 0;
-    return _bx_ ? enqueue_advance(state, [0, zero, 4, 0]) : _bx_;
+     /*<<format.ml:684:2>>*/ var _by_ = state[14] < state[15] ? 1 : 0;
+    return _by_ ? enqueue_advance(state, [0, zero, 4, 0]) : _by_;
     /*<<format.ml:686:61>>*/ }
    function pp_print_custom_break(state, fits, breaks){
      /*<<format.ml:692:2>>*/ var
      after = fits[3],
      width = fits[2],
      before = fits[1],
-     _bw_ = state[14] < state[15] ? 1 : 0;
-    if(! _bw_) return _bw_;
+     _bx_ = state[14] < state[15] ? 1 : 0;
+    if(! _bx_) return _bx_;
      /*<<format.ml:695:25>>*/ var
      size = - state[13] | 0,
       /*<<format.ml:695:25>>*/ token = [1, fits, breaks],
@@ -26082,33 +26154,33 @@
     /*<<format.ml:715:52>>*/ }
    function pp_open_tbox(state, param){
      /*<<format.ml:720:2>>*/ state[14] = state[14] + 1 | 0;
-    var _bv_ = state[14] < state[15] ? 1 : 0;
-    if(! _bv_) return _bv_;
+    var _bw_ = state[14] < state[15] ? 1 : 0;
+    if(! _bw_) return _bw_;
      /*<<format.ml:723:15>>*/  /*<<format.ml:723:15>>*/ var
      elem = [0, zero, [4, [0, [0, 0]]], 0];
      /*<<format.ml:724:4>>*/ return enqueue_advance(state, elem);
     /*<<format.ml:724:30>>*/ }
    function pp_close_tbox(state, param){
-     /*<<format.ml:729:2>>*/ var _bs_ = 1 < state[14] ? 1 : 0;
-    if(_bs_){
-     var _bt_ = state[14] < state[15] ? 1 : 0;
-     if(_bt_){
+     /*<<format.ml:729:2>>*/ var _bt_ = 1 < state[14] ? 1 : 0;
+    if(_bt_){
+     var _bu_ = state[14] < state[15] ? 1 : 0;
+     if(_bu_){
        /*<<format.ml:732:16>>*/  /*<<format.ml:732:16>>*/ var
        elem = [0, zero, 2, 0];
        /*<<format.ml:733:5>>*/ enqueue_advance(state, elem);
       state[14] = state[14] - 1 | 0;
-      var _bu_ = 0;
+      var _bv_ = 0;
      }
      else
-      var _bu_ = _bt_;
+      var _bv_ = _bu_;
     }
     else
-     var _bu_ = _bs_;
-    return _bu_;
+     var _bv_ = _bt_;
+    return _bv_;
     /*<<format.ml:735:5>>*/ }
    function pp_print_tbreak(state, width, offset){
-     /*<<format.ml:740:2>>*/ var _br_ = state[14] < state[15] ? 1 : 0;
-    if(! _br_) return _br_;
+     /*<<format.ml:740:2>>*/ var _bs_ = state[14] < state[15] ? 1 : 0;
+    if(! _bs_) return _bs_;
      /*<<format.ml:742:15>>*/ var
      size = - state[13] | 0,
       /*<<format.ml:742:15>>*/ elem = [0, size, [2, width, offset], width];
@@ -26118,17 +26190,17 @@
      /*<<format.ml:746:28>>*/ return pp_print_tbreak(state, 0, 0);
     /*<<format.ml:746:53>>*/ }
    function pp_set_tab(state, param){
-     /*<<format.ml:749:2>>*/ var _bq_ = state[14] < state[15] ? 1 : 0;
-    if(! _bq_) return _bq_;
+     /*<<format.ml:749:2>>*/ var _br_ = state[14] < state[15] ? 1 : 0;
+    if(! _br_) return _br_;
      /*<<format.ml:750:15>>*/  /*<<format.ml:750:15>>*/ var
      elem = [0, zero, 0, 0];
      /*<<format.ml:751:4>>*/ return enqueue_advance(state, elem);
     /*<<format.ml:751:30>>*/ }
    function pp_set_max_boxes(state, n){
      /*<<format.ml:761:31>>*/ var
-     _bo_ = 1 < n ? 1 : 0,
-     _bp_ = _bo_ ? (state[15] = n, 0) : _bo_;
-    return _bp_;
+     _bp_ = 1 < n ? 1 : 0,
+     _bq_ = _bp_ ? (state[15] = n, 0) : _bp_;
+    return _bq_;
     /*<<format.ml:761:68>>*/ }
    function pp_get_max_boxes(state, param){
      /*<<format.ml:764:32>>*/ return state[15];
@@ -26147,10 +26219,10 @@
      /*<<format.ml:775:2>>*/ return n < 1000000010 ? n : 1000000009;
     /*<<format.ml:775:49>>*/ }
    function pp_set_max_indent(state, n$0){
-     /*<<format.ml:791:2>>*/ var _bn_ = 1 < n$0 ? 1 : 0;
+     /*<<format.ml:791:2>>*/ var _bo_ = 1 < n$0 ? 1 : 0;
+    if(! _bo_) return _bo_;
+    var n$1 = state[6] - n$0 | 0, _bn_ = 1 <= n$1 ? 1 : 0;
     if(! _bn_) return _bn_;
-    var n$1 = state[6] - n$0 | 0, _bm_ = 1 <= n$1 ? 1 : 0;
-    if(! _bm_) return _bm_;
      /*<<format.ml:781:12>>*/  /*<<format.ml:781:12>>*/ var n = pp_limit(n$1);
     state[7] = n;
     state[8] = state[6] - state[7] | 0;
@@ -26160,19 +26232,19 @@
      /*<<format.ml:795:33>>*/ return state[8];
     /*<<format.ml:795:52>>*/ }
    function pp_set_margin(state, n){
-     /*<<format.ml:798:2>>*/ var _bk_ = 1 <= n ? 1 : 0;
-    if(! _bk_) return _bk_;
+     /*<<format.ml:798:2>>*/ var _bl_ = 1 <= n ? 1 : 0;
+    if(! _bl_) return _bl_;
      /*<<format.ml:799:12>>*/  /*<<format.ml:799:12>>*/ var n$0 = pp_limit(n);
     state[6] = n$0;
     if(state[8] <= state[6])
      var new_max_indent = state[8];
     else
       /*<<format.ml:808:15>>*/ var
-       /*<<format.ml:808:15>>*/ _bl_ =
+       /*<<format.ml:808:15>>*/ _bm_ =
          /*<<format.ml:808:15>>*/ caml_call2
          (Stdlib_Int[11], state[6] - state[7] | 0, state[6] / 2 | 0),
       new_max_indent =
-         /*<<format.ml:808:7>>*/ caml_call2(Stdlib_Int[11], _bl_, 1);
+         /*<<format.ml:808:7>>*/ caml_call2(Stdlib_Int[11], _bm_, 1);
      /*<<format.ml:811:4>>*/ return pp_set_max_indent(state, new_max_indent);
     /*<<format.ml:811:42>>*/ }
    function validate_geometry(param){
@@ -26203,11 +26275,11 @@
       /*<<format.ml:842:4>>*/ return pp_set_full_geometry(state, geometry);
      /*<<format.ml:840:28>>*/ var
      msg = match[1],
-      /*<<format.ml:840:28>>*/ _bj_ =
+      /*<<format.ml:840:28>>*/ _bk_ =
         /*<<format.ml:840:28>>*/ caml_call2
         (Stdlib[28], cst_Format_pp_set_geometry, msg);
      /*<<format.ml:840:4>>*/ throw  /*<<format.ml:840:4>>*/ caml_maybe_attach_backtrace
-           ([0, Stdlib[6], _bj_], 1);
+           ([0, Stdlib[6], _bk_], 1);
     /*<<format.ml:842:39>>*/ }
    function pp_safe_set_geometry(state, max_indent, margin){
      /*<<format.ml:845:2>>*/  /*<<format.ml:845:17>>*/ var
@@ -26260,8 +26332,8 @@
    function display_blanks(state, n){
      /*<<format.ml:896:2>>*/ var n$0 = n;
      /*<<format.ml:896:2>>*/ for(;;){
-     var _bi_ = 0 < n$0 ? 1 : 0;
-     if(! _bi_) return _bi_;
+     var _bj_ = 0 < n$0 ? 1 : 0;
+     if(! _bj_) return _bj_;
      if(80 >= n$0)
        /*<<format.ml:897:18>>*/ return  /*<<format.ml:897:18>>*/ caml_call3
               (state[17], blank_line, 0, n$0);
@@ -26281,9 +26353,9 @@
               (Stdlib[63], oc);
       /*<<format.ml:911:43>>*/ };
     state[19] =
-     function(_bh_){ /*<<?>>*/ return display_newline(state, _bh_);};
-    state[20] = function(_bg_){ /*<<?>>*/ return display_blanks(state, _bg_);};
-    state[21] = function(_bf_){ /*<<?>>*/ return display_blanks(state, _bf_);};
+     function(_bi_){ /*<<?>>*/ return display_newline(state, _bi_);};
+    state[20] = function(_bh_){ /*<<?>>*/ return display_blanks(state, _bh_);};
+    state[21] = function(_bg_){ /*<<?>>*/ return display_blanks(state, _bg_);};
     return 0;
     /*<<format.ml:914:45>>*/ }
    function default_pp_mark_open_tag(param){
@@ -26291,23 +26363,23 @@
       /*<<format.ml:924:9>>*/ return cst$10;
      /*<<format.ml:923:26>>*/ var
      s = param[2],
-      /*<<format.ml:923:26>>*/ _be_ =
+      /*<<format.ml:923:26>>*/ _bf_ =
         /*<<format.ml:923:26>>*/ caml_call2(Stdlib[28], s, cst$8);
      /*<<format.ml:923:26>>*/ return  /*<<format.ml:923:26>>*/ caml_call2
-            (Stdlib[28], cst$9, _be_);
+            (Stdlib[28], cst$9, _bf_);
     /*<<format.ml:924:11>>*/ }
    function default_pp_mark_close_tag(param){
      /*<<format.ml:925:32>>*/ if(param[1] !== String_tag)
       /*<<format.ml:927:9>>*/ return cst$13;
      /*<<format.ml:926:27>>*/ var
      s = param[2],
-      /*<<format.ml:926:27>>*/ _bd_ =
+      /*<<format.ml:926:27>>*/ _be_ =
         /*<<format.ml:926:27>>*/ caml_call2(Stdlib[28], s, cst$11);
      /*<<format.ml:926:27>>*/ return  /*<<format.ml:926:27>>*/ caml_call2
-            (Stdlib[28], cst$12, _bd_);
+            (Stdlib[28], cst$12, _be_);
     /*<<format.ml:927:11>>*/ }
-   function default_pp_print_open_tag(_bc_){ /*<<?>>*/ return 0;}
-   function default_pp_print_close_tag(_bb_){ /*<<?>>*/ return 0;}
+   function default_pp_print_open_tag(_bd_){ /*<<?>>*/ return 0;}
+   function default_pp_print_close_tag(_bc_){ /*<<?>>*/ return 0;}
    function pp_make_formatter(f, g, h, i, j){
      /*<<format.ml:936:17>>*/ var
       /*<<format.ml:936:17>>*/ pp_queue =
@@ -26321,19 +26393,19 @@
      /*<<format.ml:942:2>>*/  /*<<format.ml:942:2>>*/ caml_call2
      (Stdlib_Stack[3], [0, 1, sys_tok], scan_stack);
      /*<<format.ml:950:20>>*/ var
-     _a9_ = Stdlib[19],
-      /*<<format.ml:950:20>>*/ _a__ =
+     _a__ = Stdlib[19],
+      /*<<format.ml:950:20>>*/ _a$_ =
         /*<<format.ml:950:20>>*/ caml_call1(Stdlib_Stack[2], 0),
-      /*<<format.ml:949:19>>*/ _a$_ =
+      /*<<format.ml:949:19>>*/ _ba_ =
         /*<<format.ml:949:19>>*/ caml_call1(Stdlib_Stack[2], 0),
-      /*<<format.ml:948:20>>*/ _ba_ =
+      /*<<format.ml:948:20>>*/ _bb_ =
         /*<<format.ml:948:20>>*/ caml_call1(Stdlib_Stack[2], 0);
      /*<<format.ml:945:2>>*/ return [0,
             scan_stack,
              /*<<format.ml:947:22>>*/ caml_call1(Stdlib_Stack[2], 0),
+            _bb_,
             _ba_,
             _a$_,
-            _a__,
             78,
             10,
             68,
@@ -26343,7 +26415,7 @@
             1,
             1,
             1,
-            _a9_,
+            _a__,
             cst$14,
             f,
             g,
@@ -26363,30 +26435,30 @@
             (out_funs[1], out_funs[2], out_funs[3], out_funs[4], out_funs[5]);
     /*<<format.ml:984:23>>*/ }
    function make_formatter(output, flush){
-    function _a1_(_a8_){ /*<<?>>*/ return 0;}
-    function _a2_(_a7_){ /*<<?>>*/ return 0;}
+    function _a2_(_a9_){ /*<<?>>*/ return 0;}
+    function _a3_(_a8_){ /*<<?>>*/ return 0;}
      /*<<format.ml:990:12>>*/  /*<<format.ml:990:12>>*/ var
      ppf =
        pp_make_formatter
-        (output, flush, function(_a6_){ /*<<?>>*/ return 0;}, _a2_, _a1_);
-    ppf[19] = function(_a5_){ /*<<?>>*/ return display_newline(ppf, _a5_);};
-    ppf[20] = function(_a4_){ /*<<?>>*/ return display_blanks(ppf, _a4_);};
-    ppf[21] = function(_a3_){ /*<<?>>*/ return display_blanks(ppf, _a3_);};
+        (output, flush, function(_a7_){ /*<<?>>*/ return 0;}, _a3_, _a2_);
+    ppf[19] = function(_a6_){ /*<<?>>*/ return display_newline(ppf, _a6_);};
+    ppf[20] = function(_a5_){ /*<<?>>*/ return display_blanks(ppf, _a5_);};
+    ppf[21] = function(_a4_){ /*<<?>>*/ return display_blanks(ppf, _a4_);};
      /*<<format.ml:994:2>>*/ return ppf;
     /*<<format.ml:994:5>>*/ }
    function formatter_of_out_channel(oc){
-    function _a0_(param){
+    function _a1_(param){
       /*<<format.ml:999:50>>*/ return  /*<<format.ml:999:2>>*/ caml_call1
              (Stdlib[63], oc);
      /*<<format.ml:999:58>>*/ }
      /*<<format.ml:999:39>>*/ return make_formatter
-            ( /*<<format.ml:999:17>>*/ caml_call1(Stdlib[69], oc), _a0_);
+            ( /*<<format.ml:999:17>>*/ caml_call1(Stdlib[69], oc), _a1_);
     /*<<format.ml:999:59>>*/ }
    function formatter_of_buffer(b){
-     /*<<format.ml:1004:2>>*/ function _aY_(_aZ_){ /*<<?>>*/ return 0;}
+     /*<<format.ml:1004:2>>*/ function _aZ_(_a0_){ /*<<?>>*/ return 0;}
      /*<<format.ml:1004:42>>*/ return make_formatter
             ( /*<<format.ml:1004:17>>*/ caml_call1(Stdlib_Buffer[18], b),
-             _aY_);
+             _aZ_);
     /*<<format.ml:1004:48>>*/ }
    var pp_buffer_size = 512;
    function pp_make_buffer(param){
@@ -26417,9 +26489,9 @@
     (Stdlib_Domain[10][3], str_formatter_key, str_formatter);
     /*<<format.ml:1030:8>>*/ function buffered_out_string(key, str, ofs, len){
      /*<<format.ml:1033:2>>*/  /*<<format.ml:1033:23>>*/ var
-     _aX_ =  /*<<format.ml:1033:23>>*/ caml_call1(Stdlib_Domain[10][2], key);
+     _aY_ =  /*<<format.ml:1033:23>>*/ caml_call1(Stdlib_Domain[10][2], key);
      /*<<format.ml:1033:2>>*/ return  /*<<format.ml:1033:2>>*/ caml_call4
-            (Stdlib_Buffer[18], _aX_, str, ofs, len);
+            (Stdlib_Buffer[18], _aY_, str, ofs, len);
     /*<<format.ml:1033:55>>*/ }
    function buffered_out_flush(oc, key, param){
      /*<<format.ml:1036:2>>*/ var
@@ -26451,31 +26523,31 @@
     err_buf_key =
        /*<<format.ml:1044:18>>*/ caml_call2(Stdlib_Domain[10][1], 0, _i_);
    function _j_(param){
-    function _aG_(_aW_){ /*<<?>>*/ return 0;}
-    function _aH_(_aV_){ /*<<?>>*/ return 0;}
-    function _aI_(_aU_){ /*<<?>>*/ return 0;}
-    var _aJ_ = Stdlib[39];
-     /*<<format.ml:1049:6>>*/ function _aK_(_aT_){
-      /*<<?>>*/ return buffered_out_flush(_aJ_, std_buf_key, _aT_);
+    function _aH_(_aX_){ /*<<?>>*/ return 0;}
+    function _aI_(_aW_){ /*<<?>>*/ return 0;}
+    function _aJ_(_aV_){ /*<<?>>*/ return 0;}
+    var _aK_ = Stdlib[39];
+     /*<<format.ml:1049:6>>*/ function _aL_(_aU_){
+      /*<<?>>*/ return buffered_out_flush(_aK_, std_buf_key, _aU_);
     }
      /*<<format.ml:1048:4>>*/  /*<<format.ml:1048:4>>*/ var
      ppf =
        pp_make_formatter
-        (function(_aQ_, _aR_, _aS_){
-           /*<<?>>*/ return buffered_out_string(std_buf_key, _aQ_, _aR_, _aS_);
+        (function(_aR_, _aS_, _aT_){
+           /*<<?>>*/ return buffered_out_string(std_buf_key, _aR_, _aS_, _aT_);
          },
-         _aK_,
+         _aL_,
+         _aJ_,
          _aI_,
-         _aH_,
-         _aG_);
-    ppf[19] = function(_aP_){ /*<<?>>*/ return display_newline(ppf, _aP_);};
-    ppf[20] = function(_aO_){ /*<<?>>*/ return display_blanks(ppf, _aO_);};
-    ppf[21] = function(_aN_){ /*<<?>>*/ return display_blanks(ppf, _aN_);};
-     /*<<format.ml:1054:17>>*/ function _aL_(_aM_){
-      /*<<?>>*/ return pp_print_flush(ppf, _aM_);
+         _aH_);
+    ppf[19] = function(_aQ_){ /*<<?>>*/ return display_newline(ppf, _aQ_);};
+    ppf[20] = function(_aP_){ /*<<?>>*/ return display_blanks(ppf, _aP_);};
+    ppf[21] = function(_aO_){ /*<<?>>*/ return display_blanks(ppf, _aO_);};
+     /*<<format.ml:1054:17>>*/ function _aM_(_aN_){
+      /*<<?>>*/ return pp_print_flush(ppf, _aN_);
     }
      /*<<format.ml:1054:2>>*/  /*<<format.ml:1054:2>>*/ caml_call1
-     (Stdlib_Domain[6], _aL_);
+     (Stdlib_Domain[6], _aM_);
      /*<<format.ml:1054:2>>*/ return ppf;
     /*<<format.ml:1055:5>>*/ }
     /*<<format.ml:1046:24>>*/  /*<<format.ml:1046:24>>*/ var
@@ -26484,31 +26556,31 @@
     /*<<format.ml:1056:8>>*/  /*<<format.ml:1056:8>>*/ caml_call2
     (Stdlib_Domain[10][3], std_formatter_key, std_formatter);
    function _k_(param){
-    function _ap_(_aF_){ /*<<?>>*/ return 0;}
-    function _aq_(_aE_){ /*<<?>>*/ return 0;}
-    function _ar_(_aD_){ /*<<?>>*/ return 0;}
-    var _as_ = Stdlib[40];
-     /*<<format.ml:1061:6>>*/ function _at_(_aC_){
-      /*<<?>>*/ return buffered_out_flush(_as_, err_buf_key, _aC_);
+    function _aq_(_aG_){ /*<<?>>*/ return 0;}
+    function _ar_(_aF_){ /*<<?>>*/ return 0;}
+    function _as_(_aE_){ /*<<?>>*/ return 0;}
+    var _at_ = Stdlib[40];
+     /*<<format.ml:1061:6>>*/ function _au_(_aD_){
+      /*<<?>>*/ return buffered_out_flush(_at_, err_buf_key, _aD_);
     }
      /*<<format.ml:1060:4>>*/  /*<<format.ml:1060:4>>*/ var
      ppf =
        pp_make_formatter
-        (function(_az_, _aA_, _aB_){
-           /*<<?>>*/ return buffered_out_string(err_buf_key, _az_, _aA_, _aB_);
+        (function(_aA_, _aB_, _aC_){
+           /*<<?>>*/ return buffered_out_string(err_buf_key, _aA_, _aB_, _aC_);
          },
-         _at_,
+         _au_,
+         _as_,
          _ar_,
-         _aq_,
-         _ap_);
-    ppf[19] = function(_ay_){ /*<<?>>*/ return display_newline(ppf, _ay_);};
-    ppf[20] = function(_ax_){ /*<<?>>*/ return display_blanks(ppf, _ax_);};
-    ppf[21] = function(_aw_){ /*<<?>>*/ return display_blanks(ppf, _aw_);};
-     /*<<format.ml:1066:17>>*/ function _au_(_av_){
-      /*<<?>>*/ return pp_print_flush(ppf, _av_);
+         _aq_);
+    ppf[19] = function(_az_){ /*<<?>>*/ return display_newline(ppf, _az_);};
+    ppf[20] = function(_ay_){ /*<<?>>*/ return display_blanks(ppf, _ay_);};
+    ppf[21] = function(_ax_){ /*<<?>>*/ return display_blanks(ppf, _ax_);};
+     /*<<format.ml:1066:17>>*/ function _av_(_aw_){
+      /*<<?>>*/ return pp_print_flush(ppf, _aw_);
     }
      /*<<format.ml:1066:2>>*/  /*<<format.ml:1066:2>>*/ caml_call1
-     (Stdlib_Domain[6], _au_);
+     (Stdlib_Domain[6], _av_);
      /*<<format.ml:1066:2>>*/ return ppf;
     /*<<format.ml:1067:5>>*/ }
     /*<<format.ml:1058:24>>*/  /*<<format.ml:1058:24>>*/ var
@@ -26551,7 +26623,7 @@
             (stdbuf, str_formatter);
     /*<<format.ml:1089:45>>*/ }
    function make_synchronized_formatter(output, flush){
-    function _an_(param){
+    function _ao_(param){
       /*<<format.ml:1093:4>>*/ var
        /*<<format.ml:1093:14>>*/ buf =
          /*<<format.ml:1093:14>>*/ caml_call1
@@ -26560,12 +26632,12 @@
          /*<<format.ml:1094:18>>*/ caml_call1(Stdlib_Buffer[18], buf);
      function flush$0(param){
        /*<<format.ml:1096:6>>*/  /*<<format.ml:1096:37>>*/ var
-       _ao_ =  /*<<format.ml:1096:37>>*/ caml_call1(Stdlib_Buffer[7], buf);
+       _ap_ =  /*<<format.ml:1096:37>>*/ caml_call1(Stdlib_Buffer[7], buf);
        /*<<format.ml:1096:6>>*/  /*<<format.ml:1096:6>>*/ caml_call3
        (output,
          /*<<format.ml:1096:13>>*/ caml_call1(Stdlib_Buffer[2], buf),
         0,
-        _ao_);
+        _ap_);
        /*<<format.ml:1097:6>>*/  /*<<format.ml:1097:6>>*/ caml_call1
        (Stdlib_Buffer[8], buf);
        /*<<format.ml:1097:6>>*/ return  /*<<format.ml:1097:6>>*/ caml_call1
@@ -26574,15 +26646,15 @@
       /*<<format.ml:1100:4>>*/ return make_formatter(output$0, flush$0);
      /*<<format.ml:1100:33>>*/ }
      /*<<format.ml:1092:14>>*/ return  /*<<format.ml:1092:14>>*/ caml_call2
-            (Stdlib_Domain[10][1], 0, _an_);
+            (Stdlib_Domain[10][1], 0, _ao_);
     /*<<format.ml:1100:34>>*/ }
    function synchronized_formatter_of_out_(oc){
-    function _am_(param){
+    function _an_(param){
       /*<<format.ml:1103:63>>*/ return  /*<<format.ml:1103:2>>*/ caml_call1
              (Stdlib[63], oc);
      /*<<format.ml:1103:71>>*/ }
      /*<<format.ml:1103:52>>*/ return make_synchronized_formatter
-            ( /*<<format.ml:1103:30>>*/ caml_call1(Stdlib[69], oc), _am_);
+            ( /*<<format.ml:1103:30>>*/ caml_call1(Stdlib[69], oc), _an_);
     /*<<format.ml:1103:72>>*/ }
    function make_symbolic_output_buffer(param){ /*<<format.ml:1130:2>>*/ return [0, 0];
     /*<<format.ml:1130:35>>*/ }
@@ -26611,10 +26683,10 @@
                 /*<<format.ml:1152:48>>*/ caml_call3
                 (Stdlib_String[16], s, i, n)]);
     }
-     /*<<format.ml:1159:10>>*/ function g(_al_){
+     /*<<format.ml:1159:10>>*/ function g(_am_){
       /*<<format.ml:1148:4>>*/ return add_symbolic_output_item(sob, 0);
     }
-     /*<<format.ml:1160:10>>*/ function h(_ak_){
+     /*<<format.ml:1160:10>>*/ function h(_al_){
       /*<<format.ml:1150:4>>*/ return add_symbolic_output_item(sob, 1);
     }
      /*<<format.ml:1161:10>>*/ function i(n){
@@ -26996,8 +27068,8 @@
      /*<<format.ml:1280:31>>*/ }
     for(;;){
      if(right[1] === len){
-      var _aj_ = left[1] !== len ? 1 : 0;
-      return _aj_ ? flush(0) : _aj_;
+      var _ak_ = left[1] !== len ? 1 : 0;
+      return _ak_ ? flush(0) : _ak_;
      }
       /*<<format.ml:1283:10>>*/  /*<<format.ml:1283:10>>*/ var
       match =  /*<<format.ml:1283:10>>*/ runtime.caml_string_get(s, right[1]);
@@ -27019,7 +27091,7 @@
     else
      var
       none =
-        function(param, _ai_){
+        function(param, _aj_){
           /*<<format.ml:1295:41>>*/ return 0;
          /*<<format.ml:1295:43>>*/ };
      /*<<format.ml:1295:56>>*/ if(! param)
@@ -27118,56 +27190,56 @@
           var acc$1 = match[1];
            /*<<format.ml:1361:4>>*/ output_acc(ppf, p$0);
            /*<<format.ml:1362:43>>*/ var
-            /*<<format.ml:1362:43>>*/ _$_ = compute_tag(output_acc, acc$1),
+            /*<<format.ml:1362:43>>*/ _aa_ = compute_tag(output_acc, acc$1),
             /*<<format.ml:1362:24>>*/ match$0 =
               /*<<format.ml:1362:24>>*/ caml_call1
-              (CamlinternalFormat[20], _$_),
+              (CamlinternalFormat[20], _aa_),
            bty = match$0[2],
            indent = match$0[1];
            /*<<format.ml:1363:4>>*/ return pp_open_box_gen(ppf, indent, bty);
          case 2:
-          var _aa_ = acc[1];
-          if(typeof _aa_ !== "number" && 0 === _aa_[0]){
-           var _ab_ = _aa_[2];
-           if(typeof _ab_ !== "number" && 1 === _ab_[0]){
-            var s$0 = acc[2], size = _ab_[2], p$2 = _aa_[1];
+          var _ab_ = acc[1];
+          if(typeof _ab_ !== "number" && 0 === _ab_[0]){
+           var _ac_ = _ab_[2];
+           if(typeof _ac_ !== "number" && 1 === _ac_[0]){
+            var s$0 = acc[2], size = _ac_[2], p$2 = _ab_[1];
             break b;
            }
           }
-          var s = acc[2], p$1 = _aa_;
+          var s = acc[2], p$1 = _ab_;
           break a;
          case 3:
-          var _ac_ = acc[1];
-          if(typeof _ac_ !== "number" && 0 === _ac_[0]){
-           var _ad_ = _ac_[2];
-           if(typeof _ad_ !== "number" && 1 === _ad_[0]){
-            var c$0 = acc[2], size$0 = _ad_[2], p$4 = _ac_[1];
+          var _ad_ = acc[1];
+          if(typeof _ad_ !== "number" && 0 === _ad_[0]){
+           var _ae_ = _ad_[2];
+           if(typeof _ae_ !== "number" && 1 === _ae_[0]){
+            var c$0 = acc[2], size$0 = _ae_[2], p$4 = _ad_[1];
             break;
            }
           }
-          var c = acc[2], p$3 = _ac_;
+          var c = acc[2], p$3 = _ad_;
           break c;
          case 4:
-          var _ae_ = acc[1];
-          if(typeof _ae_ !== "number" && 0 === _ae_[0]){
-           var _af_ = _ae_[2];
-           if(typeof _af_ !== "number" && 1 === _af_[0]){
-            var s$0 = acc[2], size = _af_[2], p$2 = _ae_[1];
+          var _af_ = acc[1];
+          if(typeof _af_ !== "number" && 0 === _af_[0]){
+           var _ag_ = _af_[2];
+           if(typeof _ag_ !== "number" && 1 === _ag_[0]){
+            var s$0 = acc[2], size = _ag_[2], p$2 = _af_[1];
             break b;
            }
           }
-          var s = acc[2], p$1 = _ae_;
+          var s = acc[2], p$1 = _af_;
           break a;
          case 5:
-          var _ag_ = acc[1];
-          if(typeof _ag_ !== "number" && 0 === _ag_[0]){
-           var _ah_ = _ag_[2];
-           if(typeof _ah_ !== "number" && 1 === _ah_[0]){
-            var c$0 = acc[2], size$0 = _ah_[2], p$4 = _ag_[1];
+          var _ah_ = acc[1];
+          if(typeof _ah_ !== "number" && 0 === _ah_[0]){
+           var _ai_ = _ah_[2];
+           if(typeof _ai_ !== "number" && 1 === _ai_[0]){
+            var c$0 = acc[2], size$0 = _ai_[2], p$4 = _ah_[1];
             break;
            }
           }
-          var c = acc[2], p$3 = _ag_;
+          var c = acc[2], p$3 = _ah_;
           break c;
          case 6:
           var f$0 = acc[2], p$5 = acc[1];
@@ -27225,56 +27297,56 @@
           var acc$1 = match[1];
            /*<<format.ml:1396:4>>*/ strput_acc(ppf, p$0);
            /*<<format.ml:1397:43>>*/ var
-            /*<<format.ml:1397:43>>*/ _S_ = compute_tag(strput_acc, acc$1),
+            /*<<format.ml:1397:43>>*/ _T_ = compute_tag(strput_acc, acc$1),
             /*<<format.ml:1397:24>>*/ match$0 =
               /*<<format.ml:1397:24>>*/ caml_call1
-              (CamlinternalFormat[20], _S_),
+              (CamlinternalFormat[20], _T_),
            bty = match$0[2],
            indent = match$0[1];
            /*<<format.ml:1398:4>>*/ return pp_open_box_gen(ppf, indent, bty);
          case 2:
-          var _T_ = acc[1];
-          if(typeof _T_ !== "number" && 0 === _T_[0]){
-           var _U_ = _T_[2];
-           if(typeof _U_ !== "number" && 1 === _U_[0]){
-            var s$0 = acc[2], size = _U_[2], p$2 = _T_[1];
+          var _U_ = acc[1];
+          if(typeof _U_ !== "number" && 0 === _U_[0]){
+           var _V_ = _U_[2];
+           if(typeof _V_ !== "number" && 1 === _V_[0]){
+            var s$0 = acc[2], size = _V_[2], p$2 = _U_[1];
             break b;
            }
           }
-          var s = acc[2], p$1 = _T_;
+          var s = acc[2], p$1 = _U_;
           break a;
          case 3:
-          var _V_ = acc[1];
-          if(typeof _V_ !== "number" && 0 === _V_[0]){
-           var _W_ = _V_[2];
-           if(typeof _W_ !== "number" && 1 === _W_[0]){
-            var c$0 = acc[2], size$0 = _W_[2], p$4 = _V_[1];
+          var _W_ = acc[1];
+          if(typeof _W_ !== "number" && 0 === _W_[0]){
+           var _X_ = _W_[2];
+           if(typeof _X_ !== "number" && 1 === _X_[0]){
+            var c$0 = acc[2], size$0 = _X_[2], p$4 = _W_[1];
             break;
            }
           }
-          var c = acc[2], p$3 = _V_;
+          var c = acc[2], p$3 = _W_;
           break c;
          case 4:
-          var _X_ = acc[1];
-          if(typeof _X_ !== "number" && 0 === _X_[0]){
-           var _Y_ = _X_[2];
-           if(typeof _Y_ !== "number" && 1 === _Y_[0]){
-            var s$0 = acc[2], size = _Y_[2], p$2 = _X_[1];
+          var _Y_ = acc[1];
+          if(typeof _Y_ !== "number" && 0 === _Y_[0]){
+           var _Z_ = _Y_[2];
+           if(typeof _Z_ !== "number" && 1 === _Z_[0]){
+            var s$0 = acc[2], size = _Z_[2], p$2 = _Y_[1];
             break b;
            }
           }
-          var s = acc[2], p$1 = _X_;
+          var s = acc[2], p$1 = _Y_;
           break a;
          case 5:
-          var _Z_ = acc[1];
-          if(typeof _Z_ !== "number" && 0 === _Z_[0]){
-           var ___ = _Z_[2];
-           if(typeof ___ !== "number" && 1 === ___[0]){
-            var c$0 = acc[2], size$0 = ___[2], p$4 = _Z_[1];
+          var ___ = acc[1];
+          if(typeof ___ !== "number" && 0 === ___[0]){
+           var _$_ = ___[2];
+           if(typeof _$_ !== "number" && 1 === _$_[0]){
+            var c$0 = acc[2], size$0 = _$_[2], p$4 = ___[1];
             break;
            }
           }
-          var c = acc[2], p$3 = _Z_;
+          var c = acc[2], p$3 = ___;
           break c;
          case 6:
           var p$5 = acc[1];
@@ -27320,13 +27392,13 @@
    function kfprintf(k, ppf, param){
      /*<<format.ml:1415:2>>*/ var
      fmt = param[1],
-      /*<<format.ml:1415:2>>*/ _Q_ = 0;
-    function _R_(acc){
+      /*<<format.ml:1415:2>>*/ _R_ = 0;
+    function _S_(acc){
       /*<<format.ml:1416:16>>*/ output_acc(ppf, acc);
      return caml_call1(k, ppf);
      /*<<format.ml:1416:41>>*/ }
      /*<<format.ml:1415:2>>*/ return  /*<<format.ml:1415:2>>*/ caml_call3
-            (CamlinternalFormat[7], _R_, _Q_, fmt);
+            (CamlinternalFormat[7], _S_, _R_, fmt);
    }
    function ikfprintf(k, ppf, param){
     var fmt = param[1];
@@ -27336,47 +27408,47 @@
    function ifprintf(ppf, param){
      /*<<format.ml:1423:2>>*/ var
      fmt = param[1],
-      /*<<format.ml:1423:2>>*/ _N_ = 0;
-    function _O_(_P_){ /*<<?>>*/ return 0;}
+      /*<<format.ml:1423:2>>*/ _O_ = 0;
+    function _P_(_Q_){ /*<<?>>*/ return 0;}
      /*<<format.ml:1423:2>>*/ return  /*<<format.ml:1423:2>>*/ caml_call3
-            (CamlinternalFormat[8], _O_, _N_, fmt);
+            (CamlinternalFormat[8], _P_, _O_, fmt);
    }
    function fprintf(ppf){
-    function _K_(_M_){ /*<<?>>*/ return 0;}
-     /*<<format.ml:1425:18>>*/ return function(_L_){
-      /*<<?>>*/ return kfprintf(_K_, ppf, _L_);};
+    function _L_(_N_){ /*<<?>>*/ return 0;}
+     /*<<format.ml:1425:18>>*/ return function(_M_){
+      /*<<?>>*/ return kfprintf(_L_, ppf, _M_);};
     /*<<format.ml:1425:37>>*/ }
    function printf(param){
      /*<<format.ml:1428:2>>*/ var
      fmt = param[1],
-      /*<<format.ml:1428:2>>*/ _I_ = 0;
-    function _J_(acc){
+      /*<<format.ml:1428:2>>*/ _J_ = 0;
+    function _K_(acc){
       /*<<format.ml:1429:16>>*/ return output_acc
              ( /*<<format.ml:1429:27>>*/ caml_call1
                (Stdlib_Domain[10][2], std_formatter_key),
               acc);
      /*<<format.ml:1429:58>>*/ }
      /*<<format.ml:1428:2>>*/ return  /*<<format.ml:1428:2>>*/ caml_call3
-            (CamlinternalFormat[7], _J_, _I_, fmt);
+            (CamlinternalFormat[7], _K_, _J_, fmt);
    }
    function eprintf(param){
      /*<<format.ml:1433:2>>*/ var
      fmt = param[1],
-      /*<<format.ml:1433:2>>*/ _G_ = 0;
-    function _H_(acc){
+      /*<<format.ml:1433:2>>*/ _H_ = 0;
+    function _I_(acc){
       /*<<format.ml:1434:16>>*/ return output_acc
              ( /*<<format.ml:1434:27>>*/ caml_call1
                (Stdlib_Domain[10][2], err_formatter_key),
               acc);
      /*<<format.ml:1434:58>>*/ }
      /*<<format.ml:1433:2>>*/ return  /*<<format.ml:1433:2>>*/ caml_call3
-            (CamlinternalFormat[7], _H_, _G_, fmt);
+            (CamlinternalFormat[7], _I_, _H_, fmt);
    }
    function kdprintf(k, param){
      /*<<format.ml:1438:2>>*/ var
      fmt = param[1],
-      /*<<format.ml:1438:2>>*/ _E_ = 0;
-    function _F_(acc){
+      /*<<format.ml:1438:2>>*/ _F_ = 0;
+    function _G_(acc){
       /*<<format.ml:1439:16>>*/ return  /*<<format.ml:1439:18>>*/ caml_call1
              (k,
               function(ppf){
@@ -27384,7 +27456,7 @@
                /*<<format.ml:1439:48>>*/ });
      /*<<format.ml:1439:49>>*/ }
      /*<<format.ml:1438:2>>*/ return  /*<<format.ml:1438:2>>*/ caml_call3
-            (CamlinternalFormat[7], _F_, _E_, fmt);
+            (CamlinternalFormat[7], _G_, _F_, fmt);
    }
    function dprintf(fmt){
      /*<<format.ml:1442:18>>*/ return kdprintf
@@ -27442,44 +27514,44 @@
      /*<<format.ml:1476:11>>*/ var
       /*<<format.ml:1476:11>>*/ fs =
        pp_get_formatter_out_functions(std_formatter, 0),
-     _m_ = fs[5],
-     _n_ = fs[4],
-     _o_ = fs[3],
-     _p_ = Stdlib[39];
-     /*<<format.ml:1479:25>>*/ function _q_(_D_){
-      /*<<?>>*/ return buffered_out_flush(_p_, std_buf_key, _D_);
+     _n_ = fs[5],
+     _o_ = fs[4],
+     _p_ = fs[3],
+     _q_ = Stdlib[39];
+     /*<<format.ml:1479:25>>*/ function _r_(_E_){
+      /*<<?>>*/ return buffered_out_flush(_q_, std_buf_key, _E_);
     }
      /*<<format.ml:1477:2>>*/ pp_set_formatter_out_functions
      (std_formatter,
       [0,
-       function(_A_, _B_, _C_){
-         /*<<?>>*/ return buffered_out_string(std_buf_key, _A_, _B_, _C_);
+       function(_B_, _C_, _D_){
+         /*<<?>>*/ return buffered_out_string(std_buf_key, _B_, _C_, _D_);
        },
-       _q_,
+       _r_,
+       _p_,
        _o_,
-       _n_,
-       _m_]);
+       _n_]);
      /*<<format.ml:1481:11>>*/ var
       /*<<format.ml:1481:11>>*/ fs$0 =
        pp_get_formatter_out_functions(err_formatter, 0),
-     _r_ = fs$0[5],
-     _s_ = fs$0[4],
-     _t_ = fs$0[3],
-     _u_ = Stdlib[40];
-     /*<<format.ml:1484:25>>*/ function _v_(_z_){
-      /*<<?>>*/ return buffered_out_flush(_u_, err_buf_key, _z_);
+     _s_ = fs$0[5],
+     _t_ = fs$0[4],
+     _u_ = fs$0[3],
+     _v_ = Stdlib[40];
+     /*<<format.ml:1484:25>>*/ function _w_(_A_){
+      /*<<?>>*/ return buffered_out_flush(_v_, err_buf_key, _A_);
     }
      /*<<format.ml:1483:4>>*/ return pp_set_formatter_out_functions
             (err_formatter,
              [0,
-              function(_w_, _x_, _y_){
+              function(_x_, _y_, _z_){
                 /*<<?>>*/ return buffered_out_string
-                       (err_buf_key, _w_, _x_, _y_);
+                       (err_buf_key, _x_, _y_, _z_);
               },
-              _v_,
+              _w_,
+              _u_,
               _t_,
-              _s_,
-              _r_]);
+              _s_]);
     /*<<format.ml:1484:71>>*/ }
     /*<<format.ml:1474:9>>*/  /*<<format.ml:1474:9>>*/ caml_call1
     (Stdlib_Domain[5], _l_);
@@ -27682,6 +27754,7 @@
             : runtime.caml_call_gen(f, [a0, a1, a2, a3]);
    }
    var
+    _u_ = undefined,
     global_data = runtime.caml_get_global_data(),
     cst$3 = cst$5,
     cst$4 = cst$5,
@@ -27805,9 +27878,9 @@
      if(10 === c) ib[5] = ib[5] + 1 | 0;
       /*<<scanf.ml:171:6>>*/ return c;
     }
-    catch(_bb_){
-     var _ba_ = caml_wrap_exception(_bb_);
-     if(_ba_ !== Stdlib[12]) throw caml_maybe_attach_backtrace(_ba_, 0);
+    catch(_bc_){
+     var _bb_ = caml_wrap_exception(_bc_);
+     if(_bb_ !== Stdlib[12]) throw caml_maybe_attach_backtrace(_bb_, 0);
      ib[2] = null_char;
      ib[3] = 0;
      ib[1] = 1;
@@ -27900,8 +27973,8 @@
      /*<<scanf.ml:271:4>>*/ return create(1, next);
     /*<<scanf.ml:271:27>>*/ }
    var _a_ = 0;
-    /*<<scanf.ml:274:22>>*/ function from_function(_a$_){
-     /*<<?>>*/ return create(_a_, _a$_);
+    /*<<scanf.ml:274:22>>*/ function from_function(_ba_){
+     /*<<?>>*/ return create(_a_, _ba_);
    }
     /*<<scanf.ml:274:22>>*/  /*<<scanf.ml:274:22>>*/ var len = 1024;
    function scan_close_at_end(ic){
@@ -27948,12 +28021,12 @@
     return from_ic(scan_close_at_end, [1, fname, ic], ic);
     /*<<scanf.ml:371:53>>*/ }
    var _b_ = Stdlib[79];
-    /*<<scanf.ml:374:16>>*/ function open_in(_a__){
-     /*<<?>>*/ return open_in_file(_b_, _a__);
+    /*<<scanf.ml:374:16>>*/ function open_in(_a$_){
+     /*<<?>>*/ return open_in_file(_b_, _a$_);
    }
     /*<<scanf.ml:374:16>>*/  /*<<scanf.ml:374:16>>*/ var _c_ = Stdlib[80];
-    /*<<scanf.ml:375:20>>*/ function open_in_bin(_a9_){
-     /*<<?>>*/ return open_in_file(_c_, _a9_);
+    /*<<scanf.ml:375:20>>*/ function open_in_bin(_a__){
+     /*<<?>>*/ return open_in_file(_c_, _a__);
    }
    function from_channel(ic){
      /*<<scanf.ml:381:4>>*/ return from_ic(scan_raise_at_end, [0, ic], ic);
@@ -28016,15 +28089,15 @@
      /*<<scanf.ml:444:2>>*/ for(;;){
       /*<<scanf.ml:444:10>>*/ var
        /*<<scanf.ml:444:10>>*/ c = peek_char(ib),
-       /*<<scanf.ml:445:9>>*/ _a7_ = 1 - ib[1];
-     if(! _a7_)  /*<<scanf.ml:445:9>>*/ return _a7_;
-      /*<<scanf.ml:445:32>>*/  /*<<scanf.ml:445:32>>*/ var _a8_ = c - 9 | 0;
+       /*<<scanf.ml:445:9>>*/ _a8_ = 1 - ib[1];
+     if(! _a8_)  /*<<scanf.ml:445:9>>*/ return _a8_;
+      /*<<scanf.ml:445:32>>*/  /*<<scanf.ml:445:32>>*/ var _a9_ = c - 9 | 0;
      a:
      {
-      if(4 < _a8_ >>> 0){
-       if(23 === _a8_) break a;
+      if(4 < _a9_ >>> 0){
+       if(23 === _a9_) break a;
       }
-      else if(1 < _a8_ - 2 >>> 0) break a;
+      else if(1 < _a9_ - 2 >>> 0) break a;
        /*<<scanf.ml:449:11>>*/ return 0;
      }
       /*<<scanf.ml:448:6>>*/ invalidate_current_char(ib);
@@ -28070,23 +28143,23 @@
      /*<<scanf.ml:523:2>>*/ switch(conv){
       case 0:
         /*<<scanf.ml:529:29>>*/ var
-         /*<<scanf.ml:529:29>>*/ _a3_ = token_string(ib),
-        tok =  /*<<scanf.ml:529:22>>*/ caml_call2(Stdlib[28], cst_0b, _a3_);
+         /*<<scanf.ml:529:29>>*/ _a4_ = token_string(ib),
+        tok =  /*<<scanf.ml:529:22>>*/ caml_call2(Stdlib[28], cst_0b, _a4_);
        break;
       case 3:
         /*<<scanf.ml:527:29>>*/ var
-         /*<<scanf.ml:527:29>>*/ _a4_ = token_string(ib),
-        tok =  /*<<scanf.ml:527:22>>*/ caml_call2(Stdlib[28], cst_0o, _a4_);
+         /*<<scanf.ml:527:29>>*/ _a5_ = token_string(ib),
+        tok =  /*<<scanf.ml:527:22>>*/ caml_call2(Stdlib[28], cst_0o, _a5_);
        break;
       case 4:
         /*<<scanf.ml:526:29>>*/ var
-         /*<<scanf.ml:526:29>>*/ _a5_ = token_string(ib),
-        tok =  /*<<scanf.ml:526:22>>*/ caml_call2(Stdlib[28], cst_0u, _a5_);
+         /*<<scanf.ml:526:29>>*/ _a6_ = token_string(ib),
+        tok =  /*<<scanf.ml:526:22>>*/ caml_call2(Stdlib[28], cst_0u, _a6_);
        break;
       case 5:
         /*<<scanf.ml:528:29>>*/ var
-         /*<<scanf.ml:528:29>>*/ _a6_ = token_string(ib),
-        tok =  /*<<scanf.ml:528:22>>*/ caml_call2(Stdlib[28], cst_0x, _a6_);
+         /*<<scanf.ml:528:29>>*/ _a7_ = token_string(ib),
+        tok =  /*<<scanf.ml:528:22>>*/ caml_call2(Stdlib[28], cst_0x, _a7_);
        break;
       default: var tok = token_string(ib);
     }
@@ -28171,31 +28244,31 @@
    function is_binary_digit(param){
      /*<<scanf.ml:629:22>>*/ return 1 < param - 48 >>> 0 ? 0 : 1;
     /*<<scanf.ml:631:14>>*/ }
-    /*<<scanf.ml:634:22>>*/ function scan_binary_int(_a1_, _a2_){
-     /*<<?>>*/ return scan_digit_plus(cst_binary, is_binary_digit, _a1_, _a2_);
+    /*<<scanf.ml:634:22>>*/ function scan_binary_int(_a2_, _a3_){
+     /*<<?>>*/ return scan_digit_plus(cst_binary, is_binary_digit, _a2_, _a3_);
    }
    function is_octal_digit(param){
      /*<<scanf.ml:636:21>>*/ return 7 < param - 48 >>> 0 ? 0 : 1;
     /*<<scanf.ml:638:14>>*/ }
-    /*<<scanf.ml:641:21>>*/ function scan_octal_int(_aZ_, _a0_){
-     /*<<?>>*/ return scan_digit_plus(cst_octal, is_octal_digit, _aZ_, _a0_);
+    /*<<scanf.ml:641:21>>*/ function scan_octal_int(_a0_, _a1_){
+     /*<<?>>*/ return scan_digit_plus(cst_octal, is_octal_digit, _a0_, _a1_);
    }
    function is_hexa_digit(param){
      /*<<scanf.ml:643:20>>*/  /*<<scanf.ml:643:20>>*/ var
-     _aY_ = param - 48 | 0;
+     _aZ_ = param - 48 | 0;
     a:
     {
-     if(22 < _aY_ >>> 0){
-      if(5 < _aY_ - 49 >>> 0) break a;
+     if(22 < _aZ_ >>> 0){
+      if(5 < _aZ_ - 49 >>> 0) break a;
      }
-     else if(6 >= _aY_ - 10 >>> 0) break a;
+     else if(6 >= _aZ_ - 10 >>> 0) break a;
       /*<<scanf.ml:644:44>>*/ return 1;
     }
      /*<<scanf.ml:645:9>>*/ return 0;
     /*<<scanf.ml:645:14>>*/ }
-    /*<<scanf.ml:648:27>>*/ function scan_hexadecimal_int(_aW_, _aX_){
+    /*<<scanf.ml:648:27>>*/ function scan_hexadecimal_int(_aX_, _aY_){
      /*<<?>>*/ return scan_digit_plus
-            (cst_hexadecimal, is_hexa_digit, _aW_, _aX_);
+            (cst_hexadecimal, is_hexa_digit, _aX_, _aY_);
    }
    function scan_sign(width, ib){
      /*<<scanf.ml:654:2>>*/ var
@@ -28315,38 +28388,38 @@
       /*<<scanf.ml:785:2>>*/ len =
         /*<<scanf.ml:785:2>>*/ caml_ml_string_length(str),
       /*<<scanf.ml:786:14>>*/ width$0 = [0, width],
-      /*<<scanf.ml:787:2>>*/ _aT_ = len - 1 | 0,
-      /*<<scanf.ml:786:14>>*/ _aS_ = 0;
-    if(_aT_ >= 0){
-     var i = _aS_;
+      /*<<scanf.ml:787:2>>*/ _aU_ = len - 1 | 0,
+      /*<<scanf.ml:786:14>>*/ _aT_ = 0;
+    if(_aU_ >= 0){
+     var i = _aT_;
      for(;;){
        /*<<scanf.ml:788:12>>*/ var
         /*<<scanf.ml:788:12>>*/ c = peek_char(ib),
-        /*<<scanf.ml:789:22>>*/ _aU_ =
+        /*<<scanf.ml:789:22>>*/ _aV_ =
          lowercase( /*<<scanf.ml:789:32>>*/ caml_string_get(str, i));
-      if(lowercase(c) !== _aU_)
+      if(lowercase(c) !== _aV_)
         /*<<scanf.ml:789:45>>*/  /*<<scanf.ml:789:45>>*/ caml_call1(error, 0);
       if(0 === width$0[1])
         /*<<scanf.ml:790:23>>*/  /*<<scanf.ml:790:23>>*/ caml_call1(error, 0);
       width$0[1] = store_char(width$0[1], ib, c);
-       /*<<scanf.ml:787:2>>*/  /*<<scanf.ml:787:2>>*/ var _aV_ = i + 1 | 0;
-      if(_aT_ === i) break;
-      var i = _aV_;
+       /*<<scanf.ml:787:2>>*/  /*<<scanf.ml:787:2>>*/ var _aW_ = i + 1 | 0;
+      if(_aU_ === i) break;
+      var i = _aW_;
      }
     }
     return width$0[1];
     /*<<scanf.ml:793:8>>*/ }
    function scan_hex_float(width, precision, ib){
      /*<<scanf.ml:797:2>>*/ var
-     _aF_ = 0 === width ? 1 : 0,
-     _aG_ = _aF_ || end_of_input(ib);
-     /*<<scanf.ml:797:18>>*/ if(_aG_)
+     _aG_ = 0 === width ? 1 : 0,
+     _aH_ = _aG_ || end_of_input(ib);
+     /*<<scanf.ml:797:18>>*/ if(_aH_)
       /*<<scanf.ml:797:48>>*/ bad_hex_float(0);
      /*<<scanf.ml:798:14>>*/ var
       /*<<scanf.ml:798:14>>*/ width$0 = scan_sign(width, ib),
-     _aH_ = 0 === width$0 ? 1 : 0,
-     _aI_ = _aH_ || end_of_input(ib);
-     /*<<scanf.ml:799:18>>*/ if(_aI_)
+     _aI_ = 0 === width$0 ? 1 : 0,
+     _aJ_ = _aI_ || end_of_input(ib);
+     /*<<scanf.ml:799:18>>*/ if(_aJ_)
       /*<<scanf.ml:799:48>>*/ bad_hex_float(0);
      /*<<scanf.ml:800:8>>*/  /*<<scanf.ml:800:8>>*/ var c = peek_char(ib);
     a:
@@ -28358,9 +28431,9 @@
        if(32 <= switcher) break a;
         /*<<scanf.ml:830:16>>*/ var
          /*<<scanf.ml:830:16>>*/ width$1 = store_char(width$0, ib, c),
-        _aJ_ = 0 === width$1 ? 1 : 0,
-        _aK_ = _aJ_ || end_of_input(ib);
-        /*<<scanf.ml:831:20>>*/ if(_aK_)
+        _aK_ = 0 === width$1 ? 1 : 0,
+        _aL_ = _aK_ || end_of_input(ib);
+        /*<<scanf.ml:831:20>>*/ if(_aL_)
          /*<<scanf.ml:831:50>>*/ bad_hex_float(0);
         /*<<scanf.ml:831:50>>*/ return check_case_insensitive_string
                (width$1, ib, bad_hex_float, cst_an);
@@ -28371,24 +28444,24 @@
       if(48 === c){
         /*<<scanf.ml:802:16>>*/ var
          /*<<scanf.ml:802:16>>*/ width$3 = store_char(width$0, ib, c),
-        _aN_ = 0 === width$3 ? 1 : 0,
-        _aO_ = _aN_ || end_of_input(ib);
-        /*<<scanf.ml:803:20>>*/ if(_aO_)
+        _aO_ = 0 === width$3 ? 1 : 0,
+        _aP_ = _aO_ || end_of_input(ib);
+        /*<<scanf.ml:803:20>>*/ if(_aP_)
          /*<<scanf.ml:803:50>>*/ bad_hex_float(0);
         /*<<scanf.ml:804:16>>*/  /*<<scanf.ml:804:16>>*/ var
         width$4 =
           check_case_insensitive_string(width$3, ib, bad_hex_float, cst_x);
         /*<<scanf.ml:805:20>>*/ if(0 !== width$4 && ! end_of_input(ib)){
          /*<<scanf.ml:806:24>>*/  /*<<scanf.ml:806:24>>*/ var
-         _aP_ = peek_char(ib) - 46 | 0;
+         _aQ_ = peek_char(ib) - 46 | 0;
         b:
         {
          c:
          {
-          if(34 < _aP_ >>> 0){
-           if(66 === _aP_) break c;
+          if(34 < _aQ_ >>> 0){
+           if(66 === _aQ_) break c;
           }
-          else if(32 < _aP_ - 1 >>> 0) break c;
+          else if(32 < _aQ_ - 1 >>> 0) break c;
           var width$5 = scan_hexadecimal_int(width$4, ib);
           break b;
          }
@@ -28436,9 +28509,9 @@
             /*<<scanf.ml:827:17>>*/ return width$8;
            /*<<scanf.ml:824:24>>*/ var
             /*<<scanf.ml:824:24>>*/ width$9 = store_char(width$8, ib, c$1),
-           _aQ_ = 0 === width$9 ? 1 : 0,
-           _aR_ = _aQ_ || end_of_input(ib);
-           /*<<scanf.ml:825:28>>*/ if(_aR_)
+           _aR_ = 0 === width$9 ? 1 : 0,
+           _aS_ = _aR_ || end_of_input(ib);
+           /*<<scanf.ml:825:28>>*/ if(_aS_)
             /*<<scanf.ml:825:58>>*/ bad_hex_float(0);
            /*<<scanf.ml:825:58>>*/ return scan_optionally_signed_decimal
                   (width$9, ib);
@@ -28453,9 +28526,9 @@
      }
       /*<<scanf.ml:834:16>>*/ var
        /*<<scanf.ml:834:16>>*/ width$2 = store_char(width$0, ib, c),
-      _aL_ = 0 === width$2 ? 1 : 0,
-      _aM_ = _aL_ || end_of_input(ib);
-      /*<<scanf.ml:835:20>>*/ if(_aM_)
+      _aM_ = 0 === width$2 ? 1 : 0,
+      _aN_ = _aM_ || end_of_input(ib);
+      /*<<scanf.ml:835:20>>*/ if(_aN_)
        /*<<scanf.ml:835:50>>*/ bad_hex_float(0);
       /*<<scanf.ml:835:50>>*/ return check_case_insensitive_string
              (width$2, ib, bad_hex_float, cst_nfinity);
@@ -28464,14 +28537,14 @@
     /*<<scanf.ml:837:25>>*/ }
    function scan_caml_float_rest(width, precision, ib){
      /*<<scanf.ml:841:2>>*/ var
-     _aB_ = 0 === width ? 1 : 0,
-     _aC_ = _aB_ || end_of_input(ib);
-     /*<<scanf.ml:841:18>>*/ if(_aC_)  /*<<scanf.ml:841:48>>*/ bad_float(0);
+     _aC_ = 0 === width ? 1 : 0,
+     _aD_ = _aC_ || end_of_input(ib);
+     /*<<scanf.ml:841:18>>*/ if(_aD_)  /*<<scanf.ml:841:48>>*/ bad_float(0);
      /*<<scanf.ml:842:14>>*/ var
       /*<<scanf.ml:842:14>>*/ width$0 = scan_decimal_digit_star(width, ib),
-     _aD_ = 0 === width$0 ? 1 : 0,
-     _aE_ = _aD_ || end_of_input(ib);
-     /*<<scanf.ml:843:18>>*/ if(_aE_)  /*<<scanf.ml:843:48>>*/ bad_float(0);
+     _aE_ = 0 === width$0 ? 1 : 0,
+     _aF_ = _aE_ || end_of_input(ib);
+     /*<<scanf.ml:843:18>>*/ if(_aF_)  /*<<scanf.ml:843:48>>*/ bad_float(0);
      /*<<scanf.ml:844:10>>*/ var
       /*<<scanf.ml:844:10>>*/ c = peek_char(ib),
       /*<<scanf.ml:844:10>>*/ switcher = c - 69 | 0;
@@ -28495,22 +28568,22 @@
     /*<<scanf.ml:862:21>>*/ }
    function scan_caml_float(width, precision, ib){
      /*<<scanf.ml:866:2>>*/ var
-     _an_ = 0 === width ? 1 : 0,
-     _ao_ = _an_ || end_of_input(ib);
-     /*<<scanf.ml:866:18>>*/ if(_ao_)  /*<<scanf.ml:866:48>>*/ bad_float(0);
+     _ao_ = 0 === width ? 1 : 0,
+     _ap_ = _ao_ || end_of_input(ib);
+     /*<<scanf.ml:866:18>>*/ if(_ap_)  /*<<scanf.ml:866:48>>*/ bad_float(0);
      /*<<scanf.ml:867:14>>*/ var
       /*<<scanf.ml:867:14>>*/ width$0 = scan_sign(width, ib),
-     _ap_ = 0 === width$0 ? 1 : 0,
-     _aq_ = _ap_ || end_of_input(ib);
-     /*<<scanf.ml:868:18>>*/ if(_aq_)  /*<<scanf.ml:868:48>>*/ bad_float(0);
+     _aq_ = 0 === width$0 ? 1 : 0,
+     _ar_ = _aq_ || end_of_input(ib);
+     /*<<scanf.ml:868:18>>*/ if(_ar_)  /*<<scanf.ml:868:48>>*/ bad_float(0);
      /*<<scanf.ml:869:8>>*/  /*<<scanf.ml:869:8>>*/ var c = peek_char(ib);
     if(49 <= c){
      if(58 > c){
        /*<<scanf.ml:903:16>>*/ var
         /*<<scanf.ml:903:16>>*/ width$1 = store_char(width$0, ib, c),
-       _ar_ = 0 === width$1 ? 1 : 0,
-       _as_ = _ar_ || end_of_input(ib);
-       /*<<scanf.ml:904:20>>*/ if(_as_)  /*<<scanf.ml:904:50>>*/ bad_float(0);
+       _as_ = 0 === width$1 ? 1 : 0,
+       _at_ = _as_ || end_of_input(ib);
+       /*<<scanf.ml:904:20>>*/ if(_at_)  /*<<scanf.ml:904:50>>*/ bad_float(0);
        /*<<scanf.ml:904:50>>*/ return scan_caml_float_rest
               (width$1, precision, ib);
      }
@@ -28518,9 +28591,9 @@
     else if(48 <= c){
       /*<<scanf.ml:871:16>>*/ var
        /*<<scanf.ml:871:16>>*/ width$2 = store_char(width$0, ib, c),
-      _at_ = 0 === width$2 ? 1 : 0,
-      _au_ = _at_ || end_of_input(ib);
-      /*<<scanf.ml:872:20>>*/ if(_au_)  /*<<scanf.ml:872:50>>*/ bad_float(0);
+      _au_ = 0 === width$2 ? 1 : 0,
+      _av_ = _au_ || end_of_input(ib);
+      /*<<scanf.ml:872:20>>*/ if(_av_)  /*<<scanf.ml:872:50>>*/ bad_float(0);
       /*<<scanf.ml:873:10>>*/  /*<<scanf.ml:873:10>>*/ var
       c$0 = peek_char(ib);
      if(88 !== c$0 && 120 !== c$0)
@@ -28528,14 +28601,14 @@
               (width$2, precision, ib);
       /*<<scanf.ml:875:18>>*/ var
        /*<<scanf.ml:875:18>>*/ width$3 = store_char(width$2, ib, c$0),
-      _av_ = 0 === width$3 ? 1 : 0,
-      _aw_ = _av_ || end_of_input(ib);
-      /*<<scanf.ml:876:22>>*/ if(_aw_)  /*<<scanf.ml:876:52>>*/ bad_float(0);
+      _aw_ = 0 === width$3 ? 1 : 0,
+      _ax_ = _aw_ || end_of_input(ib);
+      /*<<scanf.ml:876:22>>*/ if(_ax_)  /*<<scanf.ml:876:52>>*/ bad_float(0);
       /*<<scanf.ml:877:18>>*/ var
        /*<<scanf.ml:877:18>>*/ width$4 = scan_hexadecimal_int(width$3, ib),
-      _ax_ = 0 === width$4 ? 1 : 0,
-      _ay_ = _ax_ || end_of_input(ib);
-      /*<<scanf.ml:878:22>>*/ if(_ay_)  /*<<scanf.ml:878:52>>*/ bad_float(0);
+      _ay_ = 0 === width$4 ? 1 : 0,
+      _az_ = _ay_ || end_of_input(ib);
+      /*<<scanf.ml:878:22>>*/ if(_az_)  /*<<scanf.ml:878:52>>*/ bad_float(0);
       /*<<scanf.ml:879:24>>*/ var
        /*<<scanf.ml:879:24>>*/ c$1 = peek_char(ib),
        /*<<scanf.ml:879:24>>*/ switcher = c$1 - 80 | 0;
@@ -28588,9 +28661,9 @@
       if(80 !== c$2 && 112 !== c$2)  /*<<scanf.ml:897:15>>*/ return width$8;
        /*<<scanf.ml:894:22>>*/ var
         /*<<scanf.ml:894:22>>*/ width$9 = store_char(width$8, ib, c$2),
-       _az_ = 0 === width$9 ? 1 : 0,
-       _aA_ = _az_ || end_of_input(ib);
-       /*<<scanf.ml:895:26>>*/ if(_aA_)
+       _aA_ = 0 === width$9 ? 1 : 0,
+       _aB_ = _aA_ || end_of_input(ib);
+       /*<<scanf.ml:895:26>>*/ if(_aB_)
         /*<<scanf.ml:895:56>>*/ bad_hex_float(0);
        /*<<scanf.ml:895:56>>*/ return scan_optionally_signed_decimal
               (width$9, ib);
@@ -28607,13 +28680,13 @@
       /*<<scanf.ml:923:7>>*/ if(ib[1])
        /*<<scanf.ml:923:28>>*/ return width$0;
      if(! stp){
-       /*<<scanf.ml:928:8>>*/  /*<<scanf.ml:928:8>>*/ var _am_ = c - 9 | 0;
+       /*<<scanf.ml:928:8>>*/  /*<<scanf.ml:928:8>>*/ var _an_ = c - 9 | 0;
       a:
       {
-       if(4 < _am_ >>> 0){
-        if(23 === _am_) break a;
+       if(4 < _an_ >>> 0){
+        if(23 === _an_) break a;
        }
-       else if(1 < _am_ - 2 >>> 0) break a;
+       else if(1 < _an_ - 2 >>> 0) break a;
         /*<<scanf.ml:930:20>>*/ var
          /*<<scanf.ml:930:20>>*/ width$2 = store_char(width$0, ib, c),
         width$0 = width$2;
@@ -28643,11 +28716,11 @@
                 (Stdlib_Printf[4], _f_, message))
             : c;
     /*<<scanf.ml:998:3>>*/ }
-    /*<<scanf.ml:1001:31>>*/ function check_next_char_for_char(_ak_, _al_){
-     /*<<?>>*/ return check_next_char(cst_a_Char, _ak_, _al_);
+    /*<<scanf.ml:1001:31>>*/ function check_next_char_for_char(_al_, _am_){
+     /*<<?>>*/ return check_next_char(cst_a_Char, _al_, _am_);
    }
-    /*<<scanf.ml:1002:33>>*/ function check_next_char_for_string(_ai_, _aj_){
-     /*<<?>>*/ return check_next_char(cst_a_String, _ai_, _aj_);
+    /*<<scanf.ml:1002:33>>*/ function check_next_char_for_string(_aj_, _ak_){
+     /*<<?>>*/ return check_next_char(cst_a_String, _aj_, _ak_);
    }
    function scan_backslash_char(width, ib){
      /*<<scanf.ml:1005:2>>*/  /*<<scanf.ml:1005:8>>*/ var
@@ -28673,16 +28746,16 @@
        b:
        {
         if(0 <= c && 255 >= c){
-         var _ag_ =  /*<<scanf.ml:963:2>>*/ caml_call1(Stdlib[29], c);
+         var _ah_ =  /*<<scanf.ml:963:2>>*/ caml_call1(Stdlib[29], c);
          break b;
         }
         var
-         _ag_ =
+         _ah_ =
            bad_input
             ( /*<<scanf.ml:961:6>>*/ caml_call4
               (Stdlib_Printf[4], _l_, c0, c1$0, c2$0));
        }
-        /*<<scanf.ml:1017:39>>*/ return store_char(width - 2 | 0, ib, _ag_);
+        /*<<scanf.ml:1017:39>>*/ return store_char(width - 2 | 0, ib, _ah_);
       }
        /*<<scanf.ml:1005:8>>*/  /*<<scanf.ml:1005:8>>*/ var
        switcher = c0 - 92 | 0;
@@ -28694,34 +28767,34 @@
             function(param){
               /*<<scanf.ml:1020:6>>*/ var
                /*<<scanf.ml:1020:14>>*/ c = next_char(ib),
-               /*<<scanf.ml:1020:14>>*/ _ah_ = c - 48 | 0;
+               /*<<scanf.ml:1020:14>>*/ _ai_ = c - 48 | 0;
              a:
              {
-              if(22 < _ah_ >>> 0){
-               if(5 < _ah_ - 49 >>> 0) break a;
+              if(22 < _ai_ >>> 0){
+               if(5 < _ai_ - 49 >>> 0) break a;
               }
-              else if(6 >= _ah_ - 10 >>> 0) break a;
+              else if(6 >= _ai_ - 10 >>> 0) break a;
                /*<<scanf.ml:1022:53>>*/ return c;
              }
               /*<<scanf.ml:1023:13>>*/ return bad_input_escape(c);
              /*<<scanf.ml:1023:31>>*/ },
            /*<<scanf.ml:1024:13>>*/ c1 = get_digit(0),
            /*<<scanf.ml:1025:13>>*/ c2 = get_digit(0),
-           /*<<scanf.ml:985:9>>*/ _ad_ = hexadecimal_value_of_char(c2),
-          c$0 = (16 * hexadecimal_value_of_char(c1) | 0) + _ad_ | 0;
+           /*<<scanf.ml:985:9>>*/ _ae_ = hexadecimal_value_of_char(c2),
+          c$0 = (16 * hexadecimal_value_of_char(c1) | 0) + _ae_ | 0;
          b:
          {
           if(0 <= c$0 && 255 >= c$0){
-           var _af_ =  /*<<scanf.ml:989:2>>*/ caml_call1(Stdlib[29], c$0);
+           var _ag_ =  /*<<scanf.ml:989:2>>*/ caml_call1(Stdlib[29], c$0);
            break b;
           }
           var
-           _af_ =
+           _ag_ =
              bad_input
               ( /*<<scanf.ml:988:6>>*/ caml_call3
                 (Stdlib_Printf[4], _m_, c1, c2));
          }
-          /*<<scanf.ml:1026:39>>*/ return store_char(width - 2 | 0, ib, _af_);
+          /*<<scanf.ml:1026:39>>*/ return store_char(width - 2 | 0, ib, _ag_);
         case 0:
         case 6:
         case 18:
@@ -28737,17 +28810,17 @@
        if(117 > c0)
         switch(c0 - 110 | 0){
           case 0:
-           var _ae_ = 10; break b;
+           var _af_ = 10; break b;
           case 4:
-           var _ae_ = 13; break b;
+           var _af_ = 13; break b;
           case 6:
-           var _ae_ = 9; break b;
+           var _af_ = 9; break b;
         }
       }
-      else if(98 === c0){var _ae_ = 8; break b;}
-      var _ae_ = c0;
+      else if(98 === c0){var _af_ = 8; break b;}
+      var _af_ = c0;
      }
-      /*<<scanf.ml:1007:33>>*/ return store_char(width, ib, _ae_);
+      /*<<scanf.ml:1007:33>>*/ return store_char(width, ib, _af_);
     }
      /*<<scanf.ml:1028:4>>*/ return bad_input_escape(c0);
     /*<<scanf.ml:1028:22>>*/ }
@@ -28765,24 +28838,24 @@
           check_next_char_for_string(width$1, ib);
        if(10 === match){
          /*<<scanf.ml:1071:26>>*/  /*<<scanf.ml:1071:26>>*/ var
-         _ab_ = ignore_char(width$1, ib);
+         _ac_ = ignore_char(width$1, ib);
          /*<<scanf.ml:1071:26>>*/ if(counter >= 50)
           /*<<scanf.ml:1071:26>>*/ return  /*<<scanf.ml:1071:26>>*/ caml_trampoline_return
-                 (skip_spaces, [0, _ab_]);
+                 (skip_spaces, [0, _ac_]);
         var counter$0 = counter + 1 | 0;
-         /*<<scanf.ml:1071:26>>*/ return skip_spaces(counter$0, _ab_);
+         /*<<scanf.ml:1071:26>>*/ return skip_spaces(counter$0, _ac_);
        }
        if(13 === match){
          /*<<scanf.ml:1070:27>>*/  /*<<scanf.ml:1070:27>>*/ var
          width$3 = ignore_char(width$1, ib);
         if(10 === check_next_char_for_string(width$3, ib)){
           /*<<scanf.ml:1076:26>>*/  /*<<scanf.ml:1076:26>>*/ var
-          _ac_ = ignore_char(width$3, ib);
+          _ad_ = ignore_char(width$3, ib);
           /*<<scanf.ml:1076:26>>*/ if(counter >= 50)
            /*<<scanf.ml:1076:26>>*/ return  /*<<scanf.ml:1076:26>>*/ caml_trampoline_return
-                  (skip_spaces, [0, _ac_]);
+                  (skip_spaces, [0, _ad_]);
          var counter$1 = counter + 1 | 0;
-          /*<<scanf.ml:1076:26>>*/ return skip_spaces(counter$1, _ac_);
+          /*<<scanf.ml:1076:26>>*/ return skip_spaces(counter$1, _ad_);
         }
          /*<<scanf.ml:1077:21>>*/ var
           /*<<scanf.ml:1077:21>>*/ width$5 = store_char(width$3, ib, 13),
@@ -28829,34 +28902,42 @@
       /*<<scanf.ml:1104:4>>*/ for(;;){
        /*<<scanf.ml:1104:12>>*/ var
         /*<<scanf.ml:1104:12>>*/ c = peek_char(ib),
-       _Z_ = 0 < i$0 ? 1 : 0;
-      if(_Z_){
+       ___ = 0 < i$0 ? 1 : 0;
+      if(___){
         /*<<scanf.ml:1105:20>>*/  /*<<scanf.ml:1105:20>>*/ var
-        ___ = 1 - ib[1];
-       if(___)
+        _$_ = 1 - ib[1];
+       if(_$_)
          /*<<scanf.ml:1106:7>>*/ var
-          /*<<scanf.ml:1106:7>>*/ _$_ =
+          /*<<scanf.ml:1106:7>>*/ _aa_ =
             /*<<scanf.ml:1106:7>>*/ caml_call2
             (CamlinternalFormat[1], char_set, c),
-          /*<<scanf.ml:1106:7>>*/ _aa_ = _$_ ? c !== stp ? 1 : 0 : _$_;
+          /*<<scanf.ml:1106:7>>*/ _ab_ = _aa_ ? c !== stp ? 1 : 0 : _aa_;
        else
-        var _aa_ = ___;
+        var _ab_ = _$_;
       }
       else
-       var _aa_ = _Z_;
-      if(! _aa_) return _aa_;
+       var _ab_ = ___;
+      if(! _ab_) return _ab_;
        /*<<scanf.ml:1108:14>>*/ store_char(Stdlib[19], ib, c);
       var i$1 = i$0 - 1 | 0, i$0 = i$1;
      }
      /*<<scanf.ml:1109:28>>*/ }
-    if(! scan_indic)  /*<<scanf.ml:1111:12>>*/ return scan_chars(width, -1);
+    if(! scan_indic){
+      /*<<scanf.ml:1111:12>>*/ scan_chars(width, -1);
+      /*<<scanf.ml:1111:12>>*/ return;
+    }
     var c = scan_indic[1];
      /*<<scanf.ml:1113:4>>*/ scan_chars(width, c);
-     /*<<scanf.ml:1114:11>>*/  /*<<scanf.ml:1114:11>>*/ var _Y_ = 1 - ib[1];
-    if(! _Y_)  /*<<scanf.ml:1114:11>>*/ return _Y_;
+     /*<<scanf.ml:1114:11>>*/  /*<<scanf.ml:1114:11>>*/ var _Z_ = 1 - ib[1];
+    if(! _Z_)  /*<<scanf.ml:1114:11>>*/ return _Z_;
      /*<<scanf.ml:1115:15>>*/  /*<<scanf.ml:1115:15>>*/ var
      ci = peek_char(ib);
-    return c === ci ? invalidate_current_char(ib) : character_mismatch(c, ci);
+    if(c === ci){
+      /*<<scanf.ml:1117:11>>*/ invalidate_current_char(ib);
+      /*<<scanf.ml:1117:11>>*/ return;
+    }
+     /*<<scanf.ml:1118:11>>*/ character_mismatch(c, ci);
+     /*<<scanf.ml:1118:11>>*/ return;
     /*<<scanf.ml:1118:34>>*/ }
    function scanf_bad_input(ib, x){
      /*<<?>>*/ if(x[1] === Scan_failure)
@@ -28933,17 +29014,17 @@
          /*<<scanf.ml:1195:44>>*/ var
          rest$13 = fmt$0[3],
          fmtty = fmt$0[2],
-          /*<<scanf.ml:1195:44>>*/ _V_ =
+          /*<<scanf.ml:1195:44>>*/ _W_ =
             /*<<scanf.ml:1195:44>>*/ caml_call1(CamlinternalFormat[21], fmtty),
-          /*<<scanf.ml:1195:33>>*/ _W_ =
+          /*<<scanf.ml:1195:33>>*/ _X_ =
             /*<<scanf.ml:1195:33>>*/ caml_call1
-            (CamlinternalFormatBasics[2], _V_);
+            (CamlinternalFormatBasics[2], _W_);
          /*<<scanf.ml:1195:5>>*/ if(counter >= 50)
           /*<<scanf.ml:1195:5>>*/ return  /*<<scanf.ml:1195:5>>*/ caml_trampoline_return
-                 (take_fmtty_format_readers$0, [0, k, _W_, rest$13]);
+                 (take_fmtty_format_readers$0, [0, k, _X_, rest$13]);
         var counter$0 = counter + 1 | 0;
          /*<<scanf.ml:1195:5>>*/ return take_fmtty_format_readers$0
-                (counter$0, k, _W_, rest$13);
+                (counter$0, k, _X_, rest$13);
        case 15:
         var rest$14 = fmt$0[1], fmt$0 = rest$14; break;
        case 16:
@@ -28951,11 +29032,11 @@
        case 17:
         var rest$16 = fmt$0[2], fmt$0 = rest$16; break;
        case 18:
-        var _X_ = fmt$0[1];
-        if(0 === _X_[0])
+        var _Y_ = fmt$0[1];
+        if(0 === _Y_[0])
           /*<<scanf.ml:1189:28>>*/ var
           rest$17 = fmt$0[2],
-          fmt$1 = _X_[1][1],
+          fmt$1 = _Y_[1][1],
            /*<<scanf.ml:1189:28>>*/ fmt$2 =
              /*<<scanf.ml:1189:28>>*/ caml_call2
              (CamlinternalFormatBasics[3], fmt$1, rest$17),
@@ -28963,7 +29044,7 @@
         else
           /*<<scanf.ml:1191:28>>*/ var
           rest$18 = fmt$0[2],
-          fmt$3 = _X_[1][1],
+          fmt$3 = _Y_[1][1],
            /*<<scanf.ml:1191:28>>*/ fmt$4 =
              /*<<scanf.ml:1191:28>>*/ caml_call2
              (CamlinternalFormatBasics[3], fmt$3, rest$18),
@@ -29073,11 +29154,11 @@
          rest = fmtty$0[3],
          ty2 = fmtty$0[2],
          ty1 = fmtty$0[1],
-          /*<<scanf.ml:1227:19>>*/ _U_ =
+          /*<<scanf.ml:1227:19>>*/ _V_ =
             /*<<scanf.ml:1227:19>>*/ caml_call1(CamlinternalFormat[21], ty1),
           /*<<scanf.ml:1227:13>>*/ ty =
             /*<<scanf.ml:1227:13>>*/ caml_call2
-            (CamlinternalFormat[22], _U_, ty2),
+            (CamlinternalFormat[22], _V_, ty2),
           /*<<scanf.ml:1228:32>>*/ fmtty$10 =
             /*<<scanf.ml:1228:32>>*/ caml_call2
             (CamlinternalFormatBasics[1], ty, rest),
@@ -29181,9 +29262,12 @@
            function(width){
              /*<<scanf.ml:1047:4>>*/  /*<<scanf.ml:1047:10>>*/ var
              c = check_next_char_for_char(width, ib);
-            return 39 === c
-                    ? ignore_char(width, ib)
-                    : character_mismatch(39, c);
+            if(39 === c){
+              /*<<scanf.ml:1034:2>>*/ ignore_char(width, ib);
+              /*<<scanf.ml:1034:2>>*/ return;
+            }
+             /*<<scanf.ml:1049:11>>*/ character_mismatch(39, c);
+             /*<<scanf.ml:1049:11>>*/ return;
             /*<<scanf.ml:1049:36>>*/ },
           /*<<scanf.ml:1035:10>>*/ c = checked_peek_char(ib);
         if(39 === c){
@@ -29224,11 +29308,11 @@
              /*<<scanf.ml:1280:4>>*/ return pad_prec_scanf
                     (ib, str_rest, readers, pad, 0, scan$0, token_string);
            case 18:
-            var _G_ = match[1];
-            if(0 === _G_[0]){
+            var _H_ = match[1];
+            if(0 === _H_[0]){
               /*<<scanf.ml:1282:4>>*/ var
               rest$3 = match[2],
-              fmt$1 = _G_[1][1],
+              fmt$1 = _H_[1][1],
                /*<<scanf.ml:1282:4>>*/ scan$1 =
                 function(width, param, ib){
                   /*<<scanf.ml:1282:26>>*/ return scan_string(_q_, width, ib);
@@ -29245,7 +29329,7 @@
             }
              /*<<scanf.ml:1286:4>>*/ var
              rest$4 = match[2],
-             fmt$2 = _G_[1][1],
+             fmt$2 = _H_[1][1],
               /*<<scanf.ml:1286:4>>*/ scan$2 =
                function(width, param, ib){
                  /*<<scanf.ml:1286:26>>*/ return scan_string(_r_, width, ib);
@@ -29422,7 +29506,7 @@
          rest$13 = fmt$0[2],
          pad$8 = fmt$0[1],
           /*<<scanf.ml:1320:4>>*/ scan$8 =
-           function(param, _T_, ib){
+           function(param, _U_, ib){
              /*<<scanf.ml:1320:22>>*/ var
               /*<<scanf.ml:1089:10>>*/ c = checked_peek_char(ib),
               /*<<scanf.ml:1090:2>>*/ m =
@@ -29448,10 +29532,10 @@
          /*<<scanf.ml:1341:16>>*/ var
          rest$15 = fmt$0[2],
          str$0 = fmt$0[1],
-          /*<<scanf.ml:1341:16>>*/ _H_ =
-           function(_S_){ /*<<?>>*/ return check_char(ib, _S_);};
+          /*<<scanf.ml:1341:16>>*/ _I_ =
+           function(_T_){ /*<<?>>*/ return check_char(ib, _T_);};
          /*<<scanf.ml:1341:4>>*/  /*<<scanf.ml:1341:4>>*/ caml_call2
-         (Stdlib_String[30], _H_, str$0);
+         (Stdlib_String[30], _I_, str$0);
         var fmt$0 = rest$15;
         break;
        case 12:
@@ -29467,10 +29551,10 @@
          s = token_string(ib);
          /*<<scanf.ml:1350:4>>*/ try{
           /*<<scanf.ml:1351:10>>*/ var
-           /*<<scanf.ml:1351:10>>*/ _I_ =
+           /*<<scanf.ml:1351:10>>*/ _J_ =
              /*<<scanf.ml:1351:10>>*/ caml_call2
              (CamlinternalFormat[14], s, fmtty),
-          fmt$3 = _I_;
+          fmt$3 = _J_;
         }
         catch(exn$0){
          var exn = caml_wrap_exception(exn$0);
@@ -29496,23 +29580,23 @@
              /*<<scanf.ml:1361:27>>*/ caml_call2
               (CamlinternalFormat[13], 0, s$0)
              [1],
-           /*<<scanf.ml:1375:36>>*/ _K_ =
+           /*<<scanf.ml:1375:36>>*/ _L_ =
              /*<<scanf.ml:1375:36>>*/ caml_call1
              (CamlinternalFormat[21], fmtty$0),
-           /*<<scanf.ml:1375:25>>*/ _L_ =
+           /*<<scanf.ml:1375:25>>*/ _M_ =
              /*<<scanf.ml:1375:25>>*/ caml_call1
-             (CamlinternalFormatBasics[2], _K_),
+             (CamlinternalFormatBasics[2], _L_),
            /*<<scanf.ml:1375:8>>*/ fmt$8 =
              /*<<scanf.ml:1375:8>>*/ caml_call2
-             (CamlinternalFormat[12], fmt$7, _L_),
-           /*<<scanf.ml:1374:24>>*/ _M_ =
+             (CamlinternalFormat[12], fmt$7, _M_),
+           /*<<scanf.ml:1374:24>>*/ _N_ =
              /*<<scanf.ml:1374:24>>*/ caml_call1
              (CamlinternalFormatBasics[2], fmtty$0),
-           /*<<scanf.ml:1374:8>>*/ _N_ =
+           /*<<scanf.ml:1374:8>>*/ _O_ =
              /*<<scanf.ml:1374:8>>*/ caml_call2
-             (CamlinternalFormat[12], fmt$6, _M_),
+             (CamlinternalFormat[12], fmt$6, _N_),
           fmt$5 = fmt$8,
-          fmt$4 = _N_;
+          fmt$4 = _O_;
         }
         catch(exn){
          var exn$0 = caml_wrap_exception(exn);
@@ -29520,9 +29604,9 @@
           throw caml_maybe_attach_backtrace(exn$0, 0);
          var
           msg$0 = exn$0[2],
-          _J_ = bad_input(msg$0),
-          fmt$5 = _J_[2],
-          fmt$4 = _J_[1];
+          _K_ = bad_input(msg$0),
+          fmt$5 = _K_[2],
+          fmt$4 = _K_[1];
         }
          /*<<scanf.ml:1378:4>>*/ return [0,
                 [0, fmt$4, s$0],
@@ -29541,19 +29625,19 @@
          /*<<scanf.ml:1401:32>>*/ var
          rest$19 = fmt$0[2],
          formatting_lit = fmt$0[1],
-          /*<<scanf.ml:1401:32>>*/ _O_ =
+          /*<<scanf.ml:1401:32>>*/ _P_ =
             /*<<scanf.ml:1401:32>>*/ caml_call1
             (CamlinternalFormat[17], formatting_lit),
-          /*<<scanf.ml:1401:16>>*/ _P_ =
-           function(_R_){ /*<<?>>*/ return check_char(ib, _R_);};
+          /*<<scanf.ml:1401:16>>*/ _Q_ =
+           function(_S_){ /*<<?>>*/ return check_char(ib, _S_);};
          /*<<scanf.ml:1401:4>>*/  /*<<scanf.ml:1401:4>>*/ caml_call2
-         (Stdlib_String[30], _P_, _O_);
+         (Stdlib_String[30], _Q_, _P_);
         var fmt$0 = rest$19;
         break;
        case 18:
-        var _Q_ = fmt$0[1];
-        if(0 === _Q_[0]){
-         var rest$20 = fmt$0[2], fmt$9 = _Q_[1][1];
+        var _R_ = fmt$0[1];
+        if(0 === _R_[0]){
+         var rest$20 = fmt$0[2], fmt$9 = _R_[1][1];
           /*<<scanf.ml:1404:4>>*/ check_char(ib, 64);
           /*<<scanf.ml:1404:23>>*/ check_char(ib, 123);
           /*<<scanf.ml:1405:18>>*/ var
@@ -29563,7 +29647,7 @@
           fmt$0 = fmt$10;
         }
         else{
-         var rest$21 = fmt$0[2], fmt$11 = _Q_[1][1];
+         var rest$21 = fmt$0[2], fmt$11 = _R_[1][1];
           /*<<scanf.ml:1407:4>>*/ check_char(ib, 64);
           /*<<scanf.ml:1407:23>>*/ check_char(ib, 91);
           /*<<scanf.ml:1408:18>>*/ var
@@ -29672,16 +29756,16 @@
        if(exc[1] !== Stdlib[6]) throw caml_maybe_attach_backtrace(exc, 0);
         /*<<scanf.ml:1470:45>>*/ var
         msg = exc[2],
-         /*<<scanf.ml:1470:45>>*/ _C_ =
-           /*<<scanf.ml:1470:45>>*/ caml_call1(Stdlib_String[25], str),
          /*<<scanf.ml:1470:45>>*/ _D_ =
-           /*<<scanf.ml:1470:45>>*/ caml_call2(Stdlib[28], _C_, cst$0),
-         /*<<scanf.ml:1470:27>>*/ _E_ =
-           /*<<scanf.ml:1470:27>>*/ caml_call2(Stdlib[28], cst_in_format, _D_),
-         /*<<scanf.ml:1470:20>>*/ _F_ =
-           /*<<scanf.ml:1470:20>>*/ caml_call2(Stdlib[28], msg, _E_);
+           /*<<scanf.ml:1470:45>>*/ caml_call1(Stdlib_String[25], str),
+         /*<<scanf.ml:1470:45>>*/ _E_ =
+           /*<<scanf.ml:1470:45>>*/ caml_call2(Stdlib[28], _D_, cst$0),
+         /*<<scanf.ml:1470:27>>*/ _F_ =
+           /*<<scanf.ml:1470:27>>*/ caml_call2(Stdlib[28], cst_in_format, _E_),
+         /*<<scanf.ml:1470:20>>*/ _G_ =
+           /*<<scanf.ml:1470:20>>*/ caml_call2(Stdlib[28], msg, _F_);
         /*<<scanf.ml:1470:20>>*/ return  /*<<scanf.ml:1470:20>>*/ caml_call1
-               (Stdlib[1], _F_);
+               (Stdlib[1], _G_);
       }
        /*<<scanf.ml:1468:8>>*/ return  /*<<scanf.ml:1468:8>>*/ caml_call2
               (ef, ib, exc);
@@ -29712,15 +29796,15 @@
              fmt);
     /*<<scanf.ml:1477:35>>*/ }
    function kscanf_opt(ib, fmt){
-    function _A_(x){
+    function _B_(x){
       /*<<scanf.ml:1480:44>>*/ return [0, x];
      /*<<scanf.ml:1480:50>>*/ }
      /*<<scanf.ml:1480:2>>*/ return kscanf_gen
             (ib,
-             function(param, _B_){
+             function(param, _C_){
                /*<<scanf.ml:1480:28>>*/ return 0;
               /*<<scanf.ml:1480:32>>*/ },
-             _A_,
+             _B_,
              fmt);
     /*<<scanf.ml:1480:55>>*/ }
    function bscanf(ib, fmt){
@@ -29751,10 +29835,10 @@
      str = token_string(ib);
      /*<<scanf.ml:1504:4>>*/ try{
       /*<<scanf.ml:1505:10>>*/ var
-       /*<<scanf.ml:1505:10>>*/ _z_ =
+       /*<<scanf.ml:1505:10>>*/ _A_ =
          /*<<scanf.ml:1505:10>>*/ caml_call2
          (CamlinternalFormat[15], str, format),
-      fmt = _z_;
+      fmt = _A_;
     }
     catch(exn$0){
      var exn = caml_wrap_exception(exn$0);
@@ -29768,30 +29852,30 @@
      /*<<scanf.ml:1513:20>>*/ return bscanf_format(from_string(s), format, f);
     /*<<scanf.ml:1513:67>>*/ }
    function format_from_string(s, fmt){
-     /*<<scanf.ml:1517:2>>*/ function _w_(x){
+     /*<<scanf.ml:1517:2>>*/ function _x_(x){
       /*<<scanf.ml:1517:63>>*/ return x;
      /*<<scanf.ml:1517:64>>*/ }
      /*<<scanf.ml:1517:24>>*/ var
-      /*<<scanf.ml:1517:24>>*/ _x_ =
-        /*<<scanf.ml:1517:24>>*/ caml_call1(Stdlib_String[25], s),
       /*<<scanf.ml:1517:24>>*/ _y_ =
-        /*<<scanf.ml:1517:24>>*/ caml_call2(Stdlib[28], _x_, cst$1);
+        /*<<scanf.ml:1517:24>>*/ caml_call1(Stdlib_String[25], s),
+      /*<<scanf.ml:1517:24>>*/ _z_ =
+        /*<<scanf.ml:1517:24>>*/ caml_call2(Stdlib[28], _y_, cst$1);
      /*<<scanf.ml:1517:53>>*/ return sscanf_format
-            ( /*<<scanf.ml:1517:16>>*/ caml_call2(Stdlib[28], cst$2, _y_),
+            ( /*<<scanf.ml:1517:16>>*/ caml_call2(Stdlib[28], cst$2, _z_),
              fmt,
-             _w_);
+             _x_);
     /*<<scanf.ml:1517:65>>*/ }
    function unescaped(s){
-     /*<<scanf.ml:1521:2>>*/ function _u_(x){
+     /*<<scanf.ml:1521:2>>*/ function _v_(x){
       /*<<scanf.ml:1521:44>>*/ return x;
      /*<<scanf.ml:1521:45>>*/ }
      /*<<scanf.ml:1521:17>>*/  /*<<scanf.ml:1521:17>>*/ var
-     _v_ =  /*<<scanf.ml:1521:17>>*/ caml_call2(Stdlib[28], s, cst$3);
+     _w_ =  /*<<scanf.ml:1521:17>>*/ caml_call2(Stdlib[28], s, cst$3);
      /*<<scanf.ml:1521:34>>*/ return  /*<<scanf.ml:1521:34>>*/ caml_call1
             (sscanf
-              ( /*<<scanf.ml:1521:9>>*/ caml_call2(Stdlib[28], cst$4, _v_),
+              ( /*<<scanf.ml:1521:9>>*/ caml_call2(Stdlib[28], cst$4, _w_),
                _t_),
-             _u_);
+             _v_);
     /*<<scanf.ml:1521:46>>*/ }
    var
     Stdlib_Scanf =
@@ -31156,6 +31240,7 @@
             : runtime.caml_call_gen(f, [a0, a1, a2]);
    }
    var
+    _d_ = undefined,
     global_data = runtime.caml_get_global_data(),
     Stdlib_List = global_data.Stdlib__List,
     Stdlib = global_data.Stdlib,
@@ -31174,7 +31259,7 @@
      /*<<ephemeron.ml:105:20>>*/  /*<<ephemeron.ml:105:20>>*/ var
      prng =
        [246,
-        function(_aM_){ /*<<?>>*/ return caml_call1(Stdlib_Random[15][2], 0);}];
+        function(_aN_){ /*<<?>>*/ return caml_call1(Stdlib_Random[15][2], 0);}];
     function create(opt, initial_size){
       /*<<ephemeron.ml:108:6>>*/ if(opt)
       var sth = opt[1], random = sth;
@@ -31185,17 +31270,17 @@
       /*<<ephemeron.ml:101:6>>*/ for(;;){
       if(initial_size > x && Stdlib_Sys[13] >= (x * 2 | 0)){var x$0 = x * 2 | 0, x = x$0; continue;}
        /*<<ephemeron.ml:109:6>>*/ if(random){
-       var _aK_ = runtime.caml_obj_tag(prng);
+       var _aL_ = runtime.caml_obj_tag(prng);
        a:
-       if(250 === _aK_)
-        var _aL_ = prng[1];
+       if(250 === _aL_)
+        var _aM_ = prng[1];
        else{
-        if(246 !== _aK_ && 244 !== _aK_){var _aL_ = prng; break a;}
-        var _aL_ = caml_call1(CamlinternalLazy[2], prng);
+        if(246 !== _aL_ && 244 !== _aL_){var _aM_ = prng; break a;}
+        var _aM_ = caml_call1(CamlinternalLazy[2], prng);
        }
        var
         seed =
-           /*<<ephemeron.ml:109:32>>*/ caml_call1(Stdlib_Random[15][4], _aL_);
+           /*<<ephemeron.ml:109:32>>*/ caml_call1(Stdlib_Random[15][4], _aM_);
       }
       else
        var seed = 0;
@@ -31210,16 +31295,16 @@
       /*<<ephemeron.ml:113:6>>*/ h[1] = 0;
       /*<<ephemeron.ml:115:6>>*/ var
       len = h[2].length - 1,
-       /*<<ephemeron.ml:115:6>>*/ _aI_ = len - 1 | 0,
-      _aH_ = 0;
-     if(_aI_ >= 0){
-      var i = _aH_;
+       /*<<ephemeron.ml:115:6>>*/ _aJ_ = len - 1 | 0,
+      _aI_ = 0;
+     if(_aJ_ >= 0){
+      var i = _aI_;
       for(;;){
         /*<<ephemeron.ml:116:8>>*/ caml_check_bound(h[2], i)[1 + i] = 0;
         /*<<ephemeron.ml:116:8>>*/  /*<<ephemeron.ml:116:8>>*/ var
-        _aJ_ = i + 1 | 0;
-       if(_aI_ === i) break;
-       var i = _aJ_;
+        _aK_ = i + 1 | 0;
+       if(_aJ_ === i) break;
+       var i = _aK_;
       }
      }
      return 0;
@@ -31236,11 +31321,11 @@
      /*<<ephemeron.ml:126:9>>*/ }
     function copy(h){
       /*<<ephemeron.ml:128:17>>*/ var
-      _aE_ = h[4],
-      _aF_ = h[3],
-       /*<<ephemeron.ml:128:33>>*/ _aG_ =
+      _aF_ = h[4],
+      _aG_ = h[3],
+       /*<<ephemeron.ml:128:33>>*/ _aH_ =
          /*<<ephemeron.ml:128:33>>*/ caml_call1(Stdlib_Array[6], h[2]);
-      /*<<ephemeron.ml:128:17>>*/ return [0, h[1], _aG_, _aF_, _aE_];
+      /*<<ephemeron.ml:128:17>>*/ return [0, h[1], _aH_, _aG_, _aF_];
      /*<<ephemeron.ml:128:52>>*/ }
     function key_index(h, hkey){
       /*<<ephemeron.ml:131:6>>*/ return hkey & (h[2].length - 1 - 1 | 0);
@@ -31260,16 +31345,16 @@
        var param$0 = rest;
       }
       /*<<ephemeron.ml:141:41>>*/ }
-     var d = h[2], _aC_ = d.length - 1 - 1 | 0, _aB_ = 0;
-     if(_aC_ >= 0){
-      var i = _aB_;
+     var d = h[2], _aD_ = d.length - 1 - 1 | 0, _aC_ = 0;
+     if(_aD_ >= 0){
+      var i = _aC_;
       for(;;){
         /*<<ephemeron.ml:145:8>>*/ d[1 + i] =
         do_bucket(caml_check_bound(d, i)[1 + i]);
         /*<<ephemeron.ml:145:8>>*/  /*<<ephemeron.ml:145:8>>*/ var
-        _aD_ = i + 1 | 0;
-       if(_aC_ === i) break;
-       var i = _aD_;
+        _aE_ = i + 1 | 0;
+       if(_aD_ === i) break;
+       var i = _aE_;
       }
      }
      return 0;
@@ -31281,9 +31366,9 @@
       nsize = osize * 2 | 0;
       /*<<ephemeron.ml:172:6>>*/ clean(h);
      var
-      _av_ = nsize < Stdlib_Sys[13] ? 1 : 0,
-      _aw_ = _av_ ? (osize >>> 1 | 0) <= h[1] ? 1 : 0 : _av_;
-     if(_aw_){
+      _aw_ = nsize < Stdlib_Sys[13] ? 1 : 0,
+      _ax_ = _aw_ ? (osize >>> 1 | 0) <= h[1] ? 1 : 0 : _aw_;
+     if(_ax_){
        /*<<ephemeron.ml:174:20>>*/  /*<<ephemeron.ml:174:20>>*/ var
        ndata =  /*<<ephemeron.ml:174:20>>*/ caml_make_vect(nsize, 0);
       h[2] = ndata;
@@ -31291,33 +31376,33 @@
        insert_bucket =
          function(param){
            /*<<ephemeron.ml:176:32>>*/ if(! param)
-            /*<<ephemeron.ml:177:21>>*/ return 0;
+            /*<<ephemeron.ml:177:21>>*/ return;
           var rest = param[3], data = param[2], hkey = param[1];
            /*<<ephemeron.ml:179:14>>*/ insert_bucket(rest);
            /*<<ephemeron.ml:180:25>>*/  /*<<ephemeron.ml:180:25>>*/ var
            nidx = key_index(h, hkey);
            /*<<ephemeron.ml:181:14>>*/ ndata[1 + nidx] =
            [0, hkey, data, caml_check_bound(ndata, nidx)[1 + nidx]];
-           /*<<ephemeron.ml:181:14>>*/ return 0;
+           /*<<ephemeron.ml:181:14>>*/ return;
           /*<<ephemeron.ml:181:60>>*/ },
-        /*<<ephemeron.ml:170:6>>*/ _ay_ = osize - 1 | 0,
-        /*<<ephemeron.ml:182:8>>*/ _ax_ = 0;
-      if(_ay_ >= 0){
-       var i = _ax_;
+        /*<<ephemeron.ml:170:6>>*/ _az_ = osize - 1 | 0,
+        /*<<ephemeron.ml:182:8>>*/ _ay_ = 0;
+      if(_az_ >= 0){
+       var i = _ay_;
        for(;;){
          /*<<ephemeron.ml:183:10>>*/ insert_bucket
          (caml_check_bound(odata, i)[1 + i]);
          /*<<ephemeron.ml:183:10>>*/  /*<<ephemeron.ml:183:10>>*/ var
-         _aA_ = i + 1 | 0;
-        if(_ay_ === i) break;
-        var i = _aA_;
+         _aB_ = i + 1 | 0;
+        if(_az_ === i) break;
+        var i = _aB_;
        }
       }
-      var _az_ = 0;
+      var _aA_ = 0;
      }
      else
-      var _az_ = _aw_;
-     return _az_;
+      var _aA_ = _ax_;
+     return _aA_;
      /*<<ephemeron.ml:185:9>>*/ }
     function add(h, key, info){
       /*<<ephemeron.ml:188:6>>*/ var
@@ -31330,8 +31415,8 @@
         [0, hkey, container, caml_check_bound(h[2], i)[1 + i]];
       /*<<ephemeron.ml:192:6>>*/ caml_check_bound(h[2], i)[1 + i] = bucket;
      h[1] = h[1] + 1 | 0;
-     var _au_ = h[2].length - 1 << 1 < h[1] ? 1 : 0;
-     return _au_ ? resize(h) : _au_;
+     var _av_ = h[2].length - 1 << 1 < h[1] ? 1 : 0;
+     return _av_ ? resize(h) : _av_;
      /*<<ephemeron.ml:194:57>>*/ }
     function remove(h, key){
       /*<<ephemeron.ml:197:6>>*/  /*<<ephemeron.ml:197:17>>*/ var
@@ -31359,17 +31444,17 @@
       /*<<ephemeron.ml:210:60>>*/ }
       /*<<ephemeron.ml:211:14>>*/ var
        /*<<ephemeron.ml:211:14>>*/ i = key_index(h, hkey),
-       /*<<ephemeron.ml:212:20>>*/ _at_ =
+       /*<<ephemeron.ml:212:20>>*/ _au_ =
         remove_bucket(caml_check_bound(h[2], i)[1 + i]);
-      /*<<ephemeron.ml:212:6>>*/ caml_check_bound(h[2], i)[1 + i] = _at_;
+      /*<<ephemeron.ml:212:6>>*/ caml_check_bound(h[2], i)[1 + i] = _au_;
       /*<<ephemeron.ml:212:6>>*/ return 0;
      /*<<ephemeron.ml:212:44>>*/ }
     function find(h, key){
       /*<<ephemeron.ml:239:6>>*/ var
        /*<<ephemeron.ml:239:17>>*/ hkey =
          /*<<ephemeron.ml:239:17>>*/ caml_call2(H[2], h[3], key),
-       /*<<ephemeron.ml:241:33>>*/ _as_ = key_index(h, hkey),
-      param = caml_check_bound(h[2], _as_)[1 + _as_];
+       /*<<ephemeron.ml:241:33>>*/ _at_ = key_index(h, hkey),
+      param = caml_check_bound(h[2], _at_)[1 + _at_];
      for(;;){
       if(! param)
         /*<<ephemeron.ml:220:10>>*/ throw  /*<<ephemeron.ml:220:10>>*/ caml_maybe_attach_backtrace
@@ -31395,8 +31480,8 @@
       /*<<ephemeron.ml:264:6>>*/ var
        /*<<ephemeron.ml:264:17>>*/ hkey =
          /*<<ephemeron.ml:264:17>>*/ caml_call2(H[2], h[3], key),
-       /*<<ephemeron.ml:266:37>>*/ _ar_ = key_index(h, hkey),
-      param = caml_check_bound(h[2], _ar_)[1 + _ar_];
+       /*<<ephemeron.ml:266:37>>*/ _as_ = key_index(h, hkey),
+      param = caml_check_bound(h[2], _as_)[1 + _as_];
      for(;;){
       if(! param)  /*<<ephemeron.ml:245:10>>*/ return 0;
       var hk = param[1], rest = param[3], c = param[2];
@@ -31444,9 +31529,9 @@
       }
       /*<<ephemeron.ml:284:29>>*/ }
       /*<<ephemeron.ml:285:29>>*/  /*<<ephemeron.ml:285:29>>*/ var
-      _aq_ = key_index(h, hkey);
+      _ar_ = key_index(h, hkey);
       /*<<ephemeron.ml:285:21>>*/ return find_in_bucket
-             (caml_check_bound(h[2], _aq_)[1 + _aq_]);
+             (caml_check_bound(h[2], _ar_)[1 + _ar_]);
      /*<<ephemeron.ml:285:46>>*/ }
     function replace(h, key, info){
       /*<<ephemeron.ml:289:6>>*/ var
@@ -31464,8 +31549,8 @@
        if(hkey === hk){
         if(!  /*<<ephemeron.ml:293:24>>*/ caml_call2(H[3], c, key)){
           /*<<ephemeron.ml:290:6>>*/  /*<<ephemeron.ml:290:6>>*/ var
-          _am_ =  /*<<ephemeron.ml:290:6>>*/ caml_call3(H[5], c, key, info);
-          /*<<ephemeron.ml:302:8>>*/ return _am_;
+          _an_ =  /*<<ephemeron.ml:290:6>>*/ caml_call3(H[5], c, key, info);
+          /*<<ephemeron.ml:302:8>>*/ return _an_;
         }
         var param = next;
        }
@@ -31473,23 +31558,23 @@
         var next$0 = param[3], param = next$0;
       }
      }
-     catch(_ap_){
-      var _an_ = caml_wrap_exception(_ap_);
-      if(_an_ !== Stdlib[8]) throw caml_maybe_attach_backtrace(_an_, 0);
+     catch(_aq_){
+      var _ao_ = caml_wrap_exception(_aq_);
+      if(_ao_ !== Stdlib[8]) throw caml_maybe_attach_backtrace(_ao_, 0);
        /*<<ephemeron.ml:304:24>>*/  /*<<ephemeron.ml:304:24>>*/ var
        container =  /*<<ephemeron.ml:304:24>>*/ caml_call2(H[1], key, info);
        /*<<ephemeron.ml:305:8>>*/ caml_check_bound(h[2], i)[1 + i] = [0, hkey, container, l];
       h[1] = h[1] + 1 | 0;
-      var _ao_ = h[2].length - 1 << 1 < h[1] ? 1 : 0;
-      return _ao_ ? resize(h) : _ao_;
+      var _ap_ = h[2].length - 1 << 1 < h[1] ? 1 : 0;
+      return _ap_ ? resize(h) : _ap_;
      }
      /*<<ephemeron.ml:307:59>>*/ }
     function mem(h, key){
       /*<<ephemeron.ml:310:6>>*/ var
        /*<<ephemeron.ml:310:17>>*/ hkey =
          /*<<ephemeron.ml:310:17>>*/ caml_call2(H[2], h[3], key),
-       /*<<ephemeron.ml:320:28>>*/ _al_ = key_index(h, hkey),
-      param = caml_check_bound(h[2], _al_)[1 + _al_];
+       /*<<ephemeron.ml:320:28>>*/ _am_ = key_index(h, hkey),
+      param = caml_check_bound(h[2], _am_)[1 + _am_];
       /*<<ephemeron.ml:311:30>>*/ for(;;){
       if(! param)  /*<<ephemeron.ml:313:10>>*/ return 0;
       var hk = param[1], rest = param[3], c = param[2];
@@ -31517,21 +31602,21 @@
      }
     }
     function stats(h){
-      /*<<ephemeron.ml:329:6>>*/ var _af_ = h[2], _ag_ = 0;
-     function _ah_(m, b){
+      /*<<ephemeron.ml:329:6>>*/ var _ag_ = h[2], _ah_ = 0;
+     function _ai_(m, b){
        /*<<ephemeron.ml:330:36>>*/  /*<<ephemeron.ml:330:46>>*/ var
-       _ak_ = bucket_length(0, b);
+       _al_ = bucket_length(0, b);
        /*<<ephemeron.ml:330:46>>*/ return  /*<<ephemeron.ml:330:46>>*/ caml_call2
-              (Stdlib_Int[11], m, _ak_);
+              (Stdlib_Int[11], m, _al_);
       /*<<ephemeron.ml:330:65>>*/ }
       /*<<ephemeron.ml:330:8>>*/ var
        /*<<ephemeron.ml:330:8>>*/ mbl =
          /*<<ephemeron.ml:330:8>>*/ caml_call3
-         (Stdlib_Array[17], _ah_, _ag_, _af_),
+         (Stdlib_Array[17], _ai_, _ah_, _ag_),
        /*<<ephemeron.ml:331:18>>*/ histo =
          /*<<ephemeron.ml:331:18>>*/ caml_make_vect(mbl + 1 | 0, 0),
-       /*<<ephemeron.ml:332:6>>*/ _ai_ = h[2];
-     function _aj_(b){
+       /*<<ephemeron.ml:332:6>>*/ _aj_ = h[2];
+     function _ak_(b){
        /*<<ephemeron.ml:334:11>>*/  /*<<ephemeron.ml:334:19>>*/ var
        l = bucket_length(0, b);
        /*<<ephemeron.ml:335:11>>*/ histo[1 + l] =
@@ -31539,7 +31624,7 @@
        /*<<ephemeron.ml:335:11>>*/ return 0;
       /*<<ephemeron.ml:335:37>>*/ }
       /*<<ephemeron.ml:332:6>>*/  /*<<ephemeron.ml:332:6>>*/ caml_call2
-      (Stdlib_Array[11], _aj_, _ai_);
+      (Stdlib_Array[11], _ak_, _aj_);
       /*<<ephemeron.ml:337:6>>*/ return [0, h[1], h[2].length - 1, mbl, histo];
      /*<<ephemeron.ml:340:34>>*/ }
     function bucket_length_alive(accu, param){
@@ -31557,22 +31642,22 @@
     function stats_alive(h){
       /*<<ephemeron.ml:349:6>>*/ var
        /*<<ephemeron.ml:349:17>>*/ size = [0, 0],
-       /*<<ephemeron.ml:350:6>>*/ _$_ = h[2],
-      _aa_ = 0;
-     function _ab_(m, b){
+       /*<<ephemeron.ml:350:6>>*/ _aa_ = h[2],
+      _ab_ = 0;
+     function _ac_(m, b){
        /*<<ephemeron.ml:352:22>>*/  /*<<ephemeron.ml:352:32>>*/ var
-       _ae_ = bucket_length_alive(0, b);
+       _af_ = bucket_length_alive(0, b);
        /*<<ephemeron.ml:352:32>>*/ return  /*<<ephemeron.ml:352:32>>*/ caml_call2
-              (Stdlib_Int[11], m, _ae_);
+              (Stdlib_Int[11], m, _af_);
       /*<<ephemeron.ml:352:57>>*/ }
       /*<<ephemeron.ml:351:8>>*/ var
        /*<<ephemeron.ml:351:8>>*/ mbl =
          /*<<ephemeron.ml:351:8>>*/ caml_call3
-         (Stdlib_Array[17], _ab_, _aa_, _$_),
+         (Stdlib_Array[17], _ac_, _ab_, _aa_),
        /*<<ephemeron.ml:354:18>>*/ histo =
          /*<<ephemeron.ml:354:18>>*/ caml_make_vect(mbl + 1 | 0, 0),
-       /*<<ephemeron.ml:355:6>>*/ _ac_ = h[2];
-     function _ad_(b){
+       /*<<ephemeron.ml:355:6>>*/ _ad_ = h[2];
+     function _ae_(b){
        /*<<ephemeron.ml:357:11>>*/  /*<<ephemeron.ml:357:19>>*/ var
        l = bucket_length_alive(0, b);
       size[1] = size[1] + l | 0;
@@ -31581,7 +31666,7 @@
        /*<<ephemeron.ml:359:11>>*/ return 0;
       /*<<ephemeron.ml:359:37>>*/ }
       /*<<ephemeron.ml:355:6>>*/  /*<<ephemeron.ml:355:6>>*/ caml_call2
-      (Stdlib_Array[11], _ad_, _ac_);
+      (Stdlib_Array[11], _ae_, _ad_);
       /*<<ephemeron.ml:361:6>>*/ return [0,
              size[1],
              h[2].length - 1,
@@ -31589,20 +31674,20 @@
              histo];
      /*<<ephemeron.ml:364:34>>*/ }
     function add_seq(tbl, i){
-     function ___(param){
+     function _$_(param){
        /*<<ephemeron.ml:367:15>>*/ var v = param[2], k = param[1];
        /*<<ephemeron.ml:367:29>>*/ return add(tbl, k, v);
       /*<<ephemeron.ml:367:41>>*/ }
       /*<<ephemeron.ml:367:6>>*/ return  /*<<ephemeron.ml:367:6>>*/ caml_call2
-             (Stdlib_Seq[4], ___, i);
+             (Stdlib_Seq[4], _$_, i);
      /*<<ephemeron.ml:367:43>>*/ }
     function replace_seq(tbl, i){
-     function _Z_(param){
+     function ___(param){
        /*<<ephemeron.ml:370:15>>*/ var v = param[2], k = param[1];
        /*<<ephemeron.ml:370:29>>*/ return replace(tbl, k, v);
       /*<<ephemeron.ml:370:45>>*/ }
       /*<<ephemeron.ml:370:6>>*/ return  /*<<ephemeron.ml:370:6>>*/ caml_call2
-             (Stdlib_Seq[4], _Z_, i);
+             (Stdlib_Seq[4], ___, i);
      /*<<ephemeron.ml:370:47>>*/ }
     function of_seq(i){
       /*<<ephemeron.ml:373:6>>*/  /*<<ephemeron.ml:373:16>>*/ var
@@ -31639,8 +31724,9 @@
             (Stdlib_Obj[24][3], t, 0);
     /*<<ephemeron.ml:396:70>>*/ }
    function set_key(t, k){
-     /*<<ephemeron.ml:397:44>>*/ return  /*<<ephemeron.ml:397:44>>*/ caml_call3
-            (Stdlib_Obj[24][5], t, 0, k);
+     /*<<ephemeron.ml:397:44>>*/  /*<<ephemeron.ml:397:44>>*/ caml_call3
+     (Stdlib_Obj[24][5], t, 0, k);
+     /*<<ephemeron.ml:397:44>>*/ return;
     /*<<ephemeron.ml:397:75>>*/ }
    function check_key(t){
      /*<<ephemeron.ml:398:39>>*/ return  /*<<ephemeron.ml:398:39>>*/ caml_call2
@@ -31726,10 +31812,10 @@
      replace_seq = include[15],
      clean = include[17],
      stats_alive = include[18],
-     _Y_ = include[1];
+     _Z_ = include[1];
     function create(sz){
       /*<<ephemeron.ml:448:20>>*/ return  /*<<ephemeron.ml:448:20>>*/ caml_call2
-             (_Y_, _a_, sz);
+             (_Z_, _a_, sz);
      /*<<ephemeron.ml:448:43>>*/ }
     function of_seq(i){
       /*<<ephemeron.ml:450:6>>*/  /*<<ephemeron.ml:450:16>>*/ var
@@ -31762,8 +31848,8 @@
      /*<<ephemeron.ml:459:18>>*/ return [0, 0];
     /*<<ephemeron.ml:459:24>>*/ }
    function add(b, k, d){
-     /*<<ephemeron.ml:460:20>>*/ var _X_ = b[1];
-    b[1] = [0, make(k, d), _X_];
+     /*<<ephemeron.ml:460:20>>*/ var _Y_ = b[1];
+    b[1] = [0, make(k, d), _Y_];
     return 0;
     /*<<ephemeron.ml:460:42>>*/ }
    function test_key(k, e){
@@ -31792,13 +31878,13 @@
     }
     /*<<ephemeron.ml:474:16>>*/ }
    function find(b, k){
-     /*<<ephemeron.ml:477:6>>*/ var _U_ = b[1];
-     /*<<ephemeron.ml:477:26>>*/ function _V_(_W_){
-      /*<<?>>*/ return test_key(k, _W_);
+     /*<<ephemeron.ml:477:6>>*/ var _V_ = b[1];
+     /*<<ephemeron.ml:477:26>>*/ function _W_(_X_){
+      /*<<?>>*/ return test_key(k, _X_);
     }
      /*<<ephemeron.ml:477:12>>*/  /*<<ephemeron.ml:477:12>>*/ var
      match =
-        /*<<ephemeron.ml:477:12>>*/ caml_call2(Stdlib_List[40], _V_, _U_);
+        /*<<ephemeron.ml:477:12>>*/ caml_call2(Stdlib_List[40], _W_, _V_);
     if(! match)  /*<<ephemeron.ml:479:16>>*/ return 0;
     var e = match[1];
      /*<<ephemeron.ml:478:18>>*/ return get_data(e);
@@ -31819,16 +31905,18 @@
             (Stdlib_Obj[24][3], t, 0);
     /*<<ephemeron.ml:493:77>>*/ }
    function set_key1(t, k){
-     /*<<ephemeron.ml:495:4>>*/ return  /*<<ephemeron.ml:495:4>>*/ caml_call3
-            (Stdlib_Obj[24][5], t, 0, k);
+     /*<<ephemeron.ml:495:4>>*/  /*<<ephemeron.ml:495:4>>*/ caml_call3
+     (Stdlib_Obj[24][5], t, 0, k);
+     /*<<ephemeron.ml:495:4>>*/ return;
     /*<<ephemeron.ml:495:35>>*/ }
    function get_key2(t){
      /*<<ephemeron.ml:498:49>>*/ return  /*<<ephemeron.ml:498:57>>*/ caml_call2
             (Stdlib_Obj[24][3], t, 1);
     /*<<ephemeron.ml:498:77>>*/ }
    function set_key2(t, k){
-     /*<<ephemeron.ml:500:4>>*/ return  /*<<ephemeron.ml:500:4>>*/ caml_call3
-            (Stdlib_Obj[24][5], t, 1, k);
+     /*<<ephemeron.ml:500:4>>*/  /*<<ephemeron.ml:500:4>>*/ caml_call3
+     (Stdlib_Obj[24][5], t, 1, k);
+     /*<<ephemeron.ml:500:4>>*/ return;
     /*<<ephemeron.ml:500:35>>*/ }
    function get_data$0(t){
      /*<<ephemeron.ml:503:48>>*/ return  /*<<ephemeron.ml:503:56>>*/ caml_call1
@@ -31873,11 +31961,11 @@
       /*<<ephemeron.ml:539:33>>*/ var
       k2 = param[2],
       k1 = param[1],
-       /*<<ephemeron.ml:539:33>>*/ _T_ =
+       /*<<ephemeron.ml:539:33>>*/ _U_ =
          /*<<ephemeron.ml:539:33>>*/ caml_call2(H2[2], seed, k2) * 65599 | 0;
       /*<<ephemeron.ml:539:8>>*/ return  /*<<ephemeron.ml:539:8>>*/ caml_call2
              (H1[2], seed, k1)
-            + _T_
+            + _U_
             | 0;
     }
     function equal(c, param){
@@ -31906,11 +31994,11 @@
     }
     function check_key(c){
       /*<<ephemeron.ml:551:24>>*/  /*<<ephemeron.ml:496:45>>*/ var
-      _S_ =  /*<<ephemeron.ml:496:45>>*/ caml_call2(Stdlib_Obj[24][7], c, 0);
-      /*<<ephemeron.ml:551:24>>*/ return _S_
+      _T_ =  /*<<ephemeron.ml:496:45>>*/ caml_call2(Stdlib_Obj[24][7], c, 0);
+      /*<<ephemeron.ml:551:24>>*/ return _T_
              ?  /*<<ephemeron.ml:501:45>>*/ caml_call2
                (Stdlib_Obj[24][7], c, 1)
-             : _S_;
+             : _T_;
      /*<<ephemeron.ml:551:52>>*/ }
      /*<<ephemeron.ml:530:28>>*/ return MakeSeeded
             ([0,
@@ -31929,13 +32017,13 @@
      /*<<ephemeron.ml:566:52>>*/ }
      /*<<ephemeron.ml:563:9>>*/ var
      equal$0 = H1[1],
-      /*<<ephemeron.ml:563:9>>*/ _Q_ = [0, equal, seeded_hash];
+      /*<<ephemeron.ml:563:9>>*/ _R_ = [0, equal, seeded_hash];
     function seeded_hash$0(seed, x){
       /*<<ephemeron.ml:561:43>>*/ return  /*<<ephemeron.ml:561:43>>*/ caml_call1
              (H1[2], x);
      /*<<ephemeron.ml:561:52>>*/ }
     var
-     include = MakeSeeded$1([0, equal$0, seeded_hash$0], _Q_),
+     include = MakeSeeded$1([0, equal$0, seeded_hash$0], _R_),
      clear = include[2],
      reset = include[3],
      copy = include[4],
@@ -31952,10 +32040,10 @@
      replace_seq = include[15],
      clean = include[17],
      stats_alive = include[18],
-     _R_ = include[1];
+     _S_ = include[1];
     function create(sz){
       /*<<ephemeron.ml:568:20>>*/ return  /*<<ephemeron.ml:568:20>>*/ caml_call2
-             (_R_, _b_, sz);
+             (_S_, _b_, sz);
      /*<<ephemeron.ml:568:43>>*/ }
     function of_seq(i){
       /*<<ephemeron.ml:570:6>>*/  /*<<ephemeron.ml:570:16>>*/ var
@@ -31988,8 +32076,8 @@
      /*<<ephemeron.ml:579:18>>*/ return [0, 0];
     /*<<ephemeron.ml:579:24>>*/ }
    function add$0(b, k1, k2, d){
-     /*<<ephemeron.ml:580:24>>*/ var _P_ = b[1];
-    b[1] = [0, make$1(k1, k2, d), _P_];
+     /*<<ephemeron.ml:580:24>>*/ var _Q_ = b[1];
+    b[1] = [0, make$1(k1, k2, d), _Q_];
     return 0;
     /*<<ephemeron.ml:580:50>>*/ }
    function test_keys(k1, k2, e){
@@ -32019,13 +32107,13 @@
     }
     /*<<ephemeron.ml:594:16>>*/ }
    function find$0(b, k1, k2){
-     /*<<ephemeron.ml:597:6>>*/ var _M_ = b[1];
-     /*<<ephemeron.ml:597:26>>*/ function _N_(_O_){
-      /*<<?>>*/ return test_keys(k1, k2, _O_);
+     /*<<ephemeron.ml:597:6>>*/ var _N_ = b[1];
+     /*<<ephemeron.ml:597:26>>*/ function _O_(_P_){
+      /*<<?>>*/ return test_keys(k1, k2, _P_);
     }
      /*<<ephemeron.ml:597:12>>*/  /*<<ephemeron.ml:597:12>>*/ var
      match =
-        /*<<ephemeron.ml:597:12>>*/ caml_call2(Stdlib_List[40], _N_, _M_);
+        /*<<ephemeron.ml:597:12>>*/ caml_call2(Stdlib_List[40], _O_, _N_);
     if(! match)  /*<<ephemeron.ml:599:16>>*/ return 0;
     var e = match[1];
      /*<<ephemeron.ml:598:18>>*/ return get_data$0(e);
@@ -32050,8 +32138,9 @@
             (Stdlib_Obj[24][3], t, n);
     /*<<ephemeron.ml:614:78>>*/ }
    function set_key$0(t, n, k){
-     /*<<ephemeron.ml:616:4>>*/ return  /*<<ephemeron.ml:616:4>>*/ caml_call3
-            (Stdlib_Obj[24][5], t, n, k);
+     /*<<ephemeron.ml:616:4>>*/  /*<<ephemeron.ml:616:4>>*/ caml_call3
+     (Stdlib_Obj[24][5], t, n, k);
+     /*<<ephemeron.ml:616:4>>*/ return;
     /*<<ephemeron.ml:616:35>>*/ }
    function get_data$1(t){
      /*<<ephemeron.ml:619:43>>*/ return  /*<<ephemeron.ml:619:51>>*/ caml_call1
@@ -32067,17 +32156,17 @@
       /*<<ephemeron.ml:625:14>>*/ eph = create$1(l);
      /*<<ephemeron.ml:626:4>>*/ set_data$1(eph, data);
      /*<<ephemeron.ml:626:4>>*/ var
-     _K_ = l - 1 | 0,
-      /*<<ephemeron.ml:626:4>>*/ _J_ = 0;
-    if(_K_ >= 0){
-     var i = _J_;
+     _L_ = l - 1 | 0,
+      /*<<ephemeron.ml:626:4>>*/ _K_ = 0;
+    if(_L_ >= 0){
+     var i = _K_;
      for(;;){
        /*<<ephemeron.ml:627:26>>*/ set_key$0
        (eph, i, caml_check_bound(keys, i)[1 + i]);
        /*<<ephemeron.ml:627:26>>*/  /*<<ephemeron.ml:627:26>>*/ var
-       _L_ = i + 1 | 0;
-      if(_K_ === i) break;
-      var i = _L_;
+       _M_ = i + 1 | 0;
+      if(_L_ === i) break;
+      var i = _M_;
      }
     }
      /*<<ephemeron.ml:628:4>>*/ return eph;
@@ -32090,10 +32179,10 @@
        /*<<ephemeron.ml:633:37>>*/ throw  /*<<ephemeron.ml:633:37>>*/ caml_maybe_attach_backtrace
              (Stdlib[3], 1);
       /*<<ephemeron.ml:631:12>>*/ var
-       /*<<ephemeron.ml:631:12>>*/ _F_ = l - 1 | 0,
-       /*<<ephemeron.ml:634:6>>*/ _E_ = 0;
-     if(_F_ >= 0){
-      var i = _E_;
+       /*<<ephemeron.ml:631:12>>*/ _G_ = l - 1 | 0,
+       /*<<ephemeron.ml:634:6>>*/ _F_ = 0;
+     if(_G_ >= 0){
+      var i = _F_;
       for(;;){
         /*<<ephemeron.ml:635:14>>*/  /*<<ephemeron.ml:635:14>>*/ var
         match = get_key$0(eph, i);
@@ -32105,19 +32194,19 @@
          /*<<ephemeron.ml:638:20>>*/ throw  /*<<ephemeron.ml:638:20>>*/ caml_maybe_attach_backtrace
                (Stdlib[3], 1);
         /*<<ephemeron.ml:634:6>>*/  /*<<ephemeron.ml:634:6>>*/ var
-        _H_ = i + 1 | 0;
-       if(_F_ === i) break;
-       var i = _H_;
+        _I_ = i + 1 | 0;
+       if(_G_ === i) break;
+       var i = _I_;
       }
      }
       /*<<ephemeron.ml:640:6>>*/  /*<<ephemeron.ml:640:6>>*/ var
-      _G_ = get_data$1(eph);
-      /*<<ephemeron.ml:640:6>>*/ return _G_;
+      _H_ = get_data$1(eph);
+      /*<<ephemeron.ml:640:6>>*/ return _H_;
     }
-    catch(_I_){
-     var _D_ = caml_wrap_exception(_I_);
-     if(_D_ === Stdlib[3])  /*<<ephemeron.ml:641:17>>*/ return 0;
-     throw caml_maybe_attach_backtrace(_D_, 0);
+    catch(_J_){
+     var _E_ = caml_wrap_exception(_J_);
+     if(_E_ === Stdlib[3])  /*<<ephemeron.ml:641:17>>*/ return 0;
+     throw caml_maybe_attach_backtrace(_E_, 0);
     }
     /*<<ephemeron.ml:641:21>>*/ }
    function MakeSeeded$2(H){
@@ -32126,17 +32215,17 @@
       c = create$1(k.length - 1);
       /*<<ephemeron.ml:649:8>>*/ set_data$1(c, d);
       /*<<ephemeron.ml:649:8>>*/ var
-      _B_ = k.length - 1 - 1 | 0,
-       /*<<ephemeron.ml:649:8>>*/ _A_ = 0;
-     if(_B_ >= 0){
-      var i = _A_;
+      _C_ = k.length - 1 - 1 | 0,
+       /*<<ephemeron.ml:649:8>>*/ _B_ = 0;
+     if(_C_ >= 0){
+      var i = _B_;
       for(;;){
         /*<<ephemeron.ml:651:10>>*/ set_key$0
         (c, i, caml_check_bound(k, i)[1 + i]);
         /*<<ephemeron.ml:651:10>>*/  /*<<ephemeron.ml:651:10>>*/ var
-        _C_ = i + 1 | 0;
-       if(_B_ === i) break;
-       var i = _C_;
+        _D_ = i + 1 | 0;
+       if(_C_ === i) break;
+       var i = _D_;
       }
      }
       /*<<ephemeron.ml:653:8>>*/ return c;
@@ -32144,22 +32233,22 @@
     function seeded_hash(seed, k){
       /*<<ephemeron.ml:655:8>>*/ var
        /*<<ephemeron.ml:655:16>>*/ h = [0, 0],
-      _w_ = k.length - 1 - 1 | 0,
-       /*<<ephemeron.ml:655:16>>*/ _v_ = 0;
-     if(_w_ >= 0){
-      var i = _v_;
+      _x_ = k.length - 1 - 1 | 0,
+       /*<<ephemeron.ml:655:16>>*/ _w_ = 0;
+     if(_x_ >= 0){
+      var i = _w_;
       for(;;){
         /*<<ephemeron.ml:657:34>>*/ var
-        _x_ = h[1],
-         /*<<ephemeron.ml:657:34>>*/ _y_ = caml_check_bound(k, i)[1 + i];
+        _y_ = h[1],
+         /*<<ephemeron.ml:657:34>>*/ _z_ = caml_check_bound(k, i)[1 + i];
        h[1] =
-        ( /*<<ephemeron.ml:657:15>>*/ caml_call2(H[2], seed, _y_) * 65599 | 0)
-        + _x_
+        ( /*<<ephemeron.ml:657:15>>*/ caml_call2(H[2], seed, _z_) * 65599 | 0)
+        + _y_
         | 0;
         /*<<ephemeron.ml:656:8>>*/  /*<<ephemeron.ml:656:8>>*/ var
-        _z_ = i + 1 | 0;
-       if(_w_ === i) break;
-       var i = _z_;
+        _A_ = i + 1 | 0;
+       if(_x_ === i) break;
+       var i = _A_;
       }
      }
      return h[1];
@@ -32179,9 +32268,9 @@
       if(! match)  /*<<ephemeron.ml:669:24>>*/ return 2;
        /*<<ephemeron.ml:671:29>>*/ var
        ki = match[1],
-        /*<<ephemeron.ml:671:29>>*/ _u_ = caml_check_bound(k, i)[1 + i];
+        /*<<ephemeron.ml:671:29>>*/ _v_ = caml_check_bound(k, i)[1 + i];
        /*<<ephemeron.ml:671:21>>*/ if
-       (!  /*<<ephemeron.ml:671:21>>*/ caml_call2(H[1], _u_, ki))
+       (!  /*<<ephemeron.ml:671:21>>*/ caml_call2(H[1], _v_, ki))
         /*<<ephemeron.ml:673:23>>*/ return 1;
        /*<<ephemeron.ml:672:23>>*/ var
         /*<<ephemeron.ml:672:23>>*/ i$0 = i - 1 | 0,
@@ -32192,17 +32281,17 @@
       /*<<ephemeron.ml:678:8>>*/  /*<<ephemeron.ml:621:40>>*/ caml_call1
       (Stdlib_Obj[24][12], c);
       /*<<ephemeron.ml:678:8>>*/ var
-      _s_ = k.length - 1 - 1 | 0,
-       /*<<ephemeron.ml:678:8>>*/ _r_ = 0;
-     if(_s_ >= 0){
-      var i = _r_;
+      _t_ = k.length - 1 - 1 | 0,
+       /*<<ephemeron.ml:678:8>>*/ _s_ = 0;
+     if(_t_ >= 0){
+      var i = _s_;
       for(;;){
         /*<<ephemeron.ml:680:10>>*/ set_key$0
         (c, i, caml_check_bound(k, i)[1 + i]);
         /*<<ephemeron.ml:680:10>>*/  /*<<ephemeron.ml:680:10>>*/ var
-        _t_ = i + 1 | 0;
-       if(_s_ === i) break;
-       var i = _t_;
+        _u_ = i + 1 | 0;
+       if(_t_ === i) break;
+       var i = _u_;
       }
      }
       /*<<ephemeron.ml:682:8>>*/ return set_data$1(c, d);
@@ -32212,19 +32301,19 @@
        /*<<ephemeron.ml:686:17>>*/ i$1 = length$1(c) - 1 | 0,
       i = i$1;
       /*<<ephemeron.ml:685:10>>*/ for(;;){
-      var _p_ = i < 0 ? 1 : 0;
-      if(_p_)
-       var _q_ = _p_;
+      var _q_ = i < 0 ? 1 : 0;
+      if(_q_)
+       var _r_ = _q_;
       else{
         /*<<ephemeron.ml:617:47>>*/  /*<<ephemeron.ml:617:47>>*/ var
-        _o_ =  /*<<ephemeron.ml:617:47>>*/ caml_call2(Stdlib_Obj[24][7], c, i);
-        /*<<ephemeron.ml:685:20>>*/ if(_o_){
+        _p_ =  /*<<ephemeron.ml:617:47>>*/ caml_call2(Stdlib_Obj[24][7], c, i);
+        /*<<ephemeron.ml:685:20>>*/ if(_p_){
         var i$0 = i - 1 | 0, i = i$0;
         continue;
        }
-       var _q_ = _o_;
+       var _r_ = _p_;
       }
-      return _q_;
+      return _r_;
      }
      /*<<ephemeron.ml:686:30>>*/ }
      /*<<ephemeron.ml:644:28>>*/ return MakeSeeded
@@ -32260,10 +32349,10 @@
      replace_seq = include[15],
      clean = include[17],
      stats_alive = include[18],
-     _n_ = include[1];
+     _o_ = include[1];
     function create(sz){
       /*<<ephemeron.ml:696:20>>*/ return  /*<<ephemeron.ml:696:20>>*/ caml_call2
-             (_n_, _c_, sz);
+             (_o_, _c_, sz);
      /*<<ephemeron.ml:696:43>>*/ }
     function of_seq(i){
       /*<<ephemeron.ml:698:6>>*/  /*<<ephemeron.ml:698:16>>*/ var
@@ -32296,8 +32385,8 @@
      /*<<ephemeron.ml:707:18>>*/ return [0, 0];
     /*<<ephemeron.ml:707:24>>*/ }
    function add$1(b, k, d){
-     /*<<ephemeron.ml:708:20>>*/ var _m_ = b[1];
-    b[1] = [0, make$3(k, d), _m_];
+     /*<<ephemeron.ml:708:20>>*/ var _n_ = b[1];
+    b[1] = [0, make$3(k, d), _n_];
     return 0;
     /*<<ephemeron.ml:708:42>>*/ }
    function test_keys$0(k, e){
@@ -32306,10 +32395,10 @@
        /*<<ephemeron.ml:712:43>>*/ throw  /*<<ephemeron.ml:712:43>>*/ caml_maybe_attach_backtrace
              (Stdlib[3], 1);
       /*<<ephemeron.ml:713:8>>*/ var
-      _i_ = k.length - 1 - 1 | 0,
-       /*<<ephemeron.ml:713:8>>*/ _h_ = 0;
-     if(_i_ >= 0){
-      var i = _h_;
+      _j_ = k.length - 1 - 1 | 0,
+       /*<<ephemeron.ml:713:8>>*/ _i_ = 0;
+     if(_j_ >= 0){
+      var i = _i_;
       for(;;){
         /*<<ephemeron.ml:714:16>>*/  /*<<ephemeron.ml:714:16>>*/ var
         match = get_key$0(e, i);
@@ -32317,9 +32406,9 @@
         var x = match[1];
         if(x === caml_check_bound(k, i)[1 + i]){
           /*<<ephemeron.ml:713:8>>*/  /*<<ephemeron.ml:713:8>>*/ var
-          _k_ = i + 1 | 0;
-         if(_i_ === i) break;
-         var i = _k_;
+          _l_ = i + 1 | 0;
+         if(_j_ === i) break;
+         var i = _l_;
          continue;
         }
        }
@@ -32327,13 +32416,13 @@
               (Stdlib[3], 1);
       }
      }
-      /*<<ephemeron.ml:718:8>>*/  /*<<ephemeron.ml:718:8>>*/ var _j_ = 1;
-      /*<<ephemeron.ml:718:8>>*/ return _j_;
+      /*<<ephemeron.ml:718:8>>*/  /*<<ephemeron.ml:718:8>>*/ var _k_ = 1;
+      /*<<ephemeron.ml:718:8>>*/ return _k_;
     }
-    catch(_l_){
-     var _g_ = caml_wrap_exception(_l_);
-     if(_g_ === Stdlib[3])  /*<<ephemeron.ml:719:19>>*/ return 0;
-     throw caml_maybe_attach_backtrace(_g_, 0);
+    catch(_m_){
+     var _h_ = caml_wrap_exception(_m_);
+     if(_h_ === Stdlib[3])  /*<<ephemeron.ml:719:19>>*/ return 0;
+     throw caml_maybe_attach_backtrace(_h_, 0);
     }
     /*<<ephemeron.ml:719:24>>*/ }
    function remove$1(b, k){
@@ -32353,13 +32442,13 @@
     }
     /*<<ephemeron.ml:728:16>>*/ }
    function find$1(b, k){
-     /*<<ephemeron.ml:731:6>>*/ var _d_ = b[1];
-     /*<<ephemeron.ml:731:26>>*/ function _e_(_f_){
-      /*<<?>>*/ return test_keys$0(k, _f_);
+     /*<<ephemeron.ml:731:6>>*/ var _e_ = b[1];
+     /*<<ephemeron.ml:731:26>>*/ function _f_(_g_){
+      /*<<?>>*/ return test_keys$0(k, _g_);
     }
      /*<<ephemeron.ml:731:12>>*/  /*<<ephemeron.ml:731:12>>*/ var
      match =
-        /*<<ephemeron.ml:731:12>>*/ caml_call2(Stdlib_List[40], _e_, _d_);
+        /*<<ephemeron.ml:731:12>>*/ caml_call2(Stdlib_List[40], _f_, _e_);
     if(! match)  /*<<ephemeron.ml:733:16>>*/ return 0;
     var e = match[1];
      /*<<ephemeron.ml:732:18>>*/ return get_data$1(e);
@@ -32424,8 +32513,6 @@
     caml_string_get = runtime.caml_string_get,
     caml_string_notequal = runtime.caml_string_notequal,
     caml_sys_getenv = runtime.caml_sys_getenv,
-    caml_trampoline = runtime.caml_trampoline,
-    caml_trampoline_return = runtime.caml_trampoline_return,
     caml_wrap_exception = runtime.caml_wrap_exception;
     /*<<?>>*/ function caml_call1(f, a0){
     return (f.l >= 0 ? f.l : f.l = f.length) == 1
@@ -32448,6 +32535,7 @@
             : runtime.caml_call_gen(f, [a0, a1, a2, a3]);
    }
    var
+    _m_ = undefined,
     global_data = runtime.caml_get_global_data(),
     cst$18 = cst$19,
     cst$17 = cst$19,
@@ -32584,39 +32672,39 @@
     /*<<filename.ml:96:34>>*/ }
    function is_relative(n){
      /*<<filename.ml:97:22>>*/ var
-     _aM_ = caml_ml_string_length(n) < 1 ? 1 : 0,
-     _aN_ =
-       _aM_
+     _aK_ = caml_ml_string_length(n) < 1 ? 1 : 0,
+     _aL_ =
+       _aK_
        || (47 !==  /*<<filename.ml:97:45>>*/ caml_string_get(n, 0) ? 1 : 0);
-    return _aN_;
+    return _aL_;
     /*<<filename.ml:97:57>>*/ }
    function is_implicit(n){
      /*<<filename.ml:99:4>>*/  /*<<filename.ml:99:4>>*/ var
-     _aH_ = is_relative(n);
-     /*<<filename.ml:99:4>>*/ if(_aH_){
+     _aF_ = is_relative(n);
+     /*<<filename.ml:99:4>>*/ if(_aF_){
      var
-      _aI_ = caml_ml_string_length(n) < 2 ? 1 : 0,
-      _aJ_ =
-        _aI_
+      _aG_ = caml_ml_string_length(n) < 2 ? 1 : 0,
+      _aH_ =
+        _aG_
         ||
           /*<<filename.ml:100:31>>*/ caml_string_notequal
           ( /*<<filename.ml:100:31>>*/ caml_call3(Stdlib_String[16], n, 0, 2),
            cst$27);
-      /*<<filename.ml:100:31>>*/ if(_aJ_)
+      /*<<filename.ml:100:31>>*/ if(_aH_)
       var
-       _aK_ = caml_ml_string_length(n) < 3 ? 1 : 0,
-       _aL_ =
-         _aK_
+       _aI_ = caml_ml_string_length(n) < 3 ? 1 : 0,
+       _aJ_ =
+         _aI_
          ||
            /*<<filename.ml:101:31>>*/ caml_string_notequal
            ( /*<<filename.ml:101:31>>*/ caml_call3(Stdlib_String[16], n, 0, 3),
             cst$28);
      else
-      var _aL_ = _aJ_;
+      var _aJ_ = _aH_;
     }
     else
-     var _aL_ = _aH_;
-     /*<<filename.ml:101:31>>*/ return _aL_;
+     var _aJ_ = _aF_;
+     /*<<filename.ml:101:31>>*/ return _aJ_;
     /*<<filename.ml:101:57>>*/ }
    function check_suffix(name, suff){
      /*<<filename.ml:103:4>>*/ return  /*<<filename.ml:103:4>>*/ caml_call2
@@ -32644,8 +32732,8 @@
         /*<<filename.ml:117:8>>*/ caml_sys_getenv("TMPDIR"),
      temp_dir_name = _l_;
    }
-   catch(_aG_){
-    var _a_ = caml_wrap_exception(_aG_);
+   catch(_aE_){
+    var _a_ = caml_wrap_exception(_aE_);
     if(_a_ !== Stdlib[8]) throw caml_maybe_attach_backtrace(_a_, 0);
     var temp_dir_name = cst_tmp;
    }
@@ -32657,10 +32745,10 @@
      /*<<filename.ml:19:2>>*/  /*<<filename.ml:19:2>>*/ caml_call2
      (Stdlib_Buffer[12], b, 39);
      /*<<filename.ml:19:2>>*/ var
-     _aD_ = l - 1 | 0,
-      /*<<filename.ml:19:2>>*/ _aC_ = 0;
-    if(_aD_ >= 0){
-     var i = _aC_;
+     _aB_ = l - 1 | 0,
+      /*<<filename.ml:19:2>>*/ _aA_ = 0;
+    if(_aB_ >= 0){
+     var i = _aA_;
      for(;;){
        /*<<filename.ml:21:7>>*/ if
        (39 ===  /*<<filename.ml:21:7>>*/ caml_string_get(s, i))
@@ -32668,14 +32756,14 @@
         (Stdlib_Buffer[16], b, quotequote);
       else{
         /*<<filename.ml:23:28>>*/  /*<<filename.ml:23:28>>*/ var
-        _aF_ =  /*<<filename.ml:23:28>>*/ caml_string_get(s, i);
+        _aD_ =  /*<<filename.ml:23:28>>*/ caml_string_get(s, i);
         /*<<filename.ml:23:9>>*/  /*<<filename.ml:23:9>>*/ caml_call2
-        (Stdlib_Buffer[12], b, _aF_);
+        (Stdlib_Buffer[12], b, _aD_);
       }
        /*<<filename.ml:23:9>>*/  /*<<filename.ml:23:9>>*/ var
-       _aE_ = i + 1 | 0;
-      if(_aD_ === i) break;
-      var i = _aE_;
+       _aC_ = i + 1 | 0;
+      if(_aB_ === i) break;
+      var i = _aC_;
      }
     }
      /*<<filename.ml:25:2>>*/  /*<<filename.ml:25:2>>*/ caml_call2
@@ -32688,47 +32776,47 @@
      var f = stderr[1];
       /*<<filename.ml:123:51>>*/ if
       ( /*<<filename.ml:123:51>>*/ caml_equal(stderr, stdout))
-      var _ar_ = cst_2_1;
+      var _ap_ = cst_2_1;
      else
        /*<<filename.ml:125:61>>*/ var
-        /*<<filename.ml:125:61>>*/ _aB_ = quote(f),
-       _ar_ =  /*<<filename.ml:125:53>>*/ caml_call2(Stdlib[28], cst_2, _aB_);
-     var _as_ = _ar_;
+        /*<<filename.ml:125:61>>*/ _az_ = quote(f),
+       _ap_ =  /*<<filename.ml:125:53>>*/ caml_call2(Stdlib[28], cst_2, _az_);
+     var _aq_ = _ap_;
     }
     else
-     var _as_ = cst$4;
+     var _aq_ = cst$4;
     if(stdout)
       /*<<filename.ml:122:55>>*/ var
       f$0 = stdout[1],
-       /*<<filename.ml:122:55>>*/ _at_ = quote(f$0),
-      _au_ =  /*<<filename.ml:122:48>>*/ caml_call2(Stdlib[28], cst, _at_);
+       /*<<filename.ml:122:55>>*/ _ar_ = quote(f$0),
+      _as_ =  /*<<filename.ml:122:48>>*/ caml_call2(Stdlib[28], cst, _ar_);
     else
-     var _au_ = cst$3;
+     var _as_ = cst$3;
      /*<<filename.ml:122:6>>*/  /*<<filename.ml:122:6>>*/ var
-     _av_ =  /*<<filename.ml:122:6>>*/ caml_call2(Stdlib[28], _au_, _as_);
+     _at_ =  /*<<filename.ml:122:6>>*/ caml_call2(Stdlib[28], _as_, _aq_);
     if(stdin)
       /*<<filename.ml:121:55>>*/ var
       f$1 = stdin[1],
-       /*<<filename.ml:121:55>>*/ _aw_ = quote(f$1),
-      _ax_ =  /*<<filename.ml:121:48>>*/ caml_call2(Stdlib[28], cst$0, _aw_);
+       /*<<filename.ml:121:55>>*/ _au_ = quote(f$1),
+      _av_ =  /*<<filename.ml:121:48>>*/ caml_call2(Stdlib[28], cst$0, _au_);
     else
-     var _ax_ = cst$2;
+     var _av_ = cst$2;
      /*<<filename.ml:121:6>>*/ var
-      /*<<filename.ml:121:6>>*/ _ay_ =
-        /*<<filename.ml:121:6>>*/ caml_call2(Stdlib[28], _ax_, _av_),
-      /*<<filename.ml:120:22>>*/ _az_ =
+      /*<<filename.ml:121:6>>*/ _aw_ =
+        /*<<filename.ml:121:6>>*/ caml_call2(Stdlib[28], _av_, _at_),
+      /*<<filename.ml:120:22>>*/ _ax_ =
         /*<<filename.ml:120:22>>*/ caml_call2
         (Stdlib_List[20], quote, [0, cmd, args]),
-      /*<<filename.ml:120:4>>*/ _aA_ =
-        /*<<filename.ml:120:4>>*/ caml_call2(Stdlib_String[7], cst$1, _az_);
+      /*<<filename.ml:120:4>>*/ _ay_ =
+        /*<<filename.ml:120:4>>*/ caml_call2(Stdlib_String[7], cst$1, _ax_);
      /*<<filename.ml:121:6>>*/ return  /*<<filename.ml:121:6>>*/ caml_call2
-            (Stdlib[28], _aA_, _ay_);
+            (Stdlib[28], _ay_, _aw_);
     /*<<filename.ml:125:69>>*/ }
-    /*<<filename.ml:126:17>>*/ function basename(_aq_){
-     /*<<?>>*/ return generic_basename(is_dir_sep, current_dir_name, _aq_);
+    /*<<filename.ml:126:17>>*/ function basename(_ao_){
+     /*<<?>>*/ return generic_basename(is_dir_sep, current_dir_name, _ao_);
    }
-    /*<<filename.ml:127:16>>*/ function dirname(_ap_){
-     /*<<?>>*/ return generic_dirname(is_dir_sep, current_dir_name, _ap_);
+    /*<<filename.ml:127:16>>*/ function dirname(_an_){
+     /*<<?>>*/ return generic_dirname(is_dir_sep, current_dir_name, _an_);
    }
     /*<<filename.ml:91:24>>*/  /*<<filename.ml:91:24>>*/ var
     Unix =
@@ -32751,96 +32839,96 @@
      /*<<filename.ml:135:23>>*/ var
       /*<<filename.ml:135:31>>*/ c =
         /*<<filename.ml:135:31>>*/ caml_string_get(s, i),
-     _am_ = 47 === c ? 1 : 0;
-    if(_am_)
-     var _an_ = _am_;
+     _ak_ = 47 === c ? 1 : 0;
+    if(_ak_)
+     var _al_ = _ak_;
     else
-     var _ao_ = 92 === c ? 1 : 0, _an_ = _ao_ || (58 === c ? 1 : 0);
-    return _an_;
+     var _am_ = 92 === c ? 1 : 0, _al_ = _am_ || (58 === c ? 1 : 0);
+    return _al_;
     /*<<filename.ml:135:70>>*/ }
    function is_relative$0(n){
      /*<<filename.ml:137:4>>*/ var
-     _ag_ = caml_ml_string_length(n) < 1 ? 1 : 0,
-     _ah_ =
-       _ag_
+     _ae_ = caml_ml_string_length(n) < 1 ? 1 : 0,
+     _af_ =
+       _ae_
        || (47 !==  /*<<filename.ml:137:28>>*/ caml_string_get(n, 0) ? 1 : 0);
-    if(_ah_){
+    if(_af_){
      var
-      _ai_ = caml_ml_string_length(n) < 1 ? 1 : 0,
-      _aj_ =
-        _ai_
+      _ag_ = caml_ml_string_length(n) < 1 ? 1 : 0,
+      _ah_ =
+        _ag_
         || (92 !==  /*<<filename.ml:138:31>>*/ caml_string_get(n, 0) ? 1 : 0);
-     if(_aj_)
+     if(_ah_)
       var
-       _ak_ = caml_ml_string_length(n) < 2 ? 1 : 0,
-       _al_ =
-         _ak_
+       _ai_ = caml_ml_string_length(n) < 2 ? 1 : 0,
+       _aj_ =
+         _ai_
          || (58 !==  /*<<filename.ml:139:31>>*/ caml_string_get(n, 1) ? 1 : 0);
      else
-      var _al_ = _aj_;
+      var _aj_ = _ah_;
     }
     else
-     var _al_ = _ah_;
-    return _al_;
+     var _aj_ = _af_;
+    return _aj_;
     /*<<filename.ml:139:44>>*/ }
    function is_implicit$0(n){
      /*<<filename.ml:141:4>>*/  /*<<filename.ml:141:4>>*/ var
-     _Z_ = is_relative$0(n);
-     /*<<filename.ml:141:4>>*/ if(_Z_){
+     _X_ = is_relative$0(n);
+     /*<<filename.ml:141:4>>*/ if(_X_){
      var
-      ___ = caml_ml_string_length(n) < 2 ? 1 : 0,
-      _$_ =
-        ___
+      _Y_ = caml_ml_string_length(n) < 2 ? 1 : 0,
+      _Z_ =
+        _Y_
         ||
           /*<<filename.ml:142:31>>*/ caml_string_notequal
           ( /*<<filename.ml:142:31>>*/ caml_call3(Stdlib_String[16], n, 0, 2),
            cst$27);
-      /*<<filename.ml:142:31>>*/ if(_$_){
+      /*<<filename.ml:142:31>>*/ if(_Z_){
       var
-       _aa_ = caml_ml_string_length(n) < 2 ? 1 : 0,
-       _ab_ =
-         _aa_
+       ___ = caml_ml_string_length(n) < 2 ? 1 : 0,
+       _$_ =
+         ___
          ||
            /*<<filename.ml:143:31>>*/ caml_string_notequal
            ( /*<<filename.ml:143:31>>*/ caml_call3(Stdlib_String[16], n, 0, 2),
             ".\\");
-       /*<<filename.ml:143:31>>*/ if(_ab_){
+       /*<<filename.ml:143:31>>*/ if(_$_){
        var
-        _ac_ = caml_ml_string_length(n) < 3 ? 1 : 0,
-        _ad_ =
-          _ac_
+        _aa_ = caml_ml_string_length(n) < 3 ? 1 : 0,
+        _ab_ =
+          _aa_
           ||
             /*<<filename.ml:144:31>>*/ caml_string_notequal
             ( /*<<filename.ml:144:31>>*/ caml_call3
               (Stdlib_String[16], n, 0, 3),
              cst$28);
-        /*<<filename.ml:144:31>>*/ if(_ad_)
+        /*<<filename.ml:144:31>>*/ if(_ab_)
         var
-         _ae_ = caml_ml_string_length(n) < 3 ? 1 : 0,
-         _af_ =
-           _ae_
+         _ac_ = caml_ml_string_length(n) < 3 ? 1 : 0,
+         _ad_ =
+           _ac_
            ||
              /*<<filename.ml:145:31>>*/ caml_string_notequal
              ( /*<<filename.ml:145:31>>*/ caml_call3
                (Stdlib_String[16], n, 0, 3),
               "..\\");
        else
-        var _af_ = _ad_;
+        var _ad_ = _ab_;
       }
       else
-       var _af_ = _ab_;
+       var _ad_ = _$_;
      }
      else
-      var _af_ = _$_;
+      var _ad_ = _Z_;
     }
     else
-     var _af_ = _Z_;
-     /*<<filename.ml:145:31>>*/ return _af_;
+     var _ad_ = _X_;
+     /*<<filename.ml:145:31>>*/ return _ad_;
     /*<<filename.ml:145:58>>*/ }
    function check_suffix$0(name, suff){
      /*<<filename.ml:147:3>>*/ var
-     _W_ = caml_ml_string_length(suff) <= caml_ml_string_length(name) ? 1 : 0;
-    if(_W_)
+     _U_ = caml_ml_string_length(suff) <= caml_ml_string_length(name) ? 1 : 0;
+    if(_U_)
       /*<<filename.ml:148:12>>*/ var
        /*<<filename.ml:148:12>>*/ s =
          /*<<filename.ml:148:12>>*/ caml_call3
@@ -32848,14 +32936,14 @@
           name,
           caml_ml_string_length(name) - caml_ml_string_length(suff) | 0,
           caml_ml_string_length(suff)),
-       /*<<filename.ml:150:31>>*/ _X_ =
+       /*<<filename.ml:150:31>>*/ _V_ =
          /*<<filename.ml:150:31>>*/ caml_call1(Stdlib_String[27], suff),
-      _Y_ =
+      _W_ =
          /*<<filename.ml:150:4>>*/ caml_string_equal
-         ( /*<<filename.ml:150:4>>*/ caml_call1(Stdlib_String[27], s), _X_);
+         ( /*<<filename.ml:150:4>>*/ caml_call1(Stdlib_String[27], s), _V_);
     else
-     var _Y_ = _W_;
-     /*<<filename.ml:150:4>>*/ return _Y_;
+     var _W_ = _U_;
+     /*<<filename.ml:150:4>>*/ return _W_;
     /*<<filename.ml:150:59>>*/ }
    function chop_suffix_opt$0(suffix, filename){
      /*<<filename.ml:153:4>>*/ var
@@ -32866,11 +32954,11 @@
       /*<<filename.ml:155:14>>*/ r =
         /*<<filename.ml:155:14>>*/ caml_call3
         (Stdlib_String[16], filename, len_f - len_s | 0, len_s),
-      /*<<filename.ml:156:36>>*/ _V_ =
+      /*<<filename.ml:156:36>>*/ _T_ =
         /*<<filename.ml:156:36>>*/ caml_call1(Stdlib_String[27], suffix);
      /*<<filename.ml:156:9>>*/ return  /*<<filename.ml:156:9>>*/ caml_string_equal
              ( /*<<filename.ml:156:9>>*/ caml_call1(Stdlib_String[27], r),
-              _V_)
+              _T_)
             ? [0,
                /*<<filename.ml:157:13>>*/ caml_call3
                (Stdlib_String[16], filename, 0, len_f - len_s | 0)]
@@ -32882,8 +32970,8 @@
         /*<<filename.ml:165:8>>*/ caml_sys_getenv("TEMP"),
      temp_dir_name$0 = _k_;
    }
-   catch(_U_){
-    var _b_ = caml_wrap_exception(_U_);
+   catch(_S_){
+    var _b_ = caml_wrap_exception(_S_);
     if(_b_ !== Stdlib[8]) throw caml_maybe_attach_backtrace(_b_, 0);
     var temp_dir_name$0 = cst$5;
    }
@@ -32894,44 +32982,23 @@
         /*<<filename.ml:168:12>>*/ caml_call1(Stdlib_Buffer[1], l + 20 | 0);
      /*<<filename.ml:169:4>>*/  /*<<filename.ml:169:4>>*/ caml_call2
      (Stdlib_Buffer[12], b, 34);
-    function add_bs(n){
-      /*<<filename.ml:186:19>>*/  /*<<filename.ml:186:19>>*/ var _S_ = 1;
-     if(n >= 1){
-      var j = _S_;
-      for(;;){
-        /*<<filename.ml:186:38>>*/  /*<<filename.ml:186:38>>*/ caml_call2
-        (Stdlib_Buffer[12], b, 92);
-        /*<<filename.ml:186:38>>*/  /*<<filename.ml:186:38>>*/ var
-        _T_ = j + 1 | 0;
-       if(n === j) break;
-       var j = _T_;
-      }
-     }
-     return 0;
-     /*<<filename.ml:186:66>>*/ }
-    function loop$0(counter, i){
+    function loop(i){
       /*<<filename.ml:171:6>>*/ var i$0 = i;
       /*<<filename.ml:171:6>>*/ for(;;){
-      if(i$0 === l)
-        /*<<filename.ml:171:20>>*/ return  /*<<filename.ml:171:20>>*/ caml_call2
-               (Stdlib_Buffer[12], b, 34);
+      if(i$0 === l){
+        /*<<filename.ml:171:20>>*/  /*<<filename.ml:171:20>>*/ caml_call2
+        (Stdlib_Buffer[12], b, 34);
+        /*<<filename.ml:171:20>>*/ return;
+      }
        /*<<filename.ml:172:12>>*/  /*<<filename.ml:172:12>>*/ var
        c =  /*<<filename.ml:172:12>>*/ caml_string_get(s, i$0);
       if(34 === c){
-       var _Q_ = 0;
-        /*<<filename.ml:173:16>>*/ if(counter >= 50)
-         /*<<filename.ml:173:16>>*/ return  /*<<filename.ml:173:16>>*/ caml_trampoline_return
-                (loop_bs, [0, _Q_, i$0]);
-       var counter$1 = counter + 1 | 0;
-        /*<<filename.ml:173:16>>*/ return loop_bs(counter$1, _Q_, i$0);
+        /*<<filename.ml:173:16>>*/ loop_bs(0, i$0);
+        /*<<filename.ml:173:16>>*/ return;
       }
       if(92 === c){
-       var _R_ = 0;
-        /*<<filename.ml:174:16>>*/ if(counter >= 50)
-         /*<<filename.ml:174:16>>*/ return  /*<<filename.ml:174:16>>*/ caml_trampoline_return
-                (loop_bs, [0, _R_, i$0]);
-       var counter$0 = counter + 1 | 0;
-        /*<<filename.ml:174:16>>*/ return loop_bs(counter$0, _R_, i$0);
+        /*<<filename.ml:174:16>>*/ loop_bs(0, i$0);
+        /*<<filename.ml:174:16>>*/ return;
       }
        /*<<filename.ml:175:16>>*/  /*<<filename.ml:175:16>>*/ caml_call2
        (Stdlib_Buffer[12], b, c);
@@ -32940,13 +33007,14 @@
        i$0 = i$1;
      }
      /*<<filename.ml:175:48>>*/ }
-    function loop_bs(counter, n, i){
+    function loop_bs(n, i){
       /*<<filename.ml:177:6>>*/ var n$0 = n, i$0 = i;
       /*<<filename.ml:177:6>>*/ for(;;){
       if(i$0 === l){
         /*<<filename.ml:178:8>>*/  /*<<filename.ml:178:8>>*/ caml_call2
         (Stdlib_Buffer[12], b, 34);
-        /*<<filename.ml:178:8>>*/ return add_bs(n$0);
+        /*<<filename.ml:178:8>>*/ add_bs(n$0);
+        /*<<filename.ml:178:8>>*/ return;
       }
        /*<<filename.ml:181:14>>*/  /*<<filename.ml:181:14>>*/ var
        match =  /*<<filename.ml:181:14>>*/ caml_string_get(s, i$0);
@@ -32954,21 +33022,13 @@
         /*<<filename.ml:182:18>>*/ add_bs((2 * n$0 | 0) + 1 | 0);
         /*<<filename.ml:182:34>>*/  /*<<filename.ml:182:34>>*/ caml_call2
         (Stdlib_Buffer[12], b, 34);
-        /*<<filename.ml:182:34>>*/  /*<<filename.ml:182:34>>*/ var
-        _P_ = i$0 + 1 | 0;
-        /*<<filename.ml:182:34>>*/ if(counter >= 50)
-         /*<<filename.ml:182:34>>*/ return  /*<<filename.ml:182:34>>*/ caml_trampoline_return
-                (loop$0, [0, _P_]);
-       var counter$1 = counter + 1 | 0;
-        /*<<filename.ml:182:34>>*/ return loop$0(counter$1, _P_);
+        /*<<filename.ml:182:34>>*/ loop(i$0 + 1 | 0);
+        /*<<filename.ml:182:34>>*/ return;
       }
       if(92 !== match){
         /*<<filename.ml:184:18>>*/ add_bs(n$0);
-        /*<<filename.ml:184:18>>*/ if(counter >= 50)
-         /*<<filename.ml:184:18>>*/ return  /*<<filename.ml:184:18>>*/ caml_trampoline_return
-                (loop$0, [0, i$0]);
-       var counter$0 = counter + 1 | 0;
-        /*<<filename.ml:184:18>>*/ return loop$0(counter$0, i$0);
+        /*<<filename.ml:184:18>>*/ loop(i$0);
+        /*<<filename.ml:184:18>>*/ return;
       }
        /*<<filename.ml:183:18>>*/ var
         /*<<filename.ml:183:18>>*/ i$1 = i$0 + 1 | 0,
@@ -32977,76 +33037,90 @@
        i$0 = i$1;
      }
      /*<<filename.ml:185:9>>*/ }
-    function loop(i){ /*<<?>>*/ return caml_trampoline(loop$0(0, i));}
+    function add_bs(n){
+      /*<<filename.ml:186:19>>*/  /*<<filename.ml:186:19>>*/ var _Q_ = 1;
+     if(n >= 1){
+      var j = _Q_;
+      for(;;){
+        /*<<filename.ml:186:38>>*/  /*<<filename.ml:186:38>>*/ caml_call2
+        (Stdlib_Buffer[12], b, 92);
+        /*<<filename.ml:186:38>>*/  /*<<filename.ml:186:38>>*/ var
+        _R_ = j + 1 | 0;
+       if(n === j) break;
+       var j = _R_;
+      }
+     }
+     return;
+     /*<<filename.ml:186:66>>*/ }
      /*<<filename.ml:188:4>>*/ loop(0);
      /*<<filename.ml:188:4>>*/ return  /*<<filename.ml:188:4>>*/ caml_call1
             (Stdlib_Buffer[2], b);
     /*<<filename.ml:189:21>>*/ }
    function quote_cmd_filename(f){
-    function _N_(param){
+    function _O_(param){
       /*<<filename.ml:222:21>>*/ if(34 !== param && 37 !== param)
        /*<<filename.ml:222:57>>*/ return 0;
       /*<<filename.ml:222:45>>*/ return 1;
      /*<<filename.ml:222:63>>*/ }
      /*<<filename.ml:222:7>>*/ if
-     (!  /*<<filename.ml:222:7>>*/ caml_call2(Stdlib_String[23], _N_, f))
+     (!  /*<<filename.ml:222:7>>*/ caml_call2(Stdlib_String[23], _O_, f))
       /*<<filename.ml:224:12>>*/ return  /*<<filename.ml:224:12>>*/ caml_call2
               (Stdlib_String[15], f, 32)
              ?  /*<<filename.ml:225:23>>*/ caml_call2
                (Stdlib_String[7], cst$7, [0, cst$6, [0, f, _c_]])
              : f;
      /*<<filename.ml:223:15>>*/  /*<<filename.ml:223:15>>*/ var
-     _O_ =
+     _P_ =
         /*<<filename.ml:223:15>>*/ caml_call2
         (Stdlib[28], cst_Filename_quote_command_bad, f);
      /*<<filename.ml:223:15>>*/ return  /*<<filename.ml:223:15>>*/ caml_call1
-            (Stdlib[2], _O_);
+            (Stdlib[2], _P_);
     /*<<filename.ml:227:7>>*/ }
    function quote_command$0(cmd, stdin, stdout, stderr, args){
      /*<<filename.ml:232:4>>*/ if(stderr){
      var f = stderr[1];
       /*<<filename.ml:240:43>>*/ if
       ( /*<<filename.ml:240:43>>*/ caml_equal(stderr, stdout))
-      var _z_ = cst_2_1$0;
+      var _A_ = cst_2_1$0;
      else
        /*<<filename.ml:242:53>>*/ var
-        /*<<filename.ml:242:53>>*/ _L_ = quote_cmd_filename(f),
-       _z_ =  /*<<filename.ml:242:45>>*/ caml_call2(Stdlib[28], cst_2$0, _L_);
-     var _A_ = _z_;
+        /*<<filename.ml:242:53>>*/ _M_ = quote_cmd_filename(f),
+       _A_ =  /*<<filename.ml:242:45>>*/ caml_call2(Stdlib[28], cst_2$0, _M_);
+     var _B_ = _A_;
     }
     else
-     var _A_ = cst$16;
-    var _B_ = [0, _A_, _d_];
+     var _B_ = cst$16;
+    var _C_ = [0, _B_, _d_];
     if(stdout)
       /*<<filename.ml:238:55>>*/ var
       f$0 = stdout[1],
-       /*<<filename.ml:238:55>>*/ _C_ = quote_cmd_filename(f$0),
-      _D_ =  /*<<filename.ml:238:48>>*/ caml_call2(Stdlib[28], cst$8, _C_);
+       /*<<filename.ml:238:55>>*/ _D_ = quote_cmd_filename(f$0),
+      _E_ =  /*<<filename.ml:238:48>>*/ caml_call2(Stdlib[28], cst$8, _D_);
     else
-     var _D_ = cst$15;
-    var _E_ = [0, _D_, _B_];
+     var _E_ = cst$15;
+    var _F_ = [0, _E_, _C_];
     if(stdin)
       /*<<filename.ml:237:55>>*/ var
       f$1 = stdin[1],
-       /*<<filename.ml:237:55>>*/ _F_ = quote_cmd_filename(f$1),
-      _G_ =  /*<<filename.ml:237:48>>*/ caml_call2(Stdlib[28], cst$9, _F_);
+       /*<<filename.ml:237:55>>*/ _G_ = quote_cmd_filename(f$1),
+      _H_ =  /*<<filename.ml:237:48>>*/ caml_call2(Stdlib[28], cst$9, _G_);
     else
-     var _G_ = cst$14;
+     var _H_ = cst$14;
      /*<<filename.ml:236:35>>*/ var
-      /*<<filename.ml:236:35>>*/ _I_ =
+      /*<<filename.ml:236:35>>*/ _J_ =
         /*<<filename.ml:236:35>>*/ caml_call2(Stdlib_List[20], quote$0, args),
       /*<<filename.ml:236:16>>*/ s =
-        /*<<filename.ml:236:16>>*/ caml_call2(Stdlib_String[7], cst$10, _I_),
+        /*<<filename.ml:236:16>>*/ caml_call2(Stdlib_String[7], cst$10, _J_),
       /*<<filename.ml:211:12>>*/ b =
         /*<<filename.ml:211:12>>*/ caml_call1
         (Stdlib_Buffer[1], caml_ml_string_length(s) + 20 | 0),
-     _H_ = [0, _G_, _E_];
-    function _y_(c){
+     _I_ = [0, _H_, _F_];
+    function _z_(c){
       /*<<filename.ml:214:8>>*/ a:
      {
       if(62 <= c){
-       var _M_ = c - 63 | 0;
-       if(60 < _M_ >>> 0){if(62 <= _M_) break a;} else if(31 !== _M_) break a;
+       var _N_ = c - 63 | 0;
+       if(60 < _N_ >>> 0){if(62 <= _N_) break a;} else if(31 !== _N_) break a;
       }
       else
        if(42 <= c){
@@ -33066,21 +33140,21 @@
              (Stdlib_Buffer[12], b, c);
      /*<<filename.ml:218:31>>*/ }
      /*<<filename.ml:212:4>>*/  /*<<filename.ml:212:4>>*/ caml_call2
-     (Stdlib_String[30], _y_, s);
+     (Stdlib_String[30], _z_, s);
      /*<<filename.ml:232:21>>*/ var
-     _J_ =
+     _K_ =
        [0,
         cst$11,
-        [0,  /*<<filename.ml:212:4>>*/ caml_call1(Stdlib_Buffer[2], b), _H_]],
-      /*<<filename.ml:232:21>>*/ _K_ =
-       [0, cst$12, [0, quote_cmd_filename(cmd), _J_]];
+        [0,  /*<<filename.ml:212:4>>*/ caml_call1(Stdlib_Buffer[2], b), _I_]],
+      /*<<filename.ml:232:21>>*/ _L_ =
+       [0, cst$12, [0, quote_cmd_filename(cmd), _K_]];
      /*<<filename.ml:232:21>>*/ return  /*<<filename.ml:232:21>>*/ caml_call2
-            (Stdlib_String[7], cst$13, _K_);
+            (Stdlib_String[7], cst$13, _L_);
     /*<<filename.ml:244:5>>*/ }
    function drive_and_path(s){
      /*<<filename.ml:252:4>>*/ var
-     _u_ = 2 <=  /*<<filename.ml:250:4>>*/ caml_ml_string_length(s) ? 1 : 0;
-    if(_u_){
+     _v_ = 2 <=  /*<<filename.ml:250:4>>*/ caml_ml_string_length(s) ? 1 : 0;
+    if(_v_){
       /*<<filename.ml:250:38>>*/  /*<<filename.ml:250:38>>*/ var
       param =  /*<<filename.ml:250:38>>*/ caml_string_get(s, 0);
      a:
@@ -33091,28 +33165,28 @@
         if(25 < param - 97 >>> 0) break b;
        }
        else if(65 > param) break b;
-       var _v_ = 1;
+       var _w_ = 1;
        break a;
       }
-      var _v_ = 0;
+      var _w_ = 0;
      }
       /*<<filename.ml:250:28>>*/  /*<<filename.ml:250:28>>*/ var
-      _w_ =
-        _v_
+      _x_ =
+        _w_
          ? 58 ===  /*<<filename.ml:250:47>>*/ caml_string_get(s, 1) ? 1 : 0
-         : _v_;
+         : _w_;
     }
     else
-     var _w_ = _u_;
-     /*<<filename.ml:252:7>>*/ if(! _w_)
+     var _x_ = _v_;
+     /*<<filename.ml:252:7>>*/ if(! _x_)
       /*<<filename.ml:254:9>>*/ return [0, cst$17, s];
      /*<<filename.ml:253:28>>*/  /*<<filename.ml:253:28>>*/ var
-     _x_ =
+     _y_ =
         /*<<filename.ml:253:28>>*/ caml_call3
         (Stdlib_String[16], s, 2, caml_ml_string_length(s) - 2 | 0);
      /*<<filename.ml:253:9>>*/ return [0,
              /*<<filename.ml:253:10>>*/ caml_call3(Stdlib_String[16], s, 0, 2),
-            _x_];
+            _y_];
     /*<<filename.ml:254:16>>*/ }
    function dirname$0(s){
      /*<<filename.ml:256:4>>*/ var
@@ -33146,11 +33220,11 @@
        quote_command$0,
        basename$0,
        dirname$0];
-    /*<<filename.ml:277:17>>*/ function basename$1(_t_){
-     /*<<?>>*/ return generic_basename(is_dir_sep$0, current_dir_name$1, _t_);
+    /*<<filename.ml:277:17>>*/ function basename$1(_u_){
+     /*<<?>>*/ return generic_basename(is_dir_sep$0, current_dir_name$1, _u_);
    }
-    /*<<filename.ml:278:16>>*/ function dirname$1(_s_){
-     /*<<?>>*/ return generic_dirname(is_dir_sep$0, current_dir_name$1, _s_);
+    /*<<filename.ml:278:16>>*/ function dirname$1(_t_){
+     /*<<?>>*/ return generic_dirname(is_dir_sep$0, current_dir_name$1, _t_);
    }
     /*<<filename.ml:264:26>>*/ var
      /*<<filename.ml:264:26>>*/ Cygwin =
@@ -33193,11 +33267,11 @@
      /*<<filename.ml:291:14>>*/ if
      (0 !== l && ! is_dir_sep$1(dirname, l - 1 | 0)){
       /*<<filename.ml:293:17>>*/  /*<<filename.ml:293:17>>*/ var
-      _r_ =
+      _s_ =
          /*<<filename.ml:293:17>>*/ caml_call2
          (Stdlib[28], dir_sep$2, filename);
       /*<<filename.ml:293:17>>*/ return  /*<<filename.ml:293:17>>*/ caml_call2
-             (Stdlib[28], dirname, _r_);
+             (Stdlib[28], dirname, _s_);
     }
      /*<<filename.ml:292:7>>*/ return  /*<<filename.ml:292:7>>*/ caml_call2
             (Stdlib[28], dirname, filename);
@@ -33300,7 +33374,7 @@
     /*<<filename.ml:338:71>>*/ }
     /*<<filename.ml:338:40>>*/ var
      /*<<filename.ml:338:40>>*/ _h_ =
-      [0, function(_q_){ /*<<?>>*/ return _q_;}],
+      [0, function(_r_){ /*<<?>>*/ return _r_;}],
      /*<<filename.ml:338:2>>*/ current_temp_dir_name =
        /*<<filename.ml:338:2>>*/ caml_call2(Stdlib_Domain[10][1], _h_, _g_);
    function set_temp_dir_name(s){
@@ -33340,17 +33414,17 @@
      }
     }
     /*<<filename.ml:351:15>>*/ }
-   function open_temp_file(opt, _o_, _n_, prefix, suffix){
+   function open_temp_file(opt, _p_, _o_, prefix, suffix){
      /*<<filename.ml:356:2>>*/ if(opt)
      var sth = opt[1], mode = sth;
     else
      var mode = _j_;
-     /*<<filename.ml:356:2>>*/ if(_o_)
-     var sth$0 = _o_[1], perms = sth$0;
+     /*<<filename.ml:356:2>>*/ if(_p_)
+     var sth$0 = _p_[1], perms = sth$0;
     else
      var perms = 384;
-     /*<<filename.ml:356:2>>*/ if(_n_)
-     var sth$1 = _n_[1], temp_dir = sth$1;
+     /*<<filename.ml:356:2>>*/ if(_o_)
+     var sth$1 = _o_[1], temp_dir = sth$1;
     else
      var
       temp_dir =
@@ -33362,12 +33436,12 @@
       name = temp_file_name(temp_dir, prefix, suffix);
       /*<<filename.ml:358:4>>*/ try{
        /*<<filename.ml:359:6>>*/  /*<<filename.ml:359:6>>*/ var
-       _p_ =
+       _q_ =
          [0,
           name,
            /*<<filename.ml:360:7>>*/ caml_call3
            (Stdlib[62], [0, 1, [0, 3, [0, 5, mode]]], perms, name)];
-       /*<<filename.ml:359:6>>*/ return _p_;
+       /*<<filename.ml:359:6>>*/ return _q_;
      }
      catch(e$0){
       var e = caml_wrap_exception(e$0);
@@ -33381,7 +33455,7 @@
      }
     }
     /*<<filename.ml:363:15>>*/ }
-   function temp_dir(opt, _m_, prefix, suffix){
+   function temp_dir(opt, _n_, prefix, suffix){
      /*<<filename.ml:367:2>>*/ if(opt)
      var sth = opt[1], temp_dir = sth;
     else
@@ -33389,8 +33463,8 @@
       temp_dir =
          /*<<filename.ml:365:26>>*/ caml_call1
          (Stdlib_Domain[10][2], current_temp_dir_name);
-     /*<<filename.ml:367:2>>*/ if(_m_)
-     var sth$0 = _m_[1], perms = sth$0;
+     /*<<filename.ml:367:2>>*/ if(_n_)
+     var sth$0 = _n_[1], perms = sth$0;
     else
      var perms = 448;
     var counter = 0;

From a18be46c71a2496f39c65538caf6731965d943a8 Mon Sep 17 00:00:00 2001
From: Hugo Heuzard <hugo.heuzard@gmail.com>
Date: Sat, 11 Nov 2023 09:31:18 +0100
Subject: [PATCH 112/112] doc

---
 CHANGES.md          |  2 +-
 TODO.txt            |  4 ----
 manual/options.wiki | 31 ++++++++++++++++---------------
 3 files changed, 17 insertions(+), 20 deletions(-)

diff --git a/CHANGES.md b/CHANGES.md
index 49c5187624..cbe1489c7a 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -1,7 +1,7 @@
 # Dev (2023-??-??) - ??
 
 ## Features/Changes
-* Compiler: global dead code elimination (#1503)
+* Compiler: global dead code elimination (Micah Cantor, #1503)
 * Compiler: change control-flow compilation strategy (#1496)
 * Compiler: Dead code elimination of unused references (#2076)
 * Compiler: reduce memory consumption (#1516)
diff --git a/TODO.txt b/TODO.txt
index c099243943..4df3b95cf8 100644
--- a/TODO.txt
+++ b/TODO.txt
@@ -12,10 +12,6 @@ Compiler optimizations
 
 - cross-function optimizations
 
-- deadcode elimination inside blocks
-  (for instance, elimination of function which are defined in a
-   functor but are not used)
-
 - should we rebind variables from a deeper level ?
   (only if used more than once...)
 
diff --git a/manual/options.wiki b/manual/options.wiki
index f5af01bb05..b8cc16db16 100644
--- a/manual/options.wiki
+++ b/manual/options.wiki
@@ -32,18 +32,19 @@
    various optimizations until a fix-point is reached
 ==List of option to "--disable" or "--enable"
 
-|= Option name |= Default |= Description                           |
-| pretty       | false    | Pretty print the javascript output     |
-| effects      | false    | Enable support for effect handlers     |
-| debuginfo    | false    | Output debug information (location)    |
-| deadcode     | true     | Deadcode elimination                   |
-| inline       | true     | Code inlining                          |
-| shortvar     | true     | Shorten variable names                 |
-| staticeval   | true     | Static evaluation of constants         |
-| share        | true     | Share string and number constants      |
-| strict       | true     | Enable strict mode                     |
-| debugger     | true     | Keep debugger statements.
-                            Stripped otherwise                     |
-| genprim      | true     | Generate dummy primitives when missing |
-| excwrap      | true     | Wrap js exception into ocaml ones      |
-| optcall      | true     | Javascript optimizations               |
+|= Option name   |= Default |= Description                           |
+| pretty         | false    | Pretty print the javascript output     |
+| effects        | false    | Enable support for effect handlers     |
+| debuginfo      | false    | Output debug information (location)    |
+| deadcode       | true     | Deadcode elimination                   |
+| glboaldeadcode | true     | Global deadcode elimination            |
+| inline         | true     | Code inlining                          |
+| shortvar       | true     | Shorten variable names                 |
+| staticeval     | true     | Static evaluation of constants         |
+| share          | true     | Share string and number constants      |
+| strict         | true     | Enable strict mode                     |
+| debugger       | true     | Keep debugger statements.
+                              Stripped otherwise                     |
+| genprim        | true     | Generate dummy primitives when missing |
+| excwrap        | true     | Wrap js exception into ocaml ones      |
+| optcall        | true     | Javascript optimizations               |